串口接收方式

最新推荐文章于 2024-08-22 18:34:27 发布
最新推荐文章于 2024-08-22 18:34:27 发布
阅读量213 收藏
点赞数 1
分类专栏： 现代单片机A31 文章标签： 单片机 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/p262664916/article/details/136044591
版权
本文详细介绍了在A31G12x平台上如何使用USART进行通信，包括初始化、数据接收处理以及XModemCRC-16校验算法的应用，确保数据传输的准确性。
摘要由CSDN通过智能技术生成 
*源文件 
 @bef  WTO  file  
*/

#include <stdio.h>
#include "A31G12x_int.h"
#include "A31G12x_usart1n.h"
#include "A31G12x_pcu.h"
#include "Wto_uart.h"
#include "Wto_Time.h" 
#include "flash.h"
extern void Delay_ms(uint16_t t_ms);

uint8_t Rxbuffer[RX_BUFFER_SIZE];
uint8_t Txbuffer[RX_BUFFER_SIZE];
uint8_t rxStates = TO_START;
//定义与初始化
UartHandle Usart11_Handle ={
 .RxHead   = 0,
 .Rxtail   = 0,
 .RxStatus = 0,
 .RxSize   = 0,
 .RxBuf    = Rxbuffer,
 .TxHead   = 0,
 .Txtail   = 0,
 .RxSize   = 0,
 .TxStatus = 0,
 .TxBuf    = Txbuffer,
};


void USART11_Receive_Data(void);
void USART11_Init(void);

struct __FILE { int handle; /* Add whatever needed */ };
FILE __stdout;
FILE __stdin;

int fputc(int ch, FILE *f) 
{
  while( UST_CheckBusy(USART11));
  UST_SendByte(USART11,ch);
  return(ch);
}

/*****************************************************************************************/
/*									串口USART											*/
/*****************************************************************************************/
void USART11_Init(void)
{
  UST_CFG_Type USTConfigStruct;
	
	PCU_SetDirection(PD, 3, ALTERN_FUNC);   
	PCU_ConfigureFunction(PD, 3, FUNC1);
	PCU_ConfigurePullupdown(PD,3, ENPU);

	PCU_SetDirection(PD, 2, ALTERN_FUNC);  
	PCU_ConfigureFunction(PD, 2, FUNC1);
  
	// 115200-8-无-1	
	USTConfigStruct.Mode = UST_UART_MODE;
	USTConfigStruct.Baud_rate = 115200;       
	USTConfigStruct.Databits  = UST_DATABIT_8;
	USTConfigStruct.Parity = UST_PARITY_NONE;
	USTConfigStruct.Stopbits = UST_STOPBIT_1;
  
	UST_Init(USART11, &USTConfigStruct);
	
	UST_IntConfig((USART1n_Type *)USART11, UST_INTCFG_RXC, ENABLE);
  
	NVIC_SetPriority(USART11_IRQn, 3);
	NVIC_EnableIRQ(USART11_IRQn);
	EInt_MaskDisable(UST11_MASK);
	UST_Enable(USART11, ENABLE);  
	
	__enable_irq();	
	
}


void USART11_Handler(void)
{
	uint32_t intsrc, tmp;	
	intsrc = UST_GetStatus(USART11);
	tmp = intsrc & UST_SR_BITMASK;  
	if ((tmp & UST_SR_RXC) == UST_SR_RXC)
	{
    USART11_Receive_Data();
	}  
	if ((tmp & UST_SR_TXC) == UST_SR_TXC)
	{
    //		 UST_ClearStatus(USART11, UST_STATUS_TXC);
	}
}

