TI

STM32 移植FreeModbus 详细过程

2019-12-08 14:17发布

站内问答 / STM32/STM8
7824 98 100
本帖最后由 xukai871105 于 2012-8-13 19:32 编辑

FreeModbus移植 经验分享一   为什么要移植Freemodbus         为什么要移植Freemodbus，这个问题需要从两个方面来回答。第一，modbus是一个非常好的应用层协议，它很简洁也相对完善。对于还没有接触过modbus的朋友来说，我非常不建议直接移植freemodbus，应该耐心的从modbus文档入手，并充分把握身边的所有资源，例如PLC的中modbus部分。第二，其实嵌入式系统的通信协议可以自己制定，但是通过实践发现自己定制的协议漏洞百出，尤其是扩展极为困难。我始终认为借鉴他人的经验是很好的途径。借鉴他人成熟的代码，可以减少调试的时间，实现的功能也多了不少。         个人观点，仅供参考。         freemodbus小提示         freemodbus只能使用从机功能。freemodbus更适合嵌入式系统，虽然例子中也有WIN32的例子，如果想要做PC机程序并实现主机功能，推荐使用另一个modbus库——NMODBUS，使用C#开发。同样WINFORM也可以通过自己编写串口代码实现modbus功能，但是这会花费很长的时间，可能是一周也可能是一个月，如果使用现成的代码库，那么开发时间可能只有10分钟。
        自己整理的modbus协议 MODBUS 协议整理.pdf (111.46 KB, 下载次数: 10973) 2012-8-12 20:06 上传 点击文件名下载附件
        代码参考了这个帖子，感谢你的分享。点击这里
二  freeemodbus中如何通过串口发送和接收数据         freemodbus通过串口中断的方式接收和发送数据。采用这种做法我想可以节省程序等待的时间，并且也短充分使用CPU的资源。串口中断接收毋庸置疑，在中断服务函数中把数据保存在数组中，以便稍后处理。但是串口发送中断使用哪种形式？串口发送中断至少有两种方式，第一种，数据寄存器空中断，只要数据寄存器为空并且中断屏蔽位置位，那么中断就会发生；第二种，发送完成中断，若数据寄存器的数据发送完成并且中断屏蔽位置位，那么中断也会发送。我非常建议各位使用串口发送完成中断。freemodbus多使用RS485通信中，从机要么接收要么发送，多数情况下从机处于接收状态，要有数据发送时才进入发送状态。进入发送状态时，数据被一个一个字节发送出去，当最后一个字节被发送出去之后，从机再次进入接收状态。如果使用发送寄存器为空中断，还需要使用其他的方法才可以判断最后一个字节的数据是否发送完成。如果使用数据寄存器为空中断，那么将很有可能丢失最后一个字节。（马潮老师的AVR图书中也推荐使用发送完成中断，交流性质的文章，就没有参考文献了。）
二  freemodbus中如何判断帧结束         大家应该清楚，modbus协议中没有明显的开始符和结束符，而是通过帧与帧之间的间隔时间来判断的。如果在指定的时间内，没有接收到新的字符数据，那么就认为收到了新的帧。接下来就可以处理数据了，首当其冲的就是判断帧的合法性。Modbus通过时间来判断帧是否接受完成，自然需要单片机中的定时器配合。
三   整体代码下面给出一个STM32平台上使用FREEMODBUS最简单的例子，操作保持寄存器，此时操作指令可以为03，06和16；
  1. <FONT size=3>#include "stm32f10x.h"
  2. #include <stdio.h>
  3. #include "mb.h"
  4. #include "mbutils.h"

  6. //保持寄存器起始地址
  7. #define REG_HOLDING_START 0x0000
  8. //保持寄存器数量
  9. #define REG_HOLDING_NREGS 8
  10. //保持寄存器内容
  11. uint16_t usRegHoldingBuf[REG_HOLDING_NREGS]
  12. = {0x147b,0x3f8e,0x147b,0x400e,0x1eb8,0x4055,0x147b,0x408e};

  14. int main(void)
  15. {
  16. //初始化 RTU模式 从机地址为1 USART1 9600 无校验
  17. eMBInit(MB_RTU, 0x01, 0x01, 9600, MB_PAR_NONE);
  18. //启动FreeModbus
  19. eMBEnable();
  20. while (1)
  21. {
  22. //FreeMODBUS不断查询
  23. eMBPoll();
  24. }
  25. }

  27. /**
  28. * @brief 保持寄存器处理函数，保持寄存器可读，可读可写
  29. * @param pucRegBuffer 读操作时--返回数据指针，写操作时--输入数据指针
  30. * usAddress 寄存器起始地址
  31. * usNRegs 寄存器长度
  32. * eMode 操作方式，读或者写
  33. * @retval eStatus 寄存器状态
  34. */
  35. eMBErrorCode
  36. eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs,
  37. eMBRegisterMode eMode )
  38. {
  39. //错误状态
  40. eMBErrorCode eStatus = MB_ENOERR;
  41. //偏移量
  42. int16_t iRegIndex;

  44. //判断寄存器是不是在范围内
  45. if( ( (int16_t)usAddress >= REG_HOLDING_START )
  46. && ( usAddress + usNRegs <= REG_HOLDING_START + REG_HOLDING_NREGS ) )
  47. {
  48. //计算偏移量
  49. iRegIndex = ( int16_t )( usAddress - REG_HOLDING_START);

  51. switch ( eMode )
  52. {
  53. //读处理函数
  54. case MB_REG_READ:
  55. while( usNRegs > 0 )
  56. {
  57. *pucRegBuffer++ = ( uint8_t )( usRegHoldingBuf[iRegIndex] >> 8 );
  58. *pucRegBuffer++ = ( uint8_t )( usRegHoldingBuf[iRegIndex] & 0xFF );
  59. iRegIndex++;
  60. usNRegs--;
  61. }
  62. break;

  64. //写处理函数
  65. case MB_REG_WRITE:
  66. while( usNRegs > 0 )
  67. {
  68. usRegHoldingBuf[iRegIndex] = *pucRegBuffer++ << 8;
  69. usRegHoldingBuf[iRegIndex] |= *pucRegBuffer++;
  70. iRegIndex++;
  71. usNRegs--;
  72. }
  73. break;
  74. }
  75. }
  76. else
  77. {
  78. //返回错误状态
  79. eStatus = MB_ENOREG;
  80. }

  82. return eStatus;
  83. }
  84. </FONT>
