【STM32F411Nucleo测评】移植 Freemodbus 库

pomin

【STM32F411Nucleo测评】移植 Freemodbus 库 [复制链接]

> 本文介绍如何移植 FreeModbus 库，在 Nucleo-F411 板上实现 Modbus 通信

## 资料准备

FreeModbus 的代码是存放在 GitHub 的，地址 https://github.com/cwalter-at/freemodbus ，拉取到本地，其中关键的就是demo和modbus两个文件夹，demo存放一些移植好的工程，modbus中存放库代码。

<ignore_js_op>

</ignore_js_op>

## 硬件连接

查看原理图的串口是接在STLink 的虚拟串口上面的，管脚为PA2和PA3

<ignore_js_op>

</ignore_js_op>

## 接口配置

将拉取到的 FreeModbus 代码添加到 keil 工程中，其中需要添加库代码中的 functions、rtu 文件夹中的代码和 mb.c

<ignore_js_op>

</ignore_js_op>

此外还需要把demo中BARE文件夹的代码复制到工程中，这里同时将demo.c修改为了data.c添加到工程

<ignore_js_op>

</ignore_js_op>

添加的代码文件如下

<ignore_js_op>

</ignore_js_op>

需要的代码文件都添加好了，下面开始对 portxxx.c进行适配，其中 portserial.c 是串口的接口层， porttimer.c 是定时器的接口层。

配置 USART2，参数如下，设置波特率为115200bps

<ignore_js_op>

</ignore_js_op>

定时器TIM11周期设置为50us

<ignore_js_op>

</ignore_js_op>

同时将 USART2 和 TIM11 的中断使能

<ignore_js_op>

</ignore_js_op>

### 串口接口适配

利用 HAL_UART_TxCpltCallback，HAL_UART_RxCpltCallback 两个HAL库的两个回调函数编写如下代码

```c
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  if(huart->Instance == uart->Instance)
  {
  pxMBFrameCBByteReceived();
  HAL_UART_Receive_IT(uart, &singlechar, 1);
  }
}

void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
  if(huart->Instance == uart->Instance)
  {
  pxMBFrameCBTransmitterEmpty();
  }
}

```

串口收发的接口代码如下

```c
/* ----------------------- Static variables ---------------------------------*/
UART_HandleTypeDef *uart = &huart2;
static uint8_t singlechar;

/* ----------------------- Start implementation -----------------------------*/
BOOL    xMBPortSerialInit( UCHAR ucPort, ULONG ulBaudRate,
           UCHAR ucDataBits, eMBParity eParity )
{
  return TRUE;
}

void vMBPortSerialEnable(BOOL xRxEnable, BOOL xTxEnable)
{
  if(xRxEnable)
  {
  HAL_UART_Receive_IT(uart, &singlechar, 1);
  }  
  else
  {
  HAL_UART_AbortReceive_IT(uart);
  }

if(xTxEnable)
  {
  pxMBFrameCBTransmitterEmpty();
  }
  else
  {
  HAL_UART_AbortTransmit_IT(uart);
  }
}

void vMBPortClose(void)
{
  HAL_UART_AbortReceive_IT(uart);
  HAL_UART_AbortTransmit_IT(uart);
}

BOOL xMBPortSerialPutByte(CHAR ucByte)
{
  HAL_UART_Transmit_IT(uart, (uint8_t*)&ucByte, 1);
  return TRUE;
}

BOOL xMBPortSerialPutBytes(volatile UCHAR *ucByte, USHORT usSize)
{
  HAL_UART_Transmit_IT(uart, (uint8_t *)ucByte, usSize);
  return TRUE;
}

BOOL xMBPortSerialGetByte(CHAR * pucByte)
{
  *pucByte = (uint8_t)(singlechar);
  return TRUE;
}
```

### 定时器接口适配

定时器使用 HAL_TIM_PeriodElapsedCallback 这个 HAL 提供的定时器周期中断时的回调函数