void USART11_Receive_Data(void)
{
  uint8_t date;
  uint32_t rLen;
  
  while(1)
  {   
    rLen = UST_Receive((USART1n_Type *)USART11, &date, 1, NONE_BLOCKING);
    if (rLen)
    {
      if( 0== Usart11_Handle.RxSize ){
      
        Usart11_Handle.RxHead = 0;
        Usart11_Handle.Rxtail = 0;
      } 
      Usart11_Handle.RxBuf[ Usart11_Handle.Rxtail] =  date;
      Usart11_Handle.Rxtail++;
     if( ++Usart11_Handle.RxSize >= RX_BUFFER_SIZE )
     {
        Usart11_Handle.RxSize = RX_BUFFER_SIZE;
        if( ++Usart11_Handle.RxHead >= RX_BUFFER_SIZE ){
              Usart11_Handle.RxHead = 0;        
        }
     }
     Usart11_Handle.RxStatus = IS_BUSY;  //  receive data now
     Usart11_Handle.RxTim = GetTickSystemTime();
    }
    else 
    {
      break;
    }
  }
}

//获取uart的接收状态
uint8_t GetUartRxStatus( void )
{
	uint32_t ticknow = GetTickSystemTime();
	if( Usart11_Handle.RxStatus == IS_BUSY )
	{	
		if( ticknow > Usart11_Handle.RxTim )
		{	
			if( ( ticknow - Usart11_Handle.RxTim ) >= 30 ) //30ms
			{
				Usart11_Handle.RxStatus = IS_IDLE;
			}
		} else {
			if( ( ( 0xffffffff - Usart11_Handle.RxTim ) + ticknow ) >= 30 )
			{
				Usart11_Handle.RxStatus = IS_IDLE;
			}
		}
	}
	return Usart11_Handle.RxStatus;
}

void UartSendCmd(uint8_t Cmd)
{
 UST_Send(USART11, &Cmd, 1, BLOCKING);
}

// 使用XModem多项式而不是Modbus多项式

// CRC算法名称	  多项式公式	         宽度  多项式	 初始值	结果异或值	输入反转	  输出反转
// CRC-16/XMODEM	 x16 + x12 + x5 + 1	  16   0x1021	  0000	 0000	    false	  false
uint16_t XModem_Crc16(const uint8_t *buffer, uint16_t len)
{
  uint16_t polynom = 0x1021; // XModem_CRC多项式
  uint8_t i;
  uint16_t crc16 = 0x0000;

  if (len == 0)
  {
    return ERROR;
  }

  while (len--)
  {
    crc16 ^= ((*buffer) << 8);
    for (i = 0; i < 8; i++)
    {
      if (crc16 & 0x8000)
      {
        crc16 <<= 1;
        crc16 ^= polynom;
      }
      else
      {
        crc16 <<= 1;
      }
    }
    buffer++;
  }
  return crc16;
}


