C on Detail's Blog

STM32 SPI

Mon, 26 Feb 2024 00:00:00 +0000

SPI简介

SPI（Serial Peripheral Interface）是由Motorola公司开发的一种通用数据总线
四根通信线：SCK（Serial Clock）、MOSI（Master Output Slave Input）、MISO（Master Input Slave Output）、SS（Slave Select）
同步，全双工
支持总线挂载多设备（一主多从）

硬件电路

所有SPI设备的SCK、MOSI、MISO分别连在一起
主机另外引出多条SS控制线，分别接到各从机的SS引脚
输出引脚配置为推挽输出，输入引脚配置为浮空或上拉输入

SPI时序单元

起始条件：SS从高电平切换到低电平
终止条件：SS从低电平切换到高电平

交换一个字节（模式0）

CPOL=0：空闲状态时，SCK为低电平
CPHA=0：SCK第一个边沿移入数据，第二个边沿移出数据

交换一个字节（模式1）

CPOL=0：空闲状态时，SCK为低电平
CPHA=1：SCK第一个边沿移出数据，第二个边沿移入数据

交换一个字节（模式2）

CPOL=1：空闲状态时，SCK为高电平
CPHA=0：SCK第一个边沿移入数据，第二个边沿移出数据

交换一个字节（模式3）

CPOL=1：空闲状态时，SCK为高电平
CPHA=1：SCK第一个边沿移出数据，第二个边沿移入数据

SPI时序

发送指令

向SS指定的设备，发送指令（0x06）

指定地址写

向SS指定的设备，发送写指令（0x02），随后在指定地址（Address[23:0]）下，写入指定数据（Data）

指定地址读

向SS指定的设备，发送读指令（0x03），随后在指定地址（Address[23:0]）下，读取从机数据（Data）

SPI外设

STM32内部集成了硬件SPI收发电路，可以由硬件自动执行时钟生成、数据收发等功能，减轻CPU的负担
可配置8位/16位数据帧、高位先行/低位先行
时钟频率： fPCLK / (2, 4, 8, 16, 32, 64, 128, 256)
支持多主机模型、主或从操作
可精简为半双工/单工通信
支持DMA
兼容I2S协议

实际外设: STM32F103C8T6 硬件SPI资源：SPI1、SPI2

代码

软件SPI

void MySPI_W_SS(uint8_t BitValue)
{
    GPIO_WriteBit(GPIOA, GPIO_Pin_4, (BitAction)BitValue);
}

void MySPI_W_SCK(uint8_t BitValue)
{
    GPIO_WriteBit(GPIOA, GPIO_Pin_5, (BitAction)BitValue);
}

void MySPI_W_MOSI(uint8_t BitValue)
{
    GPIO_WriteBit(GPIOA, GPIO_Pin_7, (BitAction)BitValue);
}

uint8_t MySPI_R_MISO(void)
{
    return GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6);
}

void MySPI_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    MySPI_W_SS(1);
    MySPI_W_SCK(0);
}

void MySPI_Start(void)
{
    MySPI_W_SS(0);
}

void MySPI_Stop(void)
{
    MySPI_W_SS(1);
}

uint8_t MySPI_SwapByte(uint8_t ByteSend)
{
    uint8_t i, ByteReceive = 0x00;
    for (i = 0; i < 8; i ++)
    {
        MySPI_W_MOSI(ByteSend & (0x80 >> i));
        MySPI_W_SCK(1);
        if (MySPI_R_MISO() == 1){ByteReceive |= (0x80 >> i);}
        MySPI_W_SCK(0);
    }
    return ByteReceive;
}

硬件SPI

待完成

STM32 I2C

Tue, 20 Feb 2024 00:00:00 +0000

I2C简介

I2C（Inter IC Bus）是由Philips公司开发的一种通用数据总线
两根通信线：SCL（Serial Clock）、SDA（Serial Data）
同步，半双工
带数据应答
支持总线挂载多设备（一主多从、多主多从）

硬件电路

所有I2C设备的SCL连在一起，SDA连在一起
设备的SCL和SDA均要配置成开漏输出模式
SCL和SDA各添加一个上拉电阻，阻值一般为4.7KΩ左右

I2C时序基本单元

起始条件：SCL高电平期间，SDA从高电平切换到低电平
终止条件：SCL高电平期间，SDA从低电平切换到高电平

发送一个字节：SCL低电平期间，主机将数据位依次放到SDA线上（高位先行），然后释放SCL，从机将在SCL高电平期间读取数据位，所以SCL高电平期间SDA不允许有数据变化，依次循环上述过程8次，即可发送一个字节

接收一个字节：SCL低电平期间，从机将数据位依次放到SDA线上（高位先行），然后释放SCL，主机将在SCL高电平期间读取数据位，所以SCL高电平期间SDA不允许有数据变化，依次循环上述过程8次，即可接收一个字节（主机在接收之前，需要释放SDA）

发送应答：主机在接收完一个字节之后，在下一个时钟发送一位数据，数据0表示应答，数据1表示非应答
接收应答：主机在发送完一个字节之后，在下一个时钟接收一位数据，判断从机是否应答，数据0表示应答，数据1表示非应答（主机在接收之前，需要释放SDA）

I2C时序

指定地址写

对于指定设备（Slave Address），在指定地址（Reg Address）下，写入指定数据（Data）

当前地址读

对于指定设备（Slave Address），在当前地址指针指示的地址下，读取从机数据（Data）

指定地址读

对于指定设备（Slave Address），在指定地址（Reg Address）下，读取从机数据（Data）

I2C外设

STM32内部集成了硬件I2C收发电路，可以由硬件自动执行时钟生成、起始终止条件生成、应答位收发、数据收发等功能，减轻CPU的负担
支持多主机模型
支持7位/10位地址模式
支持不同的通讯速度，标准速度(高达100 kHz)，快速(高达400 kHz)
支持DMA
兼容SMBus协议

实际外设: STM32F103C8T6 硬件I2C资源：I2C1、I2C2

序列图

代码

软件I2C

/*硬件*/

// SCL写
void MyI2C_W_SCL(uint8_t BitValue){
    GPIO_WriteBit(GPIOB, GPIO_Pin_10, (BitAction)BitValue);
    Delay_us(10);
}

// SDA写
void MyI2C_W_SDA(uint8_t BitValue){
    GPIO_WriteBit(GPIOB, GPIO_Pin_11, (BitAction)BitValue);
    Delay_us(10);
}

// SDA读
uint8_t MyI2C_R_SDA(void)
{
    uint8_t BitValue;
    BitValue = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_11);
    Delay_us(10);
    return BitValue;
}

//GPIO配置
void MyI2C_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);
    GPIO_SetBits(GPIOB, GPIO_Pin_10 | GPIO_Pin_11);
}


/*协议*/

//开始标志
void MyI2C_Start(void){
    MyI2C_W_SDA(1);
    MyI2C_W_SCL(1);
    MyI2C_W_SDA(0);
    MyI2C_W_SCL(0);
}

//结束标志
void MyI2C_Stop(void)
{
    MyI2C_W_SDA(0);
    MyI2C_W_SCL(1);
    MyI2C_W_SDA(1);
}

//发送数据
void MyI2C_SendByte(uint8_t Byte){
    uint8_t i;
    for (i = 0; i < 8; i ++)
    {
        MyI2C_W_SDA(Byte & (0x80 >> i));
        MyI2C_W_SCL(1);
        MyI2C_W_SCL(0);
    }
}

//接收数据
uint8_t MyI2C_ReceiveByte(void){
    uint8_t i, Byte = 0x00;
    MyI2C_W_SDA(1);
    for (i = 0; i < 8; i ++)
    {
        MyI2C_W_SCL(1);
        if (MyI2C_R_SDA() == 1){
            Byte |= (0x80 >> i);
        }
        MyI2C_W_SCL(0);
    }
    return Byte;
}

//应答信号发送
void MyI2C_SendAck(uint8_t AckBit)
{
    MyI2C_W_SDA(AckBit);
    MyI2C_W_SCL(1);
    MyI2C_W_SCL(0);
}

//应答信号接收
uint8_t MyI2C_ReceiveAck(void)
{
    uint8_t AckBit;
    MyI2C_W_SDA(1);
    MyI2C_W_SCL(1);
    AckBit = MyI2C_R_SDA();
    MyI2C_W_SCL(0);
    return AckBit;
}

硬件I2C

//硬件地址
#define ADDRESS 0xD0

//时钟配置
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);

//GPIO配置
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);

//I2C配置
I2C_InitTypeDef I2C_InitStructure;
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_ClockSpeed = 50000;
I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_InitStructure.I2C_OwnAddress1 = 0x00;
I2C_Init(I2C2, &I2C_InitStructure);

//I2C使能
I2C_Cmd(I2C2, ENABLE);

//等待事件
void I2C_WaitEvent(I2C_TypeDef* I2Cx, uint32_t I2C_EVENT)
{
    uint32_t Timeout;
    Timeout = 10000;
    while (I2C_CheckEvent(I2Cx, I2C_EVENT) != SUCCESS)
    {
        Timeout --;
        if (Timeout == 0){
            /*超时的错误处理代码，可以添加到此处*/
            break;
        }
    }
}

