21ic电子技术开发论坛 › 单片机与嵌入式系统 › 雅特力AT32 MCU › 【AT-START-L021测评】Modbus RTU 从站的实现
12下一页
返回列表 发新帖我要提问本帖赏金: 10.00元(功能说明)

[AT32L021] 【AT-START-L021测评】Modbus RTU 从站的实现

[复制链接]
6853|35
 楼主| bingbing12138 发表于 2024-12-25 22:04 | 显示全部楼层 |阅读模式
AT32L021, modbus RTU, USART, DMA, AT-START-L021测评
本帖最后由 bingbing12138 于 2024-12-26 21:20 编辑

#申请原创# #技术资源# 非常感谢雅特力官方给我这样一个测评的机会，本次主要使用AT32L021实现ModbusRTU从站功能，支持的功能码 01 02 03 04 05 06 0F 10
一、Modbus标准简介
Modbus 是由 Modicon（现为施耐德电气公司的一个品牌）在 1979 年发明的，是全球第一个真正用于工业现场的总线协议。
ModBus 网络是一个工业通信系统，由带智能终端的可编程序控制器和计算机通过公用线路或局部专用线路连接而成。其系统结构既包括硬件、亦包括软件。它可应用于各种数据采集和过程监控。
为更好地普及和推动 Modbus 在基于以太网上的分布式应用，目前施耐德公司已将 Modbus 协议的所有权移交给 IDA（Interface for Distributed Automation，分布式自动化接口）组织，并成立了Modbus-IDA 组织，为 Modbus 今后的发展奠定了基础。
在中国，Modbus 已经成为国家标准。
标准编号：GB/T19582-2008
标准名称：《基于 Modbus 协议的工业自动化网络规范》
分 3 个部分：
《GB/T 19582.1-2008 第 1 部分：Modbus 应用协议》
《GB/T 19582.2-2008 第 2 部分：Modbus 协议在串行链路上的实现指南》
《GB/T 19582.3-2008 第 3 部分: Modbus 协议在 TCP/IP 上的实现指南》
二、Modbus协议概述
49230676c14efeba88.png
23662676c150a4e135.png
Modbus 串行链路协议是一个主/从协议。该协议位于 OSI 模型的第二层。
一个主从类型的系统有一个向某个“子”节点发出显式命令并处理响应的节点(主节点)。典型的子节点在没有收到主节点的请求时并不主动发送数据，也不与其它子节点通信。
在物理层，Modbus 串行链路系统可以使用不同的物理接口(RS485、RS232)。最常用的是TIA/EIA-485 (RS485) 两线制接口。
三、Modbus 主站/从站协议原理
Modbus 串行链路协议是一个主-从协议。在同一时刻，只有一个主节点连接于总线，一个或多个子节点 (最大编号为 247 ) 连接于同一个串行总线。Modbus 通信总是由主节点发起。子节点在没有收到来自主节点的请求时，从不会发送数据。子节点之间从不会互相通信。主节点在同一时刻只会发起一个Modbus 事务处理。
主节点以两种模式对子节点发出 Modbus 请求：
单播模式：
主节点以特定地址访问某个子节点，子节点接到并处理完请求后，子节点向主节点返回一个报文(一个'应答')。在这种模式，一个 Modbus 事务处理包含 2 个报文：一个来自主节点的请求，一个来自子节点的应答。
每个子节点必须有唯一的地址 (1 到 247)，这样才能区别于其它节点被独立的寻址。
广播模式：
主节点向所有的子节点发送请求。对于主节点广播的请求没有应答返回。广播请求一般用于写命令。
所有设备必须接受广播模式的写功能。地址 0 是专门用于表示广播数据的。
地址规则：
Modbus 寻址空间有 256 个不同地址。
0 1~247 248~255
广播地址 子节点单独地址 保留

地址 0 为广播地址。所有的子节点必须识别广播地址。
Modbus 主节点没有地址，只有子节点必须有一个地址。 该地址必须在 Modbus 串行总线上唯一。
四、Modbus报文RTU
由发送设备将 Modbus 报文构造为带有已知起始和结束标记的帧。这使设备可以在报文的开始接收新帧，并且知道何时报文结束。不完整的报文必须能够被检测到而错误标志必须作为结果被设置。
在 RTU 模式，报文帧由时长至少为 3.5 个字符时间的空闲间隔区分。在后续的部分，这个时间区间被称作 t3.5。
47967676c1707a21d9.png

整个报文帧必须以连续的字符流发送。
如果两个字符之间的空闲间隔大于 1.5 个字符时间，则报文帧被认为不完整应该被接收节点丢弃。

8666676c172b3d1b8.png

注 :
RTU 接收驱动程序的实现，由于 t1.5 和 t3.5 的定时，隐含着大量的对中断的管理。在高通信速率下，这导致 CPU 负担加重。因此，在通信速率等于或低于 19200 bps 时，这两个定时必须严格遵守；
对于波特率大于 19200 bps 的情形，应该使用 2 个定时的固定值：
建议的字符间超时时间(t1.5)为 750µs，
帧间的超时时间 (t1.5) 为 1.750ms。
下图表示了对 RTU 传输模式状态图的描述。 "主节点" 和 "子节点" 的不同角度均在相同的图中表示：