void UsartReceiveHandle(void)
{
  extern uint16_t do_crc(uint16_t reg_init,uint8_t* data,uint16_t length);
  static uint8_t rxBuf[RX_BUFFER_SIZE] = {0};
  static uint8_t rxBuf_OK[128] = {0};
  static uint16_t CurrentRxSize = 0;
  static uint16_t receiveNum = 0; //计数接收数量
  static uint8_t receiveFlag = 0; //接收数据标志
  uint16_t crc16Check =0;
  uint16_t i;
  uint8_t chekL,chekH;
  uint32_t Tcnt =0;
  static uint32_t Tcnlast =0;
  static uint16_t TimerTriggle = 10000;

  if( GetUartRxStatus( ) == IS_IDLE )  //判断接收为空闲30ms时，认为接收完数据
  {     
    
    if( Usart11_Handle.RxSize )
    {
      printf("Rdata[");
      for(i=0; i< Usart11_Handle.RxSize; i++ ){
        rxBuf[i] =  Usart11_Handle.RxBuf[i];
        printf("%02x ", rxBuf[i]);       
      }
      printf("]\n");
     // printf("dataSize:%02d\n",Usart11_Handle.RxSize);
    
    CurrentRxSize = Usart11_Handle.RxSize;
    for(i =0;i< 128;i++)
    {
      rxBuf_OK[i] = rxBuf[i+3];
    }
    Usart11_Handle.RxSize = 0;
    Usart11_Handle.RxHead = 0;
    Usart11_Handle.Rxtail = 0;
   }
    crc16Check = XModem_Crc16(&rxBuf_OK[0],128);
    chekH = (uint8_t)(crc16Check >> 8);
    chekL = (uint8_t)crc16Check ;
  
     if( rxBuf[0] == SOH )  //128字节一包数据
     {
            
      if((rxBuf[1] == 0x00) && (rxBuf[2] ==(uint8_t)(~rxBuf[1])) && (rxStates == TO_START ) && ( chekH == rxBuf[CurrentRxSize-2])&&(chekL == rxBuf[CurrentRxSize-1])) 
      {
         rxStates = TO_RECEIVE_DATA; //开始状态，第一包数据
         UartSendCmd(ACK);
         Delay_ms(500);//等电压稳定
         UartSendCmd(CCC);
         receiveNum = 0;
         printf("start first pack OK \n"); 
      }
      else if( (rxBuf[2] ==(uint8_t)(~rxBuf[1])) && (rxStates == TO_RECEIVE_DATA) && (receiveFlag == 0)) 
      {
       
        FlashPageWrite(80+receiveNum,(uint8_t *)rxBuf_OK);  //10K开始写
        ++receiveNum; 
        printf(" rx data OK \n");
        receiveFlag = 1;
       // UartSendCmd(ACK);    
      }
     }
    else if( rxBuf[0] == STX )//1024字节一包数据  
    {
    
    
    }     
    else if(rxBuf[0] == EOT) //通讯结束
    {
       if(rxStates == TO_RECEIVE_DATA)
       {
         UartSendCmd(ACK);
         rxStates = TO_START;
         receiveFlag = 0;
       }
       receiveNum = 0;
    }
            
  
  }
  
   Tcnt = GetTickSystemTime();
  if((uint32_t)( Tcnt - Tcnlast ) > TimerTriggle )
  {
  Tcnlast = Tcnt; 
    if(rxStates != TO_RECEIVE_DATA)
    {
      UartSendCmd(CCC); //10秒请求主机发送一次 
      receiveFlag = 0 ;
      TimerTriggle = 10000; 
    }
    else{
      if(receiveFlag && rxStates == TO_RECEIVE_DATA ){ 
       receiveFlag = 0; 
       UartSendCmd(ACK); 
       TimerTriggle = 500;
      }
    
    }
  }
   
}

头文件--------------------------------------

#ifndef _WTO_UART_H_
#define _WTO_UART_H_

#define SOH		0x01
#define STX		0x02
#define ACK		0x06
#define NACK	0x15
#define EOT		0x04
#define CCC		0x43

/* 升级的步骤 */
enum UPDATE_STATE
{
	TO_START = 0x01,
	TO_RECEIVE_DATA = 0x02,
	TO_RECEIVE_EOT1 = 0x03,
	TO_RECEIVE_EOT2 = 0x04,
	TO_RECEIVE_END = 0x05
};

#define PACKET_HEADER           (3)
#define PACKET_TRAILER          (2)
#define PACKET_OVERHEAD         (PACKET_HEADER + 128 + PACKET_TRAILER )
#define PACKET_SIZE             (128)
#define PACKET_1K_SIZE          (1024)
#define RX_BUFFER_SIZE          (( PACKET_SIZE + PACKET_OVERHEAD ) * 2 )  //133*2=266 Bytes

#define IS_IDLE  0
#define IS_BUSY  1
typedef  struct{
uint16_t RxHead;
uint16_t Rxtail;
uint16_t RxSize;
uint32_t RxTim;
uint8_t  RxStatus;
uint8_t  *RxBuf;
uint16_t TxHead;
uint16_t Txtail;
uint16_t TxSize;
uint8_t  TxStatus;
uint8_t  *TxBuf;
}UartHandle;

extern void USART11_Init(void);
extern uint8_t GetUartRxStatus(void);
extern void UsartReceiveHandle(void);


