MCU中的LSB、MSB和大端模式、小端模式

第一章 LSB和MSB

1.1 最低有效位(Least Significant Bit, LSB)

红外接收器接收了0x45（0100 0101）之后，怎么将这个数据发送给MCU;
   LSB（least significant bit）：最低有效位优先，例如红外通信是以最低有效位发送和接收的
  LSB发送的比特顺序： 1010 0010
  
当接收到按键数据时，红外接收头将数据按照从低到高，一个bit一个bit的将数据发生转发给MCU的GPIO口；
  1.1.1 MCU的接收示例 

1. int32_t readIRData(uint8_t *pbuff){
2.        
3.         uint32_t timeout;                        // 超时时间
4.         uint8_t tempData;                        // 保存临时的1Byte数据
5.         int8_t i, j;                               
6.         uint8_t *pData = pbuff;                // 使用一个指针来指向传递进来的数组       
8.         /* 红外通讯协议要求引导码为低电平；
9.         * 如果检测端口有高电平说明错误
10.         */
11.         if(PAin(8) == 1){
12.                 return -1;
13.         }
15.         /* 检测端口低电平持续时间 */
16.         timeout = 0;
17.         while(PAin(8) == 0){
18.                 timeout++;
19.                 delay_us(10);
20.                
21.                 /* 红外接收头需要给端口输入9ms左右的低电平“引导码”
22.                 * delay_us(10) * 1000 = 10000us = 10ms
23.                 */
24.                 if(timeout >= 1000){
25.                         return -2;
26.                 }
27.         }
28.        
29.         /* 检测端口是高电平持续时间 */
30.         timeout = 0;
31.         while(PAin(8)){
32.                 timeout++;
33.                 delay_us(10);
34.                
35.                 /* 红外接收头需要给端口输入4.5ms左右的高电平“引导码”
36.                 * delay_us(10) * 500 = 5000us = 5ms
37.                 */
38.                 if(timeout >= 500){
39.                         return -3;
40.                 }
41.         }
42.        
43.        
44.         /* 接收红外接收头的4Byte数据 = 地址码 + !地址码 + 功能码 + !功能码 */
45.         for(j = 0; j < 4; j++){
46.        
47.                 /* 接收红外接收头的1Byte数据 */
48.                 tempData = 0;
49.                 for(i = 0; i < 8; i++){
50.                         /* 检测端口是低电平持续时间 */
51.                         timeout = 0;
52.                         while(PAin(8) == 0){
53.                                 timeout++;
54.                                 delay_us(10);
55.                                
56.                                 /* 红外接收头需要给端口输入0.56ms(0.56ms * 1000 = 560us)左右的低电平时序*/
57.                                 if(timeout >= 100){
58.                                         return -4;
59.                                 }
60.                         }
61.                        
62.                         /*
63.                         * 借助低电平在延时一段时间，检测再检测高电平还是低电平来判断是0还是1
64.                         * 延时只需要在0.56~1.685ms之间即可
65.                         * 如果高电平时间为0.56ms表示传输数据0， 1.685ms表示数据1；
66.                         */
67.                         delay_us(600);
68.                        
69.                        
70.                         /* 延时600us后，检测再检测高电平还是低电平
71.                         * 如果是高电平，认为红外接收头输入的是数据1，将数据1写入tempData
72.                         * 否则tempData已经全部初始化为是0，所以不必理会。
73.                         */
74.                         if(PAin(8)){
75.                                 tempData |= 1 << i;
76.                                
77.                                 /* 检测端口是高电平持续时间 */
78.                                 timeout = 0;
79.                                 while(PAin(8)){
80.                                         timeout++;
81.                                         delay_us(10);
82.                                        
83.                                         /* 已经延时了delay_us(600); 现在再延时2ms。
84.                                         * 总的延时了2.6ms，远远大于1.685ms。所以要报错*/
85.                                         if(timeout >= 200){
86.                                                 return -5;
87.                                         }
88.                                 }
89.                         }
90.                 }
91.                
92.                 /* 保存一个字节的数据 */
93.                 pData[j] = tempData;
94.         }
95.        
96.         /* 红外接收头拉低电平50us,一次通讯结束 */
97.         delay_us(50);
98.        
99.         /* 校验数据 */
100.         if((pData[0] + pData[1]) == 0xFF){
101.                 if((pData[2] + pData[3]) == 0xFF){
102.                         return 0;
103.                 }
104.         }
106.        
107.         /* 返回错误 */
108.         return -6;
109. }

