单片机IO口模拟串口UART

已于 2022-09-02 15:07:02 修改
阅读量2.5k 收藏 18
点赞数 5
文章标签： 单片机 嵌入式硬件 stm32
于 2022-08-15 22:11:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43908815/article/details/125266531
版权

文章目录

一、模拟串口思路

UART使用时一般包含1个起始位、8个数据位、1个停止位，在不发送数据时UART为高电平表示空闲，在空闲模式下出现一个位的低电平表示起始位，紧随其后的是8个数据位和一个停止位，在其9600波特率下一个位的宽度为104微妙。
我的思路是使用一个定时器产生一个位宽时间除去3的中断，除3是因为要对一位进行三次采样以次数多的为准，如三次采样中高电平次数为2次，则为1，低电平次数为2则为0，进行三次采样的原因为防止采样点落在每一位的边沿上，而进行三次采样即使有一次落在边缘上也可以保证数据的准确性。

二、参考程序

1.UART.h

/** 
 * @Author: 时间世纪
 * @Date: 2022-08-15 15:53:26
 * @Description: 模拟串口,应定时调用UART_S_ReadDrive，UART_S_SendDrive函数，
 * UART_S_SendDrive定时时间为 1秒 / 想要的波特率
 * UART_S_ReadDrive定时时间为 1秒 / 想要的波特率 / 3，除3是因为对1bit要进行三次采样以次数多的为准，如三次采样中高电平次数为2次，则为高电平
 * 否则为低电平，进行三次采样的原因为防止采样点落在bit的边缘上，而进行三次采样即使有一次落在边缘上也可以保证数据的准确性，不建议超过9600波特率
 * 如想要9600波特率，则定时时间为1秒 / 9600 / 3 = 34.7us，所以UART_S_ReadDrive为每34us调用一次，UART_S_SendDrive为每102us调用一次
 * 如果想要4800波特率，则定时时间为1秒 / 4800 / 3 = 69.4us，所以UART_S_ReadDrive为每69us调用一次，UART_S_SendDrive为每207us调用一次
 * 如果想要1200波特率，则定时时间为1秒 / 1200 / 3 = 277.7us，所以UART_S_ReadDrive为每277us调用一次，UART_S_SendDrive为每831us调用一次
 * 如果两片单片机全部使用模拟串口通信也可以自定义波特率时间
 */

#ifndef _UART_H_
#define _UART_H_

#include "HAL_Driver.h"
#include <stdio.h>
#include <stdarg.h>

typedef struct
{
    HAL_GPIO_TypeDef TX;
    HAL_GPIO_TypeDef RX;
    uint16_t RxState : 3;//发送状态
    uint16_t RxTestCnt : 3;//读取IO计数
    uint16_t RxHighCnt : 3;//高电平计数
    uint16_t RxBitCnt : 4;//接收位计数
    uint16_t RxReserve : 3;//保留
    uint8_t RxData;//接收数据
    uint8_t TxState : 3;//发送状态
    uint8_t TxBitCnt : 4;//发送位计数
    uint8_t TxBusy : 1;//发送忙标志
    uint8_t TxData;//发送数据
    uint8_t *TxBuf;//发送缓冲区
    uint8_t TxBufLen;//发送缓冲区长度
    uint8_t TxHeadIndex;//发送缓冲区头指针
    uint8_t TxTailIndex;//发送缓冲区尾指针
    uint8_t TxBufDataCnt;//发送缓冲区数据个数
    void (*ReadCallback)(void *self, uint8_t dat);//读取回调函数
    void (*ReadErrorCallback)(void *self, uint8_t errcode);//读取错误回调函数
} UART_S_TypeDef;


/** 
 * @brief 初始化一个模拟串口
 * @param UART_S_TypeDef *pUART
 * @param uint8_t *TxBuf
 * @param uint8_t TxBufLen
 * @retval 
 */
void UART_S_Init(UART_S_TypeDef * const pUART, uint8_t *TxBuf, uint8_t TxBufLen);
/** 
 * @brief 发送一个字节
 * @param UART_S_TypeDef *pUART
 * @param uint8_t dat
 * @retval 0:成功 1:失败
 */
uint8_t UART_S_SendByte(UART_S_TypeDef * const pUART, uint8_t dat);
/** 
 * @brief 发送数据
 * @param UART_S_TypeDef *pUART
 * @param uint8_t *dat
 * @param uint8_t len
 * @retval 发送的字节数
 */