```c
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  if(htim->Instance == tim->Instance)
  {
  if((++counter) >= timeout)
    pxMBPortCBTimerExpired();
  }
}
```

其他的代码就是使能、失能 TIM 的一些接口代码

```c
/* ----------------------- User defenitions ---------------------------------*/
TIM_HandleTypeDef *tim = &htim11;
static uint16_t timeout = 0;
volatile uint16_t counter = 0;

/* ----------------------- Start implementation -----------------------------*/
BOOL xMBPortTimersInit( USHORT usTim1Timerout50us )
{
  timeout = usTim1Timerout50us;
  return TRUE;
}

inline void vMBPortTimersEnable()
{
  counter=0;
  HAL_TIM_Base_Start_IT(tim);
}

inline void vMBPortTimersDisable()
{
  HAL_TIM_Base_Stop_IT(tim);
}

inline void
vMBPortTimersDelay( USHORT usTimeOutMS )
{
  HAL_Delay(usTimeOutMS);
}
```

至此接口层的代码就适配好了，代码量不大，还算比较容易，下面开始主函数编写应用代码来验证

## 验证

将main函数中while前后的代码改为如下代码，先初始化modbus库然后使能，在while循环中轮询。

```c
eMBInit(MB_RTU, 0x01, 0, 115200, MB_PAR_NONE); // 初始化modbus为RTU方式，波特率9600，奇校验
eMBEnable();           // 使能modbus协议栈
/* USER CODE END 2 */

/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
  /* USER CODE END WHILE */

/* USER CODE BEGIN 3 */
  eMBPoll();// 轮训查询
}
/* USER CODE END 3 */
```

光有这些还是不够的，现在已经完成了通信过程的适配，还需要提供保持寄存器、线圈等数据源代码，在data.c中编写代码如下

