当前位置： 首页 > wzjs >正文

企业网站网站设计百度数据指数

wzjs 2025/8/12 2:50:35
企业网站网站设计,百度数据指数,做网站对商家的好处,洛阳霞光建设网站文章目录 一、场景描述二、框架搭建设计思路通信协议设计2号单片机通讯框架框架优化建议 三、2号单片机的通讯框架如何处理消息丢失和重传？消息丢失与重传机制设计改进的通信协议重传机制实现关键机制说明优化建议 一、场景描述 有3个单片机进行通讯，分…

文章目录

  • 一、场景描述
  • 二、框架搭建
      • 设计思路
      • 通信协议设计
      • 2号单片机通讯框架
      • 框架优化建议
  • 三、2号单片机的通讯框架如何处理消息丢失和重传？
      • 消息丢失与重传机制设计
      • 改进的通信协议
      • 重传机制实现
      • 关键机制说明
      • 优化建议

一、场景描述

有3个单片机进行通讯，分别为1号，2号，3号。
1号与2号可以通讯，2号与3号可以通讯。

那么如果1号想通过2号，与3号进行通讯。

如何搭建2号的通讯框架，保证1号的通讯能够及时给3号，同时3号也能及时应答给1号。使用串口通讯，协议自定

二、框架搭建

设计思路

为了实现三个单片机之间的可靠中继通信，2号单片机需要设计一个高效的通讯框架。关键在于如何处理串口接收、消息转发和应答机制，同时保证消息的实时性和可靠性。

通信协议设计

首先需要定义一个简单但功能完整的通信协议：

消息格式: [SOF][源地址][目标地址][消息ID][长度][数据][CRC]- SOF: 起始字节 (0xAA)- 源地址: 发送方ID (1,2,3)- 目标地址: 接收方ID (1,2,3)- 消息ID: 标识消息类型 (0x01-命令, 0x02-数据, 0x03-应答)- 长度: 数据字段长度- 数据: 消息内容- CRC: 校验字节

2号单片机通讯框架

下面是2号单片机的通讯框架实现，使用状态机处理消息接收，使用双缓冲区实现消息转发：

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>// 定义系统常量
#define SOF             0xAA
#define DEVICE_ID_1     0x01
#define DEVICE_ID_2     0x02
#define DEVICE_ID_3     0x03// 消息类型定义
#define MSG_CMD         0x01
#define MSG_DATA        0x02
#define MSG_ACK         0x03// 消息缓冲区大小
#define MAX_MSG_LENGTH  64
#define BUFFER_SIZE     5// 消息结构体
typedef struct {uint8_t src_addr;uint8_t dst_addr;uint8_t msg_id;uint8_t length;uint8_t data[MAX_MSG_LENGTH];uint8_t crc;
} Message;// 接收状态机枚举
typedef enum {RX_STATE_IDLE,RX_STATE_SOF,RX_STATE_SRC,RX_STATE_DST,RX_STATE_MSGID,RX_STATE_LENGTH,RX_STATE_DATA,RX_STATE_CRC
} RxState;// 全局变量
static Message rx_buffer[BUFFER_SIZE];
static Message tx_buffer[BUFFER_SIZE];
static uint8_t rx_head = 0;
static uint8_t rx_tail = 0;
static uint8_t tx_head = 0;
static uint8_t tx_tail = 0;
static RxState rx_state = RX_STATE_IDLE;
static uint8_t rx_index = 0;
static uint8_t crc_calculated = 0;// 串口初始化函数
void UART1_Init(void) {// 配置1号串口(与1号单片机通信)// 波特率、中断等配置
}void UART2_Init(void) {// 配置2号串口(与3号单片机通信)// 波特率、中断等配置
}// CRC校验计算
uint8_t calculate_crc(uint8_t *data, uint8_t length) {uint8_t crc = 0;for (uint8_t i = 0; i < length; i++) {crc ^= data[i];}return crc;
}// 发送消息函数
void send_message(Message *msg, uint8_t uart_id) {uint8_t buffer[MAX_MSG_LENGTH + 6];uint8_t index = 0;buffer[index++] = SOF;buffer[index++] = msg->src_addr;buffer[index++] = msg->dst_addr;buffer[index++] = msg->msg_id;buffer[index++] = msg->length;for (uint8_t i = 0; i < msg->length; i++) {buffer[index++] = msg->data[i];}buffer[index++] = calculate_crc(buffer, index);// 根据uart_id选择发送串口if (uart_id == 1) {// 通过UART1发送buffer} else {// 通过UART2发送buffer}
}// 1号串口接收中断处理函数
void UART1_RX_IRQHandler(void) {uint8_t data = UART1_ReadByte();switch (rx_state) {case RX_STATE_IDLE:if (data == SOF) {rx_state = RX_STATE_SOF;crc_calculated = data;}break;case RX_STATE_SOF:rx_buffer[rx_head].src_addr = data;rx_state = RX_STATE_SRC;crc_calculated ^= data;break;case RX_STATE_SRC:rx_buffer[rx_head].dst_addr = data;rx_state = RX_STATE_DST;crc_calculated ^= data;break;case RX_STATE_DST:rx_buffer[rx_head].msg_id = data;rx_state = RX_STATE_MSGID;crc_calculated ^= data;break;case RX_STATE_MSGID:rx_buffer[rx_head].length = data;rx_state = RX_STATE_LENGTH;crc_calculated ^= data;rx_index = 0;break;case RX_STATE_LENGTH:rx_buffer[rx_head].data[rx_index++] = data;crc_calculated ^= data;if (rx_index >= rx_buffer[rx_head].length) {rx_state = RX_STATE_CRC;}break;case RX_STATE_CRC:if (data == crc_calculated) {// 消息接收成功，加入接收缓冲区rx_head = (rx_head + 1) % BUFFER_SIZE;}rx_state = RX_STATE_IDLE;break;}
}// 3号串口接收中断处理函数(与UART1_RX_IRQHandler类似)
void UART2_RX_IRQHandler(void) {// 实现类似UART1_RX_IRQHandler的逻辑// 将接收到的消息存入rx_buffer
}// 主循环中的消息处理函数
void process_messages(void) {Message msg;// 处理从1号单片机接收的消息while (rx_tail != rx_head) {msg = rx_buffer[rx_tail];// 如果消息是给3号的，转发到3号if (msg.dst_addr == DEVICE_ID_3) {// 修改源地址为2号msg.src_addr = DEVICE_ID_2;send_message(&msg, 2);  // 通过UART2发送到3号}// 如果消息是给1号的(来自3号的应答)，转发到1号else if (msg.dst_addr == DEVICE_ID_1) {// 修改源地址为2号msg.src_addr = DEVICE_ID_2;send_message(&msg, 1);  // 通过UART1发送到1号}rx_tail = (rx_tail + 1) % BUFFER_SIZE;}
}// 主函数
int main(void) {UART1_Init();UART2_Init();// 启用中断UART1_EnableIRQ();UART2_EnableIRQ();while (1) {// 处理消息转发process_messages();// 其他任务// ...}
}

框架优化建议

  1. 优先级机制：为紧急消息设置高优先级，优先处理和转发。

  2. 流量控制：当缓冲区满时，发送忙信号给发送方，防止消息丢失。

  3. 超时重传：对重要消息实现超时重传机制，确保消息可靠传输。

  4. 状态监控：添加通信状态监控，统计消息收发成功率，便于故障排查。

  5. 中断处理优化：尽量减少中断处理时间，关键数据复制到缓冲区后尽快退出中断。

通过以上设计，2号单片机可以高效地实现1号和3号之间的消息中继，同时保证通信的实时性和可靠性。

三、2号单片机的通讯框架如何处理消息丢失和重传？

消息丢失与重传机制设计

为了处理消息丢失和实现可靠重传，2号单片机的通讯框架需要增加确认机制、超时处理和消息缓存功能。以下是具体实现方案：

改进的通信协议

在原有协议基础上增加序列号和确认应答：

消息格式: [SOF][源地址][目标地址][消息ID][序列号][长度][数据][CRC]- 序列号: 8位递增数字(0-255)，用于标识消息- 确认应答(ACK)格式: [SOF][源地址][目标地址][MSG_ACK][序列号][0][CRC]

重传机制实现

以下是改进后的2号单片机通讯框架代码，增加了消息缓存和重传机制：

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>// 定义系统常量
#define SOF             0xAA
#define DEVICE_ID_1     0x01
#define DEVICE_ID_2     0x02
#define DEVICE_ID_3     0x03// 消息类型定义
#define MSG_CMD         0x01
#define MSG_DATA        0x02
#define MSG_ACK         0x03// 消息缓冲区大小
#define MAX_MSG_LENGTH  64
#define TX_BUFFER_SIZE  10
#define RX_BUFFER_SIZE  10
#define MAX_RETRIES     3
#define RETRY_TIMEOUT   100  // 毫秒// 消息结构体
typedef struct {uint8_t src_addr;uint8_t dst_addr;uint8_t msg_id;uint8_t seq_num;uint8_t length;uint8_t data[MAX_MSG_LENGTH];uint8_t crc;uint32_t timestamp;  // 发送时间戳uint8_t retries;     // 重试次数bool awaiting_ack;   // 是否等待确认
} Message;// 接收状态机枚举
typedef enum {RX_STATE_IDLE,RX_STATE_SOF,RX_STATE_SRC,RX_STATE_DST,RX_STATE_MSGID,RX_STATE_SEQ,RX_STATE_LENGTH,RX_STATE_DATA,RX_STATE_CRC
} RxState;// 全局变量
static Message tx_buffer[TX_BUFFER_SIZE];  // 发送缓冲区(用于重传)
static Message rx_buffer[RX_BUFFER_SIZE];  // 接收缓冲区
static uint8_t tx_head = 0;
static uint8_t tx_tail = 0;
static uint8_t rx_head = 0;
static uint8_t rx_tail = 0;
static RxState rx_state = RX_STATE_IDLE;
static uint8_t rx_index = 0;
static uint8_t crc_calculated = 0;
static uint8_t next_seq_num = 0;  // 下一个发送的序列号// 串口初始化函数
void UART1_Init(void) {// 配置1号串口(与1号单片机通信)// 波特率、中断等配置
}void UART2_Init(void) {// 配置2号串口(与3号单片机通信)// 波特率、中断等配置
}// CRC校验计算
uint8_t calculate_crc(uint8_t *data, uint8_t length) {uint8_t crc = 0;for (uint8_t i = 0; i < length; i++) {crc ^= data[i];}return crc;
}// 发送消息函数
void send_message(Message *msg, uint8_t uart_id, bool store_for_retry) {uint8_t buffer[MAX_MSG_LENGTH + 7];uint8_t index = 0;buffer[index++] = SOF;buffer[index++] = msg->src_addr;buffer[index++] = msg->dst_addr;buffer[index++] = msg->msg_id;buffer[index++] = msg->seq_num;buffer[index++] = msg->length;for (uint8_t i = 0; i < msg->length; i++) {buffer[index++] = msg->data[i];}buffer[index++] = calculate_crc(buffer, index);// 根据uart_id选择发送串口if (uart_id == 1) {// 通过UART1发送buffer} else {// 通过UART2发送buffer}// 如果需要存储用于重传if (store_for_retry && msg->msg_id != MSG_ACK) {// 复制消息到发送缓冲区memcpy(&tx_buffer[tx_head], msg, sizeof(Message));tx_buffer[tx_head].timestamp = get_current_time();  // 获取当前时间tx_buffer[tx_head].retries = 0;tx_buffer[tx_head].awaiting_ack = true;tx_head = (tx_head + 1) % TX_BUFFER_SIZE;}
}// 1号串口接收中断处理函数
void UART1_RX_IRQHandler(void) {uint8_t data = UART1_ReadByte();switch (rx_state) {case RX_STATE_IDLE:if (data == SOF) {rx_state = RX_STATE_SOF;crc_calculated = data;}break;// 其他状态处理...(与之前类似)case RX_STATE_CRC:if (data == crc_calculated) {// 消息接收成功，加入接收缓冲区if (rx_buffer[rx_head].msg_id == MSG_ACK) {// 处理确认应答，标记对应消息已确认process_ack(&rx_buffer[rx_head]);} else {// 普通消息，转发并发送本地ACKforward_message(&rx_buffer[rx_head]);send_ack(rx_buffer[rx_head].src_addr, rx_buffer[rx_head].seq_num);}rx_head = (rx_head + 1) % RX_BUFFER_SIZE;}rx_state = RX_STATE_IDLE;break;}
}// 3号串口接收中断处理函数
void UART2_RX_IRQHandler(void) {// 与UART1_RX_IRQHandler类似，处理来自3号的消息
}// 处理确认应答
void process_ack(Message *ack) {uint8_t index = tx_tail;while (index != tx_head) {if (tx_buffer[index].awaiting_ack && tx_buffer[index].seq_num == ack->seq_num &&tx_buffer[index].dst_addr == ack->src_addr) {// 标记消息已确认tx_buffer[index].awaiting_ack = false;break;}index = (index + 1) % TX_BUFFER_SIZE;}
}// 转发消息
void forward_message(Message *msg) {Message forward_msg;memcpy(&forward_msg, msg, sizeof(Message));if (msg->dst_addr == DEVICE_ID_3) {// 转发到3号forward_msg.src_addr = DEVICE_ID_2;send_message(&forward_msg, 2, true);} else if (msg->dst_addr == DEVICE_ID_1) {// 转发到1号forward_msg.src_addr = DEVICE_ID_2;send_message(&forward_msg, 1, true);}
}// 发送确认应答
void send_ack(uint8_t dst_addr, uint8_t seq_num) {Message ack_msg;ack_msg.src_addr = DEVICE_ID_2;ack_msg.dst_addr = dst_addr;ack_msg.msg_id = MSG_ACK;ack_msg.seq_num = seq_num;ack_msg.length = 0;if (dst_addr == DEVICE_ID_1) {send_message(&ack_msg, 1, false);} else {send_message(&ack_msg, 2, false);}
}// 检查并重传超时消息
void check_and_retransmit(void) {uint32_t current_time = get_current_time();uint8_t index = tx_tail;while (index != tx_head) {if (tx_buffer[index].awaiting_ack && (current_time - tx_buffer[index].timestamp > RETRY_TIMEOUT)) {// 检查重试次数if (tx_buffer[index].retries >= MAX_RETRIES) {// 达到最大重试次数，处理失败handle_transmission_failure(&tx_buffer[index]);tx_buffer[index].awaiting_ack = false;} else {// 重传消息tx_buffer[index].retries++;tx_buffer[index].timestamp = current_time;if (tx_buffer[index].dst_addr == DEVICE_ID_1) {send_message(&tx_buffer[index], 1, false);} else {send_message(&tx_buffer[index], 2, false);}}}index = (index + 1) % TX_BUFFER_SIZE;}// 清理已确认的消息while (tx_tail != tx_head && !tx_buffer[tx_tail].awaiting_ack) {tx_tail = (tx_tail + 1) % TX_BUFFER_SIZE;}
}// 处理传输失败
void handle_transmission_failure(Message *msg) {// 可以实现错误日志记录或通知上层应用
}// 获取当前时间(伪代码，需根据实际硬件实现)
uint32_t get_current_time(void) {// 返回系统时间(毫秒)return 0;
}// 主循环中的消息处理函数
void process_messages(void) {// 检查并重传超时消息check_and_retransmit();// 处理接收缓冲区中的消息while (rx_tail != rx_head) {// 处理消息...rx_tail = (rx_tail + 1) % RX_BUFFER_SIZE;}
}// 主函数
int main(void) {UART1_Init();UART2_Init();// 启用中断UART1_EnableIRQ();UART2_EnableIRQ();while (1) {// 处理消息转发和重传process_messages();// 其他任务// ...}
}

关键机制说明

  1. 序列号管理：

    • 每个消息分配唯一序列号(0-255循环)
    • 用于识别重复消息和匹配ACK应答

  2. 确认应答机制：

    • 接收方收到消息后发送ACK应答
    • ACK包含原始消息的序列号
    • 发送方维护待确认消息列表

  3. 超时重传：

    • 设置合理的超时时间(RETRY_TIMEOUT)
    • 超过时间未收到ACK则重传
    • 限制最大重试次数(MAX_RETRIES)

  4. 消息缓存：

    • 使用环形缓冲区存储待确认消息
    • 消息包含发送时间戳和重试次数

优化建议

  1. 滑动窗口协议：

    • 扩展当前实现，支持多消息并发发送
    • 增加窗口大小参数，提高吞吐量

  2. 动态超时调整：

    • 根据网络状况动态调整超时时间
    • 实现往返时间(RTT)测量

  3. 流量控制：

    • 当发送缓冲区满时拒绝接收新消息
    • 实现基于窗口的流量控制机制

  4. 错误恢复：

    • 实现序列号回滚机制
    • 处理序列号溢出情况

通过以上机制，2号单片机可以有效处理消息丢失问题，确保1号和3号之间的通信可靠性。

http://www.dtcms.com/wzjs/312195.html

相关文章：

  • 动画毕业设计代做网站百度在线使用
  • 郑州网站开发培训价格360收录查询
  • 落地页模板网站长沙百度快速排名
  • 长沙建网站设计营销策划方案怎么写
  • 天津市建设工程合同备案网站做seo推广一年大概的费用
  • 国外做ic的网站360地图下载最新版
  • 西安市沣东新城建设局网站网站推广公司
  • asp.net开发微网站开发建站公司最新报价
  • 公司网站重新建站通知淄博网站优化
  • 沙朗镇做网站公司sem是什么意思职业
  • 怎么做外围网站代理申请域名
  • 南阳网站排名公司口碑营销策划方案
  • 做影视网站 片源从哪里来如何做市场调研和分析
  • 域名备案名称江门搜狗网站推广优化
  • 银川做网站的有哪些东莞疫情最新消息通知
  • vps搭建网站网站搜索系统
  • 做网站会有侵权网站制作公司排行榜
  • 正保建设工程网站线上推广的公司
  • 建立网站怎么做关键字app推广刷量
  • 韩城网站建设韩城网站推广优化防控措施
  • wordpress加入aiaso优化
  • 安徽盛绿建设网站体验营销是什么
  • 青白江建设网站产品推广活动策划方案
  • 做网站用什么软件ps字体湖北网站seo策划
  • 包小盒设计网站短视频推广平台有哪些
  • 英山做网站多少钱开封网络推广公司
  • 做网站纸张大小百度互联网营销顾问
  • 搜索引擎和门户网站的区别手机百度2020最新版
  • 河南省建设银行网站年报合肥优化推广公司
  • 做游乐设施模型的网站深圳网站优化公司