#endif
pandyele
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python 串口接收字符_python串口接收数据
weixin_42537142的博客
03-01 2743
python3.5 读取串口中的数据怎么解码数据： b'\x0e\xbeUS\xf8]m\xf6\x97Z\n'采用默认通信参数 import serial t = serial.Serial('com1',9600) n = t.write('you are my world')print t.portstrprint n str = t.read(n)print str可以自己设置参数 imp...
串口数据接收处理的一种方法
Engineer Hoo的博客
09-11 5524
在处理串口接收到的数据时，面临的问题主要是是如何解析接收到的数据，对于错误的如何处理等。不管是在微控制器中使用串口还是在桌面应用中使用串口，都需要解决这个接收的数据包处理的问题。最近在做一个应用，主要是上位机发送指令，查询下位机相关的数据。假设一帧数据是由10字节构成的，指令和应答数据均为10字节，应答数据发送频率为5Hz。有两个问题需要解决，第一个就是数据帧什么时候接收完成，第二个接收完成如何处...
基于STM32HAL库的三种串口接收方式
qq_44758496的博客
08-10 4804
原理：轮询方式下CPU会不断读取串口寄存器状态。发送数据时，当检测到发送数据寄存器TDR有数据时，调用HAL_UART_Transmit发送数据。接收数据时，当检测到接收寄存器RDR有数据时，调用HAL_UART_Receive接收数据。缺点：CPU需要不断扫描寄存器状态，在一定程度上加重了CPU的负担，不适用于对系统精度较高的场所。
【自动化】C#中串口接收数据，以及主动接收和被动接收的区别
qq_35320456的博客
03-14 3273
【自动化】C#中串口接收数据，以及主动接收和被动接收的区别
串口数据接收
shen20010928的博客
12-27 463
作业
串口接收多字节 Verilog程序
04-19
串口接收多字节在数字系统设计中是一个常见的任务，特别是在使用FPGA（Field-Programmable Gate Array）进行通信接口开发时。Verilog是一种硬件描述语言，常用于描述这样的逻辑功能。本程序旨在实现一个FPGA模块，该...
串口接收模块电路设计
07-18
电路设计方面，串口接收模块的电路设计要考虑到信号的稳定采样。在设计中，需要对FPGA主频（例如50MHz）进行适当的分频，以确保采样时钟与数据传输速率（例如9600bps）相匹配。通常，采样时钟频率被设置为数据传输...
串口接收打印软件sscom
11-11
串口接收打印软件SSCOM是一款专门用于通过串行接口（Serial Port）接收并处理数据的实用工具。在工业控制、物联网设备通信、嵌入式系统等领域，串口通信仍然是广泛采用的数据传输方式。SSCOM软件简化了这一过程，让...
matlab串口接收程序
09-13
然而，对于"串口中断接收"这个标签，这意味着我们需要实现一种实时的、非阻塞的数据接收方式。在MATLAB中，我们不能直接设置串口中断，但可以通过定时轮询或事件触发来模拟中断接收。 - 定时轮询：使用`timer`对象...
RGB串口接收颜色显示器
07-05
RGB串口接收颜色显示器是一款专为IT从业者设计的实用工具，它主要应用于颜色识别和调试过程中。通过串口通信协议，这款软件能够接收下位机（如微控制器或嵌入式系统）发送的RGB（红绿蓝）颜色数据，并在上位机（如...
单片机驱动彩屏最简方案：单片机_RA8889最小开发板驱动控制TFT彩屏介绍（一）
BW.SU的博客
08-22 393
只要一颗51单片机，就能点亮彩色的视窗！
电机启动对单片机重启的影响
qq_39239990的博客
08-22 175
电机接通瞬间，类似于导线直接连接在电源上，类似于短路，使电流不再通过ASM供电单片机；直到电机开始运行产生“磁阻”后，使电源电流反回灌ASM进行供电；这一瞬间导致单片机断电重启（非专业机电，只是推测，没有相关研究资料）单片机使用ASM1117对9V电压降压供电，IO口接三极管控制电机 ，接9V；通过在mcu供电端加上大电容和二极管（ 限制回流），等待电源电流回复稳定状态，从而避免重复启动。产生原因，电机启动瞬间电流是运行的2-3倍左右，导致拉低单片机的供电；网上参考，添加滤波，电容，阻容；
单片机大小端模式
qq_59757948的博客
08-19 207
大小端指的是在存储器中存储数据的字节顺序。C语言编程过程中，我们会定义各种类型的数据，比如8bit的char型，16bit的short型或者32bit的long型，在这个过程当中不可避免的会遇到多个字节排序的问题，为了解决这个问题大端存储模式和小端存储模式诞生了。大端模式，首先存储MSB字节，高字节存储在低地址；小端模式，首先存储LSB字节，低字节存储在低地址。ARM架构的芯片一般默认使用小端模式。这里我只是简单介绍在存储中的例子，事实上在一些通信协议，Modbus或者CAN协议之中，也存在着大小端传输。
STM32——PWM波形输出
m0_74225397的博客
08-15 1212
可以看到：定时器除了基本的定时中断功能，输入捕获、输出比较均是STM32定时器的功能。
基于UDP的网络聊天室
没有百宝袋的哆啦A梦的博客
08-16 831
【代码】基于UDP的网络聊天室。
【Qt笔记】Qt建立UDP通信
qq_52924376的博客
08-16 607
UDP（User Datagram Protocol，用户数据报协议）是一种无连接的、不可靠的、面向报文的、基于网络的传输层协议。
3-4 STM32F405--定时器输入捕获
ssmy01的博客
08-18 470
定时器输入捕获
基于单片机的自动灌溉控制的系统
lantiandianzi的博客
08-21 185
本设计是一种基于单片机的自动灌溉控制的系统，主要采用单片机、步进电机、温湿度传感器、继电器、光照强度传感器、OLED显示器、时钟模块、按键模块、蓝牙模块、蜂鸣器模块等硬件设备组成。最后，按键模块设置报警的阈值将数据和灌溉阈值进行对比，判断湿度是否超过灌溉阈值，根据土壤湿度传感器检测到的土壤湿度，若检测到的土壤湿度值低于系统所设定的最低湿度值，系统则自动启动系统，继电器控制水泵，控制步进电机完成水流量的控制进行灌溉，若检测到的土壤湿度值高于系统所设定的最高湿度值，系统则报警。
uboot中 fastboot udp 协议分析
最新发布
qq_56733950的博客
08-22 573
fastboot是android系统常用的一种刷机方法。android系统设计了2种刷机方式：fastboot和recovery。不论是二者中的哪一个，都是用来给设备刷写固件的。而刷机其实就是镜像传输+烧录，fastboot刷机时使用usb来传输镜像文件，然后写入对应分区（可以拿过来用，需要芯片厂商在底层提供原始实现）fastboot是一种通信协议。基本工作原理就是上位机（pc）通过 USB 或以太网（UDP）与引导加载程序（uboot）通信。
stm32串口接收中断方式
04-28
STM32是一款广泛使用的微控制器系列，它提供了多种方式来实现串口接收中断。下面是一种常见的实现方式： 1. 配置串口：首先需要配置串口的参数，包括波特率、数据位、停止位、校验位等。可以使用STM32提供的库函数来完成串口的初始化和配置。 2. 使能中断：在配置完串口后，需要使能串口接收中断。可以通过设置相应的寄存器来实现，例如使用USART_CR1寄存器的RXNEIE位来使能接收缓冲区非空中断。 3. 编写中断处理函数：当串口接收到数据时，会触发中断，并跳转到相应的中断处理函数。在中断处理函数中，可以读取接收缓冲区的数据，并进行相应的处理。可以使用USART_DR寄存器来读取接收到的数据。 4. 清除中断标志位：在中断处理函数中，需要清除接收中断标志位，以便下一次接收中断能够触发。可以使用USART_SR寄存器的RXNE位来判断是否接收到数据，并通过读取USART_DR寄存器来清除中断标志位。 5. 其他操作：根据具体需求，可以在中断处理函数中进行其他操作，例如判断接收到的数据是否符合预期、进行数据处理或者触发其他事件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值