void I2C_WriteReg(uint8_t RegAddress, uint8_t Data)
{
    I2C_GenerateSTART(I2C2, ENABLE);
    I2C_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT);
  
    I2C_Send7bitAddress(I2C2, ADDRESS, I2C_Direction_Transmitter);
    I2C_WaitEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED);
  
    I2C_SendData(I2C2, RegAddress);
    I2C_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTING);
  
    I2C_SendData(I2C2, Data);
    I2C_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTED);
  
    I2C_GenerateSTOP(I2C2, ENABLE);
}

uint8_t I2C_ReadReg(uint8_t RegAddress)
{
    uint8_t Data;
  
    I2C_GenerateSTART(I2C2, ENABLE);
    I2C_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT);
  
    I2C_Send7bitAddress(I2C2, ADDRESS, I2C_Direction_Transmitter);
    I2C_WaitEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED);
  
    I2C_SendData(I2C2, RegAddress);
    I2C_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_TRANSMITTED);
  
    I2C_GenerateSTART(I2C2, ENABLE);
    I2C_WaitEvent(I2C2, I2C_EVENT_MASTER_MODE_SELECT);
  
    I2C_Send7bitAddress(I2C2, ADDRESS, I2C_Direction_Receiver);
    I2C_WaitEvent(I2C2, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED);
  
    I2C_AcknowledgeConfig(I2C2, DISABLE);
    I2C_GenerateSTOP(I2C2, ENABLE);
    I2C_WaitEvent(I2C2, I2C_EVENT_MASTER_BYTE_RECEIVED);
  
    Data = I2C_ReceiveData(I2C2);                                 
    I2C_AcknowledgeConfig(I2C2, ENABLE);
    return Data;
}

I2C_InitTypeDef为I2C配置结构体
- I2C_Mode为I2C模式
- I2C_ClockSpeed为时钟频率
- I2C_DutyCycle为I2C快速模式占空比
- I2C_Ack为响应使能
- I2C_AcknowledgedAddress为地址模式
- I2C_OwnAddress1为本设备的第一个ID
I2C_GenerateSTART函数发送起始条件
I2C_Send7bitAddress函数发送7位地址
I2C_SendData函数发送数据
I2C_GenerateSTOP函数发送终止条件
I2C_AcknowledgeConfig函数配置应答
I2C_CheckEvent函数读取状态
I2C_ReceiveData函数读取结果

I2C_EVENT	事件	值
I2C_EVENT_SLAVE_TRANSMITTER_ADDRESS_MATCHED	EV1	((uint32_t)0x00060082)
I2C_EVENT_SLAVE_RECEIVER_ADDRESS_MATCHED	EV1	((uint32_t)0x00020002)
I2C_EVENT_SLAVE_TRANSMITTER_SECONDADDRESS_MATCHED	EV1	((uint32_t)0x00860080)
I2C_EVENT_SLAVE_RECEIVER_SECONDADDRESS_MATCHED	EV1	((uint32_t)0x00820000)
I2C_EVENT_SLAVE_GENERALCALLADDRESS_MATCHED	EV1	((uint32_t)0x00120000)
I2C_EVENT_SLAVE_BYTE_RECEIVED	EV2	((uint32_t)0x00020040)
(I2C_EVENT_SLAVE_BYTE_RECEIVED\| I2C_FLAG_DUALF)	EV2
(I2C_EVENT_SLAVE_BYTE_RECEIVED\| I2C_FLAG_GENCALL)	EV2
I2C_EVENT_SLAVE_BYTE_TRANSMITTED	EV3	((uint32_t)0x00060084)
(I2C_EVENT_SLAVE_BYTE_TRANSMITTED\| I2C_FLAG_DUALF)	EV3
(I2C_EVENT_SLAVE_BYTE_TRANSMITTED\| I2C_FLAG_GENCALL)	EV3
I2C_EVENT_SLAVE_ACK_FAILURE	EV3_2	((uint32_t)0x00000400)
I2C_EVENT_SLAVE_STOP_DETECTED	EV4	((uint32_t)0x00000010)
I2C_EVENT_MASTER_MODE_SELECT	EV5
I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED	EV6
I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED	EV6
I2C_EVENT_MASTER_BYTE_RECEIVED	EV7
I2C_EVENT_MASTER_BYTE_TRANSMITTING	EV8
I2C_EVENT_MASTER_BYTE_TRANSMITTED	EV8_2
I2C_EVENT_MASTER_MODE_ADDRESS10	EV9

I2C事件流程（常用的主模式）

通讯开始

EV5
I2C_EVENT_MASTER_MODE_SELECT
After sending the START condition (I2C_GenerateSTART() function) the master has to wait for this event. It means that the Start condition has been correctly released on the I2C bus (the bus is free, no other devices is communicating).
发送通讯启动条件（I2C_GenerateSTART() 函数）后，主设备必须等待此事件（EV5）。此事件意味着I2C总线上的启动条件已正确释放（总线空闲，没有其他设备正在通信）。

地址确认

EV6
I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED
After checking on EV5 (start condition correctly released on the bus), the master sends the address of the slave(s) with which it will communicate (I2C_Send7bitAddress() function, it also determines the direction of the communication: Master transmitter or Receiver). Then the master has to wait that a slave acknowledges his address. If an acknowledge is sent on the bus, one of the following events will be set:
1. In case of Master Receiver (7-bit addressing): the I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED event is set.
2. In case of Master Transmitter (7-bit addressing): the I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED is set
3. In case of 10-Bit addressing mode, the master (just after generating the START and checking on EV5) has to send the header of 10-bit addressing mode (I2C_SendData() function). Then master should wait on EV9. It means that the 10-bit addressing header has been correctly sent on the bus. Then master should send the second part of the 10-bit address (LSB) using the function I2C_Send7bitAddress(). Then master should wait for event EV6.
主设备发送与其通信的从设备的地址，同时确定通信方向，然后主设备应该等待事件EV6。

通讯事件

EV8、EV8_2 / EV7
I2C_EVENT_MASTER_BYTE_TRANSMITTING、I2C_EVENT_MASTER_BYTE_TRANSMITTED / I2C_EVENT_MASTER_BYTE_RECEIVED

Others

If a communication is established (START condition generated and slave address acknowledged) then the master has to check on one of the following events for communication procedures:

Master Receiver mode: The master has to wait on the event EV7 then to read the data received from the slave (I2C_ReceiveData() function).
Master Transmitter mode: The master has to send data (I2C_SendData() function) then to wait on event EV8 or EV8_2. These two events are similar:

EV8 means that the data has been written in the data register and is being shifted out.
EV8_2 means that the data has been physically shifted out and output on the bus.
In most cases, using EV8 is sufficient for the application. Using EV8_2 leads to a slower communication but ensure more reliable test. EV8_2 is also more suitable than EV8 for testing on the last data transmission (before Stop condition generation).

In case the user software does not guarantee that this event EV7 is managed before the current byte end of transfer, then user may check on EV7 and BTF flag at the same time (ie. (I2C_EVENT_MASTER_BYTE_RECEIVED | I2C_FLAG_BTF)). In this case the communication may be slower.

STM32 DMA

Sat, 17 Feb 2024 00:00:00 +0000

DMA简介

DMA（Direct Memory Access）直接存储器存取
DMA可以提供外设和存储器或者存储器和存储器之间的高速数据传输，无须CPU干预，节省了CPU的资源
12个独立可配置的通道： DMA1（7个通道）， DMA2（5个通道）
每个通道都支持软件触发和特定的硬件触发
STM32F103C8T6 DMA资源：DMA1（7个通道）

DMA数据传输宽度与大小

DMA数据传输: 源端大于目标，高位舍弃。源端小于目标，高位补零。

代码

//全局变量，用于存储每次转运的字节数
uint16_t MyDMA_Size;

//配置时钟
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);

//DMA配置
DMA_InitTypeDef DMA_InitStructure;                              
DMA_InitStructure.DMA_PeripheralBaseAddr = AddrA;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Enable;
DMA_InitStructure.DMA_MemoryBaseAddr = AddrB;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = Size;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_M2M = DMA_M2M_Enable;
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
DMA_Init(DMA1_Channel1, &DMA_InitStructure);

//DMA使能（这里未使能）
DMA_Cmd(DMA1_Channel1, DISABLE);

void MyDMA_Transfer(void)
{
    DMA_Cmd(DMA1_Channel1, DISABLE);
    DMA_SetCurrDataCounter(DMA1_Channel1, MyDMA_Size);
    DMA_Cmd(DMA1_Channel1, ENABLE);
    while (DMA_GetFlagStatus(DMA1_FLAG_TC1) == RESET);
    DMA_ClearFlag(DMA1_FLAG_TC1);
}

DMA_InitTypeDef为DMA配置结构体