复制代码

1.1.2  MUC接收表示 

1.2 最高有效位(Most Significant Bit, MSB)

DHT11温湿度传感器一次完备的数据传输为40bit，高位先出。
数据格式：8bit湿度整数数据 + 8bit湿度小数数据 + 8bit温度整数数据 + 8bit温度小数数据 + 8bit校验和。
数据传送正确时校验和数据等于“8bit湿度整数数据 + 8bit湿度小数数据 + 8bit温度整数数据 + 8bit温度小数数据”所得效果的末8位。
温湿度传感器产生了一个字节的数据0xF4（1111 0100）之后，怎么将这个数据发送给MCU;
   MSB（Most Significant Bit）：最高有效位优先，例如获取温湿度比特流数据的时间是以最高有效位接收的。
  MSB发送的比特顺序： 1111 0100
  
当传感器产生数据时，DHT11将数据按照从高到低，一个bit一个bit的将数据发生转发给MCU的GPIO口；
  1.2.1 MCU的接收示例

1. int32_t readDHT11(uint8_t *pbuff){
2.        
3.         uint32_t timeout;                        // 超时时间
4.         uint8_t tempData;                        // 保存临时的1Byte数据
5.         int8_t i, j;                               
6.         uint8_t *pData = pbuff;                // 使用一个指针来指向传递进来的数组       
7.         uint16_t check_sum = 0;                // 定义一个变量。用于计数效验和
9.         /* 配置端口为输出模式 */
10.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
11.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
12.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
13.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
14.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
15.         GPIO_Init(GPIOG,&GPIO_InitStructure);
16.        
17.         /* 端口输出低电平 */
18.         PGout(9) = 0;
19.         delay_ms(20);
20.        
21.         /* 端口输出高电平 */
22.         PGout(9) = 1;
23.         delay_us(30);
24.        
25.         /* 将端口设置为输入模式，准备接受数据 */         
26.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
27.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
28.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
29.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
30.         GPIO_Init(GPIOG, &GPIO_InitStructure);
31.        
32.        
33.         /* 检测端口高电平持续时间 */
34.         timeout = 0;
35.         while(PGin(9)){
36.                 timeout++;
37.                 delay_us(1);
38.                
39.                 /* 高电平时间超过4000ms(DHT11数据手持可知道), 认为DHT11设备损坏 */
40.                 if(timeout >= 4000){
41.                         return -1;
42.                 }
43.         }
44.        
45.         /* 检测端口低电平持续时间 */
46.         timeout = 0;
47.         while(PGin(9) == 0){
48.                 timeout++;
49.                 delay_us(1);
50.                
51.                 /* DHT11需要给端口输入至少80us的低电平时序*/
52.                 if(timeout >= 85){
53.                         return -2;
54.                 }
55.         }
56.        
57.         /* 检测端口是高电平持续时间 */
58.         timeout = 0;
59.         while(PGin(9)){
60.                 timeout++;
61.                 delay_us(1);
62.                
63.                 /* DHT11需要给端口输入至少80us的高电平时序*/
64.                 if(timeout >= 85){
65.                         return -3;
66.                 }
67.         }
68.        
69.        
70.         /* 接收DHT11的40bit(5Byte)数据 */
71.         for(j = 0; j < 5; j++){
72.        
73.                 /* 接收DHT11的8bit(1Byte)数据 */
74.                 tempData = 0;
75.                 for(i = 7; i >= 0; i--){
76.                         /* 检测端口是低电平持续时间 */
77.                         timeout = 0;
78.                         while(PGin(9) == 0){
79.                                 timeout++;
80.                                 delay_us(1);
81.                                
82.                                 /* DHT11需要给端口输入至少50us的低电平时序*/
83.                                 if(timeout >= 60){
84.                                         return -4;
85.                                 }
86.                         }
87.                        
88.                         /*
89.                         * 借助低电平在延时一段时间，检测再检测高电平还是低电平来判断是0还是1
90.                         * 延时只需要在28~70us之间即可
91.                         * 如果高电平时间为26~28us表示传输数据0， 28~70us范围内表示数据1；
92.                         */
93.                         delay_us(40);
94.                        
95.                        
96.                         /* 延时40us后，检测再检测高电平还是低电平
97.                         * 如果是高电平，认为DHT11输入的是数据1，将数据1写入tempData
98.                         * 否则tempData已经全部初始化为是0，所以不必理会。
99.                         */
100.                         if(PGin(9)){
101.                                 tempData |= 1 << i;
102.                                
103.                                 /* 检测端口是高电平持续时间 */
104.                                 timeout = 0;
105.                                 while(PGin(9)){
106.                                         timeout++;
107.                                         delay_us(1);
108.                                        
109.                                         /* DHT11需要给端口输入大于70us的高电平时序，认为错误*/
110.                                         if(timeout >= 75){
111.                                                 return -5;
112.                                         }
113.                                 }
114.                         }
115.                 }
116.                
117.                 /* 保存一个字节的数据 */
118.                 pData[j] = tempData;
119.         }
120.        
121.         /* DHT11拉低电平50us,一次通讯结束 */
122.         delay_us(50);
123.        
124.         /* 判断效验和 */
125.         check_sum = (pData[0] + pData[1] + pData[2] + pData[3]) & 0xFF;
126.         if(check_sum != pData[4]){
127.                 return -6;
128.         }
129.        
130.         /* 全部正确，返回0 */
131.         return 0;
132. }

