STM32C8TX实现Modbus_rtu从机

已于 2024-03-29 15:58:44 修改
阅读量999 收藏 15
点赞数 13
文章标签： stm32 单片机 c语言 mcu
于 2024-03-27 15:21:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56542113/article/details/137075803
版权

本实验使用Stm32c8t6实现Modbus_rtu从机

主机为串口调试助手,通过串口调试助手来与单片机实现数据交互.

Modbus协议

Modbus协议是应用于电子控制器上的一种通用语言。通过此协议，控制器相互之间、控制器经由网络（例如以太网）和其它设备之间可以通信。它已经成为一通用工业标准.

Modbus协议格式

modbus信息帧所允许的最大长度为256个字节。所以数据的最大长度是252个字节

一个数据帧可以分为：设备码、功能码、数据码、校验码

常用的指令码(功能码)

    主设备发送读取0x03指令 
    0x00          0x03           0x0000             0x0000        0x0000
    (设备地址)  (指令码)  (从设备起始地址)    (读取个数)    (校验)
    从设备回复读取0x03指令
    0x00          0x03           0x00                0x0000         0x0000
    (设备地址)  (指令码)  (返回的字节个数)    (返回的数据)    (校验)

    主设备发送单个写入0x06指令
    0x00          0x06           0x0000              0x0000        0x0000
    (设备地址)  (指令码)  (从设备起始地址)    (写入数据)    (校验)
    从设备回复写入0x06指令
    0x00          0x06           0x0000             0x0000         0x0000
    (设备地址)  (指令码)  (从设备起始地址)    (修改数量)     (校验)

    主设备发送多个写入0x10指令
    0x00          0x10           0x0000             0x0000       0x00           0x0000           0x0000
    (设备地址)  (指令码)  (从设备起始地址)    (从哪里写)  (写入个数)  (写入数据)  (校验)
    从设备回复写入0x10指令
    0x00          0x10           0x0000             0x0000         0x0000
    (设备地址)  (指令码)  (从设备起始地址)    (修改数量)     (校验)

代码部分

本次实验使用Modbus_RTU协议,单片机做从,串口调试助手做主

首先使能串口,定时器等外设

串口USART1:
/**
*@brief     串口初始化函数
*@retval    无
*/
void Serial_UsartInit(void)
{
    //开启GPIO和串口时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    //GPIO配置
    GPIO_InitTypeDef serialgpio;
    serialgpio.GPIO_Mode = GPIO_Mode_AF_PP;
    serialgpio.GPIO_Pin = GPIO_Pin_9;//串口发送
    serialgpio.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA,&serialgpio);
    
    serialgpio.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    serialgpio.GPIO_Pin = GPIO_Pin_10;//串口接受
    GPIO_Init(GPIOA,&serialgpio);
    //串口配置
    USART_InitTypeDef serialconfig;
    serialconfig.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    serialconfig.USART_BaudRate = 9600;
    serialconfig.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    serialconfig.USART_Parity = USART_Parity_No;
    serialconfig.USART_StopBits = USART_StopBits_1;
    serialconfig.USART_WordLength = USART_WordLength_8b;
    USART_Init(USART1,&serialconfig);
    USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);
    //串口中断配置
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
    NVIC_InitTypeDef serialnvic;
    serialnvic.NVIC_IRQChannelPreemptionPriority = 1;
    serialnvic.NVIC_IRQChannelSubPriority = 1;
    serialnvic.NVIC_IRQChannelCmd = ENABLE;
    serialnvic.NVIC_IRQChannel = USART1_IRQn;
    NVIC_Init(&serialnvic);
    
    USART_Cmd(USART1,ENABLE);
}