外设配置：
DMA_PeripheralBaseAddr为外设基地址，转运来源
DMA_PeripheralDataSize为外设数据宽度
DMA_PeripheralInc为外设地址自增：
DMA_PeripheralInc_Enable开启
DMA_PeripheralInc_Disable关闭
存储器配置：
DMA_MemoryBaseAddr为存储器基地址，转运目标
DMA_MemoryDataSize为存储器数据宽度
DMA_MemoryInc为存储器地址自增：
DMA_MemoryInc_Enable开启
DMA_MemoryInc_Disable关闭
DMA_DIR为数据传输方向：
DMA_DIR_PeripheralDST存储器到外设
DMA_DIR_PeripheralSRC外设到存储器
DMA_BufferSize为转运的数据大小（转运次数）
DMA_Mode为模式，主要配置自动重装
DMA_Mode_Circular循环模式
DMA_Mode_Normal单次模式
DMA_M2M软硬件触发选择
DMA_M2M_Enable开启
DMA_M2M_Disable关闭
DMA_Priority优先级

DMA_PeripheralDataSize	值	描述
DMA_PeripheralDataSize_Byte	((uint32_t)0x00000000)	1Byte
DMA_PeripheralDataSize_HalfWord	((uint32_t)0x00000100)	2Byte
DMA_PeripheralDataSize_Word	((uint32_t)0x00000200)	4Byte

DMA_MemoryDataSize	值	描述
DMA_MemoryDataSize_Byte	((uint32_t)0x00000000)	1Byte
DMA_MemoryDataSize_HalfWord	((uint32_t)0x00000400)	2Byte
DMA_MemoryDataSize_Word	((uint32_t)0x00000800)	4Byte

DMA_Priority	值	描述
DMA_Priority_VeryHigh	((uint32_t)0x00003000)	非常高
DMA_Priority_High	((uint32_t)0x00002000)	高
DMA_Priority_Medium	((uint32_t)0x00001000)	中
DMA_Priority_Low	((uint32_t)0x00000000)	低

DMA + ADC 协同工作

DMA请求

更多DMA请求映像的相关内容：STM32F10xxx参考手册（中文）.pdf 页码147/手册10.3.7

代码

//存储数值的全局变量
uint16_t AD_Value[4];

//时钟配置
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
RCC_ADCCLKConfig(RCC_PCLK2_Div6);

//GPIO配置
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);

//ADC通道配置
ADC_RegularChannelConfig(ADC1, ADC_Channel_0, 1, ADC_SampleTime_55Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 2, ADC_SampleTime_55Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_2, 3, ADC_SampleTime_55Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_3, 4, ADC_SampleTime_55Cycles5);

//ADC配置
ADC_InitTypeDef ADC_InitStructure;
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
ADC_InitStructure.ADC_ScanConvMode = ENABLE;
ADC_InitStructure.ADC_NbrOfChannel = 4;
ADC_Init(ADC1, &ADC_InitStructure);

//DMA配置
DMA_InitTypeDef DMA_InitStructure;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&ADC1->DR;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)AD_Value;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
MA_InitStructure.DMA_BufferSize = 4;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
DMA_Init(DMA1_Channel1, &DMA_InitStructure);

//DMA和ADC使能
DMA_Cmd(DMA1_Channel1, ENABLE);
ADC_DMACmd(ADC1, ENABLE);
ADC_Cmd(ADC1, ENABLE);

//ADC校准
ADC_ResetCalibration(ADC1);
while (ADC_GetResetCalibrationStatus(ADC1) == SET);
ADC_StartCalibration(ADC1);
while (ADC_GetCalibrationStatus(ADC1) == SET);

//ADC触发
ADC_SoftwareStartConvCmd(ADC1, ENABLE);

DMA_Cmd(DMA1_Channel1, ENABLE);启用DMA通道1
ADC_DMACmd(ADC1, ENABLE);启用ADC1触发DMA1信号
ADC_Cmd(ADC1, ENABLE);启用ADC1

STM32 USART

Sat, 17 Feb 2024 00:00:00 +0000

通信接口

通信的目的：将一个设备的数据传送到另一个设备，扩展硬件系统
通信协议：制定通信的规则，通信双方按照协议规则进行数据收发

名称	引脚	双工	时钟	电平	设备
USART	TX、RX	全双工	异步	单端	点对点
I2C	SCL、SDA	半双工	同步	单端	多设备
SPI	SCLK、MOSI、MISO、CS	全双工	同步	单端	多设备
CAN	CAN_H、CAN_L	半双工	异步	差分	多设备
USB	DP、DM	半双工	异步	差分	点对点

串口

串口是一种应用十分广泛的通讯接口，串口成本低、容易使用、通信线路简单，可实现两个设备的互相通信
单片机的串口可以使单片机与单片机、单片机与电脑、单片机与各式各样的模块互相通信，极大地扩展了单片机的应用范围，增强了单片机系统的硬件实力

硬件电路

简单双向串口通信有两根通信线（发送端TX和接收端RX）
TX与RX要交叉连接
当只需单向的数据传输时，可以只接一根通信线
当电平标准不一致时，需要加电平转换芯片

电平标准

电平标准是数据1和数据0的表达方式，是传输线缆中人为规定的电压与数据的对应关系，串口常用的电平标准有如下三种：

TTL电平：+3.3V或+5V表示1，0V表示0
RS232电平：-3~-15V表示1，+3~+15V表示0
RS485电平：两线压差+2~+6V表示1，-2~-6V表示0（差分信号）

串口参数及时序

波特率：串口通信的速率
起始位：标志一个数据帧的开始，固定为低电平
数据位：数据帧的有效载荷，1为高电平，0为低电平，低位先行
校验位：用于数据验证，根据数据位计算得来
停止位：用于数据帧间隔，固定为高电平

USART简介

USART（Universal Synchronous/Asynchronous Receiver/Transmitter）通用同步/异步收发器
USART是STM32内部集成的硬件外设，可根据数据寄存器的一个字节数据自动生成数据帧时序，从TX引脚发送出去，也可自动接收RX引脚的数据帧时序，拼接为一个字节数据，存放在数据寄存器里
自带波特率发生器，最高达4.5Mbits/s
可配置数据位长度（8/9）、停止位长度（0.5/1/1.5/2）
可选校验位（无校验/奇校验/偶校验）
支持同步模式、硬件流控制、DMA、智能卡、IrDA、LIN

实际外设: STM32F103C8T6 USART资源：USART1、USART2、USART3

更多USART的相关内容：STM32F10xxx参考手册（中文）.pdf 页码516/手册25

代码

//数据接收全局变量
uint8_t Serial_RxData;
uint8_t Serial_RxFlag;

//时钟配置
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

//GPIO配置
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
    //TX
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
    //RX

//USART配置
USART_InitTypeDef USART_InitStructure;
USART_InitStructure.USART_BaudRate = 9600;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_Init(USART1, &USART_InitStructure);

//中断配置
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_Init(&NVIC_InitStructure);

//USART使能
USART_Cmd(USART1, ENABLE);

//发送字节
void Serial_SendByte(uint8_t Byte)
{
    USART_SendData(USART1, Byte);
    while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
}

//返回接收数据
uint8_t Serial_GetRxData(void)
{
    return Serial_RxData;
}

void USART1_IRQHandler(void)
{
    if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)
    {
        Serial_RxData = USART_ReceiveData(USART1);
        Serial_RxFlag = 1;
        USART_ClearITPendingBit(USART1, USART_IT_RXNE);
    }
}

USART_InitTypeDef为USART配置结构体
- USART_BaudRate为波特率：常用9600、115200等
- ~~USART_HardwareFlowControl为硬件流控制（一般不用）~~
- USART_Mode为模式
- USART_Parity为奇偶校验
- USART_StopBits为停止位
- USART_WordLength为字长
USART_ITConfig函数用于配置USART中断
USART_SendData函数用于发送数据
USART_ReceiveData函数用于读取接收到的数据
获取USART标志位
- USART_GetFlagStatus标志位
- USART_GetITStatus中断标志位

USART_HardwareFlowControl	值	描述
USART_HardwareFlowControl_None	((uint16_t)0x0000)	关闭
USART_HardwareFlowControl_RTS	((uint16_t)0x0100)	发送可接收信号
USART_HardwareFlowControl_CTS	((uint16_t)0x0200)	接收可发送信号
USART_HardwareFlowControl_RTS_CTS	((uint16_t)0x0300)	开启全部

USART_Mode	值	描述
USART_Mode_Rx	((uint16_t)0x0004)	发送
USART_Mode_Tx	((uint16_t)0x0008)	接收

USART_Parity	值	描述
USART_Parity_No	((uint16_t)0x0000)	不校验
USART_Parity_Even	((uint16_t)0x0400)	偶校验
USART_Parity_Odd	((uint16_t)0x0600)	奇校验

USART_StopBits	值	描述
USART_StopBits_1	((uint16_t)0x0000)	1位停止位
USART_StopBits_0_5	((uint16_t)0x1000)	0.5位停止位
USART_StopBits_2	((uint16_t)0x2000)	2位停止位
USART_StopBits_1_5	((uint16_t)0x3000)	1.5位停止位

USART_WordLength	值	描述
USART_WordLength_8b	((uint16_t)0x0000)	8位数据
USART_WordLength_9b	((uint16_t)0x1000)	9位数据

