stm32在freertos系统下使用串口DMA接收方式对接freemodbus-rtu协议栈

最新推荐文章于 2024-04-21 10:58:22 发布
最新推荐文章于 2024-04-21 10:58:22 发布
阅读量3.5k 收藏 32
点赞数 14
文章标签： stm32 单片机 arm 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jackchen810/article/details/127179982
版权

stm32在freertos系统下使用串口DMA接收方式对接freemodbus-rtu协议栈

文章目录

前言

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接收的方式，关键代码都已给出。像编译类，配置类问题请自行解决！

Just810
关注
  • 14
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
Freemodbus通信，串口接收模式改为DMA接收模式。
liyunzhuo的博客
03-30 4765
相信老铁们，在实际项目开发中，当使用Freemodbus从机协议栈时，会遇到一个问题，就是网上大多数对于该协议栈的移植，在数据接收这块，使用的大都是串口中断接收模式。这样做会有一个问题，如果一条Modbus总线上有若干个从机，一个个从机接收到主机的数据请求时，返回的数据长度大于1kBytes，会有一个问题，总线上其他的从机都处于串口中断接收模式，这样的话，在这段时间内，其他的从机是处于忙碌状态。可...
STM32_FreeRTOS_USART串口通信接收不定长数据
06-16
stm32 使用cubemx 创建的Freertos系统下的串口通信接收不定长数据的demo
stm32f103+freertos+USART(DMA)不定长接收
08-29
stm32f103运行FreeRTOS实现串口DMA发送和DMA不定长接收。 驱动OLED屏和空气检测传感器PMS5003ST.
基于Freertos移植FreeModbusRtu（slave从机）协议
Dd_456456的博客
04-11 490
基于FreeRTOS的N32G457VEL7之LWIP网络协议栈移植-CSDN博客。
STM32HAL库CubeMx FreeRTOS 消息队列 DMA串口空闲中断接收消息
最新发布
Troubadour~的博客
04-21 804
本文主要讲在FreeRTOS中使用消息队列传输串口接收到的不定长数据，主要传指针。串口方面使用DMA接收，然后串口空闲中断进行接收数据的管理。原理：创建一个消息队列、创建串口数据缓冲区结构体数组。数组长度多少，队列长度就有多长。该结构体至少包含数据缓冲区和数据大小，后面有代码演示的。创建完成后让DMA接收的数据放在结构体里的数据缓冲区里面，然后用指针指向这整个结构体，最后通过消息队列发送出去。
STM32之FreeRTOS
jerrylwb的专栏
11-21 2114
学习操作系统，我并没有一开始就学习UCOS，而是选择了FreeRTOS。FreeRTOS可以方便地搭建在各个平台上，因为汇编相关，都已经由官方完成，我们要做的仅是添加自己的代码，可省去很多工作量。       问题1：在使用多任务时，我想利用USART输出信息，但是如果直接放在任务中输出，往往会造成字符收发顺序不一致的情况，这是仿真时遇到的实际问题。为解决这个问题，可以在USART输出信息时挂起
基于STM32的FreeRTOS串口队列通信
04-27
最简单的任务和中断之间的数据传输：队列 将程序修改为通过队列传送数据 串口中断服务程序中，将读取到的数据发送到队列中 在OnCommunicationTask()中，将接收到的数据通过串口发送出来
STM32F429+FreeRTOS队列 串口DMA双缓存数据接收
freedompoi的博客
01-06 4724
前言 最近做项目需要用到数据大量数据处理的应用场景，本来想使用串口空闲中断+DMA传输+FreeRTOS队列的方式接收数据，然而实际使用中发现效果不理想，经常丢包。最后查明原因为在空闲中断频繁关闭/开启DMA接收会影响数据接收效率，所以在查找了相关资料之后，决定使用DMA双缓存的方式接收数据，实际测试结果表明，这种方式大大增加了数据接收效率，现在把这个知识分享给大家。 一、开发环境 芯片：STM32F429 开发软件：keilv5、STM32CubeMX os：FreeRTOS 二、原理 通过
STM32 FreeRTOS Freemodbus RTU Master
06-08
STM32f103 freeRTOS FreeModbus是一款开源的Modbus协议栈，但是只有从机开源，主机源码是需要**收费**的。同时网上也没有发现比较好的开源的Modbus主机协议栈，所以才开发这款支持主机模式的FreeModbus协议栈。本版...
FreeRTOS+STM32F103通过队列传输串口数据
11-13
STM32F103单片机上用FreeRTOS传输串口数据，在串口中断中用队列存储串口接收的数据，然后再定时器中断中，用队列接收串口的数据并打印出来。
STM32串口+DMA+环形FIFO例程 freertos.rar
08-10
stm32 串口+DMA+环形FIFO缓存收发数基本例程， 仅供参考 freertos环境，其他环境类推
STM32F407 LWIP FREERTOS FREEMODBUS
08-01
STM32F407 LWIP FREERTOS FREEMODBUS MII模式
STM32F407VE+FreeRTOS+STM32CubeIDE+串口DMA+Freemodbus移植代码
03-03
STM32F407VE+FreeRTOS+STM32CubeIDE+DMA+Freemodbus移植代码 修改了接口文件
基于STM32CubeMX+STM32G070CB+FreeRTOS+freeMODBUS-RTU的移植源程序
10-12
STM32使用HAL库移植freemodbus-v1.6 MDK-ARM V5.32 STM32CubeMX V6.92 Keil5 5.36 mbpoll 04 功能吗读取
STM32 DMA串口不定长数据收发+FreeRTOS操作系统 参考代码
08-08
使用CubeMX封装的FreeRTOS操作系统，可直接写入到正点原子mini开发板之中或者任何一块stm32F103RCT6的板子上。 实现功能：1.有一个任务实现功能是PA8引脚（外接LED灯）可以实现呼吸灯效果。 2. UART1使用DMA+双缓存...
stm32在freertos系统下使用串口dma接收方式对接freemodbus-rtu协议栈
05-01
STM32是一种非常受欢迎的微控制器，广泛应用于各种嵌入式系统。在FreeRTOS系统下使用STM32的串口DMA接收方式对接FreeModbus-RTU协议栈，可以实现高效的数据传输，提高系统性能。下面分别从串口DMA和FreeModbus-RTU两部分介绍。 串口DMA是一种直接内存访问技术，能够实现数据的高效传输，极大地提高了系统性能。在STM32中，串口DMA接收方式可以实现在接收数据时不需要CPU干预，将接收到的数据直接存储到指定的内存区域中。这种方式可以大大降低CPU的负载，提高系统的并发处理能力。 FreeModbus-RTU是一个广泛应用于工控系统的通信协议栈，具有易于移植、高效、可靠等优点。通过STM32的串口DMA接收方式对接FreeModbus-RTU协议栈，可以实现快速、高效的通信。具体实现过程中，需要根据FreeModbus-RTU协议的规则进行数据包的解析和封装。在串口DMA接收到数据后，可以通过设置相关的中断来触发数据的解析和封装。 需要注意的是，在接收数据时，由于数据包的长度是不确定的，因此需要设置合适的缓冲区大小。同时，在封装数据包时，需要按照FreeModbus-RTU协议的规则进行封装，并且需要考虑到异步通信时数据包的压缩问题，以提高通信效率。 综上所述，通过STM32的串口DMA接收方式对接FreeModbus-RTU协议栈，可以实现高效、可靠的通信，并且可以在保证系统性能的同时提高通信效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值