STM32 移植FreeModbus 详细过程【转】

奋斗哥

FreeModbus移植 经验分享【转】

一   为什么要移植Freemodbus
         为什么要移植Freemodbus，这个问题需要从两个方面来回答。第一，modbus是一个非常好的应用层协议，它很简洁也相对完善。对于还没有接触过modbus的朋友来说，我非常不建议直接移植freemodbus，应该耐心的从modbus文档入手，并充分把握身边的所有资源，例如PLC的中modbus部分。第二，其实嵌入式系统的通信协议可以自己制定，但是通过实践发现自己定制的协议漏洞百出，尤其是扩展极为困难。我始终认为借鉴他人的经验是很好的途径。借鉴他人成熟的代码，可以减少调试的时间，实现的功能也多了不少。
         个人观点，仅供参考。
         freemodbus小提示
         freemodbus只能使用从机功能。freemodbus更适合嵌入式系统，虽然例子中也有WIN32的例子，如果想要做PC机程序并实现主机功能，推荐使用另一个modbus库——NMODBUS，使用C#开发。同样WINFORM也可以通过自己编写串口代码实现modbus功能，但是这会花费很长的时间，可能是一周也可能是一个月，如果使用现成的代码库，那么开发时间可能只有10分钟。
        自己整理的modbus协议
        
二  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"
   
5. 
   
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};
    
13. 
    
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. }
    
26. 
    
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;
    
43. 
    
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);
    
50. 
    
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;
    
63. 
    
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. }
    
81. 
    
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;
   
9. 
   
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);
    
16. 
    
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;
    
29. 
    
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. }
    
47. 
    
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; //不修改校验格式
    
15. 
    
16. GPIO_InitTypeDef GPIO_InitStructure;
    
17. USART_InitTypeDef USART_InitStructure;
    
18. 
    
19. //使能USART1，GPIOA
    
20. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA |
    
21. RCC_APB2Periph_USART1, ENABLE);
    
22. 
    
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);
    
33. 
    
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);
    
44. 
    
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);
    
53. 
    
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);
    
61. 
    
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. }
    
23. 
    
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. }
    
34. 
    
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的库函数即可。
    
16. 
    
17. static void prvvUARTTxReadyISR( void )
    
18. {
    
19. //mb.c eMBInit函数中
    
20. //pxMBFrameCBTransmitterEmpty = xMBRTUTransmitFSM
    
21. //发送状态机
    
22. pxMBFrameCBTransmitterEmpty();
    
23. }
    
24. 
    
25. static void prvvUARTRxISR( void )
    
26. {
    
27. //mb.c eMBInit函数中
    
28. //pxMBFrameCBByteReceived = xMBRTUReceiveFSM
    
29. //接收状态机
    
30. pxMBFrameCBByteReceived();
    
31. }
    
32. 
    
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. }
    
42. 
    
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中稍作修改，代码如下。

1. 
   
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;
   
4. 
   
5. /* Now copy the Modbus-PDU into the Modbus-Serial-Line-PDU. */
   
6. pucSndBufferCur[MB_SER_PDU_ADDR_OFF] = ucSlaveAddress;
   
7. usSndBufferCount += usLength;
   
8. 
   
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 );
    
13. 
    
14. /* Activate the transmitter. */
    
15. //发送状态转换，在中断中不断发送
    
16. eSndState = STATE_TX_XMIT;
    
17. 
    
18. //插入代码 启动第一次发送，这样才可以进入发送完成中断
    
19. xMBPortSerialPutByte( ( CHAR )*pucSndBufferCur );
    
20. pucSndBufferCur++;
    
21. usSndBufferCount--;
    
22. 
    
23. //使能发送状态，禁止接收状态
    
24. vMBPortSerialEnable( FALSE, TRUE );
    

复制代码

写到这里给位可能看的不是很明白，建议研究一下FreeModbus的源码，稍作一些修改使用起来才会更加方便。