USART_ITs	值	USART_Flags	值	描述
USART_IT_PE	((uint16_t)0x0028)	USART_FLAG_PE	((uint16_t)0x0001)	奇偶检验错
USART_IT_TXE	((uint16_t)0x0727)	USART_FLAG_TXE	((uint16_t)0x0080)	发送数据寄存器空
USART_IT_TC	((uint16_t)0x0626)	USART_FLAG_TC	((uint16_t)0x0040)	发送完成
USART_IT_RXNE	((uint16_t)0x0525)	USART_FLAG_RXNE	((uint16_t)0x0020)	接收数据就绪可读
USART_IT_IDLE	((uint16_t)0x0424)	USART_FLAG_IDLE	((uint16_t)0x0010)	检测到空闲线路
USART_IT_LBD	((uint16_t)0x0846)	USART_FLAG_LBD	((uint16_t)0x0100)	断开标志
USART_IT_CTS	((uint16_t)0x096A)	USART_FLAG_CTS	((uint16_t)0x0200)	CTS标志
USART_IT_ERR	((uint16_t)0x0060)			未开启USART_IT_ERR时，只能由USART_GetFlagStatus(USARTx,USART_Flag_ORE) 检测到USART_IT_ORE；在开启USART_IT_ERR后，才能被 USART_GetITStatus(USARTx,USART_IT_ORE) 检测到USART_IT_ORE；
USART_IT_ORE	((uint16_t)0x0360)	USART_FLAG_ORE	((uint16_t)0x0008)	检测到数据溢出
USART_IT_NE	((uint16_t)0x0260)	USART_FLAG_NE	((uint16_t)0x0004)	噪声标志
USART_IT_FE	((uint16_t)0x0160)	USART_FLAG_FE	((uint16_t)0x0002)	帧错误

数据包设计

HEX固定包长

字符可变包长

STM32 ADC

Fri, 16 Feb 2024 00:00:00 +0000

ADC简介

ADC（Analog-Digital Converter）模拟-数字转换器
ADC可以将引脚上连续变化的模拟电压转换为内存中存储的数字变量，建立模拟电路到数字电路的桥梁
12位逐次逼近型ADC，1us转换时间
输入电压范围：0-3.3V，转换结果范围：0-4095
18个输入通道，可测量16个外部和2个内部信号源
规则组和注入组两个转换单元
模拟看门狗自动监测输入电压范围
STM32F103C8T6 ADC资源：ADC1、ADC2，10个外部输入通道

通道	ADC1	ADC2	ADC3
通道0	PA0	PA0	PA0
通道1	PA1	PA1	PA1
通道2	PA2	PA2	PA2
通道3	PA3	PA3	PA3
通道4	PA4	PA4	PF6
通道5	PA5	PA5	PF7
通道6	PA6	PA6	PF8
通道7	PA7	PA7	PF9
通道8	PB0	PB0	PF10
通道9	PB1	PB1
通道10	PC0	PC0	PC0
通道11	PC1	PC1	PC1
通道12	PC2	PC2	PC2
通道13	PC3	PC3	PC3
通道14	PC4	PC4
通道15	PC5	PC5
通道16	温度传感器
通道17	内部参考电压

转换模式

单次转换，非扫描模式

连续转换，非扫描模式

数据对齐

触发控制

AD转换的步骤：采样，保持，量化，编码
STM32 ADC的总转换时间为： $$ T_{CONV} = T_{sampling} + 12.5T_{ADC} $$
例如：当ADCCLK=14MHz，采样时间为1.5个ADC周期 $$ T_{CONV} = (1.5 + 12.5)T_{ADC} = 14T_{ADC} = 1μs $$

代码

//配置时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
RCC_ADCCLKConfig(RCC_PCLK2_Div6);

//GPIO配置
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);

//ADC配置
ADC_InitTypeDef ADC_InitStructure;
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
ADC_InitStructure.ADC_ScanConvMode = DISABLE;
ADC_InitStructure.ADC_NbrOfChannel = 1;
ADC_Init(ADC1, &ADC_InitStructure);
  
//ADC使能
ADC_Cmd(ADC1, ENABLE);
  
//ADC校准
ADC_ResetCalibration(ADC1);
while (ADC_GetResetCalibrationStatus(ADC1) == SET);
ADC_StartCalibration(ADC1);
while (ADC_GetCalibrationStatus(ADC1) == SET);

//获取值
uint16_t AD_GetValue(uint8_t ADC_Channel)
{
    ADC_RegularChannelConfig(ADC1, ADC_Channel, 1, ADC_SampleTime_55Cycles5);
    ADC_SoftwareStartConvCmd(ADC1, ENABLE);
    while (ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET);
    return ADC_GetConversionValue(ADC1);
}

RCC_ADCCLKConfig函数用于配置ADC时钟分频（ADC最高支持14M时钟）
GPIO_InitTypeDef为ADC配置结构体
- ADC_Mode为ADC模式
- ADC_DataAlign为数据对齐模式
- ADC_ExternalTrigConv为外部触发模式
- ADC_ContinuousConvMode为连续转换使能
- ADC_ScanConvMode为扫描模式使能
- ADC_NbrOfChannel为ADC通道数
ADC_ResetCalibration函数用于复位ADC校准寄存器
ADC_GetResetCalibrationStatus函数用于检查ADC校准寄存器状态
ADC_StartCalibration函数用于校准ADC
ADC_GetCalibrationStatus函数用于检查ADC校准
ADC_RegularChannelConfig函数用于配置规则组通道
- ADC_Channel为ADC通道：ADC_Channel_x
- ADC_SampleTime为采样时间
ADC_GetFlagStatus函数用于获取ADC标志位
ADC_GetConversionValue函数用于获取规则组结果
ADC_SoftwareStartConvCmd函数用于软件触发ADC

RCC_PCLK2	值	描述
RCC_PCLK2_Div2	((uint32_t)0x00000000)	二分频
RCC_PCLK2_Div4	((uint32_t)0x00004000)	四分频
RCC_PCLK2_Div6	((uint32_t)0x00008000)	六分频
RCC_PCLK2_Div8	((uint32_t)0x0000C000)	八分频

ADC_Mode	值	描述
ADC_Mode_Independent	((uint32_t)0x00000000)	独立模式
ADC_Mode_RegInjecSimult	((uint32_t)0x00010000)	混合的同步规则+注入同步模式
ADC_Mode_RegSimult_AlterTrig	((uint32_t)0x00020000)	混合的同步规则+交替触发模式
ADC_Mode_InjecSimult_FastInterl	((uint32_t)0x00030000)	混合同步注入+快速交叉模式
ADC_Mode_InjecSimult_SlowInterl	((uint32_t)0x00040000)	混合同步注入+慢速交叉模式
ADC_Mode_InjecSimult	((uint32_t)0x00050000)	注入同步模式
ADC_Mode_RegSimult	((uint32_t)0x00060000)	规则同步模式
ADC_Mode_FastInterl	((uint32_t)0x00070000)	快速交叉模式
ADC_Mode_SlowInterl	((uint32_t)0x00080000)	慢速交叉模式
ADC_Mode_AlterTrig	((uint32_t)0x00090000)	交替触发模式

更多ADC_Mode的相关内容：STM32F10xxx参考手册（中文）.pdf 页码163/手册11.9

ADC_DataAlign	值	描述
ADC_DataAlign_Right	((uint32_t)0x00000000)	右对齐
ADC_DataAlign_Left	((uint32_t)0x00000800)	左对齐

ADC_ExternalTrigConv	值	描述
ADC_ExternalTrigConv_T1_CC1	((uint32_t)0x00000000)	内部信号
ADC_ExternalTrigConv_T1_CC2	((uint32_t)0x00020000)	内部信号
ADC_ExternalTrigConv_T2_CC2	((uint32_t)0x00060000)	内部信号
ADC_ExternalTrigConv_T3_TRGO	((uint32_t)0x00080000)	内部信号
ADC_ExternalTrigConv_T4_CC4	((uint32_t)0x000A0000)	内部信号
ADC_ExternalTrigConv_Ext_IT11_TIM8_TRGO	((uint32_t)0x000C0000)	外部引脚/内部信号
ADC_ExternalTrigConv_T1_CC3	((uint32_t)0x00040000)	内部信号
ADC_ExternalTrigConv_None	((uint32_t)0x000E0000)	软件触发
ADC_ExternalTrigConv_T3_CC1	((uint32_t)0x00000000)	内部信号
ADC_ExternalTrigConv_T2_CC3	((uint32_t)0x00020000)	内部信号
ADC_ExternalTrigConv_T8_CC1	((uint32_t)0x00060000)	内部信号
ADC_ExternalTrigConv_T8_TRGO	((uint32_t)0x00080000)	内部信号
ADC_ExternalTrigConv_T5_CC1	((uint32_t)0x000A0000)	内部信号
ADC_ExternalTrigConv_T5_CC3	((uint32_t)0x000C0000)	内部信号

前六个与后六个分别对应ADC12和ADC3，第七、八个可用于ADC123 更多外部触发相关内容：STM32F10xxx参考手册（中文）.pdf 页码162/手册11.7

