comm_car_485(7241).c 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229
  1. #include "comm_car_485.h"
  2. //-------------参数定义
  3. rs485RecDate s_rs485RecDate;
  4. rs485SendDate s_rs485SendDate;
  5. /**
  6. * @brief 计算Modbus RTU消息的CRC校验码
  7. * @param ptr: 数据首地址
  8. * @param len: 数据长度
  9. * @return
  10. */
  11. uint16_t modbusCRC(uint8_t *buf, int len) {
  12. uint16_t crc = 0xFFFF;
  13. for (int pos = 0; pos < len; pos++) {
  14. crc ^= (uint16_t)buf[pos]; // XOR byte into CRC
  15. for (int i = 8; i != 0; i--) { // 循环8次
  16. if ((crc & 0x0001) != 0) { // 如果低位为1
  17. crc >>= 1; // 右移一位
  18. crc ^= 0xA001; // 与多项式码进行XOR
  19. } else {
  20. crc >>= 1; // 仅仅右移一位
  21. }
  22. }
  23. }
  24. return crc;
  25. }
  26. void modbus_recDate(void){
  27. HAL_UART_Receive_DMA(&huart2, (uint8_t*)g_usart2_rx_buf, USART2_REC_LEN); //设置接收缓冲区
  28. }
  29. /**
  30. * @brief 485发送函数
  31. * @param data: 发送的数据
  32. * @param dataLen: 发送的数据长度
  33. * @note
  34. * @retval 无
  35. */
  36. void modbus_sendDate(uint8_t data[], uint32_t dataLen){
  37. HAL_UART_Transmit(&huart2, data, dataLen, 1000);
  38. // 接收使能
  39. modbus_recDate();
  40. }
  41. // 构造Modbus RTU请求函数 03 功能码
  42. void modbus_read_holding_registers(uint8_t slave_id, uint16_t start_address, uint16_t num_of_registers) {
  43. // 请求数据包的长度为 8 个字节
  44. uint8_t request[8] = {0};
  45. // 设置从设备地址
  46. request[0] = slave_id;
  47. // 设置功能码,03 功能码用于读取保持寄存器
  48. request[1] = 0x03;
  49. // 设置寄存器起始地址
  50. request[2] = (start_address >> 8) & 0xFF; // 寄存器起始地址的高字节
  51. request[3] = start_address & 0xFF; // 寄存器起始地址的低字节
  52. // 设置读取寄存器的数量
  53. request[4] = (num_of_registers >> 8) & 0xFF; // 要读取的寄存器数量的高字节
  54. request[5] = num_of_registers & 0xFF; // 要读取的寄存器
  55. // 计算CRC
  56. uint16_t crc = modbusCRC(request, 6);
  57. request[6] = crc & 0xFF; // CRC低位
  58. request[7] = crc >> 8; // CRC高位
  59. // 发送请求
  60. modbus_sendDate(request, 8);
  61. }
  62. // 构建Modbus 10功能码(写多个寄存器)请求帧
  63. // 注意:调用此函数时需要确保`request`数组有足够的空间来存放整个请求帧,此空间应大于或等于 9 + 2 * numRegisters 字节。
  64. void modbus_write_holding_registers(uint8_t slaveID, uint16_t startAddress, uint16_t numRegisters, uint16_t *values) {
  65. uint8_t request[256] = {0}; // 确保有足够的空间
  66. uint16_t requestSize = 0;
  67. int i;
  68. request[0] = slaveID; // 从设备地址
  69. request[1] = 0x10; // 功能码(写多个寄存器)
  70. request[2] = startAddress >> 8; // 起始地址高位
  71. request[3] = startAddress & 0xFF; // 起始地址低位
  72. request[4] = numRegisters >> 8; // 寄存器数量高位
  73. request[5] = numRegisters & 0xFF; // 寄存器数量低位
  74. request[6] = numRegisters * 2; // 字节计数(每个寄存器2字节)
  75. // 循环设置寄存器的值
  76. for (i = 0; i < numRegisters; i++) {
  77. request[7 + 2*i] = values[i] >> 8; // 寄存器值高字节
  78. request[8 + 2*i] = values[i] & 0xFF; // 寄存器值低字节
  79. }
  80. // 计算整个请求帧的大小
  81. requestSize = 7 + 2 * numRegisters;
  82. // 计算CRC
  83. uint16_t crc = modbusCRC(request, requestSize);
  84. request[requestSize] = crc & 0xFF; // CRC低位
  85. request[requestSize + 1] = crc >> 8; // CRC高位
  86. // 更新请求帧大小以包含CRC
  87. requestSize += 2;
  88. // 发送请求
  89. modbus_sendDate(request, requestSize);
  90. }
  91. // 验证Modbus RTU消息的CRC校验码
  92. int checkModbusCRC(uint8_t *response, uint16_t responseSize) {
  93. if (responseSize < 4) return -1; // 不够长,无法包含CRC
  94. uint16_t receivedCRC = response[responseSize - 2] | response[responseSize - 1] << 8;
  95. uint16_t calculatedCRC = modbusCRC(response, responseSize - 2);
  96. return (receivedCRC == calculatedCRC) ? 0 : -1;
  97. }
  98. // 解析Modbus 03功能码的响应,并带有错误处理和完整性校验
  99. int parseModbus03Response(uint8_t *response, uint16_t responseSize) {
  100. rs485RecDate *p_rs485RecDate = &s_rs485RecDate;
  101. // 最小长度检查
  102. if (responseSize < 5 || response[1] != 0x03) {
  103. printf("Response too short or function code mismatch!\n");
  104. return -1;
  105. }
  106. // 解析响应数据 从第四个字节开始为第一个数据
  107. p_rs485RecDate->vehicleSpeed = ((uint16_t)response[3] << 8) | response[4];
  108. return 0; // 成功
  109. }
  110. // 解析Modbus 10功能码的响应,并带有错误处理和完整性校验
  111. int parseModbus10Response(uint8_t *response, uint16_t responseSize) {
  112. // 最小长度检查
  113. if (responseSize != 8 || response[1] != 0x10) {
  114. printf("Response length mismatch or function code mismatch!\n");
  115. return -1;
  116. }
  117. // 解析响应数据
  118. uint16_t startAddress = response[2] << 8 | response[3];
  119. uint16_t numRegisters = response[4] << 8 | response[5];
  120. // 打印结果
  121. printf("Written to start address: %d, number of registers: %d\n", startAddress, numRegisters);
  122. return 0; // 成功
  123. }
  124. /**
  125. * @brief 485接收分析函数
  126. * @param response: 接收到的数据
  127. * @note 如果在中断中进行解析,则不能加互斥量,如果是在任务中解析,则加入互斥量的获取
  128. * @retval 无
  129. */
  130. int parseModbusResponse(uint8_t *response, uint16_t responseSize){
  131. uint8_t fun_Code = 0;
  132. // 检查CRC
  133. if (checkModbusCRC(response, responseSize) != 0) {
  134. printf("CRC check failed!\n");
  135. return -1;
  136. }
  137. // 确认功能码
  138. fun_Code = response[1];
  139. /* 尝试获取互斥量,等待无限长时间 */
  140. // if(osMutexAcquire(mutex_rs485RecDateHandle, osWaitForever) == osOK){
  141. // 数据解析
  142. switch(fun_Code){
  143. case 0x03:
  144. parseModbus03Response(response, responseSize);
  145. break;
  146. case 0x10:
  147. parseModbus10Response(response, responseSize);
  148. break;
  149. default:
  150. break;
  151. }
  152. // /* 访问完成,释放互斥量 */
  153. // osMutexRelease(mutex_rs485RecDateHandle);
  154. // }
  155. return 0; // 成功
  156. }
  157. /**
  158. * @brief 轮询发送接收
  159. * @note 1s请求一次
  160. * @retval 无
  161. */
  162. void rs485_poll_sendReceive(void){
  163. uint16_t speed = 0;
  164. static uint8_t step_485 = 0;
  165. switch(step_485){
  166. case 0:
  167. // 读寄存器数据
  168. modbus_read_holding_registers(0x01, 0x0000, 1);
  169. step_485 = 1;
  170. break;
  171. case 1:
  172. // 写寄存器数据
  173. speed = s_rs485SendDate.speed;
  174. modbus_write_holding_registers(0x01, 0x0010, 1, &speed);
  175. step_485 = 0;
  176. break;
  177. default:
  178. break;
  179. }
  180. }