普通IO口模拟串口-滤波实现

已于 2023-04-26 13:47:49 修改
阅读量545 收藏 2
点赞数
文章标签： stm32 单片机 mcu
于 2023-04-26 11:59:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47867622/article/details/130382594
版权

原创文章

原创作者文章

修改内容

1、功能定义模块化，提高移植性了，白嫖党福音，拿来就是直接用！！！
2、因为资源不够用将定时器修改为系统定时器
3、修改采样位置，这个看实际情况调整的
4、增加接收超时处理
5、增加接收时间采样补偿，这个看实际情况调整的
6、因为利用定时器进行收发，在发送时需要停止接收事件

SIMU_UART.c 串口初始化

函数外部接口指针，串口参数初始化

#include "SIMU_UART.h"

#if(SIMU_UART_SRC == SIMU_METHOD1)
#include "simu_uart1.h"
#elif(SIMU_UART_SRC == SIMU_METHOD2)
#include "simu_uart2.h"
#elif(SIMU_UART_SRC == SIMU_METHOD3)
// #include "simu_uart3.h"
#endif

SIMU_UART simu_uart = {0};
volatile UART gsUARTBuff = {0}; // 定义串口
UART_KEY_MSG desk_key_msg = {0};

void simu_uart_init(void)
{
    simu_uart.baudrate = BAUDRATE;
    simu_uart.data_bits = 8;
    simu_uart.stop_bits = 1; // 这个默认
    simu_uart.parity = 0;

#if(SIMU_UART_SRC == SIMU_METHOD1)
    
    simu_uart.ext_irq = UART_EXT_IRQ_METHOD1;
    simu_uart.timer_irq = UART_TIM_IRQ_METHOD1;
    simu_uart.write = UART_Write_Data_API_METHOD1;
    simu_uart.read = UART_Read_Data_API_METHOD1;
    UART_Init_METHOD1(simu_uart);
#elif(SIMU_UART_SRC == SIMU_METHOD2)

    simu_uart.ext_irq = UART_EXT_IRQ_METHOD2;
    simu_uart.timer_irq = UART_TIM_IRQ_METHOD2;
    simu_uart.write = UART_Write_Data_API_METHOD2;
    simu_uart.read = UART_Read_Data_API_METHOD2;
    UART_Init_METHOD2(simu_uart);
#elif(SIMU_UART_SRC == SIMU_METHOD3)

#endif
    
}

void over_time_open_rx(void)
{
    // 当处于工作状态超过1000ms就超时恢复接收状态
    if(gsUARTBuff.UartStat != COM_NONE_BIT_DEAL && (++gsUARTBuff.over_rx_time > 1000))
    {
        gsUARTBuff.over_rx_time = 0;
        gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
        gsUARTBuff.RxEn = 0;
        gsUARTBuff.TxEn = 0;
#if(SIMU_UART_SRC == SIMU_METHOD1)
        UART_TIM_ENABLE_METHOD1(0, 0);
        UART_EXT_ENABLE_METHOD1(1);
#elif(SIMU_UART_SRC == SIMU_METHOD2)
        UART_TIM_ENABLE_METHOD2(0, 0);
        UART_EXT_ENABLE_METHOD2(1);
#endif
    }
}
// 测试
void simu_uart_test(void)
{
    uint8_t databuff[40] = {0}, len = 0;
    static uint16_t delay_time = 0;

    if(++delay_time > 2000)
    {
        delay_time = 0;

        len = simu_uart.read(databuff, 40);
        
        if(len)
        {
            simu_uart.write(databuff, len);
        }
    }
}

void uart_data_process(uint8_t *data, uint16_t size)
{
    uint8_t cmd_sta = CMD_FRAME_STA, len = 0, j = 0, data_buff[7] = {0};
    uint16_t check_sum = 0;

    for(uint16_t i = 0; i < size; i++)
    {
        switch (cmd_sta)
        {
        case CMD_FRAME_STA:
            if(data[i] == 0x55)
                cmd_sta = CMD_LEN_STA;
            /* code */
            break;
        case CMD_LEN_STA:
            len = data[i];
            check_sum = 0;

            cmd_sta = CMD_FRAME_STA; // 如果校验和不过就重新开始
            if(i + len < size - 1)
            {
                for(j = i; j <= i + len; j++)
                {
                    check_sum += data[j];
                }

                if(check_sum & 0xff == data[j])
                    cmd_sta = CMD_DATA_STA;
            }
            break;
        case CMD_DATA_STA:
            memcpy(data_buff, &data[i], len);
            i += len - 1;
            cmd_sta = COM_CHECK_BIT_DEAL;
            break;
        case COM_CHECK_BIT_DEAL:
            cmd_sta = CMD_FRAME_STA;
            break;    
        default:
            break;
        }
    }

    memcpy(&desk_key_msg, data_buff, 7);
}

SIMU_UART.h

#ifndef _SIMU_UART_H_
#define _SIMU_UART_H_

#include "stdint.h"
#include "AppInclude.h"

#define     SIMU_METHOD1    0
#define     SIMU_METHOD2    1    
#define     SIMU_METHOD3    2
#define     SIMU_UART_SRC     SIMU_METHOD1