ADC_SampleTime	值	描述
ADC_SampleTime_1Cycles5	((uint8_t)0x00)	Sample time equal to 1.5 cycles
ADC_SampleTime_7Cycles5	((uint8_t)0x01)	Sample time equal to 7.5 cycles
ADC_SampleTime_13Cycles5	((uint8_t)0x02)	Sample time equal to 13.5 cycles
ADC_SampleTime_28Cycles5	((uint8_t)0x03)	Sample time equal to 28.5 cycles
ADC_SampleTime_41Cycles5	((uint8_t)0x04)	Sample time equal to 41.5 cycles
ADC_SampleTime_55Cycles5	((uint8_t)0x05)	Sample time equal to 55.5 cycles
ADC_SampleTime_71Cycles5	((uint8_t)0x06)	Sample time equal to 71.5 cycles
ADC_SampleTime_239Cycles5	((uint8_t)0x07)	Sample time equal to 239.5 cycles

STM32 TIM

Mon, 05 Feb 2024 00:00:00 +0000

TIM简介

TIM（Timer）定时器
定时器可以对输入的时钟进行计数，并在计数值达到设定值时触发中断
16位计数器、预分频器、自动重装寄存器的时基单元，在72MHz计数时钟下可以实现最大59.65s的定时
不仅具备基本的定时中断功能，而且还包含内外时钟源选择、输入捕获、输出比较、编码器接口、主从触发模式等多种功能
根据复杂度和应用场景分为了高级定时器、通用定时器、基本定时器三种类型

实际外设: STM32F103C8T6定时器资源：TIM1、TIM2、TIM3、TIM4

类型	编号	总线	功能
高级定时器	TIM1、TIM8	APB2	拥有通用定时器全部功能，并额外具有重复计数器、死区生成、互补输出、刹车输入等功能
通用定时器	TIM2、TIM3、TIM4、TIM5	APB1	拥有基本定时器全部功能，并额外具有内外时钟源选择、输入捕获、输出比较、编码器接口、主从触发模式等功能
基本定时器	TIM6、TIM7	APB1	拥有定时中断、主模式触发DAC的功能

TIM结构

主要结构

预分频器 PSC
计数器 CNT
自动重装器 ARR
重复计数器 REP

高级定时器

通用定时器

基本定时器

定时器中断结构

定时器的触发模式

内部时钟触发：CK_INT
外部时钟触发（外部时钟模式2）：ETR
从模式触发（外部时钟模式1）：TRGI
编码器接口触发：TI1FP1&TI2FP2

时基单元

预分频器

计数器计数频率：

$$ CK_{CNT}=\frac{CK_{PSC}}{PSC+1} $$

计数器

计数器溢出频率：

$$ CK_{CNT_{OV}}=\frac{CK_{CNT}}{ARR+1} $$$$ CK_{CNT_{OV}}=\frac{CK_{PSC}}{(PSC+1)(ARR+1)} $$

~~ARPE=0时，TIMx_ARR无预装入。ARR值即刻生效~~（不建议） ARPE=1时，TIMx_ARR有预装入。ARR值在下次重装时生效

代码

//开启时钟
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

//配置TIM2为内部时钟
TIM_InternalClockConfig(TIM2);

//时基单元初始化
TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInitStructure.TIM_Period = 10000 - 1;
TIM_TimeBaseInitStructure.TIM_Prescaler = 7200 - 1;
TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0;
TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStructure);

//中断配置
TIM_ClearFlag(TIM2, TIM_FLAG_Update);
TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);

//NVIC配置
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_Init(&NVIC_InitStructure);

//使能定时器
TIM_Cmd(TIM2, ENABLE);

//中断函数
void TIM2_IRQHandler(void)
{
    if (TIM_GetITStatus(TIM2, TIM_IT_Update) == SET)
    {
      
        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
    }
}

配置TIM时钟

选择内部时钟( INT )：void TIM_InternalClockConfig(TIM_TypeDef* TIMx);
选择其他定时器( ITRx )：void TIM_ITRxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_InputTriggerSource);
选择外部引脚( TIx )：void TIM_TIxExternalClockConfig(TIM_TypeDef* TIMx, uint16_t TIM_TIxExternalCLKSource, uint16_t TIM_ICPolarity, uint16_t ICFilter);
选择外部时钟( ETR )
1. 模式1( TRGI )：void TIM_ETRClockMode1Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity, uint16_t ExtTRGFilter);
2. 模式2：void TIM_ETRClockMode2Config(TIM_TypeDef* TIMx, uint16_t TIM_ExtTRGPrescaler, uint16_t TIM_ExtTRGPolarity, uint16_t ExtTRGFilter);

主要参数：

TIMx为TIM编号
TIM_InputTriggerSource为输入定时器源
TIM_TIxExternalCLKSource为外部输入引脚
TIM_ICPolarity为外部引脚极性选择
ICFilter为外部引脚滤波器：0x0-0xF
TIM_ExtTRGPrescaler为外部时钟预分频器
TIM_ExtTRGPolarity为外部时钟极性
ExtTRGFilter为外部时钟滤波器：0x0-0xF

TIM_InputTriggerSource	值	描述
TIM_TS_ITR0	((uint16_t)0x0000)	TIM内部触发0
TIM_TS_ITR1	((uint16_t)0x0010)	TIM内部触发1
TIM_TS_ITR2	((uint16_t)0x0020)	TIM内部触发2
TIM_TS_ITR3	((uint16_t)0x0030)	TIM内部触发3

TIM_TIxExternalCLKSource	值	描述
TIM_TS_TI1FP1	((uint16_t)0x0050)	TIMIC1连接TI1（即使用TIMx_CH1）
TIM_TS_TI2FP2	((uint16_t)0x0060)	TIMIC2连接TI2（即使用TIMx_CH2）
TIM_TS_TI1F_ED	((uint16_t)0x0040)	TIMIC1连接TI1，使用边缘检测

TIM_ExtTRGPrescaler	值	描述
TIM_ExtTRGPSC_OFF	((uint16_t)0x0000)	TIM ETRP 不分频
TIM_ExtTRGPSC_DIV2	((uint16_t)0x1000)	TIM ETRP 二分频
TIM_ExtTRGPSC_DIV4	((uint16_t)0x2000)	TIM ETRP 四分频
TIM_ExtTRGPSC_DIV8	((uint16_t)0x3000)	TIM ETRP 八分频

TIM_ICPolarity	值	描述
TIM_ICPolarity_Rising	((uint16_t)0x0000)	上升沿有效
TIM_ICPolarity_Falling	((uint16_t)0x0002)	下降沿有效
TIM_ICPolarity_BothEdge	((uint16_t)0x000A)	双边缘有效

TIM_ICPolarity	值	描述
TIM_ExtTRGPolarity_Inverted	((uint16_t)0x8000)	极性翻转，低电平或下降沿有效
TIM_ExtTRGPolarity_NonInverted	((uint16_t)0x0000)	极性不翻转，高电平或上升沿有效

配置时基单元

TIM_ClockDivision为时钟分频，与预分频器作用类似，但作用有限
TIM_CounterMode为计数方式
TIM_Period为自动重装值( ARR )
TIM_Prescaler为预分频系数( PSC )
~~TIM_RepetitionCounter为重复计数值( REP ，仅高级定时器有效)~~

TIM_ClockDivision	值	描述
TIM_CKD_DIV1	((uint16_t)0x0000)	不分频
TIM_CKD_DIV2	((uint16_t)0x0100)	二分频
TIM_CKD_DIV4	((uint16_t)0x0200)	四分频

TIM_CounterMode	值	描述
TIM_CounterMode_Up	((uint16_t)0x0000)	向上计数模式
TIM_CounterMode_Down	((uint16_t)0x0010)	向下计数模式
TIM_CounterMode_CenterAligned1	((uint16_t)0x0020)	中心对齐计数模式，向下计数时匹配
TIM_CounterMode_CenterAligned2	((uint16_t)0x0040)	中心对齐计数模式，向上计数时匹配
TIM_CounterMode_CenterAligned3	((uint16_t)0x0060)	中心对齐计数模式，匹配所有

配置中断

在初始化时基单元后，会产生一个更新事件来装入自动重装值。因此需要用 TIM_ClearFlag清除中断标志位（当使用更新中断时）
定时器能产生多种中断，需要用 TIM_ITConfig配置

TIM_IT	值	描述
TIM_IT_Update	((uint16_t)0x0001)	更新中断，计数器向上溢出/向下溢出，计数器初始化
TIM_IT_CC1	((uint16_t)0x0002)	捕获/比较中断，CH1
TIM_IT_CC2	((uint16_t)0x0004)	捕获/比较中断，CH2
TIM_IT_CC3	((uint16_t)0x0008)	捕获/比较中断，CH3
TIM_IT_CC4	((uint16_t)0x0010)	捕获/比较中断，CH4
TIM_IT_Trigger	((uint16_t)0x0040)	触发事件(计数器启动、停止、初始化或者由内部/外部触发计数)

输出比较

OC（Output Compare）输出比较
输出比较可以通过比较CNT与CCR寄存器值的关系，来对输出电平进行置1、置0或翻转的操作，用于输出一定频率和占空比的PWM波形
每个高级定时器和通用定时器都拥有4个输出比较通道
高级定时器的前3个通道额外拥有死区生成和互补输出的功能