复制代码

1.2.2  MUC接收表示

第二章 大端模式和小端模式

2.1 大端模式

在大端模式下，多字节数据的高字节存储在低所在，低字节存储在高所在。也就是说，数据的高位在内存中存放得较前。
举个例子，如果要存储 32 位的十六进制数 0x12345678，在大端模式下，它会被按以下顺序存储在内存中：
   所在:    ...     0x01    0x02    0x03    0x04
数据:   ...      0x12    0x34    0x56    0x78
  在内存中的存储顺序是从高位到低位，先存储 0x12（最高字节），再存储 0x34，依此类推。
2.1.1 Modbus通讯协议

Modbus协议使用的是大端模式来表示16位和32位的数据类型。

• 16位数据---2Byte（表示一个寄存器数据）
  

例如，Modbus中读取的16位数据 0x1234 将会按以下方式传输：

• 高字节（MSB）：0x12
  
• 低字节（LSB）：0x34
  

因此，数据将会被按以下顺序传输：0x12 0x34（大端模式）。

• 32位数据----4byte (表示2个寄存器数据)
  

如果Modbus必要传输32位数据，协议也会将其按照大端模式进行存储，即先发送高字节，再发送低字节。例如，32位数据 0x12345678 会按以下顺序传输：

• 高字节：0x12
  
• 次高字节：0x34
  
• 次低字节：0x56
  
• 低字节：0x78
  

传输顺序为：0x12 0x34 0x56 0x78（大端模式）。

 

 2.1.1.1 ModbusRTU主机

1. #include <stdio.h>
2. #include <stdint.h>
4. // 定义宏 MAKEWORD 来组合两个字节
5. #define MAKEWORD(a, b) ((uint16_t)(((uint8_t)(a)) | ((uint16_t)((uint8_t)(b))) << 8))
7. // CRC计算函数（标准的 CRC-16-IBM 算法）
8. uint16_t crc16(const uint8_t *data, uint16_t length) {
9.     uint16_t crc = 0xFFFF;
10.     for (uint16_t i = 0; i < length; ++i) {
11.         crc ^= data[i];
12.         for (uint8_t j = 0; j < 8; ++j) {
13.             if (crc & 0x0001) {
14.                 crc = (crc >> 1) ^ 0xA001;
15.             } else {
16.                 crc >>= 1;
17.             }
18.         }
19.     }
20.     return crc;
21. }
23. int main() {
24.     // 1. 从站地址：0x01
25.     // 2. 功能码：0x03
26.     // 3. 起始寄存器地址：MAKEWORD(0x00, 0x01) => 0x0001
27.     // 4. 寄存器数量：MAKEWORD(0x00, 0x02) => 0x0002
29.     // 定义一个足够大的数组来存放 Modbus RTU 请求帧
30.     uint8_t request_frame[8];
32.     // 填充请求帧数据
33.     request_frame[0] = 0x01;   // 从站地址
34.     request_frame[1] = 0x03;   // 功能码
35.     request_frame[2] = (uint8_t)(MAKEWORD(0x00, 0x01) >> 8); // 起始寄存器地址高字节
36.     request_frame[3] = (uint8_t)(MAKEWORD(0x00, 0x01) & 0xFF); // 起始寄存器地址低字节
37.     request_frame[4] = (uint8_t)(MAKEWORD(0x00, 0x02) >> 8); // 寄存器数量高字节
38.     request_frame[5] = (uint8_t)(MAKEWORD(0x00, 0x02) & 0xFF); // 寄存器数量低字节
40.     // 计算 CRC 校验码
41.     uint16_t crc = crc16(request_frame, 6); // CRC计算不包含 CRC 字节
42.     request_frame[6] = (uint8_t)(crc & 0xFF);       // CRC 低字节
43.     request_frame[7] = (uint8_t)((crc >> 8) & 0xFF); // CRC 高字节
45.     // 输出 Modbus RTU 请求帧
46.     printf("Modbus RTU Request Frame: ");
47.     for (int i = 0; i < 8; i++) {
48.         printf("%02X ", request_frame[i]);
49.     }
50.     printf("\n");
52.     // 发送数据（在实际应用中可以通过串口发送）
53.     // send_data(request_frame, 8); // 伪代码，实际发送数据的函数
55.     return 0;
56. }