五 定时器相关部分代码编写
        定时器的作用前面已经说明了，在这里就罗列一下相关的移植代码。定时器的代码要比串口的代码简单一些。

1. static void prvvTIMERExpiredISR( void );
   
2. 
   
3. BOOL
   
4. xMBPortTimersInit( USHORT usTim1Timerout50us )
   
5. {
   
6.   TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
   
7.   NVIC_InitTypeDef NVIC_InitStructure;
   
8.   //
   
9.   uint16_t PrescalerValue = 0;
   
10.   
    
11.   //使能定时器4时钟
    
12.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
    
13.   
    
14.   //定时器时间基配置说明
    
15.   //HCLK为72MHz，APB1经过2分频为36MHz
    
16.   //TIM4的时钟倍频后为72MHz（硬件自动倍频,达到最大）
    
17.   //TIM4的分频系数为3599，时间基频率为72 / (1 + Prescaler) = 20KHz,基准为50us
    
18.   //TIM最大计数值为usTim1Timerout50u
    
19.   PrescalerValue = (uint16_t) (SystemCoreClock / 20000) - 1;
    
20.   //定时器1初始化
    
21.   TIM_TimeBaseStructure.TIM_Period = (uint16_t) usTim1Timerout50us;
    
22.   TIM_TimeBaseStructure.TIM_Prescaler = PrescalerValue;
    
23.   TIM_TimeBaseStructure.TIM_ClockDivision = 0;
    
24.   TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
    
25.   TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);
    
26.   //预装载使能
    
27.   TIM_ARRPreloadConfig(TIM4, ENABLE);
    
28.   
    
29.   NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
    
30.   //定时器4中断优先级
    
31.   NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn;
    
32.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    
33.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;
    
34.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
35.   NVIC_Init(&NVIC_InitStructure);
    
36.   
    
37.   //清除溢出中断标志位
    
38.   TIM_ClearITPendingBit(TIM4,TIM_IT_Update);
    
39.   //定时器4溢出中断关闭
    
40.   TIM_ITConfig(TIM4, TIM_IT_Update, DISABLE);
    
41.   //定时器4禁能
    
42.   TIM_Cmd(TIM4,  DISABLE);
    
43.   return TRUE;
    
44. }
    
45. 
    
46. 
    
47. void
    
48. vMBPortTimersEnable( )
    
49. {
    
50.   TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
    
51.   TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
    
52.   //设定定时器4的初始值
    
53.   TIM_SetCounter(TIM4,0x0000);
    
54.   //定时器4启动
    
55.   TIM_Cmd(TIM4, ENABLE);
    
56. }
    
57. 
    
58. void
    
59. vMBPortTimersDisable(  )
    
60. {
    
61.   TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
    
62.   TIM_ITConfig(TIM4, TIM_IT_Update, DISABLE);
    
63.   TIM_SetCounter(TIM4,0x0000);
    
64.   //关闭定时器4
    
65.   TIM_Cmd(TIM4, DISABLE);
    
66. }
    
67. 
    
68. static void prvvTIMERExpiredISR( void )
    
69. {
    
70.     ( void )pxMBPortCBTimerExpired();
    
71. }
    
72. 
    
73. void TIM4_IRQHandler(void)
    
74. {
    
75.   if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)
    
76.   {
    
77.     //清除定时器T4溢出中断标志位
    
78.     TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
    
79. 
    
80.     prvvTIMERExpiredISR( );
    
81.   }
    
82. }
    

复制代码

在这里请注意STM32的TIM有一个自动倍频的功能，如果APB1被分频的话，TIM的时钟就会自动倍频，当然再如何倍频也不应超过72MHz。
六 各种寄存器的读或写函数
         Modbus通信中，总共有四类的寄存器，开关输入寄存器，线圈寄存器，保持寄存器和输入寄存器。

1. /**
   
2. * @brief 输入寄存器处理函数，输入寄存器可读，但不可写。
   
3. * @param pucRegBuffer 返回数据指针
   
4. * usAddress 寄存器起始地址
   
5. * usNRegs 寄存器长度
   
6. * @retval eStatus 寄存器状态
   
7. */
   