复制代码先给大家一个整体的印象，先让大家会使用FREEMODBUS，再详细描述细节//保持寄存器起始地址#define REG_HOLDING_START     0x0000//保持寄存器数量#define REG_HOLDING_NREGS     8这两个宏定义，决定了保持寄存器的起始地址和总个数。需要强调的是，modbus寄存器的地址有两套规则，一套称为PLC地址，为5位十进制数，例如40001。另一套是协议地址，PLC地址40001意味着该参数类型为保持寄存器，协议地址为0x0000，这里面有对应关系，去掉PLC地址的最高位，然后剩下的减1即可。这会存在一个问题，PLC地址30002和PLC地址40002的协议地址同为0x0001，此时访问时是不是会冲突呢。亲们，当然不会了，30001为输入寄存器，需要使用04指令访问，而40001为保持寄存器，可以使用03、06和16指令访问。所以，用好modbus还是要熟悉协议本生，切不可着急。//保持寄存器内容uint16_t usRegHoldingBuf[REG_HOLDING_NREGS]= {0x147b,0x3f8e,0x147b,0x400e,0x1eb8,0x4055,0x147b,0x408e};接下来定义了保持寄存器的内容，在这里请大家注意了，保持寄存器为无符号16位数据。在测试的情况下，我随便找了一些数据进行测试。看数据的本质似乎看不出说明规律，但是usRegHoldingBuf却是以16进制保存了浮点数。
  1. int main(void)
  2. {
  3. //初始化 RTU模式 从机地址为1 USART1 9600 无校验
  4. eMBInit(MB_RTU, 0x01, 0x01, 9600, MB_PAR_NONE);
  5. //启动FreeModbus
  6. eMBEnable();
  7. while (1)
  8. {
  9. //FreeMODBUS不断查询
  10. eMBPoll();
  11. }
  12. }