复制代码

  Modbus RTU Request Frame: 01 03 00 01 00 02 F7 D4
  
2.1.1.2 ModbusRTU从机

• 主机发送
  

• 从机剖析 
  

1. #define MAKEWORD(a, b)      ((WORD)(((BYTE)(a)) | ((WORD)((BYTE)(b))) << 8))

复制代码

假设你调用 MAKEWORD(0x12, 0x34)，那么：

• a = 0x12（低字节）
  
• b = 0x34（高字节）
  

过程如下：

• 低字节： (BYTE)(a) 效果是 0x12。
  
• 高字节： (WORD)((BYTE)(b)) << 8 效果是 0x34 << 8 = 0x3400。
  

   效果是：0x34 12
  使用上述宏界说剖析主机发送来的帧；

1. typedef struct TModbusProtocol
2. {
3.         /* 缓冲区 */
4.         BYTE pRxd[256];                                        /* 接受帧缓冲地址 */
5.         BYTE pTxd[256];                                        /* 发送帧缓冲地址 */
6.         BYTE byAddress;                                 /* 装置地址 */
8.         /* 浏览结构 */
9.         DWORD dwEventSend;                                /* 动作报告浏览指针 */
11.         /* 计数器 */
12.         WORD wErrorCount;                                /* 异常报文计数,CPT3 */
13.         WORD wSuccessCount;                                /* 成功报文计数,CPT4 */
14.         DWORD dwNetStateCount;                        /* 网络状态 */
15. }TModbusProtocol;
17. static TModbusProtocol me;
18. static BYTE* s_pRxd;                         /* 接受帧缓冲地址 */
19. static BYTE s_byWritePtr;                /* 发送缓冲区写指针 */
24. /* modbus归约处理 */
25. BOOL ManageModbusProtocol(void){
27.     .........
28.         /* 读取接收帧数据 */
29.         dwLen = hw485_read(me.pRxd, 256);
30.         s_pRxd = me.pRxd;
31.     .........
33. }
37. /* 读取多个Hold Register */
38. static BYTE _Frame_03_ReadHoldRegisters(TModbusProtocol* me)
40.     WORD wStartAddr = MAKEWORD(s_pRxd[3], s_pRxd[2]);        // 0x00 01
41.     WORD wCount = MAKEWORD(s_pRxd[5], s_pRxd[4]);            // 0x00 01
43.     /* 个数判断 */
44.     if (wCount < 1 || wCount > MAX_HOLDING_REGISTER_COUNT)
45.             return ExeptionCode_3_ValidateDataValue;
47.     /* 准备工作 */
48.     me->pTxd[s_byWritePtr++] = wCount * 2;                /* BYTE Count */
49. }

复制代码

 
2.2 小端模式

在小端模式模式下，多字节数据的**低字节（LSB）**存储在低所在，**高字节（MSB）**存储在高所在。即数据的低位存放得较前。
同样以 0x12345678 为例，在小端模式下，它会被按以下顺序存储：
   内存存储顺序：
所在:    ...     0x01    0x02    0x03    0x04
数据:   ...    0x78    0x56    0x34    0x12
  2.3 总结

网络字节序、Modbus协议都是大端模式；
主机字节序是小端模式；

 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。