21ic电子技术开发论坛 › 单片机与嵌入式系统 › 瑞萨MCU/MPU › 使用瑞萨移植并验证软件算法-09 大小端转换篇 ...
返回列表 发新帖我要提问

[RA0 & RA2] 使用瑞萨移植并验证软件算法-09 大小端转换篇

[复制链接]
407|3
暮雨之仁 发表于 2026-4-28 23:37 | 显示全部楼层 |阅读模式
移植, , 使用, ,
    跨架构通信 / 跨设备 Flash 读取绝对刚需、纯位操作零复杂运算、资源占用为零的轻量级工具 —— 大小端转换通用封装。支持16/32/64 位单值转换、任意长度数组批量转换、自动检测当前系统端序（适配瑞萨 RA Cortex-M 默认小端 + 其他可能的大端场景），在瑞萨 e²s IDE + RA6M5 上实测通过.


一、函数封装介绍
大小端是指多字节数据在内存中的存储顺序：

  • 小端（Little Endian，LE）：低字节存低地址（瑞萨 RA Cortex-M 默认，x86/x64 也默认）
  • 大端（Big Endian，BE）：高字节存低地址（TCP/IP 网络协议、8051 部分外设、部分工业协议默认）

函数放在 endian_utils.c 和 endian_utils.h 中，覆盖所有常用场景，还加了端序检测宏（编译时或运行时可选，默认运行时检测，兼容性更好）。

头文件（endian_utils.h）
复制
  1. #ifndef ENDIAN_UTILS_H
    

  2. #define ENDIAN_UTILS_H
    


  3. 

  4. #include <stdint.h>
    

  5. #include <stddef.h>
    

  6. #include <stdbool.h>
    


  7. 

  8. // 端序检测：运行时检测（默认，兼容性好）
    

  9. // 若需编译时检测，可注释下面的宏，取消注释上面的
    

  10. // #define ENDIAN_IS_LITTLE 1
    

  11. // #define ENDIAN_IS_BIG 0
    

  12. bool endian_is_little(void);
    


  13. 

  14. // 16位单值大小端互换
    

  15. uint16_t endian_swap16(uint16_t val);
    

  16. // 16位单值：小端→大端
    

  17. uint16_t endian_le16_to_be16(uint16_t le_val);
    

  18. // 16位单值：大端→小端
    

  19. uint16_t endian_be16_to_le16(uint16_t be_val);
    


  20. 

  21. // 32位单值大小端互换
    

  22. uint32_t endian_swap32(uint32_t val);
    

  23. // 32位单值：小端→大端
    

  24. uint32_t endian_le32_to_be32(uint32_t le_val);
    

  25. // 32位单值：大端→小端
    

  26. uint32_t endian_be32_to_le32(uint32_t be_val);
    


  27. 

  28. // 64位单值大小端互换
    

  29. uint64_t endian_swap64(uint64_t val);
    

  30. // 64位单值：小端→大端
    

  31. uint64_t endian_le64_to_be64(uint64_t le_val);
    

  32. // 64位单值：大端→小端
    

  33. uint64_t endian_be64_to_le64(uint64_t be_val);
    


  34. 

  35. // 16位数组批量大小端互换
    

  36. void endian_swap16_array(uint16_t *arr, size_t count);
    

  37. // 16位数组批量：小端→大端
    

  38. void endian_le16_to_be16_array(uint16_t *arr, size_t count);
    

  39. // 16位数组批量：大端→小端
    

  40. void endian_be16_to_le16_array(uint16_t *arr, size_t count);
    


  41. 

  42. // 32位数组批量大小端互换
    

  43. void endian_swap32_array(uint32_t *arr, size_t count);
    

  44. // 32位数组批量：小端→大端
    

  45. void endian_le32_to_be32_array(uint32_t *arr, size_t count);
    

  46. // 32位数组批量：大端→小端
    

  47. void endian_be32_to_le32_array(uint32_t *arr, size_t count);
    


  48. 

  49. // 64位数组批量大小端互换
    

  50. void endian_swap64_array(uint64_t *arr, size_t count);
    

  51. // 64位数组批量：小端→大端
    

  52. void endian_le64_to_be64_array(uint64_t *arr, size_t count);
    

  53. // 64位数组批量：大端→小端
    

  54. void endian_be64_to_le64_array(uint64_t *arr, size_t count);
    


  55. 

  56. #endif
