USART

发布于 2023-08-11  1083 次阅读

内容纲要

USART串口笔记

通信接口

通信的目的：将一个设备的数据传送到另一个设备，扩展硬件系统

通信协议：制定通信的规则，通信双方按照协议规则进行数据收发

串口通信

硬件电路

电平标准

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

•TTL电平：+3.3V或+5V表示1，0V表示0

•RS232电平：-3~-15V表示1，+3~+15V表示0

•RS485电平：两线压差+2~+6V表示1，-2~-6V表示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框图

简单了解即可

数据包

包头包尾人为规定

HEX数据包

HEX数据包接收

USART基本结构

打通步骤

一、RCC开启时钟

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); //正点原子精英版V2的串口是PA9和PA10，所以打开GPIOA的时钟

二、GPIO初始化

把TX配置成复用输出，RX配置成输入

    // TX初始化设置
    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);
    // RX初始化设置
    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);

三、配置USART

    USART_InitTypeDef USART_InitStructure;
    USART_InitStructure.USART_BaudRate = 9600; // 波特率
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; // 硬件流控制（None为不使用流控）
    USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx; // 串口模式（Tx发送模式或Rx接收模式）
    USART_InitStructure.USART_Parity = USART_Parity_No; // 校验位（无校验）
    USART_InitStructure.USART_StopBits = USART_StopBits_1; // 停止位
    USART_InitStructure.USART_WordLength = USART_WordLength_8b; // 字长（8位）
    USART_Init(USART1, &USART_InitStructure);

四、配置中断

无需接收功能可跳过，该配置用于数据包接收

Init函数
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); // 开启RXNE标志位到NVIC的输出

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); // 分组

    NVIC_InitTypeDef NVIC_InitStructure; // NVIC初始化
    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);
中断函数
void USART1_IRQHandler(void)
{
    static uint8_t RxState = 0; // 标志当前状态变量
    static uint8_t pRxPacket = 0; // 接收到哪个
    if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET) // 判断标志位
    {
        uint8_t RxData = USART_ReceiveData(USART1); // 获取当前数据

        if (RxState == 0) // 等待包头
        {
            if (RxData == 0xFF) // 收到包头
            {
                RxState = 1; 
                pRxPacket = 0; 
            }
        }
        else if (RxState == 1) // 接收数据
        {
            Serial_RxPacket[pRxPacket] = RxData; // 将RxData存在接收数组里
            pRxPacket ++; // 移动到下一个位置
            if (pRxPacket >= 4) // 数据接收完  // 4为接收数据长度
            {
                RxState = 2;
            }
        }
        else if (RxState == 2) // 等待包尾
        {
            if (RxData == 0xFE)
            {
                RxState = 0; // 回到最初状态
                Serial_RxFlag = 1; // 置接收完成标志位
            }
        }

        USART_ClearITPendingBit(USART1, USART_IT_RXNE); // 清除标志位
    }
}

五、开启USART

    USART_Cmd(USART1, ENABLE);

部分API

void USART_DeInit(USART_TypeDef* USARTx);
void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct);
void USART_StructInit(USART_InitTypeDef* USART_InitStruct);
void USART_ClockInit(USART_TypeDef* USARTx, USART_ClockInitTypeDef* USART_ClockInitStruct); // 配置同步时钟输出
void USART_ClockStructInit(USART_ClockInitTypeDef* USART_ClockInitStruct); // 配置同步时钟输出
void USART_Cmd(USART_TypeDef* USARTx, FunctionalState NewState);
void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT, FunctionalState NewState);
void USART_DMACmd(USART_TypeDef* USARTx, uint16_t USART_DMAReq, FunctionalState NewState); // 开启USART到DMA的触发通道
void USART_SetAddress(USART_TypeDef* USARTx, uint8_t USART_Address); // 设置地址
void USART_WakeUpConfig(USART_TypeDef* USARTx, uint16_t USART_WakeUp); // 唤醒
void USART_ReceiverWakeUpCmd(USART_TypeDef* USARTx, FunctionalState NewState); 
void USART_LINBreakDetectLengthConfig(USART_TypeDef* USARTx, uint16_t USART_LINBreakDetectLength);
void USART_LINCmd(USART_TypeDef* USARTx, FunctionalState NewState);
void USART_SendData(USART_TypeDef* USARTx, uint16_t Data);
uint16_t USART_ReceiveData(USART_TypeDef* USARTx);
void USART_SendBreak(USART_TypeDef* USARTx);
void USART_SetGuardTime(USART_TypeDef* USARTx, uint8_t USART_GuardTime);
void USART_SetPrescaler(USART_TypeDef* USARTx, uint8_t USART_Prescaler);
void USART_SmartCardCmd(USART_TypeDef* USARTx, FunctionalState NewState);
void USART_SmartCardNACKCmd(USART_TypeDef* USARTx, FunctionalState NewState);
void USART_HalfDuplexCmd(USART_TypeDef* USARTx, FunctionalState NewState);
void USART_OverSampling8Cmd(USART_TypeDef* USARTx, FunctionalState NewState);
void USART_OneBitMethodCmd(USART_TypeDef* USARTx, FunctionalState NewState);
void USART_IrDAConfig(USART_TypeDef* USARTx, uint16_t USART_IrDAMode);
void USART_IrDACmd(USART_TypeDef* USARTx, FunctionalState NewState);
FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG);
void USART_ClearFlag(USART_TypeDef* USARTx, uint16_t USART_FLAG);
ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint16_t USART_IT);
void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint16_t USART_IT);

代码部分

使用开关控制串口传输实验