94726676c177666ca6.png
上面状态图的一些解释:
1从 "初始" 态到 “空闲” 态转换需要 t3.5 定时超时: 这保证帧间延迟
1“空闲” 态是没有发送和接收报文要处理的正常状态。
1在 RTU 模式， 当没有活动的传输的时间间隔达 3.5 个字符长时，通信链路被认为在 “空闲” 态。
1当链路空闲时， 在链路上检测到的任何传输的字符被识别为帧起始。 链路变为 "活动" 状态。 然后，当链路上没有字符传输的时间间个达到 t3.5 后，被识别为帧结束。
1检测到帧结束后，完成 CRC 计算和检验。然后，分析地址域以确定帧是否发往此设备，如果不是，则丢弃此帧。 为了减少接收处理时间，地址域可以在一接到就分析，而不需要等到整个帧结束。这样，CRC 计算只需要在帧寻址到该节点 (包括广播帧) 时进行。
五、CRC校验
在 RTU 模式包含一个对全部报文内容执行的，基于循环冗余校验 (CRC - Cyclical RedundancyChecking) 算法的错误检验域。CRC 域检验整个报文的内容。不管报文有无奇偶校验，均执行此检验。
CRC 包含由两个 8 位字节组成的一个 16 位值。
CRC 域作为报文的最后的域附加在报文之后。计算后，首先附加低字节，然后是高字节。CRC 高字节为报文发送的最后一个字节。
附加在报文后面的 CRC 的值由发送设备计算。接收设备在接收报文时重新计算 CRC 的值，并将计算结果于实际接收到的 CRC 值相比较。如果两个值不相等，则为错误。
CRC 的计算, 开始对一个 16 位寄存器预装全 1。然后将报文中的连续的 8 位子节对其进行后续的计算。只有字符中的 8 个数据位参与生成 CRC 的运算，起始位，停止位和校验位不参与 CRC 计算。
CRC 的生成过程中， 每个 8–位字符与寄存器中的值异或。然后结果向最低有效位(LSB)方向移动(Shift) 1 位，而最高有效位(MSB)位置充零。 然后提取并检查 LSB：如果 LSB 为 1， 则寄存器中的值与一个固定的预置值异或；如果 LSB 为 0， 则不进行异或操作。
这个过程将重复直到执行完 8 次移位。完成最后一次（第 8 次）移位及相关操作后，下一个 8 位字节与寄存器的当前值异或，然后又同上面描述过的一样重复 8 次。当所有报文中字节都运算之后得到的寄存器的最终值，就是 CRC。
六、Modubs从站源码
主程序
复制
  1. #include "at32l021_clock.h"
    

  2. #include "at32l021_board.h"
    

  3. #include "modbus_slave.h"
    

  4. #include "bsp_dma.h"
    

  5. #include "bsp_usart.h"
    

  6. #include "bsp_time.h"
    

  7. #include "crc16.h"
    


  8. 

  9. //定时器3中断服务函数 处理Modbus主任务
    

  10. void TMR3_GLOBAL_IRQHandler(void)//1ms中断
    

  11. {
    

  12.     if (tmr_flag_get(TMR3, TMR_OVF_FLAG) == SET)
    

  13.     {
    

  14.         MODBUS_SLAVE_Pool();
    

  15.         tmr_flag_clear(TMR3, TMR_OVF_FLAG);
    

  16.     }
    

  17. }
    


  18. 

  19. //定时器6中断服务函数 计算帧间隔超时计数
    

  20. void TMR6_GLOBAL_IRQHandler(void)//50us中断
    

  21. {
    

  22.     if (tmr_flag_get(TMR6, TMR_OVF_FLAG) == SET)
    

  23.     {
    

  24.         timer_record.timer_counter++;
    

  25.         tmr_flag_clear(TMR6, TMR_OVF_FLAG);
    

  26.     }
    

  27. }
    


  28. 

  29. //串口2中断服务函数 串口发送完成中断，用于判断报文发送完成从而开启接收
    

  30. void USART2_IRQHandler(void)
    

  31. {
    

  32.     if(usart_interrupt_flag_get(USART2, USART_TDC_FLAG) != RESET)
    

  33.     {
    

  34.         RS485_RX_EN();//接收使能
    

  35.         dma_channel_enable(DMA1_CHANNEL5, TRUE); //DMA接收使能
    

  36.         usart_interrupt_enable(USART2, USART_TDC_INT, FALSE);//关闭串口发送完成中断
    

  37.     }
    

  38. }
    


  39. 

  40. crm_clocks_freq_type clocks_struct;
    

  41. int main(void)
    

  42. {
    

  43.     system_clock_config();
    

  44.     crm_clocks_freq_get(&clocks_struct);
    

  45.     
    

  46.     rs485_send_init();//MAX485使能引脚初始化
    

  47.     bsp_usart_init();//串口2初始化
    

  48.     
    

  49.     bsp_dma_uart_tx_init(modbus_slave.tx_buf,TX_LEN_MAX);//初始化串口发送dma
    

  50.     bsp_dma_uart_rx_init(modbus_slave.rx_buf,RX_LEN_MAX);//初始化串口接收dma
    

  51.     
    

  52.     bsp_timer3_init();//1ms
    

  53.     bsp_timer6_init();//50us
    

  54.     /*报文接收时间间隔 由于此处使用115200波特率 
    

  55.     ModbusRTU协议规定 大于19200 bps时，帧间隔超时时间为1.75ms
    

  56.     1.75ms = 1750us  1750/50 = 35*/
    

  57.     timer_record.overtime = 35;
    

  58.     while(1)
    

  59.     {
    

  60.         ;
    

  61.     }
    

  62. }