uint8_t UART_S_SendBytes(UART_S_TypeDef * const pUART, uint8_t *dat, uint8_t len);
/** 
 * @brief 发送字符串
 * @param UART_S_TypeDef *pUART
 * @param uint8_t *dat
 * @retval 发送的字节数
 */
uint8_t UART_S_SendString(UART_S_TypeDef * const pUART, uint8_t *dat);
/** 
 * @brief 格式化发送字符串
 * @param UART_S_TypeDef *pUART
 * @param char *fmt
 * @retval: 
 */
uint8_t UART_S_Printf(UART_S_TypeDef * const pUART, const char *fmt, ...);
/** 
 * @brief 模拟串口接收驱动
 * @param UART_S_TypeDef *pUART
 * @retval 发送的字节数
 */
void UART_S_ReadDrive(UART_S_TypeDef * const pUART);
/** 
 * @brief 模拟串口发送驱动
 * @param UART_S_TypeDef *pUART
 * @retval: 
 */
void UART_S_SendDrive(UART_S_TypeDef * const pUART);

#endif

2.UART.c

#include "UART.h"

/**
 * @brief 初始化一个模拟串口
 * @param UART_S_TypeDef *pUART
 * @param uint8_t *TxBuf 发送缓冲区
 * @param uint8_t TxBufLen 发送缓冲区长度
 * @retval:
 */
void UART_S_Init(UART_S_TypeDef *const pUART, uint8_t *TxBuf, uint8_t TxBufLen)
{
    if(pUART->TX.GPIO_CLK != 0)
    {
        HAL_GPIO_Init(&pUART->TX);
        HAL_GPIO_SetOutput(&pUART->TX);
    }
    if(pUART->RX.GPIO_CLK != 0)
    {
        HAL_GPIO_Init(&pUART->RX);
        HAL_GPIO_SetInput(&pUART->RX);
    }
    pUART->RxState = 0;
    pUART->RxTestCnt = 0;
    pUART->RxHighCnt = 0;
    pUART->RxBitCnt = 0;
    pUART->RxData = 0;
    pUART->TxState = 0;
    pUART->TxBitCnt = 0;
    pUART->TxBusy = 0;
    pUART->TxHeadIndex = 0;
    pUART->TxTailIndex = 0;
    pUART->TxBufDataCnt = 0;
    pUART->TxBuf = TxBuf;
    pUART->TxBufLen = TxBufLen;
}

/** 
 * @brief 换相变换RX、TX，可能导致未知风险，使用场景为一根线通信时将其中一个设置为0，另一个设置为IO口
 * @param UART_S_TypeDef *pUART
 * @retval
 */
static void UART_S_ChangeIO(UART_S_TypeDef * const pUART)
{
    HAL_GPIO_TypeDef temp;
    temp = pUART->RX;
    pUART->RX = pUART->TX;
    pUART->TX = temp;
    if(pUART->TX.GPIO_CLK != 0)
        HAL_GPIO_SetOutput(&pUART->TX);
    if(pUART->RX.GPIO_CLK != 0)
        HAL_GPIO_SetInput(&pUART->RX);
    pUART->RxState = 0;//重置状态
    pUART->RxTestCnt = 0;
    pUART->RxHighCnt = 0;
    pUART->RxBitCnt = 0;
    pUART->RxData = 0;
    pUART->TxState = 0;
    pUART->TxBitCnt = 0;
    pUART->TxBusy = 0;
    pUART->TxHeadIndex = 0;
    pUART->TxTailIndex = 0;
    pUART->TxBufDataCnt = 0;
}

/**
 * @brief 发送一个字节
 * @param UART_S_TypeDef *pUART
 * @param uint8_t dat
 * @retval 0:成功 1:失败
 */
uint8_t UART_S_SendByte(UART_S_TypeDef *const pUART, uint8_t dat)
{
    uint8_t cnt = 0;
    do
    {
        if (pUART->TxBusy) //如果在忙状态，就填充进缓存中
        {
            if (pUART->TxBufDataCnt < pUART->TxBufLen)
            {
                pUART->TxBuf[pUART->TxHeadIndex] = dat;
                if (++pUART->TxHeadIndex == pUART->TxBufLen)
                {
                    pUART->TxHeadIndex = 0;
                }
                pUART->TxBufDataCnt++;
                return 0;
            }
        }
        else
        {
            pUART->TxData = dat;
            pUART->TxBusy = 1;
            return 0;
        }
        Delay_ms(1);
    } while (++cnt < 10);
    return 1;
}