复制代码
接下来就进入主函数部分。有三个FREEMODBUS提供的函数，eMBInit，eMBEnable和eMBPoll。eMBInit为modbus的初始化函数，eMBEnable为modbus的使能函数，而eMBPoll为modbus的查询函数，eMBPoll也是非常单纯的函数，查询是否有数据帧到达，如果有数据到达，便进行相依的处理。再次观察这几个函数，只有eMBInit有很多的参数，这些参数和位于系统底层的硬件有关，这个应该引起移植过程的更多关注。下面几个章节再议。
  1. <FONT size=3>eMBErrorCode
  2. eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs,
  3. eMBRegisterMode eMode )
  4. {
  5. //错误状态
  6. eMBErrorCode eStatus = MB_ENOERR;
  7. //偏移量
  8. int16_t iRegIndex;

  10. //判断寄存器是不是在范围内
  11. if( ( (int16_t)usAddress >= REG_HOLDING_START )
  12. && ( usAddress + usNRegs <= REG_HOLDING_START + REG_HOLDING_NREGS ) )
  13. {
  14. //计算偏移量
  15. iRegIndex = ( int16_t )( usAddress - REG_HOLDING_START);

  17. switch ( eMode )
  18. {
  19. //读处理函数
  20. case MB_REG_READ:
  21. while( usNRegs > 0 )
  22. {
  23. *pucRegBuffer++ = ( uint8_t )( usRegHoldingBuf[iRegIndex] >> 8 );
  24. *pucRegBuffer++ = ( uint8_t )( usRegHoldingBuf[iRegIndex] & 0xFF );
  25. iRegIndex++;
  26. usNRegs--;
  27. }
  28. break;

  30. //写处理函数
  31. case MB_REG_WRITE:
  32. while( usNRegs > 0 )
  33. {
  34. usRegHoldingBuf[iRegIndex] = *pucRegBuffer++ << 8;
  35. usRegHoldingBuf[iRegIndex] |= *pucRegBuffer++;
  36. iRegIndex++;
  37. usNRegs--;
  38. }
  39. break;
  40. }
  41. }
  42. else
  43. {
  44. //返回错误状态
  45. eStatus = MB_ENOREG;
  46. }

  48. return eStatus;
  49. }
  50. </FONT>
复制代码最后，如果收到一个有效的数据帧，那么就可以开始处理了。第一步，判断寄存器的地址是否在合法的范围内。  if( ( (int16_t)usAddress >= REG_HOLDING_START )      && ( usAddress + usNRegs <= REG_HOLDING_START + REG_HOLDING_NREGS ) )第二步，判断需要操作寄存器的偏移地址。         给个例子可以迅速的说明问题，例如访问寄存器的起始地址为0x0002，保持寄存器的起始地址为0x0000，那么这个访问的偏移量为2，程序就从保持寄存器数组的第2个（从0开始）开始操作。第三步，读写操作分开处理      case MB_REG_READ:        while( usNRegs > 0 )        {          *pucRegBuffer++ = ( uint8_t )( usRegHoldingBuf[iRegIndex] >> 8 );          *pucRegBuffer++ = ( uint8_t )( usRegHoldingBuf[iRegIndex] & 0xFF );          iRegIndex++;          usNRegs--;        }        break;         以读操作为例，代码不多说了，请大家注意操作的顺序。保持寄存器以16位形式保存，但是modbus通信时以字节为单位，高位字节数据在前，低位数据字节在后。四   串口相关部分代码编写         串口部分的代码编写比较常规，主要有三个函数，串口初始化，串口数据发送和串口数据接收。除了以上三个函数之外，还有串口中断服务函数。
  1. /**
  2. * @brief 串口初始化
  3. * @param ucPORT 串口号
  4. * ulBaudRate 波特率
  5. * ucDataBits 数据位
  6. * eParity 校验位
  7. * @retval None
  8. */
  9. BOOL
  10. xMBPortSerialInit( UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity )
  11. {
  12. (void)ucPORT; //不修改串口
  13. (void)ucDataBits; //不修改数据位长度
  14. (void)eParity; //不修改校验格式

  16. GPIO_InitTypeDef GPIO_InitStructure;
  17. USART_InitTypeDef USART_InitStructure;

  19. //使能USART1，GPIOA
  20. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA |
  21. RCC_APB2Periph_USART1, ENABLE);

  23. //GPIOA9 USART1_Tx
  24. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  25. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  26. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //推挽输出
  27. GPIO_Init(GPIOA, &GPIO_InitStructure);
  28. //GPIOA.10 USART1_Rx
  29. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  30. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  31. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮动输入
  32. GPIO_Init(GPIOA, &GPIO_InitStructure);

  34. USART_InitStructure.USART_BaudRate = ulBaudRate; //只修改波特率
  35. USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  36. USART_InitStructure.USART_StopBits = USART_StopBits_1;
  37. USART_InitStructure.USART_Parity = USART_Parity_No;
  38. USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  39. USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
  40. //串口初始化
  41. USART_Init(USART1, &USART_InitStructure);
  42. //使能USART1
  43. USART_Cmd(USART1, ENABLE);

  45. NVIC_InitTypeDef NVIC_InitStructure;
  46. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
  47. //设定USART1 中断优先级
  48. NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
  49. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  50. NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  51. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  52. NVIC_Init(&NVIC_InitStructure);

  54. //最后配置485发送和接收模式
  55. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE);
  56. //GPIOD.8
  57. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
  58. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  59. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  60. GPIO_Init(GPIOD, &GPIO_InitStructure);

  62. return TRUE;
  63. }