实现文件（endian_utils.c）
复制
  1. #include "endian_utils.h"
    


  2. 

  3. // 运行时端序检测
    

  4. bool endian_is_little(void) {
    

  5.     union {
    

  6.         uint16_t u16;
    

  7.         uint8_t u8[2];
    

  8.     } test_union = {0x1234};
    

  9.     return (test_union.u8[0] == 0x34);
    

  10. }
    


  11. 

  12. // 16位单值大小端互换
    

  13. uint16_t endian_swap16(uint16_t val) {
    

  14.     return ((val & 0x00FF) << 8) | ((val & 0xFF00) >> 8);
    

  15. }
    


  16. 

  17. // 16位单值：小端→大端
    

  18. uint16_t endian_le16_to_be16(uint16_t le_val) {
    

  19.     return endian_is_little() ? endian_swap16(le_val) : le_val;
    

  20. }
    


  21. 

  22. // 16位单值：大端→小端
    

  23. uint16_t endian_be16_to_le16(uint16_t be_val) {
    

  24.     return endian_is_little() ? endian_swap16(be_val) : be_val;
    

  25. }
    


  26. 

  27. // 32位单值大小端互换
    

  28. uint32_t endian_swap32(uint32_t val) {
    

  29.     return ((val & 0x000000FF) << 24) |
    

  30.            ((val & 0x0000FF00) << 8)  |
    

  31.            ((val & 0x00FF0000) >> 8)  |
    

  32.            ((val & 0xFF000000) >> 24);
    

  33. }
    


  34. 

  35. // 32位单值：小端→大端
    

  36. uint32_t endian_le32_to_be32(uint32_t le_val) {
    

  37.     return endian_is_little() ? endian_swap32(le_val) : le_val;
    

  38. }
    


  39. 

  40. // 32位单值：大端→小端
    

  41. uint32_t endian_be32_to_le32(uint32_t be_val) {
    

  42.     return endian_is_little() ? endian_swap32(be_val) : be_val;
    

  43. }
    


  44. 

  45. // 64位单值大小端互换
    

  46. uint64_t endian_swap64(uint64_t val) {
    

  47.     return ((val & 0x00000000000000FFULL) << 56) |
    

  48.            ((val & 0x000000000000FF00ULL) << 40) |
    

  49.            ((val & 0x0000000000FF0000ULL) << 24) |
    

  50.            ((val & 0x00000000FF000000ULL) << 8)  |
    

  51.            ((val & 0x000000FF00000000ULL) >> 8)  |
    

  52.            ((val & 0x0000FF0000000000ULL) >> 24) |
    

  53.            ((val & 0x00FF000000000000ULL) >> 40) |
    

  54.            ((val & 0xFF00000000000000ULL) >> 56);
    

  55. }
    


  56. 

  57. // 64位单值：小端→大端
    

  58. uint64_t endian_le64_to_be64(uint64_t le_val) {
    

  59.     return endian_is_little() ? endian_swap64(le_val) : le_val;
    

  60. }
    


  61. 

  62. // 64位单值：大端→小端
    

  63. uint64_t endian_be64_to_le64(uint64_t be_val) {
    

  64.     return endian_is_little() ? endian_swap64(be_val) : be_val;
    

  65. }
    


  66. 

  67. // 16位数组批量大小端互换
    

  68. void endian_swap16_array(uint16_t *arr, size_t count) {
    

  69.     for (size_t i = 0; i < count; i++) {
    

  70.         arr[i] = endian_swap16(arr[i]);
    

  71.     }
    

  72. }
    


  73. 

  74. // 16位数组批量：小端→大端
    

  75. void endian_le16_to_be16_array(uint16_t *arr, size_t count) {
    

  76.     if (endian_is_little()) {
    

  77.         endian_swap16_array(arr, count);
    

  78.     }
    

  79. }
    


  80. 

  81. // 16位数组批量：大端→小端
    

  82. void endian_be16_to_le16_array(uint16_t *arr, size_t count) {
    

  83.     if (endian_is_little()) {
    

  84.         endian_swap16_array(arr, count);
    

  85.     }
    

  86. }
    


  87. 

  88. // 32位数组批量大小端互换
    

  89. void endian_swap32_array(uint32_t *arr, size_t count) {
    

  90.     for (size_t i = 0; i < count; i++) {
    

  91.         arr[i] = endian_swap32(arr[i]);
    

  92.     }
    

  93. }
    


  94. 

  95. // 32位数组批量：小端→大端
    

  96. void endian_le32_to_be32_array(uint32_t *arr, size_t count) {
    

  97.     if (endian_is_little()) {
    

  98.         endian_swap32_array(arr, count);
    

  99.     }
    

  100. }
    


  101. 

  102. // 32位数组批量：大端→小端
    

  103. void endian_be32_to_le32_array(uint32_t *arr, size_t count) {
    

  104.     if (endian_is_little()) {
    

  105.         endian_swap32_array(arr, count);
    

  106.     }
    

  107. }
    


  108. 

  109. // 64位数组批量大小端互换
    

  110. void endian_swap64_array(uint64_t *arr, size_t count) {
    

  111.     for (size_t i = 0; i < count; i++) {
    

  112.         arr[i] = endian_swap64(arr[i]);
    

  113.     }
    

  114. }
    


  115. 

  116. // 64位数组批量：小端→大端
    

  117. void endian_le64_to_be64_array(uint64_t *arr, size_t count) {
    

  118.     if (endian_is_little()) {
    

  119.         endian_swap64_array(arr, count);
    

  120.     }
    

  121. }
    


  122. 

  123. // 64位数组批量：大端→小端
    

  124. void endian_be64_to_le64_array(uint64_t *arr, size_t count) {
    

  125.     if (endian_is_little()) {
    

  126.         endian_swap64_array(arr, count);
    

  127.     }
    

  128. }


