怎样用模拟串口uart发送字符串

已于 2022-08-23 16:58:48 修改
阅读量1.9k 收藏 1
点赞数
分类专栏： MTK AG3335M 文章标签： 单片机
于 2021-08-16 13:50:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_36741413/article/details/119731249
版权

1、首先用sprintf格式化字符串，还可以添加可能需要一系列的附加参数，每个参数包含了一个要被插入的值，替换了 format 参数中指定的每个 % 标签。。然后用模拟串口发送。
2、例如：

void gnss_app_output_nmea(char *nmea_buffer){
    int32_t checksum = 0;
    char temp_buffer[MNL_SERVICE_MAX_DATA_LEN] = {0};
    checksum = gnss_app_get_command_checksum((int8_t*)nmea_buffer, strlen(nmea_buffer));
    sprintf(temp_buffer,
        "$%s*%02X\r\n",
        nmea_buffer,
        (int)checksum);

    gnss_io_send_data_by_user(GNSS_IO_FLAG_OUT_NMEA, (uint8_t *)temp_buffer, strlen(temp_buffer), true);
}

上面例子就是在nmea_buffer字符串中增加变量checksum值，然后变成temp_buffer，然后发送出来。

3、模拟串口例子：



/* Includes ------------------------------------------------------------------*/
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/* Kernel includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "task_def.h"
#include "hal_gpio.h"
#include "hal_gpio_internal.h"
#include "semphr.h"

/* hal includes */
#include "hal.h"
#include "sys_init.h"
#include "syslog.h"
#include "memory_map.h"
#include "atci_adapter.h"

#include "uart2_main.h"

static uint32_t uart2_tx_handle;
static struct uart2data uart2_tx_data;         //要发送数据的临时缓存
static unsigned char uart2_tx_status = 0;      //当前是否处于发送状态
volatile static unsigned char uart2_tx_bit_status = 0;

//static volatile struct uart2data uart2_rx_data;         //要接收数据的临时缓存
static unsigned char uart2_rx_status = 0;      //当前是否处于接收状态
static unsigned char uart2_rx_bit_status = 0;
volatile unsigned char uart2_rx_complete_flag = 0;

char uart2_rx_datae[100];
unsigned char uart2_rx_data_leng;

static SemaphoreHandle_t uart2_tx_xSemaphore;


static void gpio_test(void)
{
     unsigned int i,j;

     hal_gpio_set_output(HAL_GPIO_9, HAL_GPIO_DATA_HIGH);
            
     for(i=0;i<245;i++)
     {}
       
     hal_gpio_set_output(HAL_GPIO_9, HAL_GPIO_DATA_LOW);
     
     for(j=0;j<245;j++)
     {}
}

void gpt_uart2_tx_callback(void)
{
    static unsigned int data_num = 0;
    static unsigned char bit_num = 0;
     static char temp;

    //hal_gpio_toggle_pin(HAL_GPIO_10);
    switch(uart2_tx_bit_status)
    {
        case Uart2_tx_start_bit:
            gpio_base->GPIO_DOUT.CLR[0] = (GPIO_REG_ONE_BIT_SET_CLR << 10);
            uart2_tx_bit_status = Uart2_tx_data_bit;
            temp = uart2_tx_data.uart2_data[data_num];
           // log_send("start_");
            break;
            
        case Uart2_tx_data_bit:
            if(temp & 0x01 == 1)
            {
                gpio_base->GPIO_DOUT.SET[0] = (GPIO_REG_ONE_BIT_SET_CLR << 10);
            }
            else
            {
                gpio_base->GPIO_DOUT.CLR[0] = (GPIO_REG_ONE_BIT_SET_CLR << 10);
            }
            temp = (temp >> 1);
            bit_num ++;
            if(bit_num == 8)
            {
                bit_num = 0;
                uart2_tx_bit_status = Uart2_tx_stop_bit;
            }
             //log_send("data_");
            break;
        
        case Uart2_tx_stop_bit:
            gpio_base->GPIO_DOUT.SET[0] = (GPIO_REG_ONE_BIT_SET_CLR << 10);
            uart2_tx_bit_status = Uart2_tx_start_bit;
            data_num++;
            if(data_num == uart2_tx_data.uart2_data_num)
            {
                hal_gpt_stop_timer(HAL_GPT_Uart2_Tx_PORT);
                data_num = 0;
                uart2_tx_status = Uart2_tx_normal;    
            }
            break;
            
        default:
            uart2_tx_bit_status = Uart2_tx_start_bit;
            data_num = 0;
            break;
    }     
}