/**
 * @brief 发送数据
 * @param UART_S_TypeDef *pUART
 * @param uint8_t *dat
 * @param uint8_t len
 * @retval 发送的字节数
 */
uint8_t UART_S_SendBytes(UART_S_TypeDef *const pUART, uint8_t *dat, uint8_t len)
{
    for (uint8_t i = 0; i < len; i++)
    {
        if (UART_S_SendByte(pUART, dat[i]))
        {
            return i;
        }
    }
    return len;
}

/**
 * @brief 发送字符串
 * @param UART_S_TypeDef *pUART
 * @param uint8_t *dat
 * @retval 发送的字节数
 */
uint8_t UART_S_SendString(UART_S_TypeDef *const pUART, uint8_t *dat)
{
    uint8_t len = 0;
    while (*dat)
    {
        if (UART_S_SendByte(pUART, *dat++))
        {
            return len;
        }
        len++;
    }
    return len;
}

/**
 * @brief 格式化发送字符串
 * @param UART_S_TypeDef *pUART
 * @param char *fmt
 * @retval 发送的字节数
 */
uint8_t UART_S_Printf(UART_S_TypeDef *const pUART, const char *fmt, ...)
{
    uint8_t buf[50];
    va_list args;
    va_start(args, fmt);
    uint8_t len = vsnprintf((char *)buf, 50, fmt, args);
    va_end(args);
    return UART_S_SendBytes(pUART, pUART->TxBuf, len);
}

/**
 * @brief 模拟串口接收驱动
 * @param UART_S_TypeDef *pUART
 * @retval
 */
void UART_S_ReadDrive(UART_S_TypeDef *const pUART)
{
    switch (pUART->RxState)
    {
    case 0:
        if (pUART->RX.GPIO_CLK != 0 && HAL_GPIO_Read(&pUART->RX) == 0) //检测到开始位
        {
            pUART->RxState = 1;
        }
        break;
    case 1:
        if (HAL_GPIO_Read(&pUART->RX) == 0) //第二次检测到开始位，转入接收数据
        {
            pUART->RxBitCnt = 0;
            pUART->RxHighCnt = 0;
            pUART->RxData = 0;
            pUART->RxTestCnt = 0;
            pUART->RxState = 1;
        }
        else
        {
            pUART->RxState = 0;
        }
        break;
    case 2: //读取数据位
        if (HAL_GPIO_Read(&pUART->RX) != 0)
        {
            pUART->RxHighCnt++;
        }
        if (++pUART->RxTestCnt >= 3) //检测一个Bit位三次
        {
            pUART->RxTestCnt = 0;
            pUART->RxData >>= 1;
            if (pUART->RxHighCnt >= 2) //如果有两次位高就为高电平
            {
                pUART->RxData |= 0x80;
            }
            pUART->RxHighCnt = 0;
            if (++pUART->RxBitCnt >= 8)
            {
                pUART->RxBitCnt = 0;
                pUART->RxState = 3;
            }
        }
        break;
    case 3: //检测通停止位
        if (HAL_GPIO_Read(&pUART->RX) != 0)
        {
            pUART->RxHighCnt++;
        }
        pUART->RxTestCnt++;
        if (pUART->RxTestCnt == 2) //在第二次检测停止位时如果高电平检测到的次数为0次，那么就丢弃这次数据
        {
            if (pUART->RxHighCnt == 0)
            {
                if (pUART->ReadErrorCallback)
                {
                    pUART->ReadErrorCallback(pUART, 1);
                }
                pUART->RxState = 0;
            }
        }
        else if (pUART->RxTestCnt >= 3)
        {
            if (pUART->RxHighCnt >= 2) //大于两次认为接收成功
            {
                if (pUART->ReadCallback)
                {
                    pUART->ReadCallback(pUART, pUART->RxData);
                }
                pUART->RxState = 0;
            }
        }
        break;
    }
}

/**
 * @brief 模拟串口发送驱动
 * @param UART_S_TypeDef *pUART
 * @retval:
 */
