C51实现串口1环形FIFO无阻塞数据发送和接收 并解析自定义协议

最新推荐文章于 2024-04-12 10:25:07 发布
最新推荐文章于 2024-04-12 10:25:07 发布
阅读量732 收藏 13
点赞数 9
分类专栏： Arduino 文章标签： C51 串口数据发送 环形FIFO缓冲 单片机 中断数据发送接收 自定义通信协议 stc32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxgasd/article/details/135193668
版权

串口的发送和接收数据,采用查询法, 会阻塞代码的运行, 效率比较低, 采用环形FIFO来缓冲发送和接收的数据, 再配合中断自动发送和接收, 效率会提升极大, 能把波特率带宽跑满

1.实现FIFO结构

// FIFO环形缓冲队列
typedef struct FIFOBuffer {
  unsigned char headPos;    //缓冲区头部位置
  unsigned char tailPos;    //缓冲区尾部位置
  unsigned char bufferSize; // 缓冲区长度
  unsigned char *buffer;    //缓冲区数组
};

unsigned char FIFOBuffer_available(struct FIFOBuffer *fifo_buffer) {
  return fifo_buffer->headPos != fifo_buffer->tailPos;
}

void FIFOBuffer_flush(struct FIFOBuffer *fifo_buffer) {
  fifo_buffer->headPos = 0;
  fifo_buffer->tailPos = 0;
}

unsigned char FIFOBuffer_read(struct FIFOBuffer *fifo_buffer) {
  unsigned char buf = 0;
  //如果头尾接触表示缓冲区为空
  if (fifo_buffer->headPos != fifo_buffer->tailPos) {
    buf = fifo_buffer->buffer[fifo_buffer->headPos];
    if (++fifo_buffer->headPos >= fifo_buffer->bufferSize) {
      fifo_buffer->headPos = 0;
    }
  }
  return buf;
}

void FIFOBuffer_push(struct FIFOBuffer *fifo_buffer, unsigned char buf) {
  fifo_buffer->buffer[fifo_buffer->tailPos] = buf;         //从尾部追加
  if (++fifo_buffer->tailPos >= fifo_buffer->bufferSize) { //尾节点偏移
    fifo_buffer->tailPos = 0;
  }
  if (fifo_buffer->tailPos == fifo_buffer->headPos) {
    if (++fifo_buffer->headPos >= fifo_buffer->bufferSize) {
      fifo_buffer->headPos = 0;
    }
  }
}

2.实现串口中断发送和接收

#define UartReceiveSize 128
#define UartSendSize 128
uint8 uartReceiveBuffer[UartReceiveSize] = {0};
uint8 uartSendBuffer[UartSendSize] = {0};
struct FIFOBuffer uartReceiveFIFO;
struct FIFOBuffer uartSendFIFO;
uint8 isSend = 0;

void UART1_Isr(void) interrupt 4 {
  if (TI) {
    TI = 0;
    // 队列中还有数据, 继续发送
    if (uartSendFIFO.headPos != uartSendFIFO.tailPos) {
      SBUF = FIFOBuffer_read(&uartSendFIFO);
    } else {
      isSend = 0;
    }
  }
  if (RI) {
    RI = 0;
    // 接收到数据, 放入队列
    FIFOBuffer_push(&uartReceiveFIFO, SBUF);
  }
}
void uart1Write(uint8 dat) {
  FIFOBuffer_push(&uartSendFIFO, dat);
  if (isSend == 0) {
    isSend = 1;
    SBUF = FIFOBuffer_read(&uartSendFIFO);
  }
}
void uart1WriteBuf(uint8 *buffer, uint8 length) {
  uint8 i = 0;
  for (i = 0; i < length; i++) {
    FIFOBuffer_push(&uartSendFIFO, buffer[i]);
  }
  if (isSend == 0) {
    isSend = 1;
    SBUF = FIFOBuffer_read(&uartSendFIFO);
  }
}
void uart1WriteString(uint8 *str) {
  while (*str) {
    FIFOBuffer_push(&uartSendFIFO, *str++);
  }
  if (isSend == 0) {
    isSend = 1;
    SBUF = FIFOBuffer_read(&uartSendFIFO);
  }
}

3.自定义指令解析

// 检测命令格式 {Start1,Start2, data... ,len,End1,End2}
struct MyCommand {
  unsigned char Start1;
  unsigned char Start2;
  unsigned char End1;
  unsigned char End2;
  unsigned char isStart;
  unsigned char count;
  unsigned char bufferSize;
  unsigned char *buffer;