/**
*@brief     串口发送数据函数
*@retval    无
*/
void Serial_SendByte(uint8_t byte)
{
    USART_SendData(USART1,byte);
    while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
}
定时器TIM3: 
/**
*@brief     定时器初始化函数
*@retval    无
*/
void Modbus_TimeIRQInit(void)
{
    //开启时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);
    //gpio配置
    GPIO_InitTypeDef timgpio;
    timgpio.GPIO_Mode = GPIO_Mode_AF_PP;
    timgpio.GPIO_Pin = GPIO_Pin_0;
    timgpio.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB,&timgpio);
    
    TIM_InternalClockConfig(TIM3);
    //定时器配置
    TIM_TimeBaseInitTypeDef timconfig;
    timconfig.TIM_Prescaler = 9;
    timconfig.TIM_CounterMode = TIM_CounterMode_Up;
    timconfig.TIM_Period = 7199;
    timconfig.TIM_ClockDivision = TIM_CKD_DIV1;
    timconfig.TIM_RepetitionCounter = 0;
    TIM_TimeBaseInit(TIM3,&timconfig);
    
    TIM_ClearFlag(TIM2, TIM_FLAG_Update);
    TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE);
    //中断配置
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    NVIC_InitTypeDef timnvic;
    timnvic.NVIC_IRQChannelPreemptionPriority = 1;
    timnvic.NVIC_IRQChannelSubPriority = 1;
    timnvic.NVIC_IRQChannelCmd = ENABLE;
    timnvic.NVIC_IRQChannel = TIM3_IRQn;
    NVIC_Init(&timnvic);  

    TIM_Cmd(TIM3,ENABLE);
    
}
 MODBUS相关代码
//定义一个结构体用来储存ModBus的数据
typedef struct
{
    uint8_t dev_addr;        //本设备从机地址
    uint8_t rece_buf[64];    //接受缓冲区
    uint8_t rece_cnt;        //接受计数器
    uint8_t send_buf[64];    //发送缓冲区
    uint8_t rece_flag;       //接受标志位
    uint8_t timout;          //数据持续时间
    uint8_t timrun;          //定时器开始计数标志
}Modbus_t;
//定义一个数组用于Modbus读写
uint16_t Reg[]={0x0001,0x0002,0x0003,0x0004,0x0005,0x0006,0x0007,0x0008,
                0x0009,0x0010,0x0011,0x0012,0x0013,0x0014,0x0015,0x0016};

/**
*@brief     Modbus初始化函数
*@retval    无
*/
void Modbus_Init(void)
{
    modbusdata.dev_addr = 0x02;
    modbusdata.timrun = 0;
}

/**
*@brief     CRC校验函数
*@retval    CRC校验数
*/
uint16_t Modbus_CRC16(uint8_t *ch,uint8_t len)
{
	uint16_t crc = 0xffff,code = 0xa001;
	char i,j;
	for(i = 0;i< len;i++){
		crc ^= ch[i]; 
		for(j = 0;j < 8;j++){
			if(crc&1){
				crc>>=1;
				crc^=code;
			}else{
				crc>>=1;
			}
		}
	}	
	return crc;  
}

/**
*@brief     Modbus事件函数
*@retval    错误码
*/
uint8_t Modbus_Event(void)
{
    uint16_t crc,rccrc;
    if(modbusdata.rece_flag == 0) //判断数据接受是否完成
    {
        return ERR_FlAG;    //宏定义ERR_FLAG = 0x01
    }
    //获取CRC校验
    crc = Modbus_CRC16(&modbusdata.rece_buf[0],modbusdata.rece_cnt-2);
    //获取数据帧的CRC校验
    rccrc = modbusdata.rece_buf[modbusdata.rece_cnt-1];
    rccrc <<=8;
    rccrc |= modbusdata.rece_buf[modbusdata.rece_cnt-2];
    //对比CRC校验
    if(crc == rccrc)        
    {
        //判断头码
        if(modbusdata.rece_buf[0] == modbusdata.dev_addr)
        {
            //索引功能码
            switch(modbusdata.rece_buf[1])
            {
                case 0x03:Modbus_ReadCMD();break;
                case 0x06:Modbus_WriteBitCMD();break;
                case 0x10:Modbus_WriteDataCMD();break;
                default:Serial_SendByte(0x44);break;
            }
        }
        else
        {
            modbusdata.rece_cnt = 0;
            modbusdata.rece_flag = 0;            
            return ERR_CRC; //宏定义ERR_CRC = 0x03
        }
    }
    else
    {
        modbusdata.rece_cnt = 0;
        modbusdata.rece_flag = 0;        
        return ERR_ADDR;//宏定义ERR_ADDR = 0x04
    }
    modbusdata.rece_cnt = 0;
    modbusdata.rece_flag = 0; 
    return 0x05; 
}