模式	描述
冻结	CNT=CCR时，REF保持为原状态
匹配时置有效电平	CNT=CCR时，REF置有效电平
匹配时置无效电平	CNT=CCR时，REF置无效电平
匹配时电平翻转	CNT=CCR时，REF电平翻转
强制为无效电平	CNT与CCR无效，REF强制为无效电平
强制为有效电平	CNT与CCR无效，REF强制为有效电平
PWM模式1	向上计数：CNT<CCR时，REF置有效电平，CNT≥CCR时，REF置无效电平`<br>`向下计数：CNT>CCR时，REF置无效电平，CNT≤CCR时，REF置有效电平
PWM模式2	向上计数：CNT<CCR时，REF置无效电平，CNT≥CCR时，REF置有效电平`<br>`向下计数：CNT>CCR时，REF置有效电平，CNT≤CCR时，REF置无效电平

以PWM模式1向上计数为例：

PWM频率：

$$ Freq=\frac{CK_{PSC}}{(PSC+1)(ARR+1)} $$

PWM占空比：

$$ Duty=\frac{CCR}{ARR+1} $$

PWM分辨率：

$$ Reso=\frac{1}{ARR+1} $$

代码

//开启时钟
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

//GPIO初始化
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);

//时钟配置
TIM_InternalClockConfig(TIM2);

//时基单元初始化
TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInitStructure.TIM_Period = 100 - 1;
TIM_TimeBaseInitStructure.TIM_Prescaler = 720 - 1;
TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0;
TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStructure);

//输出比较初始化
TIM_OCInitTypeDef TIM_OCInitStructure;
TIM_OCStructInit(&TIM_OCInitStructure);
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 0;
TIM_OC1Init(TIM2, &TIM_OCInitStructure);

//使能定时器
TIM_Cmd(TIM2, ENABLE);

//CCR设置函数
void PWM_SetCompare1(uint16_t Compare)
{
    TIM_SetCompare1(TIM2, Compare);
}

//ARR设置函数
void PWM_SetAutoreload(uint16_t Autoreload)
{
    TIM_SetAutoreload(TIM2, Autoreload);
}

//PSC设置函数
void PWM_SetPrescaler(uint16_t Prescaler)
{
    TIM_PrescalerConfig(TIM2, Prescaler, TIM_PSCReloadMode_Update);
}

TIM_OCInitTypeDef为输出比较配置结构体

TIM_OCStructInit函数为结构体赋默认值（特别）
TIM_SetComparex函数能设置CCRx寄存器值
TIM_SetAutoreload函数能设置ARR寄存器值
TIM_PrescalerConfig函数能设置PSC寄存器值：

TIM_PSCReloadMode_Immediate立即生效
TIM_PSCReloadMode_Update更新事件后生效

TIM_OCxInit函数能配置OCx通道
TIM_OCMode为输出比较模式
TIM_OCPolarity为输出极性：TIM_OCPolarity_High正常，TIM_OCPolarity_Low翻转
TIM_OutputState为输出使能：TIM_OutputState_Enable开启，TIM_OutputState_Disable关闭
TIM_Pulse为CCR初始值

TIM_OCMode	值	描述
TIM_OCMode_Timing	((uint16_t)0x0000)	冻结
TIM_OCMode_Active	((uint16_t)0x0010)	匹配时置有效电平
TIM_OCMode_Inactive	((uint16_t)0x0020)	匹配时置无效电平
TIM_OCMode_Toggle	((uint16_t)0x0030)	匹配时电平翻转
TIM_OCMode_PWM1	((uint16_t)0x0060)	PWM模式1
TIM_OCMode_PWM2	((uint16_t)0x0070)	PWM模式2

输入捕获

IC（Input Capture）输入捕获
输入捕获模式下，当通道输入引脚出现指定电平跳变时，当前CNT的值将被锁存到CCR中，可用于测量PWM波形的频率、占空比、脉冲间隔、电平持续时间等参
每个高级定时器和通用定时器都拥有4个输入捕获通道
可配置为PWMI模式，同时测量频率和占空比
可配合主从触发模式，实现硬件全自动测量

频率测量

测频法：在闸门时间T内，对上升沿计次，得到N，则频率
$$ f_x = \frac{N}{T} $$
测周法：两个上升沿内，以标准频率fc计次，得到N ，则频率
$$ f_x = \frac{f_c}{N} $$
中界频率：测频法与测周法误差相等的频率点
$$ f_m = \sqrt\frac{f_c}{T} $$

PWMI（测周法）

代码

//配置时钟
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

//配置GPIO
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);

//配置定时器
TIM_InternalClockConfig(TIM3);
TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInitStructure.TIM_Period = 65536 - 1;
TIM_TimeBaseInitStructure.TIM_Prescaler = 72 - 1;
TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0;
TIM_TimeBaseInit(TIM3, &TIM_TimeBaseInitStructure);

//配置捕获通道
TIM_ICInitTypeDef TIM_ICInitStructure;
TIM_ICInitStructure.TIM_Channel = TIM_Channel_1;
TIM_ICInitStructure.TIM_ICFilter = 0xF;
TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
TIM_PWMIConfig(TIM3, &TIM_ICInitStructure);
    //TIM_ICInit(TIM3, &TIM_ICInitStructure);

//配置从模式
TIM_SelectInputTrigger(TIM3, TIM_TS_TI1FP1);
TIM_SelectSlaveMode(TIM3, TIM_SlaveMode_Reset);

//使能定时器
TIM_Cmd(TIM3, ENABLE);

//获取频率
uint32_t IC_GetFreq(void)
{
    return 1000000 / (TIM_GetCapture1(TIM3) + 1);
}

//获取占空比
uint32_t IC_GetDuty(void)
{
    return (TIM_GetCapture2(TIM3) + 1) * 100 / (TIM_GetCapture1(TIM3) + 1);
}

TIM_ICInitTypeDef为输入捕获配置结构体

TIM_Channel为输入通道：TIM_Channel_x(x=1,2,3,4)
TIM_ICFilter为输入滤波器：0x0-0xF
TIM_ICPolarity为输入极性选择
TIM_ICPrescaler为预分频配置
TIM_ICSelection为信号交叉选择
TIM_PWMIConfig函数会对另一通道进行相应配置，TIM_ICInit函数只会配置当前通道
TIM_GetCapturex函数会获取CCRx寄存器的值

计算占空比时，对CCR1和CCR2的值+1的的操作可以避免除0，实际值应为

$$ val_1=CCR1+0.5\quad(\pm0.5) $$$$ val_2=CCR2+0.5\quad(\pm0.5) $$$$ Freq=\frac{CK_{PSC}}{(PSC+1)*val_1} $$$$ Duty=100\%*\frac{val_2}{val_1} $$

主从触发

从模式

1
2

TIM_SelectInputTrigger(TIM3, TIM_TS_TI1FP1);
TIM_SelectSlaveMode(TIM3, TIM_SlaveMode_Reset);

TIM_SelectInputTrigger函数用于配置从模式触发源
TIM_SelectSlaveMode函数用于配置从模式

TIM_InputTriggerSource	值	描述
TIM_TS_ITR0	((uint16_t)0x0000)	Internal Trigger 0
TIM_TS_ITR1	((uint16_t)0x0010)	Internal Trigger 1
TIM_TS_ITR2	((uint16_t)0x0020)	Internal Trigger 2
TIM_TS_ITR3	((uint16_t)0x0030)	Internal Trigger 3
TIM_TS_TI1F_ED	((uint16_t)0x0040)	TI1 Edge Detector
TIM_TS_TI1FP1	((uint16_t)0x0050)	Filtered Timer Input 1
TIM_TS_TI2FP2	((uint16_t)0x0060)	Filtered Timer Input 2
TIM_TS_ETRF	((uint16_t)0x0070)	External Trigger input

TIM_SlaveMode	值	描述
TIM_SlaveMode_Reset	((uint16_t)0x0004)	Rising edge of the selected trigger signal (TRGI) re-initializes`<br>` the counter and triggers an update of the registers.
TIM_SlaveMode_Gated	((uint16_t)0x0005)	The counter clock is enabled when the trigger signal (TRGI) is high.
TIM_SlaveMode_Trigger	((uint16_t)0x0006)	The counter starts at a rising edge of the trigger TRGI.
TIM_SlaveMode_External1	((uint16_t)0x0007)	Rising edges of the selected trigger (TRGI) clock the counter.

主模式

1
2

TIM_SelectMasterSlaveMode(TIM3, TIM_MasterSlaveMode_Enable);
TIM_SelectOutputTrigger(TIM3, TIM_TRGOSource_Update);

TIM_SelectMasterSlaveMode函数用于使能主模式：
- TIM_MasterSlaveMode_Enable开启
- TIM_MasterSlaveMode_Disable关闭
TIM_SelectOutputTrigger函数用于配置触发源