  // 检测命令格式 {Start1,Start2, data... ,len,End1,End2}
  void (*resolveCommandCallback)(unsigned char *buffer, unsigned char length);
};
#define UartCommandBufferSize 64
uint8 uartCommandBuffer[UartCommandBufferSize] = {0};
struct MyCommand uartCommand;

void MyCommand_addData(struct MyCommand *command, unsigned char tempData) {
  if (!command->isStart) {
    if (command->count == 0 && tempData != command->Start1) {
      return;
    }
    command->count++;
    if (command->count == 2) {
      if (command->Start2 == tempData) {
        command->isStart = true;
        command->count = 0;
      } else {
        command->count = 0;
        if (tempData == command->Start1) {
          command->count++;
        }
      }
    }
    if (command->count > 2) {
      command->count = 0;
      command->isStart = false;
    }
    return;
  }

  if (command->count >= command->bufferSize) {
    command->count = 0;
    command->isStart = false;
  }

  command->buffer[command->count] = tempData;
  command->count++;

  if (command->isStart && command->count >= 4) {
    // 检测结束
    if (tempData == command->End2 &&
        command->buffer[command->count - 2] == command->End1) {
      // 长度位
      if (command->buffer[command->count - 3] == command->count - 3) {
        if (command->resolveCommandCallback) {
          command->resolveCommandCallback(command->buffer, command->count - 3);
        }
        command->isStart = false;
        command->count = 0;
      }
    }
  }
}

4. 初始化结构体数据

void initUartCommand(void (*commandCallback)(uint8 *buffer, uint8 length)) {
  uartReceiveFIFO.headPos = 0;
  uartReceiveFIFO.tailPos = 0;
  uartReceiveFIFO.bufferSize = UartReceiveSize;
  uartReceiveFIFO.buffer = uartReceiveBuffer;

  uartSendFIFO.headPos = 0;
  uartSendFIFO.tailPos = 0;
  uartSendFIFO.bufferSize = UartSendSize;
  uartSendFIFO.buffer = uartSendBuffer;

  uartCommand.Start1 = 0xf0;
  uartCommand.Start2 = 0xf1;
  uartCommand.End1 = 0xe0;
  uartCommand.End2 = 0xe1;
  uartCommand.isStart = 0;
  uartCommand.count = 0;
  uartCommand.bufferSize = UartCommandBufferSize;
  uartCommand.buffer = uartCommandBuffer;
  uartCommand.resolveCommandCallback = commandCallback;
}

全部代码MyCommand.h


// FIFO环形缓冲队列
typedef struct FIFOBuffer {
  unsigned char headPos;    //缓冲区头部位置
  unsigned char tailPos;    //缓冲区尾部位置
  unsigned char bufferSize; // 缓冲区长度
  unsigned char *buffer;    //缓冲区数组
};

unsigned char FIFOBuffer_available(struct FIFOBuffer *fifo_buffer) {
  return fifo_buffer->headPos != fifo_buffer->tailPos;
}

void FIFOBuffer_flush(struct FIFOBuffer *fifo_buffer) {
  fifo_buffer->headPos = 0;
  fifo_buffer->tailPos = 0;
}

unsigned char FIFOBuffer_read(struct FIFOBuffer *fifo_buffer) {
  unsigned char buf = 0;
  //如果头尾接触表示缓冲区为空
  if (fifo_buffer->headPos != fifo_buffer->tailPos) {
    buf = fifo_buffer->buffer[fifo_buffer->headPos];
    if (++fifo_buffer->headPos >= fifo_buffer->bufferSize) {
      fifo_buffer->headPos = 0;
    }
  }
  return buf;
}

void FIFOBuffer_push(struct FIFOBuffer *fifo_buffer, unsigned char buf) {
  fifo_buffer->buffer[fifo_buffer->tailPos] = buf;         //从尾部追加
  if (++fifo_buffer->tailPos >= fifo_buffer->bufferSize) { //尾节点偏移
    fifo_buffer->tailPos = 0;
  }
  if (fifo_buffer->tailPos == fifo_buffer->headPos) {
    if (++fifo_buffer->headPos >= fifo_buffer->bufferSize) {
      fifo_buffer->headPos = 0;
    }
  }
}