/********************************************************
************各个功能码的指令格式在上面有*******************
********************************************************/

/**
*@brief     Modbus功能0x03函数
*@retval    无
*/
void Modbus_ReadCMD(void)
{
    uint8_t i,j;
    uint16_t regaddr,reglen,r_crc;
    //获取 要读取寄存器的首地址(16位)
    regaddr = modbusdata.rece_buf[2];
    regaddr <<=8;
    regaddr |= modbusdata.rece_buf[3];
    //获取 要读取寄存器的数量(16位)
    reglen = modbusdata.rece_buf[4];
    reglen <<=8;
    reglen |= modbusdata.rece_buf[5];
    //从机回复数据
    i=0;
    modbusdata.send_buf[i++] = modbusdata.dev_addr;
    modbusdata.send_buf[i++] = 0x03;
    modbusdata.send_buf[i++] = (reglen*2)%256;
    for(j=0;j<reglen;j++)
    {
        modbusdata.send_buf[i++] = Reg[j]>>8;
        modbusdata.send_buf[i++] = Reg[j];
    }
    r_crc = Modbus_CRC16(modbusdata.send_buf,i);
    modbusdata.send_buf[i++] = r_crc>>8;
    modbusdata.send_buf[i++] = r_crc;
    //从机发送回复数据
    for(j=0;j<i;j++)
    {
        Serial_SendByte(modbusdata.send_buf[j]);
    }
}

/**
*@brief     Modbus功能0x06函数
*@retval    无
*/
void Modbus_WriteBitCMD(void)
{
    uint16_t regaddr,w_data,w_crc;
    uint16_t i,j;
    //获取 要写入寄存器的起始地址(16位)
    regaddr = modbusdata.rece_buf[2];
    regaddr <<=8;
    regaddr |= modbusdata.rece_buf[3];
    //获取 要写入寄存器的数据(16位)
    w_data = modbusdata.rece_buf[4];
    w_data <<=8;
    w_data |= modbusdata.rece_buf[5];
    Reg[regaddr] = w_data;
    //从机回复数据
    i=0;
    modbusdata.send_buf[i++] = modbusdata.dev_addr;
    modbusdata.send_buf[i++] = 0x06;
    modbusdata.send_buf[i++] = regaddr>>8;
    modbusdata.send_buf[i++] = regaddr;
    modbusdata.send_buf[i++] = w_data>>8;
    modbusdata.send_buf[i++] = w_data; 
    w_crc = Modbus_CRC16(modbusdata.send_buf,i);
    modbusdata.send_buf[i++] = w_crc>>8;
    modbusdata.send_buf[i++] = w_crc; 
    //从机发送回复数据
    for(j=0;j<i;j++)
    {
        Serial_SendByte(modbusdata.send_buf[j]);
    }    
}