void UART_S_SendDrive(UART_S_TypeDef *const pUART)
{
    switch (pUART->TxState)
    {
    case 0: //发送开始位
        if (pUART->TxBusy == 1)
        {
            HAL_GPIO_Low(&pUART->TX);
            pUART->TxState = 1;
        }
        break;
    case 1: //发送数据位
        if (pUART->RxData & 0x01)
        {
            HAL_GPIO_High(&pUART->TX);
        }
        else
        {
            HAL_GPIO_Low(&pUART->TX);
        }
        pUART->RxData >>= 1;
        if (++pUART->TxBitCnt >= 8)
        {
            pUART->TxBitCnt = 0;
            pUART->TxState = 2;
        }
        break;
    case 2: //发送停止位
        HAL_GPIO_High(&pUART->TX);
        if (pUART->TxBufDataCnt > 0)
        {
            if (++pUART->TxTailIndex >= pUART->TxBufLen)
            {
                pUART->TxTailIndex = 0;
            }
            pUART->TxBufDataCnt--;
            if (pUART->TxHeadIndex == pUART->TxTailIndex)
            {
                pUART->TxBusy = 0;
            }
            else
            {
                pUART->TxData = pUART->TxBuf[pUART->TxTailIndex];
            }
        }
        else
        {
            pUART->TxBusy = 0;
        }
        pUART->TxState = 0;
        break;
    }
}

3.程序地址