void gpt_uart2_rx_callback(void)
{
    static unsigned int data_num = 0;
    static unsigned char bit_num = 0;
    volatile static char temp;
    unsigned char i;

    switch(uart2_rx_bit_status)
    {
        case Uart2_rx_start_bit:
            uart2_rx_bit_status = Uart2_rx_data_bit;      //从产生中断callback到start第一次要130us 后面都是  94us
           
            break;
            
        case Uart2_rx_data_bit:
             //gpio_base->GPIO_DOUT.SET[0] = (GPIO_REG_ONE_BIT_SET_CLR << 10);    //进入ent中断到这里195、199,后面161、160、173、164、158、157、169、163
            if (gpio_base->GPIO_DIN.R[0] & (GPIO_REG_ONE_BIT_SET_CLR << 9))   //  high
             {

               temp |= (1 << bit_num);
 
               //gpio_base->GPIO_DOUT.CLR[0] = (GPIO_REG_ONE_BIT_SET_CLR << 10);   //这个看起来比较准
             }
             else                                                            //low
             {

               temp &= (~(1 << bit_num));
 
               //gpio_base->GPIO_DOUT.SET[0] = (GPIO_REG_ONE_BIT_SET_CLR << 10);
             }
             bit_num ++;
             if(bit_num == 8)
             {
                 bit_num = 0;
                 uart2_rx_bit_status = Uart2_rx_stop_bit;
             } 
             
            break;
        
        case Uart2_rx_stop_bit:
            
            uart2_rx_datae[data_num] = temp;
            
            data_num++;
            uart2_rx_data_leng = data_num;
            temp = 0;
            uart2_rx_bit_status = Uart2_rx_detector_bit;           

            break;

        case Uart2_rx_detector_bit:
            if (gpio_base->GPIO_DIN.R[0] & (GPIO_REG_ONE_BIT_SET_CLR << 9)) 
             {
             
                 //gpio_base->GPIO_DOUT.CLR[0] = (GPIO_REG_ONE_BIT_SET_CLR << 10);
                 data_num = 0;
                 uart2_rx_complete_flag = 1;
                 hal_gpt_stop_timer(HAL_GPT_Uart2_Rx_PORT);
                 uart2_rx_pin_it_mode_init();
                 //gpio_base->GPIO_DOUT.SET[0] = (GPIO_REG_ONE_BIT_SET_CLR << 10);    //进入到pin设置为it159、163、156、154、158      首次181、175

             }
             else 
             {
                 uart2_rx_bit_status = Uart2_rx_data_bit;

             }

            break;
            
        default:
            //log_send("rx_error");
            break;

    }

}