/**
*@brief     Modbus功能0x10函数
*@retval    无
*/
void Modbus_WriteDataCMD(void)
{
    uint16_t regaddr,reglen,w_crc;
    uint16_t i,j;
    //获取 要写入寄存器的起始地址(16位)
    regaddr = modbusdata.rece_buf[2];
    regaddr <<=8;
    regaddr |= modbusdata.rece_buf[3];
    //获取 从那个寄存器开始写入(16位)
    reglen = modbusdata.rece_buf[4];
    reglen <<=8;
    reglen |= modbusdata.rece_buf[5];
    //获取 要写入寄存器的数据 
    for(i=0;i<reglen;i++)
    {
        Reg[reglen+i] = modbusdata.rece_buf[7+i*2];
        Reg[reglen+i] <<=8;
        Reg[reglen+i] |= modbusdata.rece_buf[8+i*2];
    }
    //从机回复数据
    modbusdata.send_buf[0] = modbusdata.dev_addr;
    modbusdata.send_buf[1] = 0x10;
    modbusdata.send_buf[2] = regaddr>>8;
    modbusdata.send_buf[3] = regaddr;
    modbusdata.send_buf[4] = reglen>>8;
    modbusdata.send_buf[5] = reglen;
    w_crc = Modbus_CRC16(modbusdata.send_buf,6);
    modbusdata.send_buf[6] = w_crc>>8;
    modbusdata.send_buf[7] = w_crc;  
    //从机发送回复数据  
    for(j=0;j<8;j++)
    {
        Serial_SendByte(modbusdata.send_buf[j]);
    }
}
中断配置:
/**********************************************
//中断配置时,串口的中断优先级必须大于定时器的优先级,
//否则会出问题,目前我暂且没弄明白是哪里的问题,
//知道的朋友可以评论区告诉我
**********************************************/
void USART1_IRQHandler(void)
{
    uint8_t data;
    if(USART_GetITStatus(USART1,USART_IT_RXNE) == SET)
    {
        //接受下发数据
        data = USART_ReceiveData(USART1);
        if(modbusdata.rece_flag == 1)
        {
            return;
        }
        //将下发数据储存至接受缓冲区
        modbusdata.rece_buf[modbusdata.rece_cnt++] = data;
        modbusdata.timout = 0;
        //接受一个数据后打开定时器 因为modbus rtu标准协议规定：每帧数据间隔至少为3.5个字符时间
        if(modbusdata.rece_cnt == 1)
        {
            modbusdata.timrun = 1;
        }
        USART_ClearITPendingBit(USART1,USART_IT_RXNE);
    }
}

void TIM3_IRQHandler(void)
{
    if(TIM_GetITStatus(TIM3,TIM_IT_Update) == SET)
    {
        //判断是否打开定时器
        if(modbusdata.timrun != 0)
        {
            modbusdata.timout++;
            if(modbusdata.timout >= 8)
            {
                modbusdata.timrun = 0;
                //接收数据完毕
                modbusdata.rece_flag = 1;
            }
        }
        TIM_ClearITPendingBit(TIM3,TIM_IT_Update);
    }    
}
主函数:
#include "stm32f10x.h"                  // Device header
#include "UsartModbusRTU.h"

typedef struct
{
    uint8_t error;
}system_t;

extern Modbus_t modbusdata;
system_t sys_data;

int main(void)
{
    Serial_UsartInit();
    Modbus_Init();
    Modbus_TimeIRQInit();

	while (1)
	{
        //Modbus事件轮询并且接受错误码
		sys_data.error = Modbus_Event();
        if(sys_data.error != 0x05)
        {
            switch(sys_data.error) 
            {
                //如果错误码为ERR_ADDR:表示地址错误
                case ERR_ADDR:Serial_SendByte(0x03);break;
                //如果错误码为ERR_CRC:表示校验错误
                case ERR_CRC:Serial_SendByte(0x04);break;
                default:break;                
            }
        }
	}
}

测试结果

串口助手发送  0x03功能码

串口助手发送 0x10功能码

再次发送 0x03可以看到数据已经改变

串口助手发送  0x06功能码 但是地址给个错误地址

可以看到错误码0x04表示地址错误

在此完结谢谢大家