TIM_TRGOSource	值	描述
TIM_TRGOSource_Reset	((uint16_t)0x0000)	The UG bit in the TIM_EGR register is used as the trigger output (TRGO).
TIM_TRGOSource_Enable	((uint16_t)0x0010)	The Counter Enable CEN is used as the trigger output (TRGO).
TIM_TRGOSource_Update	((uint16_t)0x0020)	The update event is selected as the trigger output (TRGO).
TIM_TRGOSource_OC1	((uint16_t)0x0030)	The trigger output sends a positive pulse when the CC1IF flag is to be set, as soon as a capture or compare match occurs (TRGO).
TIM_TRGOSource_OC1Ref	((uint16_t)0x0040)	OC1REF signal is used as the trigger output (TRGO).
TIM_TRGOSource_OC2Ref	((uint16_t)0x0050)	OC2REF signal is used as the trigger output (TRGO).
TIM_TRGOSource_OC3Ref	((uint16_t)0x0060)	OC3REF signal is used as the trigger output (TRGO).
TIM_TRGOSource_OC4Ref	((uint16_t)0x0070)	OC4REF signal is used as the trigger output (TRGO).

编码器接口

Encoder Interface 编码器接口
编码器接口可接收增量（正交）编码器的信号，根据编码器旋转产生的正交信号脉冲，自动控制CNT自增或自减，从而指示编码器的位置、旋转方向和旋转速度
每个高级定时器和通用定时器都拥有1个编码器接口
两个输入引脚借用了输入捕获的通道1和通道2

代码

//配置时钟
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);            RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

//GPIO配置（配置CH1和CH2）
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);

//时基单元配置
TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;            
TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInitStructure.TIM_Period = 65536 - 1;
TIM_TimeBaseInitStructure.TIM_Prescaler = 1 - 1;
TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0;
TIM_TimeBaseInit(TIM3, &TIM_TimeBaseInitStructure);

//通道配置（配置CH1和CH2）
TIM_ICInitTypeDef TIM_ICInitStructure;
TIM_ICStructInit(&TIM_ICInitStructure);
TIM_ICInitStructure.TIM_ICFilter = 0xF;
TIM_ICInitStructure.TIM_Channel = TIM_Channel_1;
TIM_ICInit(TIM3, &TIM_ICInitStructure);
TIM_ICInitStructure.TIM_Channel = TIM_Channel_2;
TIM_ICInit(TIM3, &TIM_ICInitStructure);

//配置编码器接口
TIM_EncoderInterfaceConfig(TIM3, TIM_EncoderMode_TI12, TIM_ICPolarity_Rising, TIM_ICPolarity_Rising);

//使能定时器
TIM_Cmd(TIM3, ENABLE);

int16_t Encoder_Get(void)
{
    // int16_t Temp;
    // Temp = TIM_GetCounter(TIM3);
    // TIM_SetCounter(TIM3, 0);
    // return Temp;
    return TIM_GetCounter(TIM3);
}

TIM_EncoderInterfaceConfig为编码器配置函数
TIM_ICxPolarity参数与通道配置重复
TIM_ICPolarity_Rising代表不反相，TIM_ICPolarity_Falling表示反相

TIM_EncoderMode	值	描述
TIM_EncoderMode_TI1	((uint16_t)0x0001)	Counter counts on TI1FP1 edge depending on TI2FP2 level.
TIM_EncoderMode_TI2	((uint16_t)0x0002)	Counter counts on TI2FP2 edge depending on TI1FP1 level.
TIM_EncoderMode_TI12	((uint16_t)0x0003)	Counter counts on both TI1FP1 and TI2FP2 edges depending on the level of the other input.

STM32简介

Mon, 05 Feb 2024 00:00:00 +0000

STM32

STM32是ST公司基于ARM Cortex-M内核开发的32位微控制器
STM32常应用在嵌入式领域，如智能车、无人机、机器人、无线通信、物联网、工业控制、娱乐电子产品等
STM32功能强大、性能优异、片上资源丰富、功耗低，是一款经典的嵌入式微控制器

ARM

ARM既指ARM公司，也指ARM处理器内核
ARM公司是全球领先的半导体知识产权（IP）提供商，全世界超过95%的智能手机和平板电脑都采用ARM架构
ARM公司设计ARM内核，半导体厂商完善内核周边电路并生产芯片

STM32F103C8T6

系列：主流系列STM32F1
内核：ARM Cortex-M3
主频：72MHz
RAM：20K（SRAM）
ROM：64K（Flash）
供电：2.0~3.6V（标准3.3V）
封装：LQFP48

片上资源/外设

英文缩写	名称
NVIC	嵌套向量中断控制器
SysTick	系统滴答定时器
RCC	复位和时钟控制
GPIO	通用IO口
AFIO	复用IO口
EXTI	外部中断
TIM	定时器
ADC	模数转换器
DMA	直接内存访问
USART	同步/异步串口通信
I2C	I2C通信
SPI	SPI通信
CAN	CAN通信
USB	USB通信
RTC	实时时钟
CRC	CRC校验
PWR	电源控制
BKP	备份寄存器
IWDG	独立看门狗
WWDG	窗口看门狗
DAC	数模转换器
SDIO	SD卡接口
FSMC	可变静态存储控制器
USB OTG	USB主机接口

命名规则

引脚定义

引脚重映射

1
2
3

RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
GPIO_PinRemapConfig(GPIO_PartialRemap1_TIM2, ENABLE);
GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);

使用引脚重映射时，需要开启AFIO时钟
该代码禁用PA15和PB3的JTAG调试，重映射为TIM2

更多PinRemapConfig的相关内容：STM32F10xxx参考手册（中文）.pdf 页码116/手册8.3

启动配置

最小系统电路

RCC时钟树

STM32 EXTI

Fri, 02 Feb 2024 00:00:00 +0000

中断

中断：在主程序运行过程中，出现了特定的中断触发条件（中断源），使得CPU暂停当前正在运行的程序，转而去处理中断程序，处理完成后又返回原来被暂停的位置继续运行
中断优先级：当有多个中断源同时申请中断时，CPU会根据中断源的轻重缓急进行裁决，优先响应更加紧急的中断源
中断嵌套：当一个中断程序正在运行时，又有新的更高优先级的中断源申请中断，CPU再次暂停当前中断程序，转而去处理新的中断程序，处理完成后依次进行返回

STM32中断

68个可屏蔽中断通道，包含EXTI、TIM、ADC、USART、SPI、I2C、RTC等多个外设
使用NVIC统一管理中断，每个中断通道都拥有16个可编程的优先等级，可对优先级进行分组，进一步设置抢占优先级和响应优先级

NVIC

基本结构

优先级分组

NVIC的中断优先级由优先级寄存器的4位（0~15）决定，这4位可以进行切分，分为高n位的抢占优先级和低4-n位的响应优先级
抢占优先级高的可以中断嵌套，响应优先级高的可以优先排队，抢占优先级和响应优先级均相同的按中断号排队

分组方式	抢占优先级	响应优先级	宏	值
分组0	0位，取值为0	4位，取值为0~15	NVIC_PriorityGroup_0	((uint32_t)0x700)
分组1	1位，取值为0~1	3位，取值为0~7	NVIC_PriorityGroup_1	((uint32_t)0x600)
分组2	2位，取值为0~3	2位，取值为0~3	NVIC_PriorityGroup_2	((uint32_t)0x500)
分组3	3位，取值为0~7	1位，取值为0~1	NVIC_PriorityGroup_3	((uint32_t)0x400)
分组4	4位，取值为0~15	0位，取值为0	NVIC_PriorityGroup_4	((uint32_t)0x300)

代码

//NVIC中断优先级分组
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);

//NVIC配置
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = EXTI15_10_IRQn;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_Init(&NVIC_InitStructure);

NVIC_InitTypeDef为NVIC初始化结构体

NVIC_IRQChannel为中断通道 ( IRQChannel )
NVIC_IRQChannelCmd为通道使能：ENABLE为开启，DISABLE为关闭
NVIC_IRQChannelPreemptionPriority为抢占优先级
NVIC_IRQChannelSubPriority为响应优先级中断触发后，将会进入中断函数 void xHandler(void)
EXTI_GetITStatus函数可获取某个中断标志位
EXTI_ClearITPendingBit函数可清除某个中断标志位（<u>必须 </u>）

中断通道（以STM32F10X_MD为准）