8. eMBErrorCode
   
9. eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
   
10. {
    
11. eMBErrorCode eStatus = MB_ENOERR;
    
12. int16_t iRegIndex;
    
13. 
    
14. //查询是否在寄存器范围内
    
15. //为了避免警告，修改为有符号整数
    
16. if( ( (int16_t)usAddress >= REG_INPUT_START ) \
    
17. && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
    
18. {
    
19. //获得操作偏移量，本次操作起始地址-输入寄存器的初始地址
    
20. iRegIndex = ( int16_t )( usAddress - REG_INPUT_START );
    
21. //逐个赋值
    
22. while( usNRegs > 0 )
    
23. {
    
24. //赋值高字节
    
25. *pucRegBuffer++ = ( uint8_t )( usRegInputBuf[iRegIndex] >> 8 );
    
26. //赋值低字节
    
27. *pucRegBuffer++ = ( uint8_t )( usRegInputBuf[iRegIndex] & 0xFF );
    
28. //偏移量增加
    
29. iRegIndex++;
    
30. //被操作寄存器数量递减
    
31. usNRegs--;
    
32. }
    
33. }
    
34. else
    
35. {
    
36. //返回错误状态，无寄存器
    
37. eStatus = MB_ENOREG;
    
38. }
    
39. 
    
40. return eStatus;
    
41. }
    
42. 
    
43. /**
    
44. * @brief 保持寄存器处理函数，保持寄存器可读，可读可写
    
45. * @param pucRegBuffer 读操作时--返回数据指针，写操作时--输入数据指针
    
46. * usAddress 寄存器起始地址
    
47. * usNRegs 寄存器长度
    
48. * eMode 操作方式，读或者写
    
49. * @retval eStatus 寄存器状态
    
50. */
    
51. eMBErrorCode
    
52. eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs,
    
53. eMBRegisterMode eMode )
    
54. {
    
55. //错误状态
    
56. eMBErrorCode eStatus = MB_ENOERR;
    
57. //偏移量
    
58. int16_t iRegIndex;
    
59. 
    
60. //判断寄存器是不是在范围内
    
61. if( ( (int16_t)usAddress >= REG_HOLDING_START ) \
    
62. && ( usAddress + usNRegs <= REG_HOLDING_START + REG_HOLDING_NREGS ) )
    
63. {
    
64. //计算偏移量
    
65. iRegIndex = ( int16_t )( usAddress - REG_HOLDING_START );
    
66. 
    
67. switch ( eMode )
    
68. {
    
69. //读处理函数
    
70. case MB_REG_READ:
    
71. while( usNRegs > 0 )
    
72. {
    
73. *pucRegBuffer++ = ( uint8_t )( usRegHoldingBuf[iRegIndex] >> 8 );
    
74. *pucRegBuffer++ = ( uint8_t )( usRegHoldingBuf[iRegIndex] & 0xFF );
    
75. iRegIndex++;
    
76. usNRegs--;
    
77. }
    
78. break;
    
79. 
    
80. //写处理函数
    
81. case MB_REG_WRITE:
    
82. while( usNRegs > 0 )
    
83. {
    
84. usRegHoldingBuf[iRegIndex] = *pucRegBuffer++ << 8;
    
85. usRegHoldingBuf[iRegIndex] |= *pucRegBuffer++;
    
86. iRegIndex++;
    
87. usNRegs--;
    
88. }
    
89. break;
    
90. }
    
91. }
    
92. else
    
93. {
    
94. //返回错误状态
    
95. eStatus = MB_ENOREG;
    
96. }
    
97. 
    
98. return eStatus;
    
99. }
    
100. 
     
101. 
     
102. /**
     
103. * @brief 线圈寄存器处理函数，线圈寄存器可读，可读可写
     
104. * @param pucRegBuffer 读操作---返回数据指针，写操作--返回数据指针
     
105. * usAddress 寄存器起始地址
     
106. * usNRegs 寄存器长度
     
107. * eMode 操作方式，读或者写
     
108. * @retval eStatus 寄存器状态
     
109. */
     