薇尔莉特●伊芙加登
关注
  • 13
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
keil5下c语言modbus函数_用KEIL编写的MODBUS_RTU从站程序（STM32）
weixin_32022555的博客
12-23 768
【实例简介】自己编写的MODBUS_RTU从站程序(STM32)，目前测试还行，共享了吧，有学哟啊的朋友，请下载！【实例截图】【核心代码】Modbus_slave└── Modbus_slave├── D_EXAMPLE.map├── D_EXAMPLE_Moban.dep├── D_EXAMPLE.plg├── D_EXAMPLE_Target 1.dep├── D_EXAMPLE.uvgui....
STM32 MODBUS_RTU从站程序，KEIL编写
08-09
STM32 做的modbus_rtu程序，使用KEIL编写，没有移植FREEMODBUS,适合搞MODBUS协议开发的朋友
STM32+modbus从站代码
12-13
实现modbus协议通信
STM32F103C8T6的MODBUS-RTU通讯（485通讯）
wshl_2018的博客
11-23 3812
STM32F103C8T6的MODBUS-RTU通讯（485通讯） 附上源码与所有资料！！！！！
基于STM32以及modbus——RTU的从机程序（STM32作为从机）
weixin_45739317的博客
04-24 1744
Modbus协议是一种应用层报文传输协议，协议本身并没有定义物理层，所以支持多种电气接口，直接可以理解成他是软件层面的，各种的电气接口比如RS232、RS485、TCP/IP等，他们是硬件层面。他们之间互不影响。3.2 Modbus通讯过程Modbus是一主多从的通信协议Modbus通信中只有一个设备可以发送请求。其他从设备接收主机发送的数据来进行响应，从机是任何外围设备，如I/O传感器，阀门，网络驱动器，或其他测量类型的设备。从站处理信息和使用Modbus将其数据发送给主站。
STM32+RS485+Modbus-RTU（主机模式+从机模式）-标准库/HAL库开发
热门推荐
qq_37281984的博客
01-29 6万+
1、对modbus协议的0x03,0x06,0x10功能码进行测试+代码编写 2、使用modbus poll软件，modbus slave软件、串口调试助手进行模拟测试 3、使用STM32分别作为modbus协议的主机和从机进行测试 4、STM32使用串口中断超时接收数据 5、STM32使用DMA传输数据 6、STM32HAL库开发（主机+从机模式均进行测试）
基于STM32C8T6、RFID_RC522模块读写Mifare One（S50）卡
qq_44955826的博客
01-03 2689
用STM32C8T6最小系统板与RFID_RC522模块通信,以实现对Mifare One（S50）卡的读写
【stm32c8t6多路舵机PWM输出】
boybs的博客
04-26 3959
stm32c8t6多路舵机PWM输出 对于舵机的简单使用大家都不陌生，在实验中使用的SG90舵机最大转动角度为180度，而对舵机控制的原理是我们每一个使用者都应该了解的，具体的可以从下面这张角度和占空比的关系看看出来。 舵机的控制一般需要一个20ms的时基脉冲，该脉冲的高电平部分一般为0.5ms~2.5ms范围内的角度控制脉冲部分。以180度角度舵机为例，那么对应的控制关系是这样的： 可以发现一个规律：角度每次增加45度，高电平时间相应增加0.5ms 总周期 - 高电平脉冲 = 低电平脉
基于STM32C8T6的智能蓝牙小车控制设计
QQ2193276455的博客
03-29 1218
*单片机设计介绍，基于单片机小型家用燃气锅炉控制系统设计。
STM32C0开发(1)----概述
xh1479的博客
03-01 1万+
STM32C0系列微控制器是意法半导体公司推出的一款低功耗、高性能的微控制器产品。它们被设计用于需要小型、低功耗和高度可集成的应用程序，如传感器、消费品、电池供电设备、家庭自动化和安全等应用。该系列的微控制器采用ARM Cortex-M0内核，具有丰富的外设。
基于STM32C8T6的智能小车项目时钟配置
RONG_YAO的博客
06-09 1232
HSE 是高速的外部时钟信号，可以由有源晶振或者无源晶振提供，频率从 3-25MHZ不等。当使用有源晶振时，时钟从OSC_IN引脚进入，OSC_OUT引脚悬空，当选用无源晶振时，时钟从OSC_IN和OSC_OUT进入，并且要配谐振电容。HSE最常使用的就是8M 的无源晶振。当确定PLL时钟来源的时候，HSE可以不分频或者2分频，这个由时钟配置寄存器CFGR的位17PLLXTPRE设置，HSE 一般设置为不分频。
STM32F103x8B_DS_CH_V10_stm32c8t6原理图_stm32c8_
10-03
stm32c8t6的原理图，开发使用方便
STM32C8T6USB虚拟串口_串口键盘_stm32c8t6通过rtc_STM32F103USB_STM32F103C8_hi
09-10
基于stm32F103C8 USB_HID设备 鼠标 键盘 虚拟串口 程序
stm32c8t6_ds1302_stm32f103c8t6_
09-30
我自己网上改的DS1302
STM32C011J4M3_RTT_LED_UART.rar
07-11
STM32CUBEIDE采用RT-THREAD NANO实现UART和LED闪灯的例程。非KEIL例程。例程所用芯片为STM32C011J4M3。介绍： https://blog.csdn.net/hwytree/article/details/125705471?spm=1001.2014.3001.5502 。
STM32高级控制定时器应用之检测输入PWM周期和占空比
最新发布
mftang的博客
05-29 1436
本文主要介绍STM32高级定时器的用法至输入捕获功能，该功能可用于捕捉外部输入信号的频率，并且计算出PWM的占空比。笔者通过详细的案例介绍这个功能，包括理论知识，实现原理，以及如何使用STM32Cube配置基本的参数，编写实用代码，实现捕捉频率当的功能。
玩转STM32-I2C通信协议（详细-慢工出细活）
2301_81355360的博客
05-28 1469
当总线处于空闲状态时，由于上拉电阻的作用，总线呈现高电平，如果某个芯片需要输出数据，可以通过输出驱动实现数据传输。为了克服I2C总线这个缺点，NXP公司开了有源I2C总线终端，它采用两个互联的充电泵来等效上拉电阻，信号变化瞬间有源器件可以提供相当大的充放电电流，加快信号转换速率，降低寄生电容的影响。I2C总线上传输数据的最小单位是一个字节，首先发送数据位最高位，每传送完一个字节，接收器必须发送一个应答位，如果数据接收器来不及处理数据，可以通过拉低时钟线SCL来通知数据发送器暂停传输；
【STM32踩坑】HAL固件库版本过高导致烧录后无法运行问题
delete_you的博客
05-27 335
STM32CUBEMX生成对应HAL库代码时，发现烧录进STM32F103后程序无法正常运行，为此给出对应的解决方案
STM32C8T6的HAL_UART_Transmit具体内容
05-19
HAL_UART_Transmit函数是STM32 HAL库中UART串口发送数据的函数，函数原型如下： HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout) 函数参数说明： - huart：UART句柄，指向UART_HandleTypeDef结构体的指针； - pData：待发送数据的缓存区地址； - Size：待发送数据的长度； - Timeout：发送数据的超时时间，单位为毫秒。 函数返回值说明： 函数返回值为HAL_StatusTypeDef类型，代表函数执行状态。函数执行成功返回HAL_OK，否则返回其他值。 函数具体内容如下： 1. 判断UART是否处于忙状态，如果处于忙状态则返回忙状态错误。 2. 将pData指向的数据写入UART的数据寄存器中，实现数据发送。 3. 等待发送完成或者发送超时。 4. 判断发送是否成功，如果成功则返回执行成功状态，否则返回发送错误状态。 以上就是HAL_UART_Transmit函数的具体内容及参数说明。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值