时间世纪
关注
  • 5
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
普通IO模拟串口
07-01
外部中断模拟串口，波特率不能超过65536 实验测试：发送57600可以正常，但接收只能 <= 38400 #include "Uart_EXT0.h" #include "MAIN.h" #define FOCS 22114800ul bit Over; bit bRxflag; unsigned char IEN0_NOW,IEN1_NOW; //中断临时变量 unsigned char idata bRxstate=0; //接收状态 unsigned char idata tmp_Len=0; //缓存数组下标 unsigned char idata bRxlen; //接收字节数 unsigned char xdata EX_buf[64]; //接收存放区 /*************************************************** baud = 56000 接收一字节 =178.6us ，接收会出现错误 baud = 38400 接收一字节 =260.4us //快速接收都容易出现错误 baud = 19200 接收一字节 =520us | baud = 14400 接收一字节 =694.5us | baud = 9600 接收一字节 =1041.6us | baud = 4800 接收一字节 =2.083ms 接收过长，定时器MODE2无法满足 //主机发送的数据最好加上校验字 发送：最大57600，发送还能正常。 ****************************************************/ void Time0_Uart(unsigned int baud) { TMOD &= 0XF0; TMOD |= 0X02; //使用定时器0方式2，使用方式1则2400波特也能有 TH0 = 256-(FOCS/12)/baud; TL0 = TH0; IP0 |= 0x02; //设置为最高优先级 IP1 |= 0x02; TR0 = 1; ET0 = 1; EA = 1; } void Time0_isr() interrupt 1 { //方式1则重装值 Over = 1; } /* 发送数据，1起始位，8数据，1停止位 发送波特率实验57600都不会错误，大量发送数据待测试 */ void Uart_set(unsigned char dat) { unsigned char i; Over = 0; TL0 = TH0; //防止发送数据开始时不知道TL0是多少 T_uart = 0; //起始位 while(Over==0); Over = 0; for(i=0;i>= 1; } // Over = 0; //数据位清零了 T_uart = 1; //停止位，此后如果没有数据则一直为高 while(Over==0); } unsigned char get_Uart() { unsigned char I=0,get_dat=0; Over = 0; TL0 = TH0; //重新赋值，防止出错 while(Over==0); Over = 0; for(I=0;I>= 1; if(Get_ex == 1) get_dat |= 0x80; else get_dat &= 0x7f; while(Over==0); Over = 0; } if(Get_ex == 1) { Over = 0; } return get_dat; } void EXuart_isr() interrupt 0 { unsigned char _chr; IEN0_NOW = IEN0; //进入接收1字节，关闭中断 IEN1_NOW = IEN1; IEN0 = 0X82; IEN1 = 0; _chr=get_Uart(); switch(bRxstate) { case 0: if(_chr==0x55) { bRxstate=1; } else bRxstate=0; break; case 1: if(_chr==0xaa) { bRxstate=2; } else bRxstate=0; break; case 2: //取得数据长度 bRxlen=_chr; bRxstate=3; break; case 3: EX_buf[tmp_Len]=_chr; tmp_Len++; if(tmp_Len==bRxlen) { bRxstate=0; tmp_Len=0; bRxflag=1; //一帧数据接收完毕，置位完成标志位 } break; default: break; } IE0 = 0; //清外部0中断标志，防止下次接收不到 IEN0 = IEN0_NOW; IEN1 = IEN1_NOW; } void main() { Time0_Uart(9600); EX_uart(); if(bRxflag==1) { bRxflag = 0; for(i=0;i<10;i++) RevBuffer[i] = EX_buf[i]; T0Uart_TX(10,RevBuffer); } }
使用单片机普通IO口模拟串口的三种方法
04-01
使用单片机普通IO口模拟串口的三种方法,延时法,计数法,中断法.
串口通信（通过stc模拟与电脑通信）
qq_53922901的博客
01-22 984
差分信号即通过两根线的电压差与地线比较。
单片机GPIO口模拟串口接收
weixin_45817947的博客
08-02 1060
做项目时，因为AT32F413CCU7串口不够用（已经用了3个串口），还有模块需要用到串口，所以做了一个模拟串口发送与接收的接口。用到的单片机外设有：GPIO定时器、外部中断。串口接收时不阻塞，但只存一帧数据（因为只对模块进行少量数据的读写，所以不做消息队列，用回调函数处理）串口发送时存在短暂阻塞（只发几帧数据，懒得去搞不阻塞的情况了）。因为是软件模拟，可能存在些许差错（波特率低时很少遇到，波特率高时需要调节定时器中断时间），所以拓展可以做字符串比较strncmp或者CRC校验。
基于stm32的USB模拟UART的实现
最新发布
weixin_44317448的博客
04-28 1081
使用stm32进行usb模拟串口的方案示例。
用51单片机模拟SPI串口通信#双机通信#C语言#
2301_80415757的博客
01-20 863
模拟SPI串口通信协议，用51单片机实现双机通信
单片机软件模拟串口
weixin_47768836的博客
01-18 8011
单片机IO模拟串口通信(收发）
单片机IO模拟串口协议
心城追梦的博客
08-27 1284
嵌入式硬件平台调试中常用的debug方法是看串口打印定位问题，但有时候会遇到单片机没有串口外设或者串口引脚被占用的情况，这时候也可以在代码里操作空闲的IO输出不同个数的脉冲来达到调试的效果，但是要用逻辑分析仪抓线逐个看波形比较费劲。既然都IO抖线了，干脆抖个串口协议出来算了，通过控制IO口电平变化模拟串口协议。
IO口模拟UART串口通信，量产代码分享
weixin_42401119的博客
12-28 5400
有些产品需要用到多个UART串口，而单片机UART数量不足，这时需要用IO口模拟UART通讯。 本文采用IO口+定时器+外部中断的方法，模拟UART时序，实现串口接收和发送的功能，程序已经在量产产品上应用了。 实现原理： 1、发送部分，通过定时器控制波特率，改变IO口电平来发送数据，比较简单。 2、接收部分，通过外部中断，识别起始位，定时器控制波特率，使IO口恰好在电平信号的中间位置读取数据，减少其他中断的影响，大大降低误码率。 注意事项： 1、目前本程序只适用于接收数据定长的情况，不定长数据不
51单片机——串口通信，小白讲解，相互学习
songbo1010的博客
03-04 7822
串口通信
STM32之IO模拟串口篇
Qurry的博客
07-26 5407
硬件基于stm32f767igt6水星板开发；软件使用了RT-Thread实时操作系统，两个空闲IO口。PE2用作串口TX端，搭配一个定时器控制发送时序；PE3用作串口RX端，并使能外部中断，触发外部中断则开启一个接收定时器。GitHub代码下载地址空闲位当uart处于空闲状态（线路没有数据传输）时，TX、RX线都处于高电平状态（逻辑“1”），一般需要把相应IO口配置为上拉。起始位由高电平跳变为低电平，且持续一个位宽度，表示触发起始信号。数据位发送状态分为空闲和发送中；...
51单片机串口通讯原理深入理解及程序源码，使用单片机IO模拟串口功能扩展串口-----day8
shishiston的博客
03-03 2387
51单片机串口通讯原理深入理解及程序源码，使用单片机IO模拟串口功能扩展串口-----day8
使用单片机IO模拟串口发送
minge1991的博客
10-20 946
波形解析（9600波特率） 如下图所示，一个bit的时间间隔为104us，波特率 = 1秒/104us = 9615左右，与波特率9600接近，偏差是由于策略误差导致。 波形生成。 首先应该有一个定时器产生104us硬件定时中断，在中断中通过控制io口电平发送数据。 （1）配置定时器位104us。 （2）1byte波形生成。 （3）发送函数。 （4）用软件定时器10ms周期读取缓存到发送1byte的数据字节。 （5）硬件定时器...
单片机IO口模拟UART串口通信程序
07-15
本文主要讲了单片机IO口模拟UART串口通信程序，希望对你的学习有所帮助。
PIC18F IO口 模拟 串口UART
11-16
单片机 PIC18F 用IO口模拟串口UART 亲自验证成功 ，已经用于项目中。分享给大家，共同学习。
模拟串口uart，适用没有串口功能的单片机
10-19
一些简单的单片机没有串口可以发送数据出来查看，比如不能看AD的数据，可以通过这种方法模拟串口发送数据出来，使用的是1个IO口，8M的频率。
普通单片机IO口模拟UART程序
09-20
利用单片机IO口模拟UART程序，系统用了一个定时器和一个外部中断，外部中断主要是用来检测串口起始位的到来。 利用单片机IO口模拟UART程序，系统用了一个定时器和一个外部中断，外部中断主要是用来检测串口起始位的...
单片机IO口模拟串口程序
08-08
前一阵一直在做单片机的程序，由于串口不够，需要用IO口来模拟出一个串口。经过若干曲折并参考了一些现有的资料，基本上完成了。现在将完整的测试程序，以及其中一些需要总结的部分贴出来。 程序硬件平台：11.0592M...
51单片机IO口模拟串口.pdf
11-11
《51单片机IO口模拟串口技术详解》 在许多嵌入式系统的设计中，51单片机因其性价比高、应用广泛而被大量使用。然而，51单片机的一个常见局限是其串行接口（UART）的数量有限，有时只有一个。这在需要多个串口通信的...
IO模拟UART发送函数定时器
06-07
好的，以下是一个基于定时器和GPIO模拟UART发送的函数： ```c void uart_send(char data) { // 设置GPIO为输出模式 GPIO_InitTypeDef gpio_init; gpio_init.Pin = GPIO_PIN_0; // 使用GPIOA的Pin 0 gpio_init.Mode = GPIO_MODE_OUTPUT_PP; gpio_init.Pull = GPIO_NOPULL; gpio_init.Speed = GPIO_SPEED_FREQ_LOW; HAL_GPIO_Init(GPIOA, &gpio_init); // 设置定时器 TIM_HandleTypeDef tim_init; tim_init.Instance = TIM2; tim_init.Init.Prescaler = 7200-1; // 10kHz的计数频率 tim_init.Init.CounterMode = TIM_COUNTERMODE_UP; tim_init.Init.Period = 100-1; // 100个计数器周期，即10ms tim_init.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; HAL_TIM_Base_Init(&tim_init); HAL_TIM_Base_Start(&tim_init); // 发送起始位 HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_RESET); HAL_Delay(1); // 延时1ms，等待UART接收端准备好 HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET); HAL_Delay(1); // 发送数据位（8位） for (int i = 0; i < 8; ++i) { if (data & (1 << i)) { HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_RESET); } else { HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET); } HAL_TIM_Base_Start(&tim_init); while (TIM2->CNT < 50); // 延时5ms，模拟时序 TIM2->CNT = 0; // 重置计数器 } // 发送停止位 HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_RESET); HAL_TIM_Base_Start(&tim_init); while (TIM2->CNT < 50); // 延时5ms，模拟时序 TIM2->CNT = 0; // 重置计数器 HAL_GPIO_WritePin(GPIOA, GPIO_PIN_0, GPIO_PIN_SET); HAL_Delay(1); // 发送完成后延时1ms } ``` 这个函数以一个字符作为参数，模拟发送一个UART数据包。其中使用GPIO模拟UART的发送线路，使用定时器模拟UART的时序。具体来说，通过`HAL_GPIO_WritePin()`函数控制GPIO的输出，通过`HAL_Delay()`函数和定时器的计数器模拟UART时序。需要注意的是，这个函数中的定时器配置和计数器值都是根据具体的硬件环境来设定的，需要根据实际情况进行调整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值