stm32在freertos系统下使用串口DMA接收方式对接freemodbus-rtu协议栈
文章目录
- stm32在freertos系统下使用串口DMA接收方式对接freemodbus-rtu协议栈
- 前言
- 码农工程师，人狠话不多，大家多看图和代码！！！
- 一、准备工作
- cubemx配置
- dma初始化的一个注意点
- 二、拆解freemodbus
- 1.porttimer.c文件不再使用（不使用定时器判断接收完成），接口代码直接返回ok。
- 2.portserial.c文件
- 3.mbrtu.c文件；修改串口收，发，收发完成3个函数。
- 4.接口处理文件；该代码来源于网上，可自行搜索调试。
- 三、freertos系统的接口部分
- USART3_IRQHandler中断处理
- HAL_UART_RxHalfCpltCallback处理
- 四、测试
- 总结
前言
10.1期间，调试设备对接s7-200 smart的plc，使用了开源freemodbus；使用网上最多的中断方式调试2天没有好，定时器判断接收完成及反复中断，极感不便。转为使用dma方式；拆解原代码调试成功后记录如下。
该代码修改思路如下：
- 串口接收dma方式（参考dma+idle中断接收方式）
- 理解freemodbus代码；原代码使用中断按Byte接收组成帧的方式。 该拆解手术直接dma接收成帧，返回给协议栈。
- 发送时间使用HAL_UART_Transmit 接口发送完成。
- 去掉porttimer.c的应用。
- 帧数据的收发都在portserial.c文件中完成
- 尽可能不动协议栈代码；只需要修改mbrtu.c文件中三个函数；完成收发。
码农工程师，人狠话不多，大家多看图和代码！！！
一、准备工作
cubemx配置
主要配置串口： 9600， 8， N，1； 接收DMA。
直接生成代码
dma初始化的一个注意点
使用dma初始化的一个注意点，见图中注释
二、拆解freemodbus
协议栈代码自行搜索下载。关键修改如下：
1.porttimer.c文件不再使用（不使用定时器判断接收完成），接口代码直接返回ok。
代码如下（示例）：
/* ----------------------- Start implementation -----------------------------*/
BOOL
xMBPortTimersInit( USHORT usTim1Timerout50us )
{
return TRUE;
}
inline void
vMBPortTimersEnable( )
{
/* Enable the timer with the timeout passed to xMBPortTimersInit( ) */
return;
}
inline void
vMBPortTimersDisable( ) //取消定时器中断
{
/* Disable any pending timers. */
return;
}2.portserial.c文件
整个代码都放来来，内部有些耦合性头文件，debug等大家自行修改。
代码如下（示例）：
/* ----------------------- Platform includes --------------------------------*/
#include "mb.h"
#include "mbport.h"
#include "mbrtu.h"
#include "port.h"
/* ----------------------- Modbus includes ----------------------------------*/
#include "o3_debug.h"
#include "stm32f1xx_hal.h"
extern UART_HandleTypeDef huart3;
/* ----------------------- static functions ---------------------------------*/
//static void prvvUARTTxReadyISR( void );
//static void prvvUARTRxISR( void );
/* ----------------------- Start implementation -----------------------------*/
/*
STM32F103RBT6 没有uart4，op320和modbus可以配置其中一个实验uart3
STM32F103RCT6 有uart4
*/
extern UART_HandleTypeDef huart3;
extern DMA_HandleTypeDef hdma_usart3_rx;
UART_HandleTypeDef *p_huart_modbus = &huart3;
#ifndef MB_SER_PDU_SIZE_MAX
#define MB_SER_PDU_SIZE_MAX 256 /*!< Maximum size of a Modbus RTU frame. */
#endif
extern volatile UCHAR ucRTUBuf[MB_SER_PDU_SIZE_MAX];
extern volatile USHORT usRcvBufferPos;
extern volatile USHORT usSndBufferCount;
/* ----------------------- Start implementation -----------------------------*/
void
vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
{
if (xRxEnable){
/// eRcvState 由 STATE_RX_INIT 转成 STATE_RX_RCV
pxMBFrameCBByteReceived( );
DEBUG_Printf(DEBUG_MBS, "[MODBUS] vMBPortSerialEnable, 0x%x, 0x%x\r\n", xRxEnable, xTxEnable);
}
if (xTxEnable){
MODBUS_UART_Send_Data(( UCHAR * ) ucRTUBuf, usSndBufferCount);
DEBUG_Printf(DEBUG_MBS, "[MODBUS] send data, len=%d: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\r\n",
usSndBufferCount, ucRTUBuf[0], ucRTUBuf[1], ucRTUBuf[2], ucRTUBuf[3],ucRTUBuf[4], ucRTUBuf[5], ucRTUBuf[6], ucRTUBuf[7], ucRTUBuf[8], ucRTUBuf[9]);
/// 发送完成，准备接收
/// eRcvState 由 STATE_RX_RCV 转成 STATE_RX_IDLE
pxMBFrameCBByteReceived( );
}
}
BOOL
xMBPortSerialInit( UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity )
{
uint8_t i = 0;
ucPORT = ucPORT;
ulBaudRate = ulBaudRate;
ucDataBits = ucDataBits;
eParity = eParity;
while(HAL_UART_Receive_DMA(p_huart_modbus,(uint8_t *)&i, 1) == HAL_BUSY)
{
__HAL_UNLOCK(p_huart_modbus);//解锁
}
/* 开启接收错误中断 */
__HAL_UART_ENABLE_IT(p_huart_modbus, UART_IT_ERR);
//下方为自己添加的代码
__HAL_UART_ENABLE_IT(p_huart_modbus, UART_IT_IDLE); //使能IDLE中断
//DMA接收函数，此句一定要加，不加接收不到第一次传进来的实数据，是空的，
//且此时接收到的数据长度为缓存器的数据长度
HAL_UART_Receive_DMA(p_huart_modbus, (uint8_t *)ucRTUBuf, sizeof(ucRTUBuf));
//读使能
MBS_RS485_READ_EN();
return TRUE;
}
/* ----------------------- Start implementation -----------------------------*/
/// @brief 拷贝有效数量到buf
/// @param valid_num
void MODBUS_Event_2_mbs(uint32_t valid_num)
{
if (valid_num >= MB_SER_PDU_SIZE_MAX){
return;
}
DEBUG_Printf(DEBUG_MBS, "[MODBUS] recv data, len=%d: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\r\n",
valid_num, ucRTUBuf[0], ucRTUBuf[1], ucRTUBuf[2], ucRTUBuf[3],ucRTUBuf[4], ucRTUBuf[5], ucRTUBuf[6], ucRTUBuf[7], ucRTUBuf[8], ucRTUBuf[9]);
/// @brief 通知协议栈，一帧数据接收完成。
/// @param none
usRcvBufferPos = valid_num;
/// 接收完成，准备接收
/// eRcvState 由 STATE_RX_RCV 转成 STATE_RX_IDLE
pxMBPortCBTimerExpired();
}
//注意，空闲中断，串口rx配置上拉
//stm32f1xx_it.c 文件中 USART3_IRQHandler（）接口
//空闲中断是接收到一个数据以后，接收停顿超过一字节时间 认为桢收完，总线空闲中断是在检测到在接收数据后，数据总线上一个字节的时间内，没有再接到数据后发生。
void __MODBUS_UART_DMA_Recv_Begin_Handler(UART_HandleTypeDef *huart)
{
uint32_t tmp_flag = 0;
uint32_t dma_idle_num ;
uint32_t valid_num ;
tmp_flag =__HAL_UART_GET_FLAG(huart, UART_FLAG_IDLE); //获取IDLE标志位
if((tmp_flag != RESET))//idle标志被置位
{
__HAL_UART_CLEAR_IDLEFLAG(huart);//清除标志位
//temp = huart4.Instance->SR; //清除状态寄存器SR,读取SR寄存器可以实现清除SR寄存器的功能
//temp = huart4.Instance->DR; //读取数据寄存器中的数据
//这两句和上面那句等效
//关闭串口接收的DMA通道。一是防止又有数据接收到，产生干扰；二是便于DMA重新配置赋值。
HAL_UART_DMAStop(huart); //
dma_idle_num = __HAL_DMA_GET_COUNTER(&hdma_usart3_rx);// 获取DMA中未传输的数据个数
//temp = hdma_usart4_rx.Instance->NDTR;//读取NDTR寄存器 获取DMA中未传输的数据个数，
//这句和上面那句等效
//总计数减去未传输的数据个数，得到已经接收的数据个数
/// 使用RS485发送数据测试，该长度准确
/// 这里keil调试时，会积压数据，就是多个帧的数据一起收到。暂时忽略
valid_num = sizeof(ucRTUBuf) - dma_idle_num;
MODBUS_Event_2_mbs(valid_num);
}
return;
}
//中断完成触发
//stm32f1xx_it.c 文件中 USART3_IRQHandler（）接口
void __MODBUS_UART_DMA_Recv_Complete_Handler(UART_HandleTypeDef *huart)
{
//且此时接收到的数据长度为缓存器的数据长度
HAL_UART_Receive_DMA(p_huart_modbus, (uint8_t *)ucRTUBuf, sizeof(ucRTUBuf));
}
/*
通过对HAL库中HAL_UART_RxCpltCallback这个弱函数的重写可以实现对DMA完成中断的处理，
这个函数虽然声明在stm32f4xx_hal_uart.c中，其实DMA完成中断最后调用的是串口接收完成的回调函数。
*/
/* |half a | half b |*/
void __MODBUS_UART_RxHalfCpltCallback(void)
{
//DMA接收函数，此句一定要加，不加接收不到第一次传进来的实数据，是空的，
//且此时接收到的数据长度为缓存器的数据长度
HAL_UART_Receive_DMA(p_huart_modbus, (uint8_t *)ucRTUBuf, sizeof(ucRTUBuf));
}
/**
* USART2发送len个字节.
* buf:发送区首地址
* len:发送的字节数(为了和本代码的接收匹配,这里建议不要超过64个字节)
**/
void MODBUS_UART_Send_Data(unsigned char *buf, uint16_t len)
{
MBS_RS485_WRITE_EN();
osDelay(2);
while(HAL_UART_Transmit(p_huart_modbus, (uint8_t*)buf, len, 0xFFFF)!= HAL_OK); //发送字符串，用户提示信息
MBS_RS485_READ_EN();
osDelay(2);
}3.mbrtu.c文件；修改串口收，发，收发完成3个函数。
下面三个函数和串口中断相关，需要修改，其他函数保持不变。
思路：
eRcvState 的状态保留； STATE_RX_RCV标识准备收状态，一直到接收完成后，状态变成STATE_RX_IDLE
eSndState状态不在使用
xMBRTUReceiveFSM
xMBRTUTransmitFSM
xMBRTUTimerT35Expired
以下函数做改动，方便DMA成帧接收。 by jackchen 2022.10.5
BOOL
xMBRTUReceiveFSM( void )
{
BOOL xNeedPoll = FALSE;
switch ( eRcvState )
{
/* 发送完成后调用，准备接收， STATE_RX_RCV 接收态 */
case STATE_RX_IDLE:
case STATE_RX_INIT: //eMBRTUStart 需要 init
xNeedPoll = xMBPortEventPost( EV_READY );
eRcvState = STATE_RX_RCV;
break;
/* An error occured while receiving the frame. */
case STATE_RX_ERROR:
break;
/* Function called in an illegal state. */
default:
}
return xNeedPoll;
}
BOOL
xMBRTUTransmitFSM( void )
{
BOOL xNeedPoll = FALSE;
/// @brief 发送不使用状态机了
/// @param
/// @return
return xNeedPoll;
}
BOOL
xMBRTUTimerT35Expired( void )
{
BOOL xNeedPoll = FALSE;
switch ( eRcvState )
{
/// @brief 解决然死锁，停留在STATE_RX_IDLE 状态，无法处理包的情况，
/// 如图该情况出现，第二次回回复收包状态
case STATE_RX_IDLE:
xNeedPoll = xMBPortEventPost( EV_READY );
eRcvState = STATE_RX_RCV;
break;
/* A frame was received and t35 expired. Notify the listener that
* a new frame was received. */
//DMA 收到后调用，接收到数据帧
case STATE_RX_RCV:
xNeedPoll = xMBPortEventPost( EV_FRAME_RECEIVED );
eRcvState = STATE_RX_IDLE; ///发送回应前的状态，要保持STATE_RX_IDLE； eMBRTUSend有判断
break;
/* An error occured while receiving the frame. */
case STATE_RX_ERROR:
break;
/* Function called in an illegal state. */
default:
}
return xNeedPoll;
}4.接口处理文件；该代码来源于网上，可自行搜索调试。
这里也放上1份，仅供参考。
/*
* FreeModbus Libary: BARE Demo Application
* Copyright (C) 2006 Christian Walter <wolti@>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
* File: $Id$
*/
/* ----------------------- Modbus includes ----------------------------------*/
#include "mb.h"
#include "mbport.h"
#include "mbutils.h"
/* ----------------------- Defines ------------------------------------------*/
/*
离散量输出（线圈）和保持寄存器支持读请求和写请求。
离散量输入（触点）和输入寄存器仅支持读请求。
S7-200 SMART 支持以下地址范围：
对于离散量输出（线圈），为 00001 至 09999
对于离散量输入（触点），为 10001 至 19999
对于输入寄存器，为 30001 至 39999
对于保持寄存器，为 40001 至 49999 和 400001 至 465535
*/
/* ----------------------- Static variables ---------------------------------*/
//输入寄存器起始地址
#define REG_INPUT_START 0x30001
//输入寄存器数量
#define REG_INPUT_NREGS 8
//保持寄存器起始地址
#define REG_HOLDING_START 0x00001
//保持寄存器数量
#define REG_HOLDING_NREGS 64
//线圈起始地址
#define REG_COILS_START 0x00001
//线圈数量
#define REG_COILS_SIZE 24
//开关寄存器起始地址
#define REG_DISCRETE_START 0x10001
//开关寄存器数量
#define REG_DISCRETE_SIZE 16
/* Private variables ---------------------------------------------------------*/
//输入寄存器内容
uint16_t usRegInputBuf[REG_INPUT_NREGS] = {0x0000,0x1001,0x1002,0x1003,0x1004,0x1005,0x1006,0x1007};
//寄存器起始地址
uint16_t usRegInputStart = REG_INPUT_START;
//保持寄存器内容
uint16_t usRegHoldingBuf[REG_HOLDING_NREGS] = {0x0000,0x0000,0x0000,0x400e,0x1eb8,0x4055,0x147b,0x0000};
//保持寄存器起始地址
uint16_t usRegHoldingStart = REG_HOLDING_START;
//线圈状态
uint8_t ucRegCoilsBuf[REG_COILS_SIZE / 8] = {0x02,0x00,0x00};
//开关输入状态
uint8_t ucRegDiscreteBuf[REG_DISCRETE_SIZE / 8] = {0x00,0x00};
/**
* @brief 输入寄存器处理函数，输入寄存器可读，但不可写。
* @param pucRegBuffer 返回数据指针
* usAddress 寄存器起始地址
* usNRegs 寄存器长度
* @retval eStatus 寄存器状态
*/
eMBErrorCode
eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
{
eMBErrorCode eStatus = MB_ENOERR;
int16_t iRegIndex;
//查询是否在寄存器范围内
//为了避免警告，修改为有符号整数
if( ( (int16_t)usAddress >= REG_INPUT_START ) \
&& ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
{
//获得操作偏移量，本次操作起始地址-输入寄存器的初始地址
iRegIndex = ( int16_t )( usAddress - REG_INPUT_START );
//逐个赋值
while( usNRegs > 0 )
{
//赋值高字节
*pucRegBuffer++ = ( uint8_t )( usRegInputBuf[iRegIndex] >> 8 );
//赋值低字节
*pucRegBuffer++ = ( uint8_t )( usRegInputBuf[iRegIndex] & 0xFF );
//偏移量增加
iRegIndex++;
//被操作寄存器数量递减
usNRegs--;
}
}
else
{
//返回错误状态，无寄存器
eStatus = MB_ENOREG;
}
return eStatus;
}
/**
* @brief 保持寄存器处理函数，保持寄存器可读，可读可写
* @param pucRegBuffer 读操作时--返回数据指针，写操作时--输入数据指针
* usAddress 寄存器起始地址
* usNRegs 寄存器长度
* eMode 操作方式，读或者写
* @retval eStatus 寄存器状态
*/
eMBErrorCode
eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs,
eMBRegisterMode eMode )
{
//错误状态
eMBErrorCode eStatus = MB_ENOERR;
//偏移量
int16_t iRegIndex;
//判断寄存器是不是在范围内
if( ( (int16_t)usAddress >= REG_HOLDING_START ) \
&& ( usAddress + usNRegs <= REG_HOLDING_START + REG_HOLDING_NREGS ) )
{
//计算偏移量
iRegIndex = ( int16_t )( usAddress - REG_HOLDING_START );
switch ( eMode )
{
//读处理函数
case MB_REG_READ:
while( usNRegs > 0 )
{
*pucRegBuffer++ = ( uint8_t )( usRegHoldingBuf[iRegIndex] >> 8 );
*pucRegBuffer++ = ( uint8_t )( usRegHoldingBuf[iRegIndex] & 0xFF );
iRegIndex++;
usNRegs--;
}
break;
//写处理函数
case MB_REG_WRITE:
while( usNRegs > 0 )
{
usRegHoldingBuf[iRegIndex] = *pucRegBuffer++ << 8;
usRegHoldingBuf[iRegIndex] |= *pucRegBuffer++;
iRegIndex++;
usNRegs--;
}
break;
}
}
else
{
//返回错误状态
eStatus = MB_ENOREG;
}
return eStatus;
}
/**
* @brief 线圈寄存器处理函数，线圈寄存器可读，可读可写
* @param pucRegBuffer 读操作---返回数据指针，写操作--返回数据指针
* usAddress 寄存器起始地址
* usNRegs 寄存器长度
* eMode 操作方式，读或者写
* @retval eStatus 寄存器状态
*/
eMBErrorCode
eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils,
eMBRegisterMode eMode )
{
//错误状态
eMBErrorCode eStatus = MB_ENOERR;
//寄存器个数
int16_t iNCoils = ( int16_t )usNCoils;
//寄存器偏移量
int16_t usBitOffset;
//检查寄存器是否在指定范围内
if( ( (int16_t)usAddress >= REG_COILS_START ) &&
( usAddress + usNCoils <= REG_COILS_START + REG_COILS_SIZE ) )
{
//计算寄存器偏移量
usBitOffset = ( int16_t )( usAddress - REG_COILS_START );
switch ( eMode )
{
//读操作
case MB_REG_READ:
while( iNCoils > 0 )
{
*pucRegBuffer++ = xMBUtilGetBits( ucRegCoilsBuf, usBitOffset,
( uint8_t )( iNCoils > 8 ? 8 : iNCoils ) );
iNCoils -= 8;
usBitOffset += 8;
}
break;
//写操作
case MB_REG_WRITE:
while( iNCoils > 0 )
{
xMBUtilSetBits( ucRegCoilsBuf, usBitOffset,
( uint8_t )( iNCoils > 8 ? 8 : iNCoils ),
*pucRegBuffer++ );
iNCoils -= 8;
usBitOffset += 8;
}
break;
}
}
else
{
eStatus = MB_ENOREG;
}
return eStatus;
}
/**
* @brief 开关输入寄存器处理函数，开关输入寄存器，可读
* @param pucRegBuffer 读操作---返回数据指针，写操作--返回数据指针
* usAddress 寄存器起始地址
* usNRegs 寄存器长度
* eMode 操作方式，读或者写
* @retval eStatus 寄存器状态
*/
eMBErrorCode
eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
{
//错误状态
eMBErrorCode eStatus = MB_ENOERR;
//操作寄存器个数
int16_t iNDiscrete = ( int16_t )usNDiscrete;
//偏移量
uint16_t usBitOffset;
//判断寄存器时候再指定范围内
if( ( (int16_t)usAddress >= REG_DISCRETE_START ) &&
( usAddress + usNDiscrete <= REG_DISCRETE_START + REG_DISCRETE_SIZE ) )
{
//获得偏移量
usBitOffset = ( uint16_t )( usAddress - REG_DISCRETE_START );
while( iNDiscrete > 0 )
{
*pucRegBuffer++ = xMBUtilGetBits( ucRegDiscreteBuf, usBitOffset,
( uint8_t)( iNDiscrete > 8 ? 8 : iNDiscrete ) );
iNDiscrete -= 8;
usBitOffset += 8;
}
}
else
{
eStatus = MB_ENOREG;
}
return eStatus;
}三、freertos系统的接口部分
代码简单，3个函数接口，只放图片
USART3_IRQHandler中断处理
__MODBUS_UART_DMA_Recv_Begin_Handler；
__MODBUS_UART_DMA_Recv_Complete_Handler
HAL_UART_RxHalfCpltCallback处理
__MODBUS_UART_RxHalfCpltCallback
四、测试
- 收发测试，使用1台主机，测试正常，收发配对正常
2. 压力收发测试，使用2台主机，同时发包，出现了eRcvState状态死锁在STATE_RX_IDLE的状态，该文代码已解决。
总结
例如：介绍了freemodbus移植到stm32使用串口DMA接收的方式，关键代码都已给出。像编译类，配置类问题请自行解决！
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