串口模块
#include "stm32f10x.h"                  // Device header

uint8_t Serial_TxPacket[4];             
uint8_t Serial_RxPacket[4];
uint8_t Serial_RxFlag; // 接收标志位

void Serial_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); //开启时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

    GPIO_InitTypeDef GPIO_InitStructure; // 配置GPIO口
    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);

    USART_InitTypeDef USART_InitStructure; // 配置USART串口
    USART_InitStructure.USART_BaudRate = 9600;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Tx;
    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); // 开启RXNE标志位到NVIC的输出

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); // 分组

    NVIC_InitTypeDef NVIC_InitStructure; // NVIC初始化
    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_Cmd(USART1, ENABLE); // 开启USART
}

void Serial_SendByte(uint8_t Byte) // 发送数据函数
{
    USART_SendData(USART1, Byte); // 发送数据
    while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET); // 等待标志位
}

void Serial_SendArray(uint8_t *Array, uint16_t Length) // 发送数组函数
{
    uint16_t i;
    for (i = 0; i < Length; i ++) // for循环循环length次，对数组进行遍历
    {
        Serial_SendByte(Array[i]); // 发送单个数据
    }
}

void Serial_SendString(char *String) // 发送字符串函数
{
    uint8_t i;
    for (i = 0; String[i] != '\0'; i ++) // for循环循环length次，对数组进行遍历
    {
        Serial_SendByte(String[i]); // 发送单个数据
    }
}

uint32_t Serial_Pow(uint32_t X, uint32_t Y) // 次方函数，为下面的发送数字函数服务
{
    uint32_t Result = 1;
    while (Y --)
    {
        Result *= X;
    }
    return Result;
}

void Serial_SendNumber(uint32_t Number, uint8_t Length) // 发送数字函数
{
    uint8_t i;
    for (i = 0; i < Length; i ++)
    {
        Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');
    }
}

uint8_t Serial_GetRxFlag(void) // 读后自动清除
{
    if (Serial_RxFlag == 1)
    {
        Serial_RxFlag = 0;
        return 1;
    }
    return 0;
}

void Serial_SendPacket(void)
{
    Serial_SendByte(0xFF); // 发送包头
    Serial_SendArray(Serial_TxPacket, 4); // 依次发送4个载荷数据
    Serial_SendByte(0xFE);
}

void USART1_IRQHandler(void)
{
    static uint8_t RxState = 0; // 标志当前状态变量
    static uint8_t pRxPacket = 0; // 接收到哪个
    if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET) // 判断标志位
    {
        uint8_t RxData = USART_ReceiveData(USART1); // 获取当前数据

        if (RxState == 0) // 等待包头
        {
            if (RxData == 0xFF) // 收到包头
            {
                RxState = 1; 
                pRxPacket = 0; 
            }
        }
        else if (RxState == 1) // 接收数据
        {
            Serial_RxPacket[pRxPacket] = RxData; // 将RxData存在接收数组里
            pRxPacket ++; // 移动到下一个位置
            if (pRxPacket >= 4) // 数据接收完  // 4为接收数据长度
            {
                RxState = 2;
            }
        }
        else if (RxState == 2) // 等待包尾
        {
            if (RxData == 0xFE)
            {
                RxState = 0; // 回到最初状态
                Serial_RxFlag = 1; // 置接收完成标志位
            }
        }

        USART_ClearITPendingBit(USART1, USART_IT_RXNE); // 清除标志位
    }
}
Key模块
#include "stm32f10x.h"                  // Device header
#include "Delay.h"

void Key_Init(void){
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE,ENABLE); //时钟初始化

    GPIO_InitTypeDef GPIO_InitStructure; //初始化GPIO口
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //采用上拉输入
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_4;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOE,&GPIO_InitStructure);
}

uint8_t Key_GetNum(void){
    uint8_t KeyNum = 0;
    if(GPIO_ReadInputDataBit(GPIOE,GPIO_Pin_3) == 0){ //按下时判断式子为0，即返回值为1，识别按键1成功
        Delay_ms(20); //延迟消抖
        while(GPIO_ReadInputDataBit(GPIOE,GPIO_Pin_3) == 0);
        Delay_ms(20);
        KeyNum = 1;
    }
    if(GPIO_ReadInputDataBit(GPIOE,GPIO_Pin_4) == 0){ //按下时判断式子为0，即返回值为2，识别按键2成功
        Delay_ms(20);
        while(GPIO_ReadInputDataBit(GPIOE,GPIO_Pin_4) == 0);
        Delay_ms(20);
        KeyNum = 2;
    }
    return KeyNum;
}
主函数模块
#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "Serial.h"
#include "Key.h"

uint8_t KeyNum;

int main(void)
{
    Key_Init();
    Serial_Init();

    Serial_TxPacket[0] = 0x01;
    Serial_TxPacket[1] = 0x02;
    Serial_TxPacket[2] = 0x03;
    Serial_TxPacket[3] = 0x04;

    while (1)
    {
        KeyNum = Key_GetNum();
        if (KeyNum == 1)
        {
            Serial_TxPacket[0] ++; // 通过控制按键使数据包数据自增
            Serial_TxPacket[1] ++;
            Serial_TxPacket[2] ++;
            Serial_TxPacket[3] ++;

            Serial_SendPacket(); // 取出数组内容并发送（加上包头包尾）
        }

        if (Serial_GetRxFlag() == 1) // 若收到数据包
        {

        }
    }
}
世界のネズミは彼らが望むものに依存し、彼らは彼ら自身から誰も求めません
最后更新于 2023-08-27
啥也没有呀