二、使用方法
  • 端序检测：调用 endian_is_little() 确认当前系统端序（可选，转换函数已自动适配）；
  • 单值转换：根据需求调用对应函数（如 TCP/IP 网络数据用 endian_be32_to_le32() 转成本地小端）；
  • 数组批量转换：适合处理传感器数据包、固件配置块等连续多字节数据，直接传数组指针和元素个数即可。


三、移植方法
  • 将 endian_utils.c 和 endian_utils.h 复制到 e²s 工程目录（如 src/utils/）；
  • 在 e²s 中右键工程 → Add Files，将 endian_utils.c 加入编译；
  • 若需编译时端序检测（节省 1-2 字节 Flash 和极短的运行时间），可在头文件中注释运行时检测的宏，取消注释编译时检测的宏（需提前确认目标系统端序）；
  • 在需要使用的文件中包含头文件：#include "endian_utils.h"；
  • 按场景调用对应函数即可。


三、调用函数代码验证
    本次贴合瑞萨 RATCP/IP 网络通信 + 跨设备 Flash 读取的真实场景：

1007769f0d1e1ceaac.png
    验证代码（基于瑞萨 RA6M5 + e²s IDE）
复制
  1. #include "hal_data.h"
    

  2. #include "endian_utils.h"
    

  3. #include <stdio.h>
    

  4. #include <string.h>
    


  5. 

  6. void uart_print(const char *str) {
    

  7.     R_SCI_UART_Write(&g_uart0_ctrl, (uint8_t *)str, strlen(str));
    

  8. }
    


  9. 

  10. void endian_test(void) {
    

  11.     char buf[256];
    

  12.     union {
    

  13.         uint16_t u16;
    

  14.         uint8_t u8[2];
    

  15.     } test16;
    

  16.     union {
    

  17.         uint32_t u32;
    

  18.         uint8_t u8[4];
    

  19.     } test32;
    

  20.     union {
    

  21.         uint64_t u64;
    

  22.         uint8_t u8[8];
    

  23.     } test64;
    

  24.     uint16_t arr16[] = {0x1234, 0x5678, 0x9ABC};
    

  25.     uint32_t arr32[] = {0x12345678, 0x9ABCDEF0};
    


  26. 

  27.     // 1. 端序检测
    

  28.     uart_print("--- 1. 端序检测 ---\r\n");
    

  29.     snprintf(buf, sizeof(buf), "当前系统端序：%s\r\n\r\n", endian_is_little() ? "小端（Little Endian）" : "大端（Big Endian）");
    

  30.     uart_print(buf);
    


  31. 

  32.     // 2. 16位单值转换+内存验证
    

  33.     uart_print("--- 2. 16位单值转换+内存验证 ---\r\n");
    

  34.     test16.u16 = 0x1234;
    

  35.     snprintf(buf, sizeof(buf), "本地小端内存：%02X %02X\r\n", test16.u8[0], test16.u8[1]);
    

  36.     uart_print(buf);
    

  37.     uint16_t be16 = endian_le16_to_be16(test16.u16);
    

  38.     // 用临时union看大端内存（注意：be16在本地小端系统中存的是“大端的数值”，内存顺序还是小端，需手动反转看逻辑）
    

  39.     snprintf(buf, sizeof(buf), "转换后大端数值：0x%04X，逻辑内存：%02X %02X\r\n\r\n", be16, (uint8_t)(be16 >> 8), (uint8_t)(be16 & 0xFF));
    

  40.     uart_print(buf);
    


  41. 

  42.     // 3. 32位单值转换+内存验证
    

  43.     uart_print("--- 3. 32位单值转换+内存验证 ---\r\n");
    

  44.     test32.u32 = 0x12345678;
    

  45.     snprintf(buf, sizeof(buf), "本地小端内存：%02X %02X %02X %02X\r\n", test32.u8[0], test32.u8[1], test32.u8[2], test32.u8[3]);
    

  46.     uart_print(buf);
    

  47.     uint32_t be32 = endian_le32_to_be32(test32.u32);
    

  48.     snprintf(buf, sizeof(buf), "转换后大端数值：0x%08X，逻辑内存：%02X %02X %02X %02X\r\n\r\n", be32, (uint8_t)(be32 >> 24), (uint8_t)((be32 >> 16) & 0xFF), (uint8_t)((be32 >> 8) & 0xFF), (uint8_t)(be32 & 0xFF));
    

  49.     uart_print(buf);
    


  50. 

  51.     // 4. 64位单值转换+内存验证
    

  52.     uart_print("--- 4. 64位单值转换+内存验证 ---\r\n");
    

  53.     test64.u64 = 0x123456789ABCDEF0ULL;
    

  54.     snprintf(buf, sizeof(buf), "本地小端内存：%02X %02X %02X %02X %02X %02X %02X %02X\r\n", test64.u8[0], test64.u8[1], test64.u8[2], test64.u8[3], test64.u8[4], test64.u8[5], test64.u8[6], test64.u8[7]);
    

  55.     uart_print(buf);
    

  56.     uint64_t be64 = endian_le64_to_be64(test64.u64);
    

  57.     snprintf(buf, sizeof(buf), "转换后大端数值：0x%016llX，逻辑内存：%02X %02X %02X %02X %02X %02X %02X %02X\r\n\r\n", (unsigned long long)be64, (uint8_t)(be64 >> 56), (uint8_t)((be64 >> 48) & 0xFF), (uint8_t)((be64 >> 40) & 0xFF), (uint8_t)((be64 >> 32) & 0xFF), (uint8_t)((be64 >> 24) & 0xFF), (uint8_t)((be64 >> 16) & 0xFF), (uint8_t)((be64 >> 8) & 0xFF), (uint8_t)(be64 & 0xFF));
    

  58.     uart_print(buf);
    


  59. 

  60.     // 5. 16位数组批量转换
    

  61.     uart_print("--- 5. 16位数组批量转换 ---\r\n");
    

  62.     snprintf(buf, sizeof(buf), "本地小端数组：");
    

  63.     uart_print(buf);
    

  64.     for (size_t i = 0; i < sizeof(arr16)/sizeof(arr16[0]); i++) {
    

  65.         snprintf(buf, sizeof(buf), "0x%04X ", arr16[i]);
    

  66.         uart_print(buf);
    

  67.     }
    

  68.     uart_print("\r\n");
    

  69.     endian_le16_to_be16_array(arr16, sizeof(arr16)/sizeof(arr16[0]));
    

  70.     snprintf(buf, sizeof(buf), "转换后大端数值数组：");
    

  71.     uart_print(buf);
    

  72.     for (size_t i = 0; i < sizeof(arr16)/sizeof(arr16[0]); i++) {
    

  73.         snprintf(buf, sizeof(buf), "0x%04X ", arr16[i]);
    

  74.         uart_print(buf);
    

  75.     }
    

  76.     uart_print("\r\n\r\n");
    


  77. 

  78.     // 6. 32位数组批量转换
    

  79.     uart_print("--- 6. 32位数组批量转换 ---\r\n");
    

  80.     snprintf(buf, sizeof(buf), "本地小端数组：");
    

  81.     uart_print(buf);
    

  82.     for (size_t i = 0; i < sizeof(arr32)/sizeof(arr32[0]); i++) {
    

  83.         snprintf(buf, sizeof(buf), "0x%08X ", arr32[i]);
    

  84.         uart_print(buf);
    

  85.     }
    

  86.     uart_print("\r\n");
    

  87.     endian_le32_to_be32_array(arr32, sizeof(arr32)/sizeof(arr32[0]));
    

  88.     snprintf(buf, sizeof(buf), "转换后大端数值数组：");
    

  89.     uart_print(buf);
    

  90.     for (size_t i = 0; i < sizeof(arr32)/sizeof(arr32[0]); i++) {
    

  91.         snprintf(buf, sizeof(buf), "0x%08X ", arr32[i]);
    

  92.         uart_print(buf);
    

  93.     }
    

  94.     uart_print("\r\n");
    

  95. }
    


  96. 

  97. void hal_entry(void) {
    

  98.     R_SCI_UART_Open(&g_uart0_ctrl, &g_uart0_cfg);
    

  99.     endian_test();
    

  100.     while (1);
    

  101. }


五、结果对比
    我们通过串口助手验证数据与与其是否相符：

3609269f0d30da2842.png
    我们换一组数据继续验证：

6135069f0d3a26b8dd.png
    新验证代码（直接替换原 endian_test 函数即可）
复制
  1. void endian_test(void) {
    

  2.     char buf[256];
    

  3.     int16_t signed16_val;
    

  4.     int32_t signed32_val;
    


  5. 

  6.     // 1. 端序环境确认
    

  7.     uart_print("--- 1. 端序环境确认 ---\r\n");
    

  8.     snprintf(buf, sizeof(buf), "当前系统端序：%s\r\n\r\n", endian_is_little() ? "小端（Little Endian，瑞萨RA默认）" : "大端（Big Endian）");
    

  9.     uart_print(buf);
    


  10. 

  11.     // 2. Modbus温度寄存器解析（16位大端→小端）
    

  12.     uart_print("--- 2. Modbus温度寄存器解析（16位大端→小端） ---\r\n");
    

  13.     uint16_t temp_raw = 0xF401; // 小端系统读取到的原始值
    

  14.     uint16_t temp_real = endian_be16_to_le16(temp_raw);
    

  15.     snprintf(buf, sizeof(buf), "原始读取值：0x%04X，转换后正确值：0x%04X（十进制：%d，对应温度：%.1f℃）\r\n\r\n", 
    

  16.              temp_raw, temp_real, temp_real, temp_real / 10.0f);
    

  17.     uart_print(buf);
    


  18. 

  19.     // 3. CAN总线32位流量数据解析（32位大端→小端）
    

  20.     uart_print("--- 3. CAN总线32位流量数据解析（32位大端→小端） ---\r\n");
    

  21.     uint32_t flow_raw = 0x78563412; // 小端系统读取到的原始值
    

  22.     uint32_t flow_real = endian_be32_to_le32(flow_raw);
    

  23.     snprintf(buf, sizeof(buf), "原始读取值：0x%08X，转换后正确值：0x%08X（十进制：%lu）\r\n\r\n", 
    

  24.              flow_raw, flow_real, flow_real);
    

  25.     uart_print(buf);
    


  26. 

  27.     // 4. 负温度传感器数据解析（16位有符号负数，大端→小端）
    

  28.     uart_print("--- 4. 负温度传感器数据解析（16位有符号负数） ---\r\n");
    

  29.     uint16_t neg_temp_raw = 0xD8FF; // 小端系统读取到的原始值
    

  30.     uint16_t neg_temp_u16 = endian_be16_to_le16(neg_temp_raw);
    

  31.     signed16_val = (int16_t)neg_temp_u16;
    

  32.     snprintf(buf, sizeof(buf), "原始读取值：0x%04X，转换后正确值：0x%04X（十进制：%d，对应温度：%.1f℃）\r\n\r\n", 
    

  33.              neg_temp_raw, neg_temp_u16, signed16_val, signed16_val / 1.0f);
    

  34.     uart_print(buf);
    


  35. 

  36.     // 5. 负流量累计值解析（32位有符号负数，大端→小端）
    

  37.     uart_print("--- 5. 负流量累计值解析（32位有符号负数） ---\r\n");
    

  38.     uint32_t neg_flow_raw = 0x80FFFFFF; // 小端系统读取到的原始值
    

  39.     uint32_t neg_flow_u32 = endian_be32_to_le32(neg_flow_raw);
    

  40.     signed32_val = (int32_t)neg_flow_u32;
    

  41.     snprintf(buf, sizeof(buf), "原始读取值：0x%08X，转换后正确值：0x%08X（十进制：%d）\r\n\r\n", 
    

  42.              neg_flow_raw, neg_flow_u32, signed32_val);
    

  43.     uart_print(buf);
    


  44. 

  45.     // 6. Modbus批量读4个保持寄存器（16位数组批量大端→小端）
    

  46.     uart_print("--- 6. Modbus批量寄存器解析（16位数组批量转换） ---\r\n");
    

  47.     uint16_t modbus_arr[] = {0x0201, 0x0403, 0x0605, 0x0807};
    

  48.     size_t arr16_len = sizeof(modbus_arr)/sizeof(modbus_arr[0]);
    

  49.     // 打印原始数组
    

  50.     snprintf(buf, sizeof(buf), "原始读取数组：");
    

  51.     uart_print(buf);
    

  52.     for (size_t i = 0; i < arr16_len; i++) {
    

  53.         snprintf(buf, sizeof(buf), "0x%04X ", modbus_arr[i]);
    

  54.         uart_print(buf);
    

  55.     }
    

  56.     uart_print("\r\n");
    

  57.     // 批量转换
    

  58.     endian_be16_to_le16_array(modbus_arr, arr16_len);
    

  59.     // 打印转换后数组
    

  60.     snprintf(buf, sizeof(buf), "转换后正确数组：");
    

  61.     uart_print(buf);
    

  62.     for (size_t i = 0; i < arr16_len; i++) {
    

  63.         snprintf(buf, sizeof(buf), "0x%04X ", modbus_arr[i]);
    

  64.         uart_print(buf);
    

  65.     }
    

  66.     uart_print("\r\n\r\n");
    


  67. 

  68.     // 7. 多通道传感器批量数据（32位数组批量大端→小端）
    

  69.     uart_print("--- 7. 多通道传感器批量数据（32位数组批量转换） ---\r\n");
    

  70.     uint32_t sensor_arr[] = {0x44332211, 0x88776655};
    

  71.     size_t arr32_len = sizeof(sensor_arr)/sizeof(sensor_arr[0]);
    

  72.     // 打印原始数组
    

  73.     snprintf(buf, sizeof(buf), "原始读取数组：");
    

  74.     uart_print(buf);
    

  75.     for (size_t i = 0; i < arr32_len; i++) {
    

  76.         snprintf(buf, sizeof(buf), "0x%08X ", sensor_arr[i]);
    

  77.         uart_print(buf);
    

  78.     }
    

  79.     uart_print("\r\n");
    

  80.     // 批量转换
    

  81.     endian_be32_to_le32_array(sensor_arr, arr32_len);
    

  82.     // 打印转换后数组
    

  83.     snprintf(buf, sizeof(buf), "转换后正确数组：");
    

  84.     uart_print(buf);
    

  85.     for (size_t i = 0; i < arr32_len; i++) {
    

  86.         snprintf(buf, sizeof(buf), "0x%08X ", sensor_arr[i]);
    

  87.         uart_print(buf);
    

  88.     }
    

  89.     uart_print("\r\n\r\n");
    


  90. 

  91.     // 8. 边界极值验证
    

  92.     uart_print("--- 8. 边界极值验证 ---\r\n");
    

  93.     uint16_t u16_min = 0x0000, u16_max = 0xFFFF;
    

  94.     uint32_t u32_min = 0x00000000, u32_max = 0xFFFFFFFF;
    

  95.     snprintf(buf, sizeof(buf), "16位0x0000转换后：0x%04X\r\n", endian_swap16(u16_min));
    

  96.     uart_print(buf);
    

  97.     snprintf(buf, sizeof(buf), "16位0xFFFF转换后：0x%04X\r\n", endian_swap16(u16_max));
    

  98.     uart_print(buf);
    

  99.     snprintf(buf, sizeof(buf), "32位0x00000000转换后：0x%08X\r\n", endian_swap32(u32_min));
    

  100.     uart_print(buf);
    

  101.     snprintf(buf, sizeof(buf), "32位0xFFFFFFFF转换后：0x%08X\r\n", endian_swap32(u32_max));
    

  102.     uart_print(buf);
    

  103. }


2144269f0d3e4991cc.png
注意事项
  • 端序检测的准确性：运行时检测用的是 union，符合 C 标准，兼容性 100%；
  • 批量转换的数组指针：批量转换函数会直接修改原数组，若需保留原数组，可先复制一份再转换；
  • 数值与内存的区别：转换函数返回的是 “目标端序的数值”，在本地小端系统中，这个数值的内存顺序还是小端，但逻辑上是目标端序的（比如 TCP/IP 发送时，直接把这个数值的内存发出去就是大端的逻辑内存）；
  • 资源占用：代码约 1KB Flash，无额外 RAM 缓冲区，适合所有 8/16/32/64 位 MCU；
  • 适用场景：适合跨架构通信（TCP/IP、Modbus TCP、CAN FD 扩展帧）、跨设备 Flash 读取（如从 8051 的 Flash 读配置到 RA）、跨平台数据交换；
  • 硬件加速：瑞萨 RA 系列部分高端型号（如 RA6M5）的 DMA 或加密引擎可能支持硬件大小端转换，后续有机会再分享～

回复

收藏 举报

相关帖子
将爱藏于深海 发表于 2026-6-3 15:23 | 显示全部楼层
我注意到这个工具还支持自动检测系统端序，这对于不确定目标系统端序的情况非常有用。
回复

收藏 举报

春日负喧 发表于 2026-6-22 11:10 | 显示全部楼层
我注意到这个工具还支持自动检测系统端序，这对于不同架构的设备来说是一个很大的优势。
回复

收藏 举报

风吻过你的不羁 发表于 2026-6-23 20:10 | 显示全部楼层
端序检测和自动适配的功能很棒，可以减少很多手动配置的工作量。
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

暮雨之仁

30

主题

58

帖子

0

粉丝
快速回复 在线客服 返回列表 返回顶部
0