#define SYSTICK_TIM_ENABLE  1
#define TIM_SRC_FREQ    96 * 1000000  // 时钟频率，单位：Hz
#define TIM_PRESCALER   1 // 默认1
#define BAUDRATE        9600
#define DATA_BUFF_LEN   100

#define TX_IO(x)      if(x){SetPB6();}else{ResetPB6();}

#define RX_IO       ReadPB0()

#define TEST_IO(x)     if(x){SetPC5();}else{ResetPC5();}

#define TEST_IO_DELAY(x)   {TEST_IO(1);DelayUs(x);TEST_IO(0);DelayUs(x);}
        
#define MAX(x,y) ((x) > (y) ? (x) : (y))
#define MIN(x,y) ((x) > (y) ? (y) : (x))
#define COMPARE(x, y) ((x) == (y) ? 1 : 0)      
        
typedef struct
{
    uint16_t baudrate;
    uint8_t data_bits;
    uint8_t stop_bits;
    uint8_t parity;

    void (*timer_irq)(void);
    void (*ext_irq)(void);
    uint8_t (*write)(uint8_t *data, uint16_t size);
    uint16_t (*read)(uint8_t *data, uint16_t size);
}SIMU_UART;

typedef enum
{
    COM_NONE_BIT_DEAL = 0,
    COM_START_BIT_DEAL,
    COM_DATA_BIT_DEAL,
    COM_CHECK_BIT_DEAL,
    COM_STOP_BIT_DEAL,
}UART_RX_STA;

typedef enum
{
    // CMD_NONE_STA = 0,
    CMD_FRAME_STA = 0,
    CMD_LEN_STA,
    CMD_DATA_STA,
    CMD_CHECK_STA,
}UART_PRO_STA;

typedef struct
{
    uint8_t CheckType;
    uint8_t DataBits;

    uint8_t UartStat;
    uint8_t TxEn;
    uint8_t RxEn;

    uint8_t UART_Send_buf[DATA_BUFF_LEN];
    uint8_t UART_Recv_buf[DATA_BUFF_LEN];

    uint16_t Sendlength;
    uint16_t Recvlength;

    float BaudTime;

    uint16_t curren_time;
    uint16_t over_rx_time;
}UART;

typedef struct
{
    uint8_t height;
    uint8_t Key_1_sta;
    uint8_t Key_2_sta;
    uint8_t Key_3_sta;
    uint8_t Key_s_sta;
    uint8_t Key_up_sta;
    uint8_t Key_down_sta;
}UART_KEY_MSG;

void simu_uart_init(void);
void simu_uart_test(void);
void over_time_open_rx(void);
void uart_data_process(uint8_t *data, uint16_t size);

extern SIMU_UART simu_uart;

extern volatile UART gsUARTBuff;

extern UART_KEY_MSG desk_key_msg;
#endif

simu_uart1.c 模拟串口实现

一些io初始化

/*
// 使用通用定时器和外部中断：外部中断触发启动接收，三次接收滤波。定时器负责接收、发送。
// 定时时钟源48M，分频后定时器3M
*/

#include "simu_uart1.h"
// 定时器加载值
static uint32_t TimeSet[5];

// 时间,第一个是调节开始采集数据的位置
float TimeSetBuff[][5] = {
    {250, 20, 20, 793.33, 833.33}, // 1200
    {100, 20, 20, 376.67, 416.67},  // 2400
    {30, 20, 20, 168.33, 208.33},    // 4800
    {5, 20, 20, 64.17, 104.17},    // 9600
    {0, 0, 0, 0, 0},            // 预留
};

// 时间
// float TimeSetBuff[][5] = {
//     {400, 20, 20, 793.33, 833.33}, // 1200
//     {180, 20, 20, 376.67, 416.67},  // 2400
//     {80, 20, 20, 168.33, 208.33},    // 4800
//     {50, 10, 10, 84.17, 104.17},    // 9600
//     {0, 0, 0, 0, 0},            // 预留
// };

static uint8_t ucRecvData = 0;    // 每次接收的字节
static uint8_t ucAcquCx = 0;      // 三次滤波计数
static uint8_t ucRecvBitCx = 0;   // 接收位计数
static uint8_t ucSendBitCx = 0;   // 发送位计数
static uint8_t ucSendLengCx = 0;  // 发送长度计数
static uint8_t ucRecvBitBuff = 0; // 采集位保存
static uint8_t time_offset = 0;

#if (!SYSTICK_TIM_ENABLE)
TIM_HandleTypeDef htim6;
#endif
/*******************************************************************************
 * @FunctionName   : UART_TIM_Init_METHOD1.
 * @Description    : 定时器初始化.
 * @Input          : 定时器时间.
 * @Output         : None.
 * @Return         : None.
 * @Author&Data    : MrShuCai  2019.4.11.
 *******************************************************************************/