```c
#include "mb.h"
#include "mbport.h"
 
 
// 十路输入寄存器
#define REG_INPUT_SIZE10
uint16_t REG_INPUT_BUF[REG_INPUT_SIZE];
 
 
// 十路保持寄存器
#define REG_HOLD_SIZE 10
uint16_t REG_HOLD_BUF[REG_HOLD_SIZE];
 
 
// 十路线圈
#define REG_COILS_SIZE 10
uint8_t REG_COILS_BUF[REG_COILS_SIZE] = {1, 1, 1, 1, 0, 0, 0, 0, 1, 1};
 
 
// 十路离散量
#define REG_DISC_SIZE10
uint8_t REG_DISC_BUF[REG_DISC_SIZE] = {1,1,1,1,0,0,0,0,1,1};
 
 
/// CMD4命令处理回调函数
eMBErrorCode eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
{
  USHORT usRegIndex = usAddress - 1;
 
  // 非法检测
  if((usRegIndex + usNRegs) > REG_INPUT_SIZE)
  {
  return MB_ENOREG;
  }
 
  // 循环读取
  while( usNRegs > 0 )
  {
  *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] >> 8 );
  *pucRegBuffer++ = ( unsigned char )( REG_INPUT_BUF[usRegIndex] & 0xFF );
  usRegIndex++;
  usNRegs--;
  }
 
  // 模拟输入寄存器被改变
  for(usRegIndex = 0; usRegIndex < REG_INPUT_SIZE; usRegIndex++)
  {
  REG_INPUT_BUF[usRegIndex]++;
  }
 
  return MB_ENOERR;
}
 
/// CMD6、3、16命令处理回调函数
eMBErrorCode eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
{
  USHORT usRegIndex = usAddress - 1;
 
  // 非法检测
  if((usRegIndex + usNRegs) > REG_HOLD_SIZE)
  {
  return MB_ENOREG;
  }
 
  // 写寄存器
  if(eMode == MB_REG_WRITE)
  {
  while( usNRegs > 0 )
  {
    REG_HOLD_BUF[usRegIndex] = (pucRegBuffer[0] << 8) | pucRegBuffer[1];
    pucRegBuffer += 2;
    usRegIndex++;
    usNRegs--;
  }
  }
 
  // 读寄存器
  else
  {
  while( usNRegs > 0 )
  {
    *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] >> 8 );
    *pucRegBuffer++ = ( unsigned char )( REG_HOLD_BUF[usRegIndex] & 0xFF );
    usRegIndex++;
    usNRegs--;
  }
  }
 
  return MB_ENOERR;
}
 
/// CMD1、5、15命令处理回调函数
eMBErrorCode eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode )
{
  USHORT usRegIndex = usAddress - 1;
  UCHARucBits   = 0;
  UCHARucState  = 0;
  UCHARucLoops  = 0;
 
  // 非法检测
  if((usRegIndex + usNCoils) > REG_COILS_SIZE)
  {
  return MB_ENOREG;
  }
 
  if(eMode == MB_REG_WRITE)
  {
  ucLoops = (usNCoils - 1) / 8 + 1;
  while(ucLoops != 0)
  {
    ucState = *pucRegBuffer++;
    ucBits= 0;
    while(usNCoils != 0 && ucBits < 8)
    {
      REG_COILS_BUF[usRegIndex++] = (ucState >> ucBits) & 0X01;
      usNCoils--;
      ucBits++;
    }
    ucLoops--;
  }
  }
  else
  {
  ucLoops = (usNCoils - 1) / 8 + 1;
  while(ucLoops != 0)
  {
    ucState = 0;
    ucBits= 0;
    while(usNCoils != 0 && ucBits < 8)
    {
      if(REG_COILS_BUF[usRegIndex])
      {
      ucState |= (1 << ucBits);
      }
      usNCoils--;
      usRegIndex++;
      ucBits++;
    }
    *pucRegBuffer++ = ucState;
    ucLoops--;
  }
  }
 
  return MB_ENOERR;
}
 
/// CMD2命令处理回调函数
eMBErrorCode eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
{
  USHORT usRegIndex = usAddress - 1;
  UCHARucBits   = 0;
  UCHARucState  = 0;
  UCHARucLoops  = 0;
 
  // 非法检测
  if((usRegIndex + usNDiscrete) > REG_DISC_SIZE)
  {
  return MB_ENOREG;
  }
 
  ucLoops = (usNDiscrete - 1) / 8 + 1;
  while(ucLoops != 0)
  {
  ucState = 0;
  ucBits= 0;
  while(usNDiscrete != 0 && ucBits < 8)
  {
    if(REG_DISC_BUF[usRegIndex])
    {
      ucState |= (1 << ucBits);
    }
    usNDiscrete--;
    usRegIndex++;
    ucBits++;
  }
  *pucRegBuffer++ = ucState;
  ucLoops--;
  }
 
  // 模拟离散量输入被改变
  for(usRegIndex = 0; usRegIndex < REG_DISC_SIZE; usRegIndex++)
  {
  REG_DISC_BUF[usRegIndex] = !REG_DISC_BUF[usRegIndex];
  }
 
  return MB_ENOERR;
}
 
```

其中设置了十路输入寄存器、离散量、保持寄存器、线圈，并且离散量和输入寄存器模拟不断变化

编译烧录到开发板，使用 MThing 来查看线圈状态和一个输入寄存器的值，与预期一样。

<ignore_js_op>

</ignore_js_op>

qiao---

请问一下，你是用的这个modbus调试工具是什么啊

pomin

qiao--- 发表于 2024-3-10 00:07 请问一下，你是用的这个modbus调试工具是什么啊

mthings

freebsder

谢谢分享，期待modbus相关的后续尝试。

chejm

感谢楼主分享的技术内容，开阔了眼界，非常值得学习，希望楼主后续能提供更好的内容

【STM32F411Nucleo测评】移植 Freemodbus 库 [复制链接]

最新回复

点评