NVIC_IRQChannel	值	描述
WWDG_IRQn	0	Window WatchDog Interrupt
PVD_IRQn	1	PVD through EXTI Line detection Interrupt
TAMPER_IRQn	2	Tamper Interrupt
RTC_IRQn	3	RTC global Interrupt
FLASH_IRQn	4	FLASH global Interrupt
RCC_IRQn	5	RCC global Interrupt
EXTI0_IRQn	6	EXTI Line0 Interrupt
EXTI1_IRQn	7	EXTI Line1 Interrupt
EXTI2_IRQn	8	EXTI Line2 Interrupt
EXTI3_IRQn	9	EXTI Line3 Interrupt
EXTI4_IRQn	10	EXTI Line4 Interrupt
DMA1_Channel1_IRQn	11	DMA1 Channel 1 global Interrupt
DMA1_Channel2_IRQn	12	DMA1 Channel 2 global Interrupt
DMA1_Channel3_IRQn	13	DMA1 Channel 3 global Interrupt
DMA1_Channel4_IRQn	14	DMA1 Channel 4 global Interrupt
DMA1_Channel5_IRQn	15	DMA1 Channel 5 global Interrupt
DMA1_Channel6_IRQn	16	DMA1 Channel 6 global Interrupt
DMA1_Channel7_IRQn	17	DMA1 Channel 7 global Interrupt
ADC1_2_IRQn	18	ADC1 and ADC2 global Interrupt
USB_HP_CAN1_TX_IRQn	19	USB Device High Priority or CAN1 TX Interrupts
USB_LP_CAN1_RX0_IRQn	20	USB Device Low Priority or CAN1 RX0 Interrupts
CAN1_RX1_IRQn	21	CAN1 RX1 Interrupt
CAN1_SCE_IRQn	22	CAN1 SCE Interrupt
EXTI9_5_IRQn	23	External Line[9:5] Interrupts
TIM1_BRK_IRQn	24	TIM1 Break Interrupt
TIM1_UP_IRQn	25	TIM1 Update Interrupt
TIM1_TRG_COM_IRQn	26	TIM1 Trigger and Commutation Interrupt
TIM1_CC_IRQn	27	TIM1 Capture Compare Interrupt
TIM2_IRQn	28	TIM2 global Interrupt
TIM3_IRQn	29	TIM3 global Interrupt
TIM4_IRQn	30	TIM4 global Interrupt
I2C1_EV_IRQn	31	I2C1 Event Interrupt
I2C1_ER_IRQn	32	I2C1 Error Interrupt
I2C2_EV_IRQn	33	I2C2 Event Interrupt
I2C2_ER_IRQn	34	I2C2 Error Interrupt
SPI1_IRQn	35	SPI1 global Interrupt
SPI2_IRQn	36	SPI2 global Interrupt
USART1_IRQn	37	USART1 global Interrupt
USART2_IRQn	38	USART2 global Interrupt
USART3_IRQn	39	USART3 global Interrupt
EXTI15_10_IRQn	40	External Line[15:10] Interrupts
RTCAlarm_IRQn	41	RTC Alarm through EXTI Line Interrupt
USBWakeUp_IRQn	42	USB Device WakeUp from suspend through EXTI Line Interrupt

EXTI

基本结构

EXTI（Extern Interrupt）外部中断
EXTI可以监测指定GPIO口的电平信号，当其指定的GPIO口产生电平变化时，EXTI将立即向NVIC发出中断申请，经过NVIC裁决后即可中断CPU主程序，使CPU执行EXTI对应的中断程序
支持的触发方式：上升沿/下降沿/双边沿/软件触发
支持的GPIO口：所有GPIO口，但相同的Pin不能同时触发中断
通道数：16个GPIO_Pin，外加PVD输出、RTC闹钟、USB唤醒、以太网唤醒
触发响应方式：中断响应/事件响应

代码

EXTI_InitTypeDef EXTI_InitStructure;
EXTI_InitStructure.EXTI_Line = EXTI_Line14;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
EXTI_Init(&EXTI_InitStructure);

EXTI_Line为中断线来源
EXTI_LineCmd为中断线使能：ENABLE为开启，DISABLE为关闭
EXTI_Mode为EXTI的模式
EXTI_Trigger为触发边缘

EXTI_Line	值	描述
EXTI_Line0	((uint32_t)0x00001)	External interrupt line 0
EXTI_Line1	((uint32_t)0x00002)	External interrupt line 1
EXTI_Line2	((uint32_t)0x00004)	External interrupt line 2
EXTI_Line3	((uint32_t)0x00008)	External interrupt line 3
EXTI_Line4	((uint32_t)0x00010)	External interrupt line 4
EXTI_Line5	((uint32_t)0x00020)	External interrupt line 5
EXTI_Line6	((uint32_t)0x00040)	External interrupt line 6
EXTI_Line7	((uint32_t)0x00080)	External interrupt line 7
EXTI_Line8	((uint32_t)0x00100)	External interrupt line 8
EXTI_Line9	((uint32_t)0x00200)	External interrupt line 9
EXTI_Line10	((uint32_t)0x00400)	External interrupt line 10
EXTI_Line11	((uint32_t)0x00800)	External interrupt line 11
EXTI_Line12	((uint32_t)0x01000)	External interrupt line 12
EXTI_Line13	((uint32_t)0x02000)	External interrupt line 13
EXTI_Line14	((uint32_t)0x04000)	External interrupt line 14
EXTI_Line15	((uint32_t)0x08000)	External interrupt line 15
EXTI_Line16	((uint32_t)0x10000)	External interrupt line 16 Connected to the PVD Output
EXTI_Line17	((uint32_t)0x20000)	External interrupt line 17 Connected to the RTC Alarm event
EXTI_Line18	((uint32_t)0x40000)	External interrupt line 18 Connected to the USB Device/USB OTG FS Wakeup from suspend event
EXTI_Line19	((uint32_t)0x80000)	External interrupt line 19 Connected to the Ethernet Wakeup event

AFIO

基本结构

AFIO主要用于引脚复用功能的选择和重定义
在STM32中，AFIO主要完成两个任务：复用功能引脚重映射、中断引脚选择

代码

//开启时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
//配置AFIO
GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource14);

GPIO_PortSourceGPIOx为选择的GPIO_Port
GPIO_PinSource为选择的GPIO_Pin

外部中断完整配置流程

配置时钟
1. GPIO时钟 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
2. AFIO时钟 RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
配置GPIO GPIO_Init(GPIOB, &GPIO_InitStructure);
配置AFIO GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource14);
配置EXTI EXTI_Init(&EXTI_InitStructure);
配置NVIC
1. 中断分组 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
2. 中断配置 NVIC_Init(&NVIC_InitStructure);

STM32 GPIO

Wed, 31 Jan 2024 00:00:00 +0000

GPIO概述

GPIO(General Purpose Input Output)通用输入输出口
可配置为8种输入输出模式
引脚电平：0V~3.3V，部分引脚可容忍5V
输出模式下可控制端口输出高低电平，用以驱动LED、控制蜂鸣器、模拟通信协议输出时序等
输入模式下可读取端口的高低电平或电压，用于读取按键输入、外接模块电平信号输入、ADC电压采集、模拟通信协议接收数据等

GPIO详细介绍

GPIO基本结构

所有GPIO都处于APB2总线上，因此使用GPIO时务必开启APB2总线的时钟。

IO口结构

图中错误: 图中TTL肖特基触发器应为TTL施密特触发器

GPIO的不同模式

模式名称	性质	特征
浮空输入	数字输入	可读取引脚电平，若引脚悬空，则电平不确定
上拉输入	数字输入	可读取引脚电平，内部连接上拉电阻，悬空时默认高电平
下拉输入	数字输入	可读取引脚电平，内部连接下拉电阻，悬空时默认低电平
模拟输入	模拟输入	GPIO无效，引脚直接接入内部ADC
开漏输出	数字输出	可输出引脚电平，高电平为高阻态，低电平接VSS
推挽输出	数字输出	可输出引脚电平，高电平接VDD，低电平接VSS
复用开漏输出	数字输出	由片上外设控制，高电平为高阻态，低电平接VSS
复用推挽输出	数字输出	由片上外设控制，高电平接VDD，低电平接VSS

代码实现

结构体

//开启时钟
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
//配置GPIO
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);

GPIO_InitTypeDef为GPIO初始化结构体

GPIO_Mode为GPIO口模式
GPIO_Pin为GPIO引脚编号，和 GPIO_Init的第一个参数共同指定引脚
GPIO_Speed为GPIO工作速度

模式	GPIO_Mode	值
模拟输入	GPIO_Mode_AIN	0x0
浮空输入	GPIO_Mode_IN_FLOATING	0x04
下拉输入	GPIO_Mode_IPD	0x28
上拉输入	GPIO_Mode_IPU	0x48
开漏输出	GPIO_Mode_Out_OD	0x14
推挽输出	GPIO_Mode_Out_PP	0x10
复用开漏输出	GPIO_Mode_AF_OD	0x1C
复用推挽输出	GPIO_Mode_AF_PP	0x18

速度	GPIO_Speed	值
10M	GPIO_Speed_10MHz	1
2M	GPIO_Speed_2MHz	2
50M	GPIO_Speed_50MHz	3

GPIO输出

//方法1
GPIO_ResetBits(GPIOA, GPIO_Pin_0);
GPIO_SetBits(GPIOA, GPIO_Pin_0);

//方法2
GPIO_WriteBit(GPIOA, GPIO_Pin_0, Bit_RESET);
GPIO_WriteBit(GPIOA, GPIO_Pin_0, Bit_SET);

//方法3
GPIO_WriteBit(GPIOA, GPIO_Pin_0, (BitAction)0);
GPIO_WriteBit(GPIOA, GPIO_Pin_0, (BitAction)1);

//方法4
uint16_t data = 0x00;
GPIO_Write(GPIOA, data);

GPIO输入

//方法1
uint8_t data = GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0);

//方法2
uint16_t data = GPIO_ReadInputData(GPIOA);

//读取输出寄存器
uint8_t data = GPIO_ReadOutputDataBit(GPIOA, GPIO_Pin_0);
uint16_t data = GPIO_ReadOutputData(GPIOA);