void gpt_uart2_rx_int_callback(void *user_data)
{

    //gpio_base->GPIO_DOUT.CLR[0] = (GPIO_REG_ONE_BIT_SET_CLR << 10);

    hal_eint_mask(HAL_EINT_NUMBER_9);   
    //log_send("int_callback");
    
    uart2_rx_pin_io_mode_init();
    uart2_rx_bit_status = Uart2_rx_data_bit;

    hal_gpt_start_timer_us(HAL_GPT_Uart2_Rx_PORT,Uart2_Rx_bit_time,HAL_GPT_TIMER_TYPE_REPEAT);   
    //gpio_base->GPIO_DOUT.SET[0] = (GPIO_REG_ONE_BIT_SET_CLR << 10);      //进入中断到初始化定时器完成要47        、45、49、60、53、44、50首次72、71
    hal_eint_unmask(HAL_EINT_NUMBER_9);
}



 void log_send(unsigned char *buf)
{
    unsigned char buf_num;
    unsigned char i   ;
    buf_num = strlen(buf);
    for(i=0;i<buf_num;i++)
    {
        hal_uart_put_char(HAL_UART_0,buf[i]);
    }
}

int fputc(int ch, FILE *f)
{ 
    //USART_SendData(USART1, (uint8_t) ch);
    //while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
    uart2_send_data(&ch,1);
    return (ch);
}

void uart2_send_string(char *str)
{
    
    uart2_send_data(str,strlen(str));
    //atci_mem_free(buf);

}

void uart2_send_data(char *data, unsigned int data_long)
{
   //unsigned char k;
   // hal_uart_put_char(HAL_UART_0,data_long);
   //log_send("uart2");

    if((uart2_tx_status == Uart2_tx_normal) && (data_long > 0))  
    {   
        //log_send("send");
        //xSemaphoreTake(uart2_tx_xSemaphore, portMAX_DELAY);
        uart2_tx_status = Uart2_tx_busy;
        uart2_tx_data.uart2_data = data;
        uart2_tx_data.uart2_data_num = data_long;

        uart2_tx_bit_status = Uart2_tx_start_bit;

        hal_gpt_start_timer_us(HAL_GPT_Uart2_Tx_PORT,Uart2_Tx_bit_time,HAL_GPT_TIMER_TYPE_REPEAT);   
        /*while(1)
        {
            if(uart2_tx_status == Uart2_tx_normal)
                break;
        }*/

    }  
    
}

static void uart2_rx_pin_io_mode_init(void)
{
    
    hal_gpio_init(HAL_GPIO_9);                //uart2 rx
    hal_pinmux_set_function(HAL_GPIO_9, HAL_GPIO_9_GPIO9); 
    hal_gpio_set_direction(HAL_GPIO_9, HAL_GPIO_DIRECTION_INPUT);
    //hal_gpio_set_output(HAL_GPIO_9, HAL_GPIO_DATA_HIGH);
}

static void uart2_rx_pin_it_mode_init(void)
{

    hal_eint_config_t uart2_rx_config;

    hal_gpio_init(HAL_GPIO_9);                //uart2 rx
    hal_pinmux_set_function(HAL_GPIO_9, HAL_GPIO_9_EINT9); 
    //hal_gpio_set_direction(HAL_GPIO_9,HAL_GPIO_DIRECTION_INPUT);
    //hal_gpio_pull_up(HAL_GPIO_9);
    hal_eint_mask(HAL_EINT_NUMBER_9);

    uart2_rx_config.debounce_time = 0;
    uart2_rx_config.trigger_mode = HAL_EINT_EDGE_FALLING;

    hal_eint_init(HAL_EINT_NUMBER_9,&uart2_rx_config);
    hal_eint_register_callback(HAL_EINT_NUMBER_9,gpt_uart2_rx_int_callback,NULL);

    hal_eint_unmask(HAL_EINT_NUMBER_9);

}