// 检测命令格式 {Start1,Start2, data ,len,End1,End2}
struct MyCommand {
  unsigned char Start1;
  unsigned char Start2;
  unsigned char End1;
  unsigned char End2;
  unsigned char isStart;
  unsigned char count;
  unsigned char bufferSize;
  unsigned char *buffer;

  // 检测命令格式 {Start1,Start2, data... ,len,End1,End2}
  void (*resolveCommandCallback)(unsigned char *buffer, unsigned char length);
};
#define UartCommandBufferSize 64
uint8 uartCommandBuffer[UartCommandBufferSize] = {0};
struct MyCommand uartCommand;

void MyCommand_addData(struct MyCommand *command, unsigned char tempData) {
  if (!command->isStart) {
    if (command->count == 0 && tempData != command->Start1) {
      return;
    }
    command->count++;
    if (command->count == 2) {
      if (command->Start2 == tempData) {
        command->isStart = true;
        command->count = 0;
      } else {
        command->count = 0;
        if (tempData == command->Start1) {
          command->count++;
        }
      }
    }
    if (command->count > 2) {
      command->count = 0;
      command->isStart = false;
    }
    return;
  }

  if (command->count >= command->bufferSize) {
    command->count = 0;
    command->isStart = false;
  }

  command->buffer[command->count] = tempData;
  command->count++;

  if (command->isStart && command->count >= 4) {
    // 检测结束
    if (tempData == command->End2 &&
        command->buffer[command->count - 2] == command->End1) {
      // 长度位
      if (command->buffer[command->count - 3] == command->count - 3) {
        if (command->resolveCommandCallback) {
          command->resolveCommandCallback(command->buffer, command->count - 3);
        }
        command->isStart = false;
        command->count = 0;
      }
    }
  }
}

#define UartReceiveSize 128
#define UartSendSize 128
uint8 uartReceiveBuffer[UartReceiveSize] = {0};
uint8 uartSendBuffer[UartSendSize] = {0};
struct FIFOBuffer uartReceiveFIFO;
struct FIFOBuffer uartSendFIFO;
uint8 isSend = 0;

void UART1_Isr(void) interrupt 4 {
  if (TI) {
    TI = 0;
    // 队列中还有数据, 继续发送
    if (uartSendFIFO.headPos != uartSendFIFO.tailPos) {
      SBUF = FIFOBuffer_read(&uartSendFIFO);
    } else {
      isSend = 0;
    }
  }
  if (RI) {
    RI = 0;
    // 接收到数据, 放入队列
    FIFOBuffer_push(&uartReceiveFIFO, SBUF);
  }
}
void uart1Write(uint8 dat) {
  FIFOBuffer_push(&uartSendFIFO, dat);
  if (isSend == 0) {
    isSend = 1;
    SBUF = FIFOBuffer_read(&uartSendFIFO);
  }
}
void uart1WriteBuf(uint8 *buffer, uint8 length) {
  uint8 i = 0;
  for (i = 0; i < length; i++) {
    FIFOBuffer_push(&uartSendFIFO, buffer[i]);
  }
  if (isSend == 0) {
    isSend = 1;
    SBUF = FIFOBuffer_read(&uartSendFIFO);
  }
}
void uart1WriteString(uint8 *str) {
  while (*str) {
    FIFOBuffer_push(&uartSendFIFO, *str++);
  }
  if (isSend == 0) {
    isSend = 1;
    SBUF = FIFOBuffer_read(&uartSendFIFO);
  }
}

void initUartCommand(void (*commandCallback)(uint8 *buffer, uint8 length)) {
  uartReceiveFIFO.headPos = 0;
  uartReceiveFIFO.tailPos = 0;
  uartReceiveFIFO.bufferSize = UartReceiveSize;
  uartReceiveFIFO.buffer = uartReceiveBuffer;

  uartSendFIFO.headPos = 0;
  uartSendFIFO.tailPos = 0;
  uartSendFIFO.bufferSize = UartSendSize;
  uartSendFIFO.buffer = uartSendBuffer;

  uartCommand.Start1 = 0xf0;
  uartCommand.Start2 = 0xf1;
  uartCommand.End1 = 0xe0;
  uartCommand.End2 = 0xe1;
  uartCommand.isStart = 0;
  uartCommand.count = 0;
  uartCommand.bufferSize = UartCommandBufferSize;
  uartCommand.buffer = uartCommandBuffer;
  uartCommand.resolveCommandCallback = commandCallback;
}

5.使用demo, 运行芯片为stc32g8k64, 编译环境基于天问block工具, 关于JSTime.h看上篇上篇博客

#define IRC_24M
#define PLL_NO
#define boolean unsigned char
#define true 1
#define false 0
#define HIGH 1
#define LOW 0

#include <STC32G.h>
uint32 sys_clk = 24000000; // 设置PWM、定时器、串口、EEPROM频率参数
#include <stdio.h>
#include "lib/rcclock.h"
#include "lib/UART.h"
#include "lib/ADC.h"
#include "lib/delay.h"
#include "lib/eeprom.h"
#include "myLib/MyCommand.h"
#include "myLib/JSTime.h"

#define LED_PIN P2_1

uint32 loopCount = 0; // 程序循环次数
uint32 answerTimeoutId = 0;

// 编写一个方法计算字节的校验和
uint8 getCheckSum(uint8 *buffer, uint8 start, uint8 end)
{
  uint8 i = 0;
  uint8 sum = 0;
  for (i = start; i < end; i++)
  {
    sum += buffer[i];
  }
  return sum;
}

void answerOk()
{
  uint8 i = 0;
  uint8 cmdData[20] = {0};
  uint32 curTime = micros();
  cmdData[i++] = uartCommand.Start1;
  cmdData[i++] = uartCommand.Start2;
  cmdData[i++] = '0';
  cmdData[i++] = 'k';
  cmdData[i++] = i - 2;
  cmdData[i++] = uartCommand.End1;
  cmdData[i++] = uartCommand.End2;
  uart1WriteBuf(cmdData, i);
}

// 接收到指令回调
// 返回的buffer, 会去掉帧头f0 f1
void receiveUartDataCallback(uint8 *buffer, uint8 length)
{
  // 测试发送
  // f0 f1 01 02 00 00 05 e0 e1
  if (buffer[0] == 0x01 && buffer[1] == 0x02)
  {
    // 延时1000ms回复
    clearTime(answerTimeoutId);
    answerTimeoutId = setTimeout(answerOk, 1000);
  }
}

void sendDemo()
{
  uint8 i = 0;
  uint8 cmdData[20] = {0};
  uint32 curTime = micros();
  cmdData[i++] = uartCommand.Start1;
  cmdData[i++] = uartCommand.Start2;
  cmdData[i++] = 0x02;
  cmdData[i++] = 0x01;
  // loopCount
  cmdData[i++] = loopCount >> 24;
  cmdData[i++] = loopCount >> 16;
  cmdData[i++] = loopCount >> 8;
  cmdData[i++] = loopCount & 0x000000ff;
  // curTime
  cmdData[i++] = curTime >> 24;
  cmdData[i++] = curTime >> 16;
  cmdData[i++] = curTime >> 8;
  cmdData[i++] = curTime & 0x000000ff;

  cmdData[i++] = getCheckSum(cmdData, 2, i); // 校验和
  cmdData[i++] = i - 2;
  cmdData[i++] = uartCommand.End1;
  cmdData[i++] = uartCommand.End2;

  uart1WriteBuf(cmdData, i);
}

void mytask1()
{
  LED_PIN = !LED_PIN;
}

void mytask2()
{
  sendDemo();
}

void setup()
{
  rcclock_set_irc(1);
  P2M1 &= ~0x01;
  P2M0 |= 0x01; // 推挽输出
  P2M1 &= ~0x02;
  P2M0 |= 0x02; // 推挽输出
  P2M1 &= ~0x04;
  P2M0 |= 0x04; // 推挽输出
  P2M1 &= ~0x08;
  P2M0 |= 0x08; // 推挽输出
  P3M1 |= 0x04;
  P3M0 &= ~0x04;                                                 // P3.2 高阻输入
  uart_init(UART_1, UART1_RX_P30, UART1_TX_P31, 1000000, TIM_1); // 初始化串口
  JSTime_init();
  initUartCommand(receiveUartDataCallback);
  ES = 1; // 允许串行口中断
  EA = 1; // 允许总中断
  delay(200);
  setInterval(mytask1, 500);
  setInterval(mytask2, 1000);
}

void ispDowbload()
{
  if (P3_2 == LOW)
  {
    if (P3_2 == LOW)
    {
      IAP_CONTR = 0x60; // 进入ISP下载
    }
  }
}

void uartLoopRead()
{
  while (uartReceiveFIFO.headPos != uartReceiveFIFO.tailPos)
  {
    MyCommand_addData(&uartCommand, FIFOBuffer_read(&uartReceiveFIFO));
  }
}

void loop()
{
  JSTime_refresh();
  ispDowbload();
  uartLoopRead();
  loopCount++;
}

void main(void)
{
  setup();
  while (1)
  {
    loop();
  }
}

我就是做web前端开发的, 用javascript的思想来开发C51用来diy个小东西, 我发现专业人员是不乐意分享代码的, 那我就来分享, web前端是所有编程领域内最具分享精神的

仁泉之子
关注
  • 9
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现FIFO环形存储器
weixin_47057981的博客
04-16 2094
前言 在CSDN社区看了很多FIFO的C语言实现，发现大多写的很复杂，看不懂。FIFO机制在嵌入式开发中串口数据收发处理相当方便，因此决定分享一下C语言的实现方法。代码很简单，就两个函数:fifo_put和fifo_get,可以结合串口直接进行调用，在项目中使用过。 FIFO环形存储器读写说明 为了解释方便，定义几个变量fifo.in：写入地址指针，fifo.out：读取地址指针，fifo.cou...
FPGA串口数据包协议解析后的通过单口RAM和FIFO数据存储
02-22
FPGA先根据数据包协议接收数据并存储到RAM，在接收到完整一包数据后，将数据从RAM转移到FIFO中，后端的数据处理或者数据转发可以直接从FIFO读取。本代码模拟数据写入RAM，然后到FIFO过程。开发环境 Quartus18.1 ，...
C语言实现一个简易的环形FIFO
stephenbruce的博客
02-12 527
设计一个环形FIFO缓冲区，用于存储原始数据。环形FIFO缓冲区最大有10个节点，每个节点有200个原始数据，即200个unsigned int类型的数据。其中，包括写FIFO函数，读FIFO函数，删除某节点函数，删除整个FIFO函数等。
环形队列FIFO实现方法
DanielLee_ustb的专栏
01-06 7576
有的单片机串口没有FIFO，或者可分配的FIFO大小是非常有限的，如果在程序中需要向外设发送一个很大的数据包，需要很长的时间，为了解决应用程序与外设硬件读写同步的问题，很有必要自己实现环形FIFO。 #include "stdafx.h" #include #include using namespace std; #define  ERROR_FULL_W  -1 #define
STM32环形串口队列实现大数据串口收发，实时不丢包
最新发布
wAtXqHv的博客
04-12 376
因为串口通信是一种常见的通信方式，许多不同的单片机都提供了串口功能，用户可以根据自己的需求选择适合的单片机平台，并将该程序移植过去使用。STM32环形串口队列程序 大数据串口收发 实时不丢包 串口程序平常产品开发中编写或移植的程序并亲自测试通过，均为工程文件格式，可直接编译使用。该程序为大数据量吞吐的串口收发例程，中断接收，边收边发，采用大数据环形队列，处理过程超快不丢包，接收buffer可以定义成2K,4K,8K均可。注：这个程序是经过验证的，并且提供了工程文件格式，可以直接编译和使用。
51单片机串口接收一个数组
weixin_30701521的博客
07-04 2725
/****************************************************************************************** 串口中断函数 ReData[]: 里是一个字节类型的数组,这里一次只接收8个字节数据. *********************************************************...
【STM32】HAL库开发教程(四)—串口FIFO使用
weixin_44064233的博客
09-14 6154
前言
51单片机之——串口通信（含实现部分）
热门推荐
欢迎一起交流问题！
09-25 2万+
本篇文章将实现两个部分，第一部分为实现单片机通过串口向电脑发送数据；第二部分为实现电脑通过串口控制单片机LED灯
（FIFO）串口接收和发送.zip_FIFO 串口 接收_fsmc和fifo_stm32 fifo队列_stm32 实现队列_串
07-15
使用stm32的串口实现fifo队列缓冲读写数据，值得新手学习
软件环形FIFO数据存储
06-20
环形FIFO（First In First Out）数据存储是一种常见的数据管理策略，尤其在计算机系统和通信领域中广泛应用。它的核心思想是数据元素按照先进先出的规则进行存取，类似于现实生活中的排队现象。在环形FIFO中，数据...
STM32进阶之串口环形缓冲区实现 FIFO
01-26
本主题将深入探讨如何在STM32上实现串口通信的FIFO（先进先出）环形缓冲区，这是一项对于高效、稳定的数据传输至关重要的技术。 **FIFO（先进先出）原理** FIFO是一种数据结构，其中数据按照插入的顺序被取出。在...
51单片机接收数组知识
08-18
最近在做一个项目，其中有一模块是需要通过串口使单片机与电脑进行通信，在单片机中我是用C语言进行编程，在应用程序中是用.net编程。其中有一个要求是电脑一次发送十个数据，单片机里定义一个数组，接收这10个数据。
利用光纤通道协议和异步FIFO实现FC-AL通信弹性缓存的设计
01-19
接收机在时钟Clk1的上升沿把数据写入弹性缓存，发送机在时钟Clk2的上升沿从弹性缓存中读出数据，从而实现数据的同步。　虽然光纤通道仲裁环中的所有通信设备必须工作在同一频率，但图1中两个不同源的时钟信号Clk1和...
STM32实现串口转发功能，使用UART DMA方式不定长接收，FIFO接收与发送，数据零拷贝
05-13
程序设计：基于STM32HAL库，UART DMA方式接收与发送，串口数据缓存使用lwrb（FIFO），接收与发送的数据实现零拷贝，为了单片机使用效率，可以参考。 测试验证：上位机向两个串口进行1ms定时发送1024字节，百万数据量...
HAL库STM32f0串口DMA空闲中断接收fifo数据处理
09-03
在测试过程中，确保串口、DMA和中断配置正确，通过示波器或逻辑分析仪检查串口通信信号，以及使用终端工具发送和接收数据，验证程序的正确性和稳定性。 总结，"HAL库STM32f0串口DMA空闲中断接收fifo数据处理"涉及了...
FIFO环形存储器C实现.rar
04-16
`fifo_write`和`fifo_read`分别实现了向FIFO写入数据和从FIFO读取数据，它们会根据环形存储的特性进行操作，即当写入指针追上或超过读取指针时，表示FIFO已满；当读取指针追上或超过写入指针时，表示FIFO为空。 `...
异步FIFO设计代码
kobetriumph的博客
07-01 2059
异步FIFO的RTL代码实现
C51片内数据传送指令
MasterC的博客
11-13 1912
前言: direct代表一个十六进制地址，例如32H，direct代表什么，传入的就是direct地址中的内容，例如MOV A,32H且32H中的内容是20H，那么执行完该指令之后，A中的内容是20H #data代表一个立即数，使用的时候，将data替换即可，例如#32H,#后面接什么数，传入的就是什么数，例如MOV A,#20H，那么执行完该指令后，A中的内容是20H @Ri(其中i=0或
FPGA学习笔记(3):FIFO
qq_19655649的博客
03-29 1165
FIFO是First Input First Output的英文简写 代表先进的数据先出 ，后进的数据后出。FIFO通常用于跨时钟域设计，所以说通常是双时钟设计。即读\写的时钟是分开来的。但是直接设计这样的系统对我们的有很高的要求，我企图由同步FIFO的设计，虽然同步FIFO在实际运用中运用范围有限但是其还是为我们的异步设计带来了启发。本人水平有限，文章有错误的地方希望大家不吝赐教。
c51串口通信接收数据
09-13
要通过C51实现串口通信接收数据，你可以按照以下步骤进行操作： 1. 首先，确保你已经正确连接了串口设备。根据引用中提到的，你需要将数据线连接到C51的相应引脚，即P3^3口。 2. 接下来，你需要在C51的代码中配置串口通信相关的寄存器。具体的配置步骤可以参考引用中提到的"C51串口通讯5-一串数据中断定时超时接收接收应答CRC校验"章节。 3. 在代码中，你可以使用中断或轮询的方式来接收数据。如果你选择使用中断方式，你需要配置相应的中断向量和中断服务程序，以便在接收到数据时能够及时处理。 4. 在中断服务程序或主循环中，你可以通过读取串口接收缓冲区的数据来获取接收到的数据。具体的读取方式可以参考引用中提到的"串口数据接收"部分。 总结起来，你需要首先连接好硬件，并在C51的代码中进行串口通信配置。然后，根据你选择的接收方式（中断或轮询），编写相应的代码来获取接收到的数据。请注意，具体的代码实现可能会因为你使用的C51开发环境和硬件平台而有所不同。因此，建议你参考引用中的具体章节和引用中的示例代码，来获得更详细的指导。希望这些信息对你有所帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值