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方式；拆解原代码调试成功后记录如下。

该代码修改思路如下：

1. 串口接收dma方式（参考dma+idle中断接收方式）
2. 理解freemodbus代码；原代码使用中断按Byte接收组成帧的方式。 该拆解手术直接dma接收成帧，返回给协议栈。
3. 发送时间使用HAL_UART_Transmit 接口发送完成。
4. 去掉porttimer.c的应用。
5. 帧数据的收发都在portserial.c文件中完成
6. 尽可能不动协议栈代码；只需要修改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@sil.at>
 *
 * 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. 收发测试，使用1台主机，测试正常，收发配对正常
   2. 压力收发测试，使用2台主机，同时发包，出现了eRcvState状态死锁在STATE_RX_IDLE的状态，该文代码已解决。
   

---

总结

例如：介绍了freemodbus移植到stm32使用串口DMA接收的方式，关键代码都已给出。像编译类，配置类问题请自行解决！