由于内容限制，这里只展示从站主要源码，程序实现Modbus功能码 01 02 03 04 05 06 0F 10：
复制
  1. /************************************************************************/
    

  2. /*  “文件包含”处理                                                       */
    

  3. /************************************************************************/
    

  4. #include "modbus_slave.h"
    

  5. #include "bsp_dma.h"
    

  6. #include "bsp_time.h"
    

  7. #include "bsp_usart.h"
    

  8. #include "crc16.h"
    


  9. 

  10. /************************************************************************/
    

  11. /*  全局变量定义                                                         */
    

  12. /************************************************************************/
    

  13. Modbus_Slave_t modbus_slave = {0};
    

  14. uint16_t test_hold_reg[3] = {0};// 03  06 10 功能码使用
    

  15. uint8_t test_led[15] = {0};// 01 05  功能码使用
    

  16. uint8_t test_adc[5] = {0x66, 0x77};// 04  功能码使用
    

  17. /************************************************************************/
    

  18. /*  函数声明                                                             */
    

  19. /************************************************************************/
    

  20. static void MODBUS_SLAVE_FunctionCodeHandle(void);
    

  21. static void MODBUS_SLAVE_01H(void);// 01功能码通过修改test_led[15]数组的值
    

  22. static void MODBUS_SLAVE_02H(void);// 02功能码通过函数MODBUS_SLAVE_BSP_GetKeyState 返回值
    

  23. static void MODBUS_SLAVE_03H(void);// 03功能码通过读取test_hold_reg[3]数组的值
    

  24. static void MODBUS_SLAVE_04H(void);// 04功能码通过读取test_adc[5]数组的值
    

  25. static void MODBUS_SLAVE_05H(void);// 05功能码通过修改test_led[15]数组的值
    

  26. static void MODBUS_SLAVE_06H(void);// 06功能码通过修改test_hold_reg[3]数组的值
    

  27. static void MODBUS_SLAVE_10H(void);// 10功能码通过修改多个test_hold_reg[3]数组的值
    

  28. static void MODBUS_SLAVE_0FH(void);// 0F功能码通过修改多个test_led[15]数组的值
    

  29. void MODBUS_SLAVE_SendAckErr(uint8_t ErrCode);
    


  30. 

  31. //Modbus主程序
    

  32. void MODBUS_SLAVE_Pool(void)
    

  33. {
    

  34.     uBit16 addr;
    

  35.     uBit16 crc1;
    

  36.     
    

  37.     modbus_slave.curr_dma_cnt = dma_data_number_get(DMA1_CHANNEL5);//获取当前串口接收DMA传输计数器中的值
    

  38.     if (timer_record.timer_start_flag == 0 && modbus_slave.curr_dma_cnt != RX_LEN_MAX)
    

  39.     {
    

  40.         timer_record.timer_start_flag = 1;//表示开始接收了
    

  41.         timer_record.StartTime = timer_record.timer_counter; // 记录开始时间
    

  42.         
    

  43.         modbus_slave.last_dma_cnt = modbus_slave.curr_dma_cnt;
    

  44.     }
    

  45.     if (timer_record.timer_start_flag == 1)
    

  46.     {
    

  47.         if (modbus_slave.curr_dma_cnt == modbus_slave.last_dma_cnt)
    

  48.         {
    

  49.             timer_record.Currvalue = timer_record.timer_counter - timer_record.StartTime;//获取经过的时间
    

  50.             if (timer_record.Currvalue > timer_record.overtime)//判断是否超时
    

  51.             {
    

  52.                 timer_record.timer_start_flag = 0;//清除接收标志
    

  53.                 modbus_slave.recv_len = RX_LEN_MAX - modbus_slave.curr_dma_cnt;//已经接收的字节数
    

  54.                 
    

  55.                 //成功接收到一帧报文
    

  56.                 bsp_dma_uart_rx_init(modbus_slave.rx_buf,RX_LEN_MAX);//初始化串口接收DMA
    

  57.                 dma_channel_enable(DMA1_CHANNEL5, FALSE);//接收DMA失能
    

  58.                 RS485_TX_EN();//发送使能
    

  59.                 
    

  60.                 if (modbus_slave.recv_len < 4)  /* 接收到的数据小于4个字节就认为错误 */
    

  61.                 {
    

  62.                     RS485_RX_EN();//接收使能
    

  63.                     dma_channel_enable(DMA1_CHANNEL5, TRUE); //DMA接收使能
    

  64.                     goto err_ret;
    

  65.                 }
    

  66.                 
    

  67.                 /* 计算CRC校验和 */
    

  68.                 crc1 = CRC16_Modbus(modbus_slave.rx_buf, modbus_slave.recv_len);
    

  69.                 if (crc1 != 0)
    

  70.                 {
    

  71.                     RS485_RX_EN();//接收使能
    

  72.                     dma_channel_enable(DMA1_CHANNEL5, TRUE); //DMA接收使能
    

  73.                     goto err_ret;
    

  74.                 }
    

  75.                 /* 站地址 (1字节） */
    

  76.                 addr = modbus_slave.rx_buf[0];                                /* 第1字节 站号 */
    

  77.                 if (addr != SADDR485)                                         /* 判断主机发送的命令地址是否符合 */
    

  78.                 {
    

  79.                     RS485_RX_EN();//接收使能
    

  80.                     dma_channel_enable(DMA1_CHANNEL5, TRUE); //DMA接收使能
    

  81.                     goto err_ret;
    

  82.                 }
    

  83.                 
    

  84.                 //功能码处理
    

  85.                 MODBUS_SLAVE_FunctionCodeHandle();
    

  86.             }
    

  87.         }
    

  88.         else
    

  89.         {
    

  90.             // 如果 DMA 接收计数值发生变化，则更新计数
    

  91.             timer_record.StartTime = timer_record.timer_counter; // 更新开始时间
    

  92.         }
    

  93.         modbus_slave.last_dma_cnt = modbus_slave.curr_dma_cnt;//更新此次DMA值
    

  94.     }
    

  95. err_ret:
    

  96.     memset(modbus_slave.rx_buf, 0, modbus_slave.recv_len);
    

  97.     modbus_slave.recv_len = 0;/* 必须清零计数器，方便下次帧同步 */
    

  98. }
    


  99. 

  100. //Modbus功能码处理
    

  101. static void MODBUS_SLAVE_FunctionCodeHandle(void)
    

  102. {
    

  103.     switch (modbus_slave.rx_buf[1])                                /* 第2个字节 功能码 */
    

  104.     {
    

  105.         case 0x01:  /* 读取线圈状态（此例程用led代替）*/
    

  106.             MODBUS_SLAVE_01H();
    

  107.             break;
    


  108. 

  109.         case 0x02:  /* 读取输入状态（按键状态）*/
    

  110.             MODBUS_SLAVE_02H();
    

  111.             break;
    

  112.         
    

  113.         case 0x03:  /* 读取保持寄存器*/
    

  114.             MODBUS_SLAVE_03H();
    

  115.             break;
    

  116.         
    

  117.         case 0x04:  /* 读取输入寄存器（ADC的值）*/
    

  118.             MODBUS_SLAVE_04H();
    

  119.             break;
    

  120.         
    

  121.         case 0x05:  /* 强制单线圈（设置led）*/
    

  122.             MODBUS_SLAVE_05H();
    

  123.             break;
    

  124.         
    

  125.         case 0x06:  /* 写单个保存寄存器*/
    

  126.             MODBUS_SLAVE_06H();        
    

  127.             break;
    

  128.             
    

  129.         case 0x10:  /* 写多个保存寄存器*/
    

  130.             MODBUS_SLAVE_10H();
    

  131.             break;
    

  132.         
    

  133.         case 0x0F:  /* 写多个线圈寄存器*/
    

  134.             MODBUS_SLAVE_0FH();
    

  135.             break;
    

  136.         default:
    

  137.             modbus_slave.RTU_response_code = RSP_ERR_CMD;
    

  138.             MODBUS_SLAVE_SendAckErr(modbus_slave.RTU_response_code);        /* 告诉主机命令错误 */
    

  139.             break;
    

  140.     }
    

  141. }
    


  142. 


  143. 

  144. //将两字节转换为16位
    

  145. uBit16 MODBUS_SLAVE_BEBufToUint16(uBit8 *_pBuf)
    

  146. {
    

  147.     return (((uBit16)_pBuf[0] << 8) | _pBuf[1]);
    

  148. }
    


  149. 


  150. 

  151. //串口发送
    

  152. void MODBUS_SLAVE_UartSend(uBit8 *buf, uBit16 len)
    

  153. {
    

  154.     //发送函数
    

  155.     bsp_dma_uart_tx_init(modbus_slave.tx_buf, len);//初始化dma,重置传输计数器
    

  156.     dma_channel_enable(DMA1_CHANNEL4, TRUE); /* usart2 tx begin dma transmitting */
    

  157.     usart_flag_clear(USART2, USART_TDC_FLAG);
    

  158.     usart_interrupt_enable(USART2, USART_TDC_INT, TRUE);
    

  159. }
    


  160. 


  161. 

  162. //发送加crc
    

  163. void MODBUS_SLAVE_SendWithCRC(uint8_t *buf, uint8_t len)
    

  164. {
    

  165.     uint16_t crc;
    

  166.     
    

  167.     crc = CRC16_Modbus(buf, len);
    

  168.     buf[len++] = crc >> 8;
    

  169.     buf[len++] = crc;
    

  170.     
    

  171.     MODBUS_SLAVE_UartSend(buf, len);
    

  172. }
    


  173. 


  174. 

  175. //发送错误应答  ErrCode : 错误代码
    

  176. void MODBUS_SLAVE_SendAckErr(uint8_t ErrCode)
    

  177. {
    

  178.     modbus_slave.send_len = 0;
    

  179.     
    

  180.     modbus_slave.tx_buf[modbus_slave.send_len++] = modbus_slave.rx_buf[0];          /* 485地址 */
    

  181.     modbus_slave.tx_buf[modbus_slave.send_len++] = modbus_slave.rx_buf[1] | 0x80;   /* 异常的功能码 */
    

  182.     modbus_slave.tx_buf[modbus_slave.send_len++] = ErrCode;                      /* 错误代码(01,02,03,04) */
    


  183. 

  184.     MODBUS_SLAVE_SendWithCRC(modbus_slave.tx_buf, modbus_slave.send_len);
    

  185. }
    


  186. 

  187. //判断LED指示灯是否已经点亮
    

  188. uint8_t MODBUS_SLAVE_BSPIsLedOn(uint8_t num)
    

  189. {
    

  190.     if (num == 1)
    

  191.     {
    

  192.         if (test_led[0])
    

  193.         {
    

  194.             return 1;
    

  195.         }
    

  196.         return 0;
    

  197.     }
    

  198.     else if (num == 2)
    

  199.     {
    

  200.         if (test_led[1])
    

  201.         {
    

  202.             return 1;
    

  203.         }
    

  204.         return 0;
    

  205.     }
    

  206.     else if (num == 3)
    

  207.     {
    

  208.         if (test_led[2])
    

  209.         {
    

  210.             return 1;
    

  211.         }
    

  212.         return 0;
    

  213.     }
    

  214.     else if (num == 4)
    

  215.     {
    

  216.         if (test_led[3])
    

  217.         {
    

  218.             return 1;
    

  219.         }
    

  220.         return 0;
    

  221.     }
    


  222. 

  223.     return 0;
    

  224. }
    


  225. 


  226. 

  227. //读线圈状态功能码 01H
    

  228. static void MODBUS_SLAVE_01H(void)
    

  229. {
    

  230.     uBit16 reg;
    

  231.     uBit16 num;
    

  232.     uBit16 i;
    

  233.     uBit16 m;
    

  234.     uBit8 status[10];
    


  235. 

  236.     modbus_slave.RTU_response_code = RSP_OK;
    


  237. 

  238.     if (modbus_slave.recv_len != 8)
    

  239.     {
    

  240.         modbus_slave.RTU_response_code = RSP_ERR_VALUE; // 数据值域错误
    

  241.         return;
    

  242.     }
    

  243.     
    

  244.     reg = MODBUS_SLAVE_BEBufToUint16(&modbus_slave.rx_buf[2]);   // 寄存器号
    

  245.     num = MODBUS_SLAVE_BEBufToUint16(&modbus_slave.rx_buf[4]);   // 寄存器个数
    


  246. 

  247.     m = (num + 7) / 8;
    


  248. 

  249.     if ((reg >= REG_D01) && (num > 0) && (reg + num <= REG_DXX + 1))
    

  250.     {
    

  251.         for (i = 0; i < m; i++)
    

  252.         {
    

  253.             status[i] = 0;
    

  254.         }
    

  255.         for (i = 0; i < num; i++)
    

  256.         {
    

  257.             if (MODBUS_SLAVE_BSPIsLedOn(i + 1 + reg - REG_D01)) // 读LED的状态，写入状态寄存器的每一位
    

  258.             {  
    

  259.                 status[i / 8] |= (1 << (i % 8));
    

  260.             }
    

  261.         }
    

  262.     }
    

  263.     else
    

  264.     {
    

  265.         modbus_slave.RTU_response_code = RSP_ERR_REG_ADDR;  // 寄存器地址错误
    

  266.     }
    


  267. 

  268.     if (modbus_slave.RTU_response_code == RSP_OK)   // 正确应答
    

  269.     {
    

  270.         modbus_slave.send_len = 0;
    

  271.         modbus_slave.tx_buf[modbus_slave.send_len++] = modbus_slave.rx_buf[0];
    

  272.         modbus_slave.tx_buf[modbus_slave.send_len++] = modbus_slave.rx_buf[1];
    

  273.         modbus_slave.tx_buf[modbus_slave.send_len++] = m;   // 返回字节数
    


  274. 

  275.         for (i = 0; i < m; i++)
    

  276.         {
    

  277.             modbus_slave.tx_buf[modbus_slave.send_len++] = status[i];
    

  278.         }
    

  279.         MODBUS_SLAVE_SendWithCRC(modbus_slave.tx_buf, modbus_slave.send_len);
    

  280.     }
    

  281.     else
    

  282.     {
    

  283.         MODBUS_SLAVE_SendAckErr(modbus_slave.RTU_response_code);    // 告诉主机命令错误
    

  284.     }
    

  285. }
    


  286. 


  287. 

  288. //02读取输入状态
    

  289. uint8_t MODBUS_SLAVE_BSP_GetKeyState(uint8_t _ucKeyID)
    

  290. {
    

  291.     return 1;//此处应该返回按键按下状态，这里模拟都为1
    

  292. }
    


  293. 

  294. //读取输入状态功能码 02H
    

  295. static void MODBUS_SLAVE_02H(void)
    

  296. {
    

  297.     uint16_t reg;
    

  298.     uint16_t num;
    

  299.     uint16_t i;
    

  300.     uint16_t m;
    

  301.     uint8_t status[10];
    


  302. 

  303.     modbus_slave.RTU_response_code = RSP_OK;
    


  304. 

  305.     if (modbus_slave.recv_len != 8)
    

  306.     {
    

  307.         modbus_slave.RTU_response_code = RSP_ERR_VALUE; /* 数据值域错误 */
    

  308.         return;
    

  309.     }
    


  310. 

  311.     reg = MODBUS_SLAVE_BEBufToUint16(&modbus_slave.rx_buf[2]);   /* 寄存器号 */
    

  312.     num = MODBUS_SLAVE_BEBufToUint16(&modbus_slave.rx_buf[4]);   /* 寄存器个数 */
    


  313. 

  314.     m = (num + 7) / 8;
    

  315.     if ((reg >= REG_T01) && (num > 0) && (reg + num <= REG_TXX + 1))
    

  316.     {
    

  317.         for (i = 0; i < m; i++)
    

  318.         {
    

  319.             status[i] = 0;
    

  320.         }
    

  321.         for (i = 0; i < num; i++)
    

  322.         {
    

  323.             if (MODBUS_SLAVE_BSP_GetKeyState(reg - REG_T01 + i))
    

  324.             {
    

  325.                 status[i / 8] |= (1 << (i % 8));
    

  326.             }
    

  327.         }
    

  328.     }
    

  329.     else
    

  330.     {
    

  331.         modbus_slave.RTU_response_code = RSP_ERR_REG_ADDR;  /* 寄存器地址错误 */
    

  332.     }
    


  333. 

  334.     if (modbus_slave.RTU_response_code == RSP_OK)   /* 正确应答 */
    

  335.     {
    

  336.         modbus_slave.send_len = 0;
    

  337.         modbus_slave.tx_buf[modbus_slave.send_len++] = modbus_slave.rx_buf[0];
    

  338.         modbus_slave.tx_buf[modbus_slave.send_len++] = modbus_slave.rx_buf[1];
    

  339.         modbus_slave.tx_buf[modbus_slave.send_len++] = m;   /* 返回字节数 */
    


  340. 

  341.         for (i = 0; i < m; i++)
    

  342.         {
    

  343.             modbus_slave.tx_buf[modbus_slave.send_len++] = status[i];   /* T01-02状态 */
    

  344.         }
    

  345.         MODBUS_SLAVE_SendWithCRC(modbus_slave.tx_buf, modbus_slave.send_len);
    

  346.     }
    

  347.     else
    

  348.     {
    

  349.         MODBUS_SLAVE_SendAckErr(modbus_slave.RTU_response_code);    /* 告诉主机命令错误 */
    

  350.     }
    

  351. }
    


  352. 

  353. //读取保持寄存器的值
    

  354. uint8_t MODBUS_SLAVE_ReadRegValue(uint16_t reg_addr, uint8_t *reg_value)
    

  355. {
    

  356.     uint16_t value;
    


  357. 

  358.     switch (reg_addr)   /* 判断寄存器地址 */
    

  359.     {
    

  360.         case SLAVE_REG_P01:
    

  361.             value = test_hold_reg[0];
    

  362.             break;
    


  363. 

  364.         case SLAVE_REG_P02:
    

  365.             value = test_hold_reg[1];   /* 将寄存器值读出 */
    

  366.             break;
    


  367. 

  368.         default:
    

  369.             return 0;   /* 参数异常，返回 0 */
    

  370.     }
    


  371. 

  372.     reg_value[0] = value >> 8;
    

  373.     reg_value[1] = value;
    


  374. 

  375.     return 1;   /* 读取成功 */
    

  376. }
    


  377. 


  378. 

  379. //读取保持寄存器功能码 03H
    

  380. static void MODBUS_SLAVE_03H(void)
    

  381. {
    

  382.     uint16_t reg;
    

  383.     uint16_t num;
    

  384.     uint16_t i;
    

  385.     uint8_t reg_value[64];
    


  386. 

  387.     modbus_slave.RTU_response_code = RSP_OK;
    


  388. 

  389.     if (modbus_slave.recv_len != 8) /* 03H命令必须是8个字节 */
    

  390.     {
    

  391.         modbus_slave.RTU_response_code = RSP_ERR_VALUE; /* 数据值域错误 */
    

  392.         goto err_ret;
    

  393.     }
    


  394. 

  395.     reg = MODBUS_SLAVE_BEBufToUint16(&modbus_slave.rx_buf[2]);   /* 寄存器号 */
    

  396.     num = MODBUS_SLAVE_BEBufToUint16(&modbus_slave.rx_buf[4]);   /* 寄存器个数 */
    

  397.     if (num > sizeof(reg_value) / 2)
    

  398.     {
    

  399.         modbus_slave.RTU_response_code = RSP_ERR_VALUE; /* 数据值域错误 */
    

  400.         goto err_ret;
    

  401.     }
    


  402. 

  403.     for (i = 0; i < num; i++)
    

  404.     {
    

  405.         if (MODBUS_SLAVE_ReadRegValue(reg, ®_value[2 * i]) == 0) /* 读出寄存器值放入reg_value */
    

  406.         {
    

  407.             modbus_slave.RTU_response_code = RSP_ERR_REG_ADDR;  /* 寄存器地址错误 */
    

  408.             break;
    

  409.         }
    

  410.         reg++;
    

  411.     }
    


  412. 

  413. err_ret:
    

  414.     if (modbus_slave.RTU_response_code == RSP_OK)   /* 正确应答 */
    

  415.     {
    

  416.         modbus_slave.send_len = 0;
    

  417.         modbus_slave.tx_buf[modbus_slave.send_len++] = modbus_slave.rx_buf[0];
    

  418.         modbus_slave.tx_buf[modbus_slave.send_len++] = modbus_slave.rx_buf[1];
    

  419.         modbus_slave.tx_buf[modbus_slave.send_len++] = num * 2; /* 返回字节数 */
    


  420. 

  421.         for (i = 0; i < num; i++)
    

  422.         {
    

  423.             modbus_slave.tx_buf[modbus_slave.send_len++] = reg_value[2*i];
    

  424.             modbus_slave.tx_buf[modbus_slave.send_len++] = reg_value[2*i+1];
    

  425.         }
    

  426.         MODBUS_SLAVE_SendWithCRC(modbus_slave.tx_buf, modbus_slave.send_len);   /* 发送正确应答 */
    

  427.     }
    

  428.     else
    

  429.     {
    

  430.         MODBUS_SLAVE_SendAckErr(modbus_slave.RTU_response_code);    /* 发送错误应答 */
    

  431.     }
    

  432. }
    


  433. 

  434. //读取输入寄存器功能码 04H
    

  435. static void MODBUS_SLAVE_04H(void)
    

  436. {
    

  437.     uint16_t reg;
    

  438.     uint16_t num;
    

  439.     uint16_t i;
    

  440.     uint16_t status[10];
    


  441. 

  442.     memset(status, 0, 10);
    


  443. 

  444.     modbus_slave.RTU_response_code = RSP_OK;
    


  445. 

  446.     if (modbus_slave.recv_len != 8)
    

  447.     {
    

  448.         modbus_slave.RTU_response_code = RSP_ERR_VALUE; /* 数据值域错误 */
    

  449.         goto err_ret;
    

  450.     }
    


  451. 

  452.     reg = MODBUS_SLAVE_BEBufToUint16(&modbus_slave.rx_buf[2]);   /* 寄存器号 */
    

  453.     num = MODBUS_SLAVE_BEBufToUint16(&modbus_slave.rx_buf[4]);   /* 寄存器个数 */
    


  454. 

  455.     if ((reg >= REG_A01) && (num > 0) && (reg + num <= REG_AXX + 1))
    

  456.     {
    

  457.         for (i = 0; i < num; i++)
    

  458.         {
    

  459.             switch (reg)
    

  460.             {
    

  461.                 /* 测试参数 */
    

  462.                 case REG_A01:
    

  463.                       status[i] = test_adc[0];
    

  464.                     break;
    

  465.                     
    

  466.                 default:
    

  467.                     status[i] = 0;
    

  468.                     break;
    

  469.             }
    

  470.             reg++;
    

  471.         }
    

  472.     }
    

  473.     else
    

  474.     {
    

  475.         modbus_slave.RTU_response_code = RSP_ERR_REG_ADDR;  /* 寄存器地址错误 */
    

  476.     }
    


  477. 

  478. err_ret:
    

  479.     if (modbus_slave.RTU_response_code == RSP_OK)   /* 正确应答 */
    

  480.     {
    

  481.         modbus_slave.send_len = 0;
    

  482.         modbus_slave.tx_buf[modbus_slave.send_len++] = modbus_slave.rx_buf[0];
    

  483.         modbus_slave.tx_buf[modbus_slave.send_len++] = modbus_slave.rx_buf[1];
    

  484.         modbus_slave.tx_buf[modbus_slave.send_len++] = num * 2; /* 返回字节数 */
    


  485. 

  486.         for (i = 0; i < num; i++)
    

  487.         {
    

  488.             modbus_slave.tx_buf[modbus_slave.send_len++] = status[i] >> 8;
    

  489.             modbus_slave.tx_buf[modbus_slave.send_len++] = status[i] & 0xFF;
    

  490.         }
    

  491.         MODBUS_SLAVE_SendWithCRC(modbus_slave.tx_buf, modbus_slave.send_len);
    

  492.     }
    

  493.     else
    

  494.     {
    

  495.         MODBUS_SLAVE_SendAckErr(modbus_slave.RTU_response_code);    /* 告诉主机命令错误 */
    

  496.     }
    

  497. }
    


  498. 

  499. //强制单线圈功能码 05H
    

  500. static void MODBUS_SLAVE_05H(void)
    

  501. {
    

  502.     uint16_t reg;
    

  503.     uint16_t value;
    


  504. 

  505.     modbus_slave.RTU_response_code = RSP_OK;
    


  506. 

  507.     if (modbus_slave.recv_len != 8)
    

  508.     {
    

  509.         modbus_slave.RTU_response_code = RSP_ERR_VALUE; /* 数据值域错误 */
    

  510.         goto err_ret;
    

  511.     }
    


  512. 

  513.     reg = MODBUS_SLAVE_BEBufToUint16(&modbus_slave.rx_buf[2]);   /* 寄存器号 */
    

  514.     value = MODBUS_SLAVE_BEBufToUint16(&modbus_slave.rx_buf[4]); /* 数据 */
    


  515. 

  516.     if ((value>>8) != 0x00 && (value>>8) != 0xFF)
    

  517.     {
    

  518.         modbus_slave.RTU_response_code = RSP_ERR_VALUE; /* 数据值域错误 */
    

  519.         goto err_ret;
    

  520.     }
    


  521. 

  522.     //此处处理可以优化
    

  523.     if (value>>8)//右移8位为0xFF 则值1 表示打开
    

  524.         value = 1;
    

  525.     else//右移8位为0x00 则值0 表示关闭
    

  526.         value = 0;
    

  527.     
    

  528.     if (reg == REG_D01)
    

  529.     {
    

  530.         test_led[0] = value;//模拟LED状态
    

  531.     }
    

  532.     else if (reg == REG_D02)
    

  533.     {
    

  534.         test_led[1] = value;
    

  535.     }
    

  536.     else if (reg == REG_D03)
    

  537.     {
    

  538.         test_led[2] = value;
    

  539.     }
    

  540.     else if (reg == REG_D04)
    

  541.     {
    

  542.         test_led[3] = value;//模拟LED状态
    

  543.     }
    

  544.     else
    

  545.     {
    

  546.         modbus_slave.RTU_response_code = RSP_ERR_REG_ADDR;  /* 寄存器地址错误 */
    

  547.     }
    

  548. err_ret:
    

  549.     if (modbus_slave.RTU_response_code == RSP_OK)   /* 正确应答 */
    

  550.     {
    

  551.         //此命令码应答报文与请求报文一致
    

  552.         memcpy(modbus_slave.tx_buf, modbus_slave.rx_buf, modbus_slave.recv_len - 2);//不复制crc位
    

  553.         modbus_slave.send_len = (modbus_slave.recv_len - 2);//不复制crc位
    

  554.         MODBUS_SLAVE_SendWithCRC(modbus_slave.tx_buf, modbus_slave.send_len);
    

  555.     }
    

  556.     else
    

  557.     {
    

  558.         MODBUS_SLAVE_SendAckErr(modbus_slave.RTU_response_code);    /* 告诉主机命令错误 */
    

  559.     }
    

  560. }
    


  561. 


  562. 

  563. //读取保持寄存器的值
    

  564. uint8_t MODBUS_SLAVE_WriteRegValue(uint16_t reg_addr, uint16_t reg_value)
    

  565. {
    

  566.     switch (reg_addr)   /* 判断寄存器地址 */
    

  567.     {
    

  568.         case SLAVE_REG_P01:
    

  569.             test_hold_reg[0] = reg_value;   /* 将值写入保存寄存器 */
    

  570.             break;
    

  571.         
    

  572.         case SLAVE_REG_P02:
    

  573.             test_hold_reg[1] = reg_value;   /* 将值写入保存寄存器 */
    

  574.             break;
    

  575.         
    

  576.         default:
    

  577.             return 0;   /* 参数异常，返回 0 */
    

  578.     }
    


  579. 

  580.     return 1;   /* 读取成功 */
    

  581. }
    


  582. 

  583. //写单个寄存器功能码 06H
    

  584. static void MODBUS_SLAVE_06H(void)
    

  585. {
    

  586.     uint16_t reg;
    

  587.     uint16_t value;
    


  588. 

  589.     modbus_slave.RTU_response_code = RSP_OK;
    


  590. 

  591.     if (modbus_slave.recv_len != 8)
    

  592.     {
    

  593.         modbus_slave.RTU_response_code = RSP_ERR_VALUE; /* 数据值域错误 */
    

  594.         goto err_ret;
    

  595.     }
    


  596. 

  597.     reg = MODBUS_SLAVE_BEBufToUint16(&modbus_slave.rx_buf[2]);   /* 寄存器号 */
    

  598.     value = MODBUS_SLAVE_BEBufToUint16(&modbus_slave.rx_buf[4]); /* 寄存器值 */
    


  599. 

  600.     if (MODBUS_SLAVE_WriteRegValue(reg, value) == 1)    /* 该函数会把写入的值存入寄存器 */
    

  601.     {
    

  602.         ;
    

  603.     }
    

  604.     else
    

  605.     {
    

  606.         modbus_slave.RTU_response_code = RSP_ERR_REG_ADDR;  /* 寄存器地址错误 */
    

  607.     }
    


  608. 

  609. err_ret:
    

  610.     if (modbus_slave.RTU_response_code == RSP_OK)   /* 正确应答 */
    

  611.     {
    

  612.         //此命令码应答报文与请求报文一致
    

  613.         memcpy(modbus_slave.tx_buf, modbus_slave.rx_buf, modbus_slave.recv_len - 2);//不复制crc位
    

  614.         modbus_slave.send_len = (modbus_slave.recv_len - 2);//不复制crc位
    

  615.         MODBUS_SLAVE_SendWithCRC(modbus_slave.tx_buf, modbus_slave.send_len);
    

  616.     }
    

  617.     else
    

  618.     {
    

  619.         MODBUS_SLAVE_SendAckErr(modbus_slave.RTU_response_code);    /* 告诉主机命令错误 */
    

  620.     }
    

  621. }
    


  622. 

  623. //写多个寄存器功能码 10H
    

  624. static void MODBUS_SLAVE_10H(void)
    

  625. {
    

  626.     uint16_t reg_addr;
    

  627.     uint16_t reg_num;
    

  628.     uint8_t byte_num;
    

  629.     uint8_t i;
    

  630.     uint16_t value;
    


  631. 

  632.     modbus_slave.RTU_response_code = RSP_OK;
    


  633. 

  634.     if (modbus_slave.recv_len < 11)
    

  635.     {
    

  636.         modbus_slave.RTU_response_code = RSP_ERR_VALUE; /* 数据值域错误 */
    

  637.         goto err_ret;
    

  638.     }
    


  639. 

  640.     reg_addr = MODBUS_SLAVE_BEBufToUint16(&modbus_slave.rx_buf[2]);  /* 寄存器号 */
    

  641.     reg_num = MODBUS_SLAVE_BEBufToUint16(&modbus_slave.rx_buf[4]);   /* 寄存器个数 */
    

  642.     byte_num = modbus_slave.rx_buf[6];  /* 后面的数据体字节数 */
    


  643. 

  644.     if (byte_num != 2 * reg_num)
    

  645.     {
    

  646.         ;
    

  647.     }
    


  648. 

  649.     for (i = 0; i < reg_num; i++)
    

  650.     {
    

  651.         value = MODBUS_SLAVE_BEBufToUint16(&modbus_slave.rx_buf[7 + 2 * i]); /* 寄存器值 */
    


  652. 

  653.         if (MODBUS_SLAVE_WriteRegValue(reg_addr + i, value) == 1)
    

  654.         {
    

  655.             ;
    

  656.         }
    

  657.         else
    

  658.         {
    

  659.             modbus_slave.RTU_response_code = RSP_ERR_REG_ADDR;  /* 寄存器地址错误 */
    

  660.             break;
    

  661.         }
    

  662.     }
    


  663. 

  664. err_ret:
    

  665.     if (modbus_slave.RTU_response_code == RSP_OK)   /* 正确应答 */
    

  666.     {
    

  667.         //此命令码应答报文与请求报文一致
    

  668.         memcpy(modbus_slave.tx_buf, modbus_slave.rx_buf, 6);//不复制crc位
    

  669.         modbus_slave.send_len = 6;//不复制crc位
    

  670.         MODBUS_SLAVE_SendWithCRC(modbus_slave.tx_buf, modbus_slave.send_len);
    

  671.     }
    

  672.     else
    

  673.     {
    

  674.         MODBUS_SLAVE_SendAckErr(modbus_slave.RTU_response_code);    /* 告诉主机命令错误 */
    

  675.     }
    

  676. }
    


  677. 

  678. //写多个线圈
    

  679. uint8_t MODBUS_SLAVE_BSPSetLed(uint8_t num, uint8_t value)
    

  680. {
    

  681.     static uint8_t last, last_flag;
    

  682.     if (num / 8)
    

  683.     {
    

  684.         num = 8;
    

  685.         last++;
    

  686.     }
    

  687.     else
    

  688.     {
    

  689.         num %= 8;
    

  690.         last_flag = 1;
    

  691.     }
    

  692.     for (uint16_t i = 0; i < num; i++)
    

  693.     {
    

  694.         if (last_flag == 0)
    

  695.         {
    

  696.             test_led[i+((last - 1) * 8)] = (value & (0x01 << i)) >> i;
    

  697.         }
    

  698.         if (last_flag == 1)
    

  699.         {
    

  700.             test_led[i + (last * 8)] = (value & (0x01 << i)) >> i;
    

  701.         }
    

  702.         
    

  703.     }
    

  704.     
    

  705.     if (last_flag)
    

  706.     {
    

  707.         last_flag = 0;
    

  708.         last = 0;
    

  709.     }
    

  710.     return 0;
    

  711. }
    


  712. 

  713. //写多个线圈功能码 0FH
    

  714. static void MODBUS_SLAVE_0FH(void)
    

  715. {
    

  716.     uint16_t reg_num;
    

  717.     uint8_t byte_num;
    

  718.     uint8_t i;
    

  719.     uint16_t value;
    


  720. 

  721.     modbus_slave.RTU_response_code = RSP_OK;
    


  722. 

  723.     if (modbus_slave.recv_len < 10)
    

  724.     {
    

  725.         modbus_slave.RTU_response_code = RSP_ERR_VALUE;                        /* 数据值域错误 */
    

  726.         goto err_ret;
    

  727.     }
    


  728. 

  729.     reg_num = MODBUS_SLAVE_BEBufToUint16(&modbus_slave.rx_buf[4]);                /* 寄存器个数 */
    

  730.     byte_num = modbus_slave.rx_buf[6];                                        /* 后面的数据体字节数 */
    


  731. 

  732.     //判断寄存器数量与字节数是否对应
    

  733.     if (reg_num % 8)//寄存器数量不是整数字节，需要+1之后比较
    

  734.     {
    

  735.         if (byte_num != ((reg_num / 8) + 1))
    

  736.         {
    

  737.             ;
    

  738.         }
    

  739.     }
    

  740.     else//寄存器数量是整数字节直接进行比较
    

  741.     {
    

  742.         if (byte_num != (reg_num / 8))
    

  743.         {
    

  744.             ;
    

  745.         }
    

  746.     }
    

  747.     
    

  748.     for (i = 0; i < byte_num; i++)
    

  749.     {
    

  750.         value = modbus_slave.rx_buf[7 + i];/* 寄存器值 */
    

  751.         MODBUS_SLAVE_BSPSetLed(reg_num, value);
    

  752.         reg_num -= 8;
    

  753.     }
    


  754. 

  755. err_ret:
    

  756.     if (modbus_slave.RTU_response_code == RSP_OK)   /* 正确应答 */
    

  757.     {
    

  758.         //此命令码应答报文与请求报文一致
    

  759.         memcpy(modbus_slave.tx_buf, modbus_slave.rx_buf, 6);//不复制crc位
    

  760.         modbus_slave.send_len = 6;//不复制crc位
    

  761.         MODBUS_SLAVE_SendWithCRC(modbus_slave.tx_buf, modbus_slave.send_len);
    

  762.     }
    

  763.     else
    

  764.     {
    

  765.         MODBUS_SLAVE_SendAckErr(modbus_slave.RTU_response_code);    /* 告诉主机命令错误 */
    

  766.     }
    

  767. }
    


  768.