复制代码传入的参数有端口号，波特率，数据位和校验位，可以根据实际的情况修改代码。在这里我并没有修改其他参数，至于传入的波特率是有效的。除了配置串口的相关参数之外，还需要配置串口的中断优先级。最后，由于使用485模式，还需要一个发送接收控制端，该IO配置为推挽输出模式。
  1. <FONT size=3>/**
  2. * @brief 控制接收和发送状态
  3. * @param xRxEnable 接收使能、
  4. * xTxEnable 发送使能
  5. * @retval None
  6. */
  7. void
  8. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
  9. {
  10. if(xRxEnable)
  11. {
  12. //使能接收和接收中断
  13. USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
  14. //MAX485操作 低电平为接收模式
  15. GPIO_ResetBits(GPIOD,GPIO_Pin_8);
  16. }
  17. else
  18. {
  19. USART_ITConfig(USART1, USART_IT_RXNE, DISABLE);
  20. //MAX485操作 高电平为发送模式
  21. GPIO_SetBits(GPIOD,GPIO_Pin_8);
  22. }

  24. if(xTxEnable)
  25. {
  26. //使能发送完成中断
  27. USART_ITConfig(USART1, USART_IT_TC, ENABLE);
  28. }
  29. else
  30. {
  31. //禁止发送完成中断
  32. USART_ITConfig(USART1, USART_IT_TC, DISABLE);
  33. }

  35. }
  36. </FONT>
复制代码由于485使用半双工模式，从机一般处于接收状态，有数据发送时才会进入发送模式。在FreeModbus中有专门的控制接收和发送状态的函数，在这里不但可以打开或关闭接收和发送中断，还可以控制485收发芯片的发送接收端口。代码非常简单，但是还是建议各位使用发送完成中断。

  1. <FONT size=3>BOOL
  2. xMBPortSerialPutByte( CHAR ucByte )
  3. {
  4. //发送数据
  5. USART_SendData(USART1, ucByte);
  6. return TRUE;
  7. }
  8. BOOL
  9. xMBPortSerialGetByte( CHAR * pucByte )
  10. {
  11. //接收数据
  12. *pucByte = USART_ReceiveData(USART1);
  13. return TRUE;
  14. }
  15. xMBPortSerialPutByte和xMBPortSerialGetByte两个函数用于串口发送和接收数据，在这里只要调用STM32的库函数即可。

  17. static void prvvUARTTxReadyISR( void )
  18. {
  19. //mb.c eMBInit函数中
  20. //pxMBFrameCBTransmitterEmpty = xMBRTUTransmitFSM
  21. //发送状态机
  22. pxMBFrameCBTransmitterEmpty();
  23. }

  25. static void prvvUARTRxISR( void )
  26. {
  27. //mb.c eMBInit函数中
  28. //pxMBFrameCBByteReceived = xMBRTUReceiveFSM
  29. //接收状态机
  30. pxMBFrameCBByteReceived();
  31. }

  33. void USART1_IRQHandler(void)
  34. {
  35. //发生接收中断
  36. if(USART_GetITStatus(USART1, USART_IT_RXNE) == SET)
  37. {
  38. prvvUARTRxISR();
  39. //清除中断标志位
  40. USART_ClearITPendingBit(USART1, USART_IT_RXNE);
  41. }

  43. //发生完成中断
  44. if(USART_GetITStatus(USART1, USART_IT_TC) == SET)
  45. {
  46. prvvUARTTxReadyISR();
  47. //清除中断标志
  48. USART_ClearITPendingBit(USART1, USART_IT_TC);
  49. }
  50. }
  51. </FONT>