void uart2_pin_init(void)
{   
    uart2_rx_pin_it_mode_init();
  
    if(hal_gpt_init(HAL_GPT_Uart2_Rx_PORT)== HAL_GPT_STATUS_OK)      //9
    {
        hal_gpt_register_callback(HAL_GPT_Uart2_Rx_PORT,gpt_uart2_rx_callback,NULL);
        //hal_gpt_start_timer_us(HAL_GPT_Uart2_Rx_PORT,1000000,HAL_GPT_TIMER_TYPE_REPEAT);
    }
    else
    {
        hal_gpt_stop_timer(HAL_GPT_Uart2_Rx_PORT);
        hal_gpt_deinit(HAL_GPT_Uart2_Rx_PORT);
    }


    hal_gpio_init(HAL_GPIO_10);                 //Uart2 tx
    hal_pinmux_set_function(HAL_GPIO_10, HAL_GPIO_10_GPIO10); 
    hal_gpio_set_direction(HAL_GPIO_10, HAL_GPIO_DIRECTION_OUTPUT);
    hal_gpio_set_output(HAL_GPIO_10, HAL_GPIO_DATA_HIGH);

    if(hal_gpt_init(HAL_GPT_Uart2_Tx_PORT)== HAL_GPT_STATUS_OK)     //10
    {
        //log_send("init_ok_");
        hal_gpt_register_callback(HAL_GPT_Uart2_Tx_PORT,gpt_uart2_tx_callback,NULL);
        // hal_gpt_start_timer_us(HAL_GPT_Uart2_Tx_PORT,Uart2_Tx_bit_time,HAL_GPT_TIMER_TYPE_REPEAT);
    }
    else
    {
        hal_gpt_stop_timer(HAL_GPT_Uart2_Tx_PORT);
        hal_gpt_deinit(HAL_GPT_Uart2_Tx_PORT);
    }

}

void gpt_uart2_rx_callback_test(void)
{
    uart2_send_data("simcom.com", 10);
}


void gpt_uart2_tx_callback_test(void)
{
    
}

void uart2_processing(void)
{
    unsigned char sendbuf[512];
    unsigned int i = 0;
    unsigned int k = 0;
    unsigned char j = 0;
    char *test_buf ="leiting test";


    //log_send("task_enter_");
    
    uart2_pin_init();


    while(1)
    {

      if(uart2_rx_complete_flag == 1)
      {
          uart2_rx_complete_flag = 0;

          for(k=0;k<uart2_rx_data_leng;k++)
          {
              hal_uart_put_char(HAL_UART_0,uart2_rx_datae[k]);
          }

          
          uart2_send_data(uart2_rx_datae, uart2_rx_data_leng);

          /*for(i=0;i<sizeof(sendbuf);i++)
          {
              sendbuf[i] = j;
              j++;
          }
          uart2_send_data(sendbuf,sizeof(sendbuf));*/

      }
    }
}
实验三：UART发送字符以及接受led显示测试
weixin_74882709的博客
05-08 129
通过远程实验系统完成UART发送字符测试
利用虚拟串口工具实现串口通信数据的发送和接收
DevGOOD的博客
09-02 1152
总结起来，利用 C# 编程语言和虚拟串口工具，我们可以轻松实现串口通信数据的发送和接收。通过合理配置串口对象，并注册相应的事件处理方法，我们可以实现异步接收数据，并进行相应的处理。在 C# 编程语言中，我们可以利用虚拟串口工具来实现串口通信数据的发送和接收。通过虚拟串口，我们可以模拟真实的串口通信环境，进行数据传输和交互。首先，我们需要使用 C# 的串口类（SerialPort）来配置和操作虚拟串口。通过该类，我们可以设置串口的基本参数（如波特率、数据位、停止位等），以及注册事件来监听串口的数据接收。
STM8S003F使用I/O口模拟串口（一）发送数据
尹泽宇的博客
06-11 9017
最近在使用STM8S003F模拟串口发送数据，网上资源很多，但是没有找到我需要的，因此自己写一篇文章，做一个总结，这一片文章主要是实现发送简单的过程。
模拟串口发送数据助手
01-21
java语言，模拟串口，但是又是一款专用的串口测试软件，初次接触java，做的很笨拙，只供学习之用，文件里还有需要导入的包，以及生成的windows下可执行程序！
c# 串口 多线程_STM32的串口通信
weixin_39822728的博客
10-25 766
在基础实验成功的基础上，对串口的调试方法进行实践。硬件代码顺利完成之后，对日后调试需要用到的printf重定义进行调试，固定在自己的库函数中。b) 初始化函数定义：void USART_Configuration(void); //定义串口初始化函数c) 初始化函数调用：void UART_Configuration(void); //串口初始化函数调用初始化代码：void USA...
串口通信发送字符串
qq_45551969的博客
03-23 3565
如何虚拟串口间发送数据
02-18
vspd为虚拟串口，安装后可以任意虚拟两个互通的串口，使用上位机可以选择任意一个串口作为接收，然后使用sscom5.13像另外一个串口发送文件"B0网跳动数据源“文件即可模拟串口接收。
IO模拟UART串口 C语言
02-29
本文将详细讲解如何使用C语言在FT32F0xxx芯片上通过IO模拟UART串口，实现9600波特率的稳定通信，并讨论其可移植性。 首先，我们需要理解UART的工作原理。UART是一种半双工通信协议，数据以起始位、数据位、奇偶校验...
GPIO模拟UART串口发送和接收
热门推荐
weixin_43504224的博客
06-07 1万+
GPIO模拟UART串口发送和接收
STM8S103F UART1外设串口通信向PC发送数据，适合调试时看实时变量，自己写的，亲测可用。STM8S其他型号也适用
02-24
2.发送字符串SendStr 3.发送16进制数SendHex16 4.发送8进制数SendHex8 5.发送十进制数SendDec （int型） 使用方法： 1.复制到用户函数处 2.在mian.c或者主函数c文件中引用UART.h 3.在PC上设置串口软件与UART_Init中...
C8051F330串口UART0示例程序
07-25
`Uart0_Transmit`函数负责发送单个字符，而`sendstr`函数则通过循环调用`Uart0_Transmit`函数来发送整个字符串。 ##### 6. 延时函数 (delay_1ms/delay_ms) ```c void delay_1ms(); void delay_ms(unsigned int i);...
(完整版)c51单片机从串口接收发送字符串.docx
11-11
在本文中，我们将深入探讨如何使用C51编程语言在单片机上实现串口通信，特别是关于串口接收和发送字符串的细节。C51是针对8051系列单片机的一种特定的编程语言，它扩展了标准的C语言以适应微控制器的硬件特性。在...
串口232向PC发送字符串程序
08-08
绝对可用，本程序亲测，向pc发送的字符串可自行改动，有汉语注释
uart发送一个字符串
04-24
将单片机数据通过蓝牙向上位机发送一个字符串
stm32 使用GPIO模拟串口发送
jingling122的博客
07-08 1193
在STM32微控制器上实现模拟串口输出（也称为软件串口或比特邦定（Bit-Banging）串口），主要是因为硬件上的UART资源有限或者为了特定需求而需要更多的串口通信接口。模拟串口意味着使用GPIO引脚模拟UART的TX（发送）和RX（接收）功能，通过软件控制GPIO引脚的电平变化来发送和接收数据。
cortex-a7 UART实验
crispy715的博客
09-15 221
arm 0915
用串口发送字符串（仅供参考）
最新发布
2401_83112194的博客
07-10 1001
/传入字符串 \r\n表示字符串换行的意思。//当TI为0时则！TH1 = 0xFD;//8位自动重装模式 TH1数据溢出自动装入TL1。//这样配目的是无时差。//配置定时器1 8位自动重装模式。//将字符串传入出去。//让波特率更加稳定，防止掉帧。void senddate(char date) //串口发出数据函数。//配置计算波特率模式。void sendstring(char* str) //传入字符串。
串口发送字符串
weixin_46619179的博客
11-17 6433
一、发送字符 1.1定义 1.2声明 1.3调用 效果：按一下复位键，发送一次OK 二、发送字符串 2.1定义 2.2声明 2.3调用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值