复制
  1. #ifndef  _MODBUS_SLAVE_H_
    

  2. #define  _MODBUS_SLAVE_H_
    


  3. 

  4. /************************************************************************/
    

  5. /*  “文件包含”处理                                                       */
    

  6. /************************************************************************/
    

  7. #include "data_types.h"
    


  8. 


  9. 

  10. #ifdef __cplusplus
    

  11.  extern "C" {
    

  12. #endif
    


  13. 

  14. /************************************************************************/
    

  15. /*  宏定义                                                               */
    

  16. /************************************************************************/
    

  17. #define SADDR485            (1)     // 从机地址
    

  18. #define RX_LEN_MAX          (255)   // 报文接收缓冲区大小
    

  19. #define TX_LEN_MAX          (255)   // 报文发送缓冲区大小
    


  20. 

  21. /* 01H 读强制单线圈 */
    

  22. /* 05H 写强制单线圈 */
    

  23. #define REG_D01     0x1000
    

  24. #define REG_D02     0x1002
    

  25. #define REG_D03     0x1003
    

  26. #define REG_D04     0x1004
    

  27. #define REG_DXX     REG_D04
    


  28. 

  29. /* 02H 读取输入状态 */
    

  30. #define REG_T01     0x2001
    

  31. #define REG_T02     0x2002
    

  32. #define REG_T03     0x2003
    

  33. #define REG_TXX     REG_T03
    


  34. 

  35. /* 03H 读保持寄存器 */
    

  36. /* 06H 写保持寄存器 */
    

  37. /* 10H 写多个保存寄存器 */
    

  38. #define SLAVE_REG_P01       0x3001
    

  39. #define SLAVE_REG_P02       0x3002
    


  40. 

  41. /* 04H 读取输入寄存器(模拟信号) */
    

  42. #define REG_A01     0x4001
    

  43. #define REG_AXX     REG_A01
    


  44. 


  45. 

  46. /* RTU 应答代码 */
    

  47. #define RSP_OK              (0)     // 成功
    

  48. #define RSP_ERR_CMD         (0x01)  // 不支持的功能码
    

  49. #define RSP_ERR_REG_ADDR    (0x02)  // 寄存器地址错误
    

  50. #define RSP_ERR_VALUE       (0x03)  // 数据值域错误
    

  51. #define RSP_ERR_WRITE       (0x04)  // 写入失败 
    

  52.      
    

  53. /************************************************************************/
    

  54. /*  类型定义                                                             */
    

  55. /************************************************************************/
    

  56. typedef struct
    

  57. {
    

  58.     uBit8 rx_buf[RX_LEN_MAX];       // 报文接收处理缓冲区
    

  59.     uBit8 tx_buf[TX_LEN_MAX];       // 报文发送处理缓冲区
    

  60.     uBit16 curr_dma_cnt;            // 表示当前DMA传输计数器中的值
    

  61.     uBit16 last_dma_cnt;            // 表示上次DMA传输计数器中的值
    

  62.     uBit16 recv_len;                // 接收的字节数
    

  63.     uBit16 send_len;                // 发送的字节数
    

  64.     uBit8 RTU_response_code;        // RTU应答码
    

  65. }Modbus_Slave_t;
    


  66. 


  67. 


  68. 

  69. /************************************************************************/
    

  70. /*  全局变量声明                                                         */
    

  71. /************************************************************************/
    

  72. extern Modbus_Slave_t modbus_slave;
    


  73. 


  74. 

  75. /************************************************************************/
    

  76. /*  函数声明                                                             */
    

  77. /************************************************************************/
    

  78. void MODBUS_SLAVE_Pool(void);
    


  79. 


  80. 

  81. #ifdef __cplusplus
    

  82. }
    

  83. #endif
    


  84. 

  85. #endif
    


  86.
七、效果展示(由于篇幅限制只展示部分功能码)
80246676c1dc0cd658.jpg
01功能码：
12123676c1b5d34dcc.png

05功能码：
99249676c1c1208aa4.png

0F功能码：
38490676c1f851b6f5.png



95765676c17285eb78.png
80885676c1b551b1de.png

AT32L021C8T7_Modbus_slave .zip

991.58 KB, 下载次数: 40

源码
回复

收藏 举报

打赏榜单

ArterySW 打赏了 10.00 元 2025-01-07
理由：作品优秀

相关帖子
saservice 发表于 2025-1-3 20:59 | 显示全部楼层
详细介绍了如何在AT-START-L021开发板上实现Modbus RTU从站的功能。
回复

收藏 举报

robertesth 发表于 2025-1-3 21:50 | 显示全部楼层
提供的实现方案具有很强的实用性，可以直接应用于实际项目中。
回复

收藏 举报

nomomy 发表于 2025-1-3 23:21 | 显示全部楼层
在软件实现方面，详细介绍了 Modbus RTU 协议的具体内容，包括数据帧格式、CRC 校验算法等。作者不仅讲解了如何编写代码实现 Modbus RTU 从站功能，还给出了代码示例，使读者能够更好地理解和应用。
回复

收藏 举报

burgessmaggie 发表于 2025-1-4 02:26 | 显示全部楼层
先介绍了Modbus RTU协议的背景和基本概念，然后详细阐述了AT32L021微控制器的特点和优势，最后给出了具体的实现步骤和代码示例。这种结构有助于读者更好地理解和把握整个实现过程。
回复

收藏 举报

benjaminka 发表于 2025-1-4 07:22 | 显示全部楼层
描述了Modbus RTU协议的原理，以及如何在AT-START-L021开发板上实现从站功能。
回复

收藏 举报

mikewalpole 发表于 2025-1-5 09:41 | 显示全部楼层
Modbus RTU协议的实现，这是一个在工业自动化领域广泛使用的通信协议。
回复

收藏 举报

maqianqu 发表于 2025-1-5 10:40 | 显示全部楼层
描述了 Modbus RTU 从站硬件连接的各个方面，包括通信接口的选择（如 RS485 接口）以及相关引脚的连接方式。例如，明确指出了 AT32L021 的串口引脚与 RS485 芯片的连接方式，这对于实际硬件搭建非常关键。
回复

收藏 举报

51xlf 发表于 2025-1-5 11:37 | 显示全部楼层
考虑创建一个系列教程，涵盖Modbus RTU从站的不同方面，如性能优化、安全性等。
回复

收藏 举报

nomomy 发表于 2025-1-5 12:05 | 显示全部楼层
若包含相关的代码示例，无论是简单的配置代码还是完整的通信处理代码，都能极大地增强帖子的实用性。代码示例可以作为开发者快速上手和调试的参考，减少开发过程中的困惑。
回复

收藏 举报

updownq 发表于 2025-1-5 13:50 | 显示全部楼层
对于Modbus RTU协议的帧格式、地址域、功能码等关键概念进行了详细的解释和说明，同时对于实现过程中可能遇到的常见问题也给出了相应的解决方案。
回复

收藏 举报

sdCAD 发表于 2025-1-5 14:40 | 显示全部楼层
对于理解Modbus RTU从站的实现非常有帮助。
回复

收藏 举报

maudlu 发表于 2025-1-5 16:21 | 显示全部楼层
包括硬件连接、软件配置、代码示例等。
回复

收藏 举报

backlugin 发表于 2025-1-5 16:45 | 显示全部楼层
列出了实现的步骤，例如从硬件连接（如串口引脚的配置、与主站的电气连接等）到软件编程（包括初始化串口、设置Modbus从站相关参数如寄存器地址映射、功能码处理等）的每一个环节，这将是非常有价值的。这种详细程度有助于不同水平的开发者理解和操作。
回复

收藏 举报

burgessmaggie 发表于 2025-1-5 17:08 | 显示全部楼层
从Modbus RTU协议的基本概念讲起，逐步深入到从站的具体实现，逻辑清晰，易于理解。
回复

收藏 举报

usysm 发表于 2025-1-5 17:34 | 显示全部楼层
对 Modbus RTU 从站的功能实现进行了全面的阐述，包括数据的读写操作、异常处理等。例如，通过对 Modbus 寄存器的操作实现了对不同类型数据的读写功能，并且在遇到异常情况时能够及时处理。
回复

收藏 举报

ingramward 发表于 2025-1-7 13:33 | 显示全部楼层
提供了完整的代码示例，包括初始化、数据接收和处理、响应发送等关键部分。
回复

收藏 举报

beacherblack 发表于 2025-1-7 14:01 | 显示全部楼层
一个很不错的关于AT - START - L021设备Modbus RTU从站实现的参考资料。
回复

收藏 举报

qiufengsd 发表于 2025-1-7 15:22 | 显示全部楼层
对于了解Modbus RTU协议和AT32L021微控制器的应用具有较高的参考价值，同时也为读者提供了具体的实现步骤和代码示例
回复

收藏 举报

loutin 发表于 2025-1-7 19:22 | 显示全部楼层
使用AT32L021实现Modbus RTU从站功能的过程，涵盖了Modbus RTU协议的基本原理、AT32L021微控制器的相关配置以及具体的实现步骤。内容具有一定的深度和专业性，对于了解Modbus RTU协议和AT32L021微控制器的应用具有一定的参考价值。
回复

收藏 举报

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

本版积分规则

bingbing12138

2

主题

2

帖子

0

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