void UART_TIM_Init_METHOD1(uint32_t time)
{
#if (SYSTICK_TIM_ENABLE)
#if (TIM_PRESCALER > 1)
    /*
    code systick分频代码
    */
#endif

    // 初始化为波特率时间：us
    if (time <= 0xFFFFFFUL)
    {
        SysTick->LOAD = (uint32_t)time; /* set reload register */

        NVIC_SetPriority(SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */

        SysTick->VAL = 0UL; /* Load the SysTick Counter Value  | (1UL << 0)*/
        SysTick->CTRL = (1UL << 2) | (1UL << 1);
        
    }
#else
    __HAL_RCC_TIM6_CLK_ENABLE();

    htim6.Instance = TIM6;
    htim6.Init.Prescaler = 15;
    htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim6.Init.Period = time;
    htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;

    HAL_NVIC_SetPriority(TIM6_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(TIM6_IRQn);

    HAL_TIM_Base_Init(&htim6);
#endif
}

/*******************************************************************************
 * @FunctionName   : UART_GPIO_Init_METHOD1.
 * @Description    : 串口模拟io口初始化.
 * @Input          : None.
 * @Output         : None.
 * @Return         : None.
 * @Author&Data    : MrShuCai  2019.4.11.
 *******************************************************************************/
void UART_GPIO_Init_METHOD1(void)
{
    SetInputModePB0();
    SetPullUpPB0();

    SetOutputModePB6();
    SetPullUpPB6();

    SetOutputModePC5();
    SetPullUpPC5();

    rSYSTEM1.per1.csbscl_gpio_sel = 0;

}
/*******************************************************************************
 * @FunctionName   : UART_Rx_Ext_Init_METHOD1.
 * @Description    : 串口模拟io口所用中断初始化.
 * @Input          : None.
 * @Output         : None.
 * @Return         : None.
 * @Author&Data    : MrShuCai  2019.4.11.
 *******************************************************************************/
void UART_Rx_Ext_Init_METHOD1(void)
{
	rSYSTEM2.per0.ext_intr2_level_edge_sel = 1;		// 选择边沿触发
	rSYSTEM2.per0.ext_intr2_rise_falling_sel = 1;	// 下降沿触发
	
	rINTR.sts.ext_intr2 = 1;						// 请中断
	rINTR.mask.ext_intr2 = 1;						// 开中断

	NVIC_SetPriority(ExtIntr2_IRQ,1);
	NVIC_ClearPendingIRQ(ExtIntr2_IRQ);
	NVIC_EnableIRQ(ExtIntr2_IRQ);
}
/*******************************************************************************
 * @FunctionName   : UART_Init_METHOD1.
 * @Description    : 模拟串口结构体初始化.
 * @Input          : 串口参数结构体.
 * @Output         : None.
 * @Return         : None.
 * @Author&Data    : MrShuCai  2019.4.11.
 *******************************************************************************/
void UART_Init_METHOD1(SIMU_UART simu_uart)
{
    float temp_buff[5] = {0};

    gsUARTBuff.CheckType = simu_uart.parity;
    gsUARTBuff.DataBits = simu_uart.data_bits;

    gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;

    if (simu_uart.baudrate == 1200)
    {
        memcpy(temp_buff, &TimeSetBuff[0][0], sizeof(temp_buff));
    }
    else if (simu_uart.baudrate == 2400)
    {
        memcpy(temp_buff, &TimeSetBuff[1][0], sizeof(temp_buff));
    }
    else if (simu_uart.baudrate == 4800)
    {
        memcpy(temp_buff, &TimeSetBuff[2][0], sizeof(temp_buff));
    }
    else if (simu_uart.baudrate == 9600)
    {
        memcpy(temp_buff, &TimeSetBuff[3][0], sizeof(temp_buff));
    }

    for (uint8_t i = 0; i < 5; i++)
    {
        TimeSet[i] = (uint32_t)(TIM_SRC_FREQ / TIM_PRESCALER / 1000000.0 * temp_buff[i] + 0.5 - 1);
    }

    time_offset = (uint8_t)(TIM_SRC_FREQ / TIM_PRESCALER / 1000000.0);

    UART_GPIO_Init_METHOD1();

    UART_Rx_Ext_Init_METHOD1();

    UART_TIM_Init_METHOD1(TimeSet[TimeSendStep]);

}

/*******************************************************************************
 * @FunctionName   : UART_EXT_IRQ_METHOD1.
 * @Description    : 接收引脚外部中断，下降沿触发，触发后即进入起始位判断.
 * @Input          : None.
 * @Output         : None.
 * @Return         : None.
 * @Author&Data    : MrShuCai  2019.4.11.
 *******************************************************************************/
void UART_EXT_IRQ_METHOD1(void)
{
    /*
    // 清除中断标志等操作
    // if (__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_4) != RESET)
    // {
    //     __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
    //     flag = 1;
    // }
    */

    static uint8_t flag = 1;
    
    if (gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
    {
        gsUARTBuff.over_rx_time = 0;

        gsUARTBuff.RxEn = 1;
        ucRecvData = 0;
        ucRecvBitCx = 0;
        gsUARTBuff.UartStat = COM_START_BIT_DEAL;
        // buff溢出进行重新初始化索引
        if(gsUARTBuff.Recvlength >= DATA_BUFF_LEN)
            gsUARTBuff.Recvlength = 0;

        UART_EXT_ENABLE_METHOD1(0); // 接收先屏蔽事件

        UART_TIM_ENABLE_METHOD1(1, TimeSet[TimeRecvStartStep1]);
    }
}

/*******************************************************************************
 * @FunctionName   : UART_TIM_IRQ_METHOD1.
 * @Description    : 中断处理函数，包括发送和接收两部分.
 * @Input          : None.
 * @Output         : None.
 * @Return         : None.
 * @Author&Data    : MrShuCai  2019.4.11.
 *******************************************************************************/
void UART_TIM_IRQ_METHOD1(void)
{
    /*
    // 清除中断标志等操作
    // HAL_TIM_IRQHandler(&htim6); // This function handles TIM interrupts requests.
    */

    UART_Send_Data_METHOD1();

    UART_Recv_Data_METHOD1();

}

/*******************************************************************************
 * @FunctionName   : UART_Send_Data_METHOD1.
 * @Description    : 发送数据.
 * @Input          : None.
 * @Output         : None.
 * @Return         : None.
 * @Author&Data    : MrShuCai  2019.4.11.
 *******************************************************************************/
void UART_Send_Data_METHOD1(void)
{
    if (gsUARTBuff.TxEn == 1) /*数据发送，发送优先，无发送后才进入接收状态*/
    {
        switch (gsUARTBuff.UartStat) /*串口发送位状态判断*/
        {
        // 启动位
        case COM_START_BIT_DEAL:
        {
            TX_IO(0);                               // 拉低初始化io
            gsUARTBuff.UartStat = COM_DATA_BIT_DEAL; // 进入下个阶段
            ucSendBitCx = 0;                         // 初始化发送记数
        }
        break;
        // 数据位
        case COM_DATA_BIT_DEAL:
        {
            TX_IO((gsUARTBuff.UART_Send_buf[ucSendLengCx] >> ucSendBitCx) & 0x01);

            ucSendBitCx++;

            if (ucSendBitCx >= gsUARTBuff.DataBits)
            {
                if (gsUARTBuff.CheckType == 0)
                {
                    gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
                }
                else
                {
                    gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
                }
            }
        }
        break;

        case COM_CHECK_BIT_DEAL:
        {
        }
        break;

        case COM_STOP_BIT_DEAL:
        {
            TX_IO(1); // 拉高停止

            ucSendBitCx = 0;

            // 判断是否发送结束
            if (ucSendLengCx < gsUARTBuff.Sendlength - 1)
            {
                gsUARTBuff.UartStat = COM_START_BIT_DEAL;
                ucSendLengCx++;
            }
            else
            {
                ucSendLengCx = 0;
                gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
                gsUARTBuff.TxEn = 0;
                gsUARTBuff.RxEn = 1;

                UART_TIM_ENABLE_METHOD1(0, 0);
                UART_EXT_ENABLE_METHOD1(1);
            }
        }
        break;

        default:
            break;
        }
    }
}

/*******************************************************************************
 * @FunctionName   : UART_Send_Data_METHOD1.
 * @Description    : 接收数据.
 * @Input          : None.
 * @Output         : None.
 * @Return         : None.
 * @Author&Data    : MrShuCai  2019.4.11.
 *******************************************************************************/
void UART_Recv_Data_METHOD1(void)
{
    if (gsUARTBuff.RxEn == 1)
    {
        
        switch (gsUARTBuff.UartStat)
        {
        case COM_START_BIT_DEAL:
        {
            
            // 接收保存
            ucRecvBitBuff = (ucRecvBitBuff << 1) | (RX_IO & 0x01);

            if (++ucAcquCx >= 3)
            {   
                // 启动位-拉低，否则无效
                if (BitValueChk(ucRecvBitBuff) == 0)
                {
                    gsUARTBuff.UartStat = COM_DATA_BIT_DEAL;
                    UART_TIM_CTRL_METHOD1(TimeSet[ucAcquCx]);
                }
                else
                {
                    gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
                }

                ucRecvBitBuff = 0;
                ucAcquCx = 0;
            }
            else
            {
                UART_TIM_CTRL_METHOD1(TimeSet[ucAcquCx]); // 修改重载值
            }
        }
        break;

        case COM_DATA_BIT_DEAL: // 数据位
        {

            ucRecvBitBuff = (ucRecvBitBuff << 1) | (RX_IO & 0x01);

            if (++ucAcquCx >= 3)
            {   
                ucRecvData |= (BitValueChk(ucRecvBitBuff) & 0x01) << ucRecvBitCx;

                if (ucRecvBitCx >= gsUARTBuff.DataBits - 1)
                {
                    ucRecvBitCx = 0;

                    if (gsUARTBuff.CheckType == 0)
                    {
                        gsUARTBuff.UartStat = COM_STOP_BIT_DEAL;
                    }
                    else
                    {
                        gsUARTBuff.UartStat = COM_CHECK_BIT_DEAL;
                    }
                }
                else
                {
                    ucRecvBitCx++;
                }

                UART_TIM_CTRL_METHOD1(TimeSet[ucAcquCx]);
                ucAcquCx = 0;
                ucRecvBitBuff = 0;
            }
            else
            {
                UART_TIM_CTRL_METHOD1(TimeSet[ucAcquCx]);
            }
        }
        break;

        case COM_CHECK_BIT_DEAL: // 校验位
        {
        }
        break;

        case COM_STOP_BIT_DEAL: // 停止位
        {

            ucRecvBitBuff = (ucRecvBitBuff << 1) | (RX_IO & 0x01);

            if (++ucAcquCx >= 3)
            {   
                // 空闲-拉高，否则重新记数获取停止位
                if (BitValueChk(ucRecvBitBuff) == 1)
                {
                    if (gsUARTBuff.Recvlength < DATA_BUFF_LEN)
                    {
                        gsUARTBuff.UART_Recv_buf[gsUARTBuff.Recvlength] = ucRecvData;
                        gsUARTBuff.Recvlength++;

                        
                    }

                    gsUARTBuff.UartStat = COM_NONE_BIT_DEAL;
                    gsUARTBuff.RxEn = 0;
                    UART_TIM_ENABLE_METHOD1(0, 0);
                    UART_EXT_ENABLE_METHOD1(1);
                }
                else
                {
                    ucAcquCx = 0;
                }

                ucRecvBitBuff = 0;
                ucAcquCx = 0;
            }
            else
            {
                UART_TIM_CTRL_METHOD1(TimeSet[ucAcquCx]);
            }
        }
        break;

        default:
            break;
        }
    }
}

/*******************************************************************************
 * @FunctionName   : UART_TIM_ENABLE_METHOD1.
 * @Description    : 定时器使用前后使能.
 * @Input          : 是否使能，初始化时间（适用使能）.
 * @Output         : None.
 * @Return         : None.
 * @Author&Data    : MrShuCai  2019.4.11.
 *******************************************************************************/
void UART_TIM_ENABLE_METHOD1(uint8_t flag, uint32_t time)
{
#if (SYSTICK_TIM_ENABLE)
    if (flag)
    {
        if(SysTick->CTRL & 0x01)
            SysTick->CTRL &= ~(1UL << 0);

        SysTick->LOAD = (uint32_t)time;
        SysTick->VAL = 0UL;
        SysTick->CTRL |= (1UL << 0);
    }
    else
    {
        SysTick->CTRL &= ~(1UL << 0);
        SysTick->VAL = 0UL;
    }
#else
    if (flag)
    {
        TIM6->ARR = time;
        TIM6->EGR = TIM_EGR_UG;

        HAL_TIM_Base_Start_IT(&htim6);
    }
    else
    {
        HAL_TIM_Base_Stop_IT(&htim6);
        TIM6->CNT = 0;
    }
#endif
}

/*******************************************************************************
 * @FunctionName   : UART_TIM_CTRL_METHOD1.
 * @Description    : 定时器重加载.
 * @Input          : 初始化时间.
 * @Output         : None.
 * @Return         : None.
 * @Author&Data    : MrShuCai  2019.4.11.
 *******************************************************************************/
void UART_TIM_CTRL_METHOD1(uint32_t time)
{
    time = TimeSet_Offset(time);

#if (SYSTICK_TIM_ENABLE)
    // if(SysTick->CTRL & 0x01)
    //     SysTick->CTRL &= ~(1UL << 0);

    SysTick->LOAD = (uint32_t)time;

    // SysTick->CTRL |= (1UL << 0);
    // UART_TIM_ENABLE_METHOD1(1, time); // 这里有些奇异，如果重启会不准，和清空记数有关
#else
    TIM6->ARR = time;
#endif
}

/*******************************************************************************
 * @FunctionName   : UART_EXT_ENABLE_METHOD1.
 * @Description    : 定时器使用前后使能.
 * @Input          : 是否使能.
 * @Output         : None.
 * @Return         : None.
 * @Author&Data    : MrShuCai  2019.4.11.
 *******************************************************************************/
void UART_EXT_ENABLE_METHOD1(uint8_t flag)
{
    if (flag)
    {
        rINTR.sts.ext_intr2 = 1;						// 请中断
        rINTR.mask.ext_intr2 = 1;						// 开中断

        // EXTI->IMR |= 0x10;
        // EXTI->EMR |= 0x10;
    }
    else
    {
        rINTR.sts.ext_intr2 = 1;						// 请中断
        rINTR.mask.ext_intr2 = 0;						// 关中断

        // EXTI->IMR &= ~(0x10); // 中断屏蔽
        // EXTI->EMR &= ~(0x10); // 事件屏蔽
    }
}

/*******************************************************************************
 * @FunctionName   : UART_Write_Data_API_METHOD1.
 * @Description    : 模拟串口发送数据接口.
 * @Input          : 数据，数据长度.
 * @Output         : None.
 * @Return         : 发送状态.
 * @Author&Data    : MrShuCai  2019.4.11.
 *******************************************************************************/
uint8_t UART_Write_Data_API_METHOD1(uint8_t *data, uint16_t size)
{
    if (gsUARTBuff.UartStat == COM_NONE_BIT_DEAL)
    {
        gsUARTBuff.over_rx_time = 0;
        // memcpy(gsUARTBuff.UART_Send_buf, data, size);

        if(DATA_BUFF_LEN < size)
            size = DATA_BUFF_LEN;

        gsUARTBuff.Sendlength = size;
        for(uint16_t i = 0; i < size; i++)
        {
            gsUARTBuff.UART_Send_buf[i] = data[i];
        }
        
        ucSendLengCx = 0;
        gsUARTBuff.TxEn = 1;
        gsUARTBuff.RxEn = 0;
        gsUARTBuff.UartStat = COM_START_BIT_DEAL;
        // 发送前一定要屏蔽接收中断，要不然发送时基会被打乱
        UART_EXT_ENABLE_METHOD1(0);
        UART_TIM_ENABLE_METHOD1(1, TimeSet[TimeSendStep]);

        return 1;
    }

    return 0;
}

/*******************************************************************************
 * @FunctionName   : UART_Read_Data_API_METHOD1.
 * @Description    : 模拟串口读取数据接口初始化.
 * @Input          : 数据.
 * @Output         : 接收数据.
 * @Return         : 数据长度.
 * @Author&Data    : MrShuCai  2019.4.11.
 *******************************************************************************/
uint16_t UART_Read_Data_API_METHOD1(uint8_t *data, uint16_t size)
{
    if (gsUARTBuff.UartStat == COM_NONE_BIT_DEAL && gsUARTBuff.Recvlength)
    {
        gsUARTBuff.over_rx_time = 0;
        // memcpy(data, gsUARTBuff.UART_Recv_buf, gsUARTBuff.Recvlength);

        if(gsUARTBuff.Recvlength < size)
            size = gsUARTBuff.Recvlength;

        for(uint16_t i = 0; i < size; i++)
        {
            data[i] = gsUARTBuff.UART_Recv_buf[i];
        }

        gsUARTBuff.Recvlength = 0;

        return size;
    }
    return 0;
}

/*******************************************************************************
 * @FunctionName   : BitValueChk.
 * @Description    : 判断采集bit值，三次中为1的次数大于等于2则值为1否则为0.
 * @Input          : n 采集记录的位值.
 * @Output         : BitValue.
 * @Return         : BitValue.
 * @Author&Data    : MrShuCai  2019.5.1.
 *******************************************************************************/
uint8_t BitValueChk(uint8_t n)
{
    uint8_t BitValCx = 0;

    for (BitValCx = 0; n; n >>= 1)
    {
        BitValCx += n & 0x01;
    }

    return (BitValCx < 2) ? (0) : (1);
}


uint32_t TimeSet_Offset(uint32_t time)
{
#if(BAUDRATE == 9600)
    if(ucRecvBitCx > 6)
    {
        if(ucAcquCx == 1 || ucAcquCx == 2)
        {
            time -= time_offset * (ucRecvBitCx - 1);
        }
        else if(ucAcquCx == 3)
        {
            time += time_offset * (ucRecvBitCx - 1) * 2;
        }
    }
#endif

    return time;
    
}

simu_uart1.h

#ifndef _SIMU_UART1_H_
#define _SIMU_UART1_H_

#include "stdint.h"
#include "string.h"
#include "SIMU_UART.h"

typedef enum
{
    TimeRecvStartStep1 = 0,
    TimeRecvStep1 = 1,
    TimeRecvStep2 = 2,
    TimeRecvStep3 = 3,
    TimeSendStep = 4,

}TimeStep;

void UART_EXT_ENABLE_METHOD1(uint8_t flag); // 外部中断事件使能

void UART_TIM_ENABLE_METHOD1(uint8_t flag, uint32_t time); // 定时器使用前后使能

void UART_TIM_CTRL_METHOD1(uint32_t time);

void UART_TIM_IRQ_METHOD1(void); // 定时器中断

void UART_EXT_IRQ_METHOD1(void); // 外部中断

void UART_GPIO_Init_METHOD1(void); // 串口模拟io口初始化

void UART_TIM_Init_METHOD1(uint32_t time); // 定时器配置

void UART_Rx_Ext_Init_METHOD1(void); // 串口模拟io口所用中断初始化

void UART_Init_METHOD1(SIMU_UART simu_uart); // 串口初始化

void UART_Send_Data_METHOD1(void); // 发送数据

void UART_Recv_Data_METHOD1(void); // 接收数据

uint8_t BitValueChk(uint8_t n); // 滤波
uint32_t TimeSet_Offset(uint32_t time);

uint8_t UART_Write_Data_API_METHOD1(uint8_t *data, uint16_t size); // 发送数据
uint16_t UART_Read_Data_API_METHOD1(uint8_t *data, uint16_t size); // 接收数据

#endif

说明

此文章主要用于学习记录，如有违规引用，请联系博主删除。

晓江口
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用GPIO来模拟UART
weixin_56646002的博客
06-28 5204
本文使用32的两个IO口来模拟串口，可以缓解芯片串口外设紧张的问题。
单片机IO口模拟串口UART
weixin_43908815的博客
08-15 2628
模拟串口
RS232电路中的RC滤波器
ShineRoyal
09-06 2692
先盗一波滤波器的图： 一阶RC滤波器电路图如上，截止频率公式为：f=1/(2πRC) 如R=51Ω，C=22uF，则截止频率f=141Hz。意味着，高通RC滤波器会对低于141Hz的信号起抑制作用。低通滤波器会对高于141Hz的信号起抑制作用。（实际运用时，要留有余量，因为到达截止频率时，信号已经产生了3dB衰减，一般选取的截止频率值要比实际有用信号的最高频率稍大一些） 那么设计的原理图如下...
USB接口EMC设计方案
兰陵笑笑生SD的博客
02-26 1860
USB接口EMC设计方案 一、 接口概述 USB 通用串行总线（英文：Universal Serial Bus，简称USB）是连接外部装置的一个串口汇流排标准，在计算机上使用广泛，但也可以用在机顶盒和游戏机上，补充标准On-The-Go（ OTG）使其能够用于在便携装置之间直接交换资料。USB接口的电磁兼容性能关系到设备稳定行与数据传输的准确性，下面从接口原理图、结构设计，线缆设计三个方面来设计USB2.0接口的EMC设计方案 二、 接口电路 原理图的EMC设计 USB 2.0接口防静电设计 图1
一种基于IO口的模拟串口（LOG）实现方法
darin_wang的博客
11-18 815
一种基于IO口的模拟串口（LOG）实现方法
stm32f103zet6普通IO口模拟串口
03-13
通过以上步骤，我们便能成功地在STM32F103ZET6上使用普通GPIO口模拟串口通信，实现与其它设备的交互。这种技术在资源有限的嵌入式系统中非常实用，可以极大地扩展STM32的串口通信能力。提供的MDK工程文件则可以帮助...
单片机学习--单片机IO扩展
02-24
4. 串行接口扩展：如I2C、SPI、UART等，这些串行通信协议能够以较少的引脚数量实现多个IO口的控制。比如I2C总线只需要两根线（SDA和SCL）就能连接多个IO扩展设备。 在实际应用中，我们还需要考虑IO口的电平匹配、...
Stm32 IO口直接驱动OV7670 V1.0(keil)_OV7670STM32_Stm32IO口直接驱动OV7670_
10-03
STM32 IO口直接驱动OV7670摄像头程序是一个技术含量较高的项目，涉及到嵌入式系统、微控制器编程以及图像传感器的知识。STM32是一款基于ARM Cortex-M内核的微控制器，而OV7670则是一款常用的CMOS图像传感器，常用于...
Linear推出可兼容IO-Link PHY的工业收发器LT3669
01-20
IO-Link是一种开放的串行通信标准，它允许设备与控制系统之间进行双向通信，简化了现场设备的配置和诊断。LT3669作为IO-Link PHY的兼容收发器，是构建IO-Link网络的关键组件。它集成了一个高效的降压型开关稳压器和...
cm4io-product-brief_hardware_
09-30
2. **I/O端口**：扩展板提供了哪些额外的输入/输出接口，如GPIO引脚、串行接口（UART）、SPI、I2C、模拟输入/输出、数字输入/输出等。 3. **电源管理**：扩展板如何处理电源输入，是否支持不同电压范围，是否有过载...
单片机IO口模拟UART串口通信程序
07-15
本文主要讲了单片机IO口模拟UART串口通信程序，希望对你的学习有所帮助。
普通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口模拟串口的三种方法,延时法,计数法,中断法.
一种非常适合单片机的滤波算法
07-14
单片机大多资源小，算法占用的资源越小越好，现在介绍就是一个占用很小资源的算法，这个算法是本人在进行扫描仪设计，实现灰度转二值时实现动态阈值，当时为了跟踪灰度等级的变化，需要一个灰度积分跟踪电路，开始使用一个电容积分电路，用灰度信号对电容充电，放电时以该电容电压的比例进行，实现对输入信号的跟踪，但用电容的电路设计比较复杂。过后发现这种比例放电的思想用软件实现非常简单，且具有积分、微分的作用。
PIC18F IO口 模拟 串口UART
11-16
单片机 PIC18F 用IO口模拟串口UART 亲自验证成功 ，已经用于项目中。分享给大家，共同学习。
STM32 IO口模拟串口
qq_39436581的博客
04-01 2329
在做IO口模拟串口试验之前要搞懂串口通信的原理。一般的串行通信是以10位数据为一帧传送数据，包括一位起始位，8位数据位，一位停止位。 在传送数据之前，引脚一直抱保持高电平，起始位是低电平，接着跟8位数据，最后将电平拉高。 那么在模拟发送数据时，首先将IO口的电平置一。 void RCC_Configuration(void) { SystemInit(); RCC_APB2PeriphClockC...
单片机IO模拟串口协议
心城追梦的博客
08-27 1337
嵌入式硬件平台调试中常用的debug方法是看串口打印定位问题，但有时候会遇到单片机没有串口外设或者串口引脚被占用的情况，这时候也可以在代码里操作空闲的IO输出不同个数的脉冲来达到调试的效果，但是要用逻辑分析仪抓线逐个看波形比较费劲。既然都IO抖线了，干脆抖个串口协议出来算了，通过控制IO口电平变化模拟串口协议。
IO口模拟UART串口通信，量产代码分享
weixin_42401119的博客
12-28 5477
有些产品需要用到多个UART串口，而单片机UART数量不足，这时需要用IO口模拟UART通讯。 本文采用IO口+定时器+外部中断的方法，模拟UART时序，实现串口接收和发送的功能，程序已经在量产产品上应用了。 实现原理： 1、发送部分，通过定时器控制波特率，改变IO口电平来发送数据，比较简单。 2、接收部分，通过外部中断，识别起始位，定时器控制波特率，使IO口恰好在电平信号的中间位置读取数据，减少其他中断的影响，大大降低误码率。 注意事项： 1、目前本程序只适用于接收数据定长的情况，不定长数据不
#循循渐进学51单片机#UART串口通信#not.10
最新发布
2301_77479336的博客
09-22 618
IO口模拟串口通信，让大家了解了串口通信的本质，但是我们的单片机程序却需要不停的检测扫描单片机IO口收到的数据，大量占用了单片机的运行时间。这时候就会有聪明人想了，其实我们并不是很关心通信的过程，我们只需要一个通信的结果，最终得到接收到的数据就行了。这样我们可以在单片机内部做一个硬件模块，让它自动接收数据，接收完了，通知我们一下就可以了，我们的51单片机内部就存在这样一个UART模块，要正确使用它，当然还得先把对应的特殊功能寄存器配置好。
MPU6050卡尔曼滤波6轴 模拟鼠标 C# 代码
06-02
您好！感谢您的提问。以下是使用MPU6050卡尔曼滤波实现6轴模拟鼠标的C#代码示例： ``` using System.Collections; using System.Collections.Generic; using UnityEngine; using System.IO.Ports; public class MPU6050Mouse : MonoBehaviour { SerialPort sp = new SerialPort("COM3", 9600); //定义串口 float[] angle = new float[3]; float[] gyro = new float[3]; float[] accel = new float[3]; float[] gyro_offset = new float[3]; float[] accel_offset = new float[3]; float[] angle_speed = new float[3]; float[] angle_last = new float[3]; float[] angle_now = new float[3]; float[] angle_acc = new float[3]; float[] angle_offset = new float[3]; float[] Q = new float[3] { 0.001f, 0.001f, 0.001f }; float[] R = new float[3] { 0.03f, 0.03f, 0.03f }; float[] P = new float[3] { 0f, 0f, 0f }; float[] K = new float[3] { 0f, 0f, 0f }; float dt; float roll, pitch, yaw; float mouse_speed_x, mouse_speed_y; // Start is called before the first frame update void Start() { sp.Open(); //打开串口 sp.ReadTimeout = 20; //设置读取超时时间 gyro_offset[0] = 0; gyro_offset[1] = 0; gyro_offset[2] = 0; accel_offset[0] = 0; accel_offset[1] = 0; accel_offset[2] = 0; angle_last[0] = 0; angle_last[1] = 0; angle_last[2] = 0; } // Update is called once per frame void Update() { string str = sp.ReadLine(); //读取串口数据 string[] data = str.Split(','); //分割数据 gyro[0] = float.Parse(data[0]); gyro[1] = float.Parse(data[1]); gyro[2] = float.Parse(data[2]); accel[0] = float.Parse(data[3]); accel[1] = float.Parse(data[4]); accel[2] = float.Parse(data[5]); dt = Time.deltaTime; gyro[0] -= gyro_offset[0]; gyro[1] -= gyro_offset[1]; gyro[2] -= gyro_offset[2]; if (Mathf.Abs(accel[0]) < 0.6f && Mathf.Abs(accel[1]) < 0.6f && Mathf.Abs(accel[2]) < 0.6f) { angle_acc[0] = Mathf.Atan(accel[1] / Mathf.Sqrt(Mathf.Pow(accel[0], 2) + Mathf.Pow(accel[2], 2))) * Mathf.Rad2Deg; angle_acc[1] = Mathf.Atan(-accel[0] / Mathf.Sqrt(Mathf.Pow(accel[1], 2) + Mathf.Pow(accel[2], 2))) * Mathf.Rad2Deg; angle_acc[2] = 0; angle_speed[0] = gyro[0] - angle_offset[0]; angle_speed[1] = gyro[1] - angle_offset[1]; angle_speed[2] = gyro[2] - angle_offset[2]; for (int i = 0; i < 3; i++) { angle_now[i] = angle_last[i] + angle_speed[i] * dt; P[i] = P[i] + Q[i]; K[i] = P[i] / (P[i] + R[i]); angle_now[i] = angle_now[i] + K[i] * (angle_acc[i] - angle_now[i]); P[i] = (1 - K[i]) * P[i]; angle_last[i] = angle_now[i]; } roll = angle_now[0]; pitch = angle_now[1]; yaw = angle_now[2]; mouse_speed_x = pitch; mouse_speed_y = roll; Cursor.lockState = CursorLockMode.Locked; Cursor.visible = false; transform.Rotate(-mouse_speed_x, mouse_speed_y, 0); //旋转物体 } } void OnApplicationQuit() { sp.Close(); //关闭串口 } } ``` 以上代码实现了通过MPU6050卡尔曼滤波获取物体的旋转角度，从而模拟鼠标的移动。其中，gyro_offset和accel_offset是用来校准陀螺仪和加速度计的偏移量；Q、R、P和K是卡尔曼滤波中的参数；mouse_speed_x和mouse_speed_y是模拟鼠标的速度。希望对您有所帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值