复制代码若进入串口中断服务函数，则要调用FreeModbus中响应的函数，串口接收中断服务函数对应prvvUARTRxISR()，其代码如下
  1. <FONT size=3>static void prvvUARTRxISR( void )
  2. {
  3. //mb.c eMBInit函数中
  4. //pxMBFrameCBByteReceived = xMBRTUReceiveFSM
  5. //接收状态机
  6. pxMBFrameCBByteReceived();
  7. }
  8. </FONT>
复制代码在prvvUARTRxISR中又调用了pxMBFrameCBByteReceived()，其实pxMBFrameCBTransmitterEmpty()并不是一个函数，而是一个函数指针。其定义如下，请注意函数指针的声明和函数声明的区别。BOOL( *pxMBFrameCBTransmitterEmpty ) ( void );在mb.c文件的eMBInit函数完成赋值。一般情况下都会选择RTU模式，那么pxMBFrameCBByteReceived就和xMBRTUReceiveFSM等价了，pxMBFrameCBByteReceived = xMBRTUReceiveFSM;
同理，若发生串口发送完成中断，该中断服务函数对应prvvUARTTxReadyISR，其代码如下
  1. <FONT size=3>static void prvvUARTTxReadyISR( void )
  2. {
  3. //mb.c eMBInit函数中
  4. //pxMBFrameCBTransmitterEmpty = xMBRTUTransmitFSM
  5. //发送状态机
  6. pxMBFrameCBTransmitterEmpty();
  7. }
  8. </FONT>
复制代码在prvvUARTTxReadyISR中又调用了pxMBFrameCBTransmitterEmpty()，pxMBFrameCBTransmitterEmpty也是函数指针，在eMBInit函数完成赋值，它等价于xMBRTUTransmitFSM。         特别提醒，由于我使用的是串口发送完成中断，想要进入该中断服务函数，需要发送一个字节的数据并启动串口发送中断，代码还需要少许修改。在mbRTU.c的eMBRTUSend中稍作修改，代码如下。

  2. <P style="MARGIN: 0cm 0cm 0pt" class=MsoNormal> </P>
复制代码
  1. /* First byte before the Modbus-PDU is the slave address. */
  2. pucSndBufferCur = ( UCHAR * ) pucFrame - 1;
  3. usSndBufferCount = 1;

  5. /* Now copy the Modbus-PDU into the Modbus-Serial-Line-PDU. */
  6. pucSndBufferCur[MB_SER_PDU_ADDR_OFF] = ucSlaveAddress;
  7. usSndBufferCount += usLength;

  9. /* Calculate CRC16 checksum for Modbus-Serial-Line-PDU. */
  10. usCRC16 = usMBCRC16( ( UCHAR * ) pucSndBufferCur, usSndBufferCount );
  11. ucRTUBuf[usSndBufferCount++] = ( UCHAR )( usCRC16 & 0xFF );
  12. ucRTUBuf[usSndBufferCount++] = ( UCHAR )( usCRC16 >> 8 );

  14. /* Activate the transmitter. */
  15. //发送状态转换，在中断中不断发送
  16. eSndState = STATE_TX_XMIT;

  18. //插入代码 启动第一次发送，这样才可以进入发送完成中断
  19. xMBPortSerialPutByte( ( CHAR )*pucSndBufferCur );
  20. pucSndBufferCur++;
  21. usSndBufferCount--;

  23. //使能发送状态，禁止接收状态
  24. vMBPortSerialEnable( FALSE, TRUE );
复制代码写到这里给位可能看的不是很明白，建议研究一下FreeModbus的源码，稍作一些修改使用起来才会更加方便。
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
98条回答
yaodongliang
2019-12-09 20:31
data/attach/1912/h7dz51inrzp6lxjwk6o5hur3mv58xaal.jpg
xukai871105 发表于 2012-8-12 20:00
五 定时器相关部分代码编写
        定时器的作用前面已经说明了，在这里就罗列一下相关的移植代码。定时器 ...

楼主，不知你是否测试了下本代码的稳定性呢？我在使用串口发送完成进中断的时候，长期测试，会出现丢字节的现象，有时候第一个字节数据会丢失。在串口接收到数据，启动串口发送，我是在使能串口发送的时候进行的处理。

一周热门 更多>

相关文章