110. eMBErrorCode
     
111. eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils,
     
112. eMBRegisterMode eMode )
     
113. {
     
114. //错误状态
     
115. eMBErrorCode eStatus = MB_ENOERR;
     
116. //寄存器个数
     
117. int16_t iNCoils = ( int16_t )usNCoils;
     
118. //寄存器偏移量
     
119. int16_t usBitOffset;
     
120. 
     
121. //检查寄存器是否在指定范围内
     
122. if( ( (int16_t)usAddress >= REG_COILS_START ) &&
     
123. ( usAddress + usNCoils <= REG_COILS_START + REG_COILS_SIZE ) )
     
124. {
     
125. //计算寄存器偏移量
     
126. usBitOffset = ( int16_t )( usAddress - REG_COILS_START );
     
127. switch ( eMode )
     
128. {
     
129. //读操作
     
130. case MB_REG_READ:
     
131. while( iNCoils > 0 )
     
132. {
     
133. *pucRegBuffer++ = xMBUtilGetBits( ucRegCoilsBuf, usBitOffset,
     
134. ( uint8_t )( iNCoils > 8 ? 8 : iNCoils ) );
     
135. iNCoils -= 8;
     
136. usBitOffset += 8;
     
137. }
     
138. break;
     
139. 
     
140. //写操作
     
141. case MB_REG_WRITE:
     
142. while( iNCoils > 0 )
     
143. {
     
144. xMBUtilSetBits( ucRegCoilsBuf, usBitOffset,
     
145. ( uint8_t )( iNCoils > 8 ? 8 : iNCoils ),
     
146. *pucRegBuffer++ );
     
147. iNCoils -= 8;
     
148. }
     
149. break;
     
150. }
     
151. 
     
152. }
     
153. else
     
154. {
     
155. eStatus = MB_ENOREG;
     
156. }
     
157. return eStatus;
     
158. }
     
159. 
     
160. /**
     
161. * @brief 开关输入寄存器处理函数，开关输入寄存器，可读
     
162. * @param pucRegBuffer 读操作---返回数据指针，写操作--返回数据指针
     
163. * usAddress 寄存器起始地址
     
164. * usNRegs 寄存器长度
     
165. * eMode 操作方式，读或者写
     
166. * @retval eStatus 寄存器状态
     
167. */
     
168. eMBErrorCode
     
169. eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
     
170. {
     
171. //错误状态
     
172. eMBErrorCode eStatus = MB_ENOERR;
     
173. //操作寄存器个数
     
174. int16_t iNDiscrete = ( int16_t )usNDiscrete;
     
175. //偏移量
     
176. uint16_t usBitOffset;
     
177. 
     
178. //判断寄存器时候再制定范围内
     
179. if( ( (int16_t)usAddress >= REG_DISCRETE_START ) &&
     
180. ( usAddress + usNDiscrete <= REG_DISCRETE_START + REG_DISCRETE_SIZE ) )
     
181. {
     
182. //获得偏移量
     
183. usBitOffset = ( uint16_t )( usAddress - REG_DISCRETE_START );
     
184. 
     
185. while( iNDiscrete > 0 )
     
186. {
     
187. *pucRegBuffer++ = xMBUtilGetBits( ucRegDiscreteBuf, usBitOffset,
     
188. ( uint8_t)( iNDiscrete > 8 ? 8 : iNDiscrete ) );
     
189. iNDiscrete -= 8;
     
190. usBitOffset += 8;
     
191. }
     
192. 
     
193. }
     
194. else
     
195. {
     
196. eStatus = MB_ENOREG;
     
197. }
     
198. return eStatus;
     
199. }
     

复制代码

fjjjnk1234

沙发，谢谢分享！顶一个！！！

fj1161

赞一个~~~~~~~~~~~~~~~~~~~~~