Modbus RTU 从机代码实现——STM32

原创 已于 2025-01-06 12:44:26 修改 · 2.6k 阅读 · 26 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
Modbus RTU

当前文章被收录于：

Modbus RTU
6 篇文章 3 人学习

Modbus Poll , Modbus Slave软件的安装与使用。 Modbus RTU协议讲解 Modbus RTU主从机代码实现--STM32F103

订阅专栏 查看详情
于 2025-01-06 12:32:25 首次发布

此专栏一共6篇文章

Modbus Poll 软件安装-CSDN博客

Modbus Slave 软件安装-CSDN博客

Modbus Poll 、Modbus Slave 软件使用-CSDN博客

Modbus RTU-CSDN博客

Modbus RTU主机代码实现——STM32-CSDN博客

Modbus RTU 从机代码实现——STM32-CSDN博客

外设配置

选用芯片——STM32f103C6T6

UART1

用于485多机通信

阻塞发送，中断接收

波特率115200

1起始位 8数据位 0校验位 1停止位

Timer3

用于T3.5判断

向上计数，72分频，重装载值100——100us中断

从机程序

仅提供一个思路，具体项目里怎么写还需自己发挥

一共涉及8个文件

LH_ModbusSlave.c

LH_RS485.c

LH_UART.c

LH_ISR.c

main.c

LH_ModbusSlave.h

LH_RS485.h

LH_UART.h

LH_ModbusSlave.c

//*******************************************************

//作者------LH

//时间------2025.01.05

//模块功能--Modbus RTU 从机程序  已实现--03H  04H  10H  没有写广播模式

//*******************************************************

#include "stm32f1xx_hal.h"

#include "LH_ModbusSlave.h"

#include "LH_RS485.h"

#include "LH_UART.h"

#include "LH_LED.h"

 

uint8_t guca_ModS_RxBuff[256];//接收缓冲区-每帧最大256字节

uint8_t guca_ModS_TxBuff[256];//发送缓冲区-每帧最大256字节

 

//从机参数

uint8_t guc_ModS_ID = 0x09; //从机地址

 

//波特率115200   T3.5 = 1000000/115200*(1+8+0+1)*3.5 = 303us

//波特率115200   T3.5 = 1000000/115200*(1+8+1+1)*3.5 = 334us

uint32_t    guw_ModS_RxT35 = 334;  //3.5字符时间 us

uint32_t    guw_ModS_RXTCnt = 0;   //接收字符时间间隔

 

 

uint16_t    guh_ModS_RxLength = 0;//接收数据长度

uint8_t     guc_ModS_RXEndFlag = 0; //接收结束标志

 

 

#define  INPUTREGNUM 80  //输入寄存器数量

#define  HOLDREGNUM  100  //保持寄存器数量

 

uint16_t guhpa_ModS_InputReg[INPUTREGNUM];

uint32_t guhpa_ModS_HoldReg[HOLDREGNUM];

 

 

//使用外部变量

extern UART_HandleTypeDef huart1;

 

//寄存器与变量相结合--------------------------

//这里用define实现，将全局变量与寄存器相结合，读写寄存器值即读写相应的变量值

//建议用一个global.h文件来管理全局变量，将所有的 extern uintx_t xxx；写在里面

//当有.c文件要使用外部全局变量时，直接#include "global.h"

uint8_t  guc_a0;

uint16_t guh_a1;

uint32_t guw_a2;

 

#define guc_a0 guhpa_ModS_HoldReg[0]

#define guh_a1 guhpa_ModS_HoldReg[1]

#define guw_a2 (uint32_t)(guhpa_ModS_HoldReg[2] << 16) |(guhpa_ModS_HoldReg[3])

 

uint8_t guc_ModS_RxOneByte[1];

 

//从机初始化程序

void LH_ModS_Init(void)

{

  //调试时用的数据 可以不要

  guhpa_ModS_HoldReg[0] = 3210;

  guhpa_ModS_HoldReg[1] = 5678;

  guhpa_ModS_HoldReg[2] = 9999;

  guhpa_ModS_HoldReg[3] = 1111;

 

  guhpa_ModS_InputReg[0] = 2020;

  guhpa_ModS_InputReg[1] = 2021;

  guhpa_ModS_InputReg[2] = 2022;

  guhpa_ModS_InputReg[3] = 2023;

  //----------------------------------------

  LH_UART1_Start(guc_ModS_RxOneByte, 1);

 

}

 

//从机接收程序

//UART设置中断接收 每次1字节

//在串口中断服务函数里调用

void LH_ModS_RXISR(uint8_t RxOneByte)//

{

  if (guh_ModS_RxLength<256) //一次帧接收字节<256

  {

    guca_ModS_RxBuff[guh_ModS_RxLength++] = RxOneByte;

    guw_ModS_RXTCnt = 0;

  }

  else

  {

    //一次接收超过256字节就不接收了

  }

}

 

void LH_ModS_ReceiveISR()

{

  if (guh_ModS_RxLength<256) //一次帧接收字节<256

  {

    guca_ModS_RxBuff[guh_ModS_RxLength++] = guc_ModS_RxOneByte[0];

    guw_ModS_RXTCnt = 0;

  }

  else

  {

    //一次接收超过256字节就不接收了

 

  }

 

  HAL_UART_Receive_IT(&huart1, guc_ModS_RxOneByte, 1); //再次开中断

 

}

 

 

//接收完成判断程序

//需要一个定时器 100us中断

//在定时器中断服务函数里调用

void LH_ModS_RXT35ISR(void) //100us中断

{

  guw_ModS_RXTCnt += 100;

 

  if ((guw_ModS_RXTCnt >  guw_ModS_RxT35)) //字符间隔超过T35

  {

    if (guh_ModS_RxLength != 0) //已经开始接收

    {

      guc_ModS_RXEndFlag =1;

    }

  }

 

}

 

 

//CRC16计算程序

uint16_t LH_ModS_GetCRC16(uint8_t *Data, uint16_t length)

{

  uint16_t CRC16 = 0xffff;  // CRC校验码

  uint16_t Polynomial = 0xa001; //生成多项式

 

  for (int i = 0; i < length; i++)

  {

    CRC16 ^= Data[i];

 

    for (int j = 0; j < 8; j++)

    {

      if ((CRC16 & 0x0001) != 0) //x&1 = 1

      {

        CRC16 >>= 1;

        CRC16 ^= Polynomial;

      }

      else

      {

        CRC16 >>= 1;

      }

    }

  }

 

  return CRC16;

}

 

 

 

 

//从机指令执行程序

//10ms调用一次

void LH_ModS_ExeCmd(void)

{

  if (guc_ModS_RXEndFlag == 1) //接收帧结束

  {

 

    uint8_t RecID = guca_ModS_RxBuff[0];

 

    if (RecID == guc_ModS_ID) //ID正确

    {

      uint16_t CalRxBuffCRC, RecRXBuffCRC;

      CalRxBuffCRC = LH_ModS_GetCRC16(guca_ModS_RxBuff, guh_ModS_RxLength-2);

 

      RecRXBuffCRC = guca_ModS_RxBuff[guh_ModS_RxLength - 2]

                     | (((uint16_t)guca_ModS_RxBuff[guh_ModS_RxLength-1])<<8);//接收CRC

 

      if (CalRxBuffCRC==RecRXBuffCRC) //CRC校验正确

      {

        //LH_LED_Change();

 

        switch (guca_ModS_RxBuff[1]) //根据不同的功能码进行处理

        {

          case 03: //读多个保持寄存器

          {

            LH_ModS_03H();

            break;

          }

 

          case 04: //读多个输入寄存器

          {

            LH_ModS_04H();

            break;

          }

 

          case 16: //读多个输入寄存器

          {

            LH_ModS_10H();

            break;

          }

 

          default :

            //非法功能码---------------------------------------------------

            //发送非法功能码

            break;

        }

      }

      else

      {

        //不响应

      }

 

    }

 

    guc_ModS_RXEndFlag = 0;

    guh_ModS_RxLength = 0;

    guw_ModS_RXTCnt = 0;

  }

 

}

 

 

 

 

//从机指令解析函数--各功能码函数

void LH_ModS_03H(void)

{

  //操作寄存器起始地址

  uint16_t StartRegAddr = (((uint16_t)guca_ModS_RxBuff[2]) << 8) | guca_ModS_RxBuff[3];

  //操作寄存器数量

  uint16_t OpRegNum = (((uint16_t)guca_ModS_RxBuff[4]) << 8) | guca_ModS_RxBuff[5];

 

  if ((StartRegAddr + OpRegNum) < HOLDREGNUM) // 寄存器地址+数量 在设定地址范围内

  {

    guca_ModS_TxBuff[0] =  guca_ModS_RxBuff[0] ;

    guca_ModS_TxBuff[1] =  guca_ModS_RxBuff[1] ;

    guca_ModS_TxBuff[2] =  OpRegNum * 2;

 

    for (int i=0 ; i<OpRegNum*2; i++)

    {

      //先发送高位

      guca_ModS_TxBuff[3+i*2] = ((guhpa_ModS_HoldReg[StartRegAddr+i]) >> 8) &0x00FF;//先发送高字节--再发送低字节

      guca_ModS_TxBuff[4+i*2] = ((guhpa_ModS_HoldReg[StartRegAddr+i]) & 0x00FF); //

      //方法二——联合体

    }

 

    uint16_t TxCRC;

    TxCRC  = LH_ModS_GetCRC16(guca_ModS_TxBuff, 3 + OpRegNum*2);;

 

    guca_ModS_TxBuff[3 + OpRegNum*2] = TxCRC ;

    guca_ModS_TxBuff[4 + OpRegNum*2] = (TxCRC >> 8);//先发送CRC低位 后发送高位

 

    LH_ModS_SendData(guca_ModS_TxBuff, 5 + OpRegNum*2);

 

  }

  else

  {

    guca_ModS_TxBuff[0] =  guca_ModS_RxBuff[0] ;

    guca_ModS_TxBuff[1] =  guca_ModS_RxBuff[1] | 0x80 ;

    guca_ModS_TxBuff[2] =  0x02; //地址异常-----------------------------------

 

    uint16_t TxCRC;

    TxCRC = LH_ModS_GetCRC16(guca_ModS_TxBuff, 3);

 

    guca_ModS_TxBuff[3] = TxCRC ;

    guca_ModS_TxBuff[4] = (TxCRC >> 8); //先发送CRC低位 后发送高位

 

    LH_ModS_SendData(guca_ModS_TxBuff, 5);

  }

 

}

 

 

 

void LH_ModS_04H(void)

{

  //操作寄存器起始地址

  uint16_t StartRegAddr = (((uint16_t)guca_ModS_RxBuff[2]) << 8) | guca_ModS_RxBuff[3];

  //操作寄存器数量

  uint16_t OpRegNum = (((uint16_t)guca_ModS_RxBuff[4]) << 8) | guca_ModS_RxBuff[5];

 

  if ((StartRegAddr + OpRegNum) < INPUTREGNUM) // 寄存器地址+数量 在设定地址范围内

  {

    guca_ModS_TxBuff[0] =  guca_ModS_RxBuff[0] ;

    guca_ModS_TxBuff[1] =  guca_ModS_RxBuff[1] ;

    guca_ModS_TxBuff[2] =  OpRegNum * 2;

 

    for (int i=0 ; i<OpRegNum*2; i++)

    {

      //先发送高位

      guca_ModS_TxBuff[3+i*2] = ((guhpa_ModS_InputReg[StartRegAddr+i]) >> 8) &0x00FF;//先发送高字节--再发送低字节

      guca_ModS_TxBuff[4+i*2] = ((guhpa_ModS_InputReg[StartRegAddr+i]) & 0x00FF); //

      //方法二——联合体

    }

 

    uint16_t TxCRC;

    TxCRC  = LH_ModS_GetCRC16(guca_ModS_TxBuff, 3 + OpRegNum*2);;

 

    guca_ModS_TxBuff[3 + OpRegNum*2] = TxCRC ;

    guca_ModS_TxBuff[4 + OpRegNum*2] = (TxCRC >> 8);//先发送CRC低位 后发送高位

 

    LH_ModS_SendData(guca_ModS_TxBuff, 5 + OpRegNum*2);

 

  }

  else

  {

    guca_ModS_TxBuff[0] =  guca_ModS_RxBuff[0] ;

    guca_ModS_TxBuff[1] =  guca_ModS_RxBuff[1] | 0x80 ;

    guca_ModS_TxBuff[2] =  0x02; //地址异常-----------------------------------

 

    uint16_t TxCRC;

    TxCRC = LH_ModS_GetCRC16(guca_ModS_TxBuff, 3);

 

    guca_ModS_TxBuff[3] = TxCRC ;

    guca_ModS_TxBuff[4] = (TxCRC >> 8); //先发送CRC低位 后发送高位

 

    LH_ModS_SendData(guca_ModS_TxBuff, 5);

  }

 

}

 

 

 

void LH_ModS_10H(void)

{

  //操作寄存器起始地址

  uint16_t StartRegAddr = (((uint16_t)guca_ModS_RxBuff[2]) << 8) | guca_ModS_RxBuff[3];

  //操作寄存器数量

  uint16_t OpRegNum = (((uint16_t)guca_ModS_RxBuff[4]) << 8) | guca_ModS_RxBuff[5];

 

  if ((StartRegAddr + OpRegNum) < HOLDREGNUM) // 寄存器地址+数量 在设定地址范围内

  {

    //写数据

    for (int i=0 ; i<OpRegNum; i++)

    {

      guhpa_ModS_HoldReg[StartRegAddr+i] = (((uint16_t)guca_ModS_RxBuff[7+i*2]) << 8) | guca_ModS_RxBuff[8+i*2];

    }

 

    //响应报文

    guca_ModS_TxBuff[0] =  guca_ModS_RxBuff[0] ;

    guca_ModS_TxBuff[1] =  guca_ModS_RxBuff[1] ;

    guca_ModS_TxBuff[2] =  guca_ModS_RxBuff[2] ;

    guca_ModS_TxBuff[3] =  guca_ModS_RxBuff[3];

    guca_ModS_TxBuff[4] =  guca_ModS_RxBuff[4] ;

    guca_ModS_TxBuff[5] =  guca_ModS_RxBuff[5];

 

    uint16_t TxCRC;

    TxCRC  = LH_ModS_GetCRC16(guca_ModS_TxBuff, 6);

 

    guca_ModS_TxBuff[6] = TxCRC ;

    guca_ModS_TxBuff[7] = (TxCRC >> 8);//先发送CRC低位 后发送高位

 

    LH_ModS_SendData(guca_ModS_TxBuff, 8);

 

  }

  else

  {

    guca_ModS_TxBuff[0] =  guca_ModS_RxBuff[0] ;

    guca_ModS_TxBuff[1] =  guca_ModS_RxBuff[1] | 0x80 ;

    guca_ModS_TxBuff[2] =  0x02; //地址异常---------------------------------

 

    uint16_t TxCRC;

    TxCRC = LH_ModS_GetCRC16(guca_ModS_TxBuff, 3);

 

    guca_ModS_TxBuff[3 ] = TxCRC ;

    guca_ModS_TxBuff[4 ] = (TxCRC >> 8); //先发送CRC低位 后发送高位

 

    LH_ModS_SendData(guca_ModS_TxBuff, 5);

  }

 

}

 

 

//从机响应程序

//接收指令分析完调用

void LH_ModS_SendData(uint8_t *TxBuff, uint16_t length)

{

  LH_RS485_SendData(TxBuff, length);

  LH_LED_Change();

}

LH_ModbusSlave.h

#ifndef __LH_MODBUSSLAVE_H

#define __LH_MODBUSSLAVE_H

 

#include "stdint.h"

 

 

void LH_ModS_Init(void);

   

void LH_ModS_SendData(uint8_t *p ,uint16_t length);

void LH_ModS_ReceiveISR(void);

 

void LH_ModS_ExeCmd(void);//从机指令执行程序——10ms周期调用一次

 

void LH_ModS_RXT35ISR(void); //T35判断程序

 

void LH_ModS_03H(void);

void LH_ModS_04H(void);

void LH_ModS_10H(void);

#endif

 

LH_RS485.c

//*******************************************************

//作者------LH

//时间------2025.01.05

//模块功能--485发送 接收数据

//用的485电路是自控流向的，所以不需要引脚控制流向

//*******************************************************

 

#include "LH_RS485.h"

#include "LH_UART.h"

#include "LH_ModbusSlave.h"

#include "LH_ModbusMaster.h"

 

//485发送函数

void LH_RS485_SendData(uint8_t *TxBuff, uint16_t length)

{

  LH_UART1_SendData(TxBuff, length);

 

}

 

void LH_RS485_ReceiveISR(void)

{

 

  //主机

  //LH_ModM_ReceiveISR();

  //在LH_ModM_ReceiveISR里再次开中断

 

  //从机

  LH_ModS_ReceiveISR();

  //在LH_ModS_ReceiveISR里再次开中断

 

}

LH_RS485.h

#ifndef __LH_RS485_H

#define __LH_RS485_H

 

#include "stdint.h"

 

 

//485发送函数

void LH_RS485_SendData(uint8_t *TxBuff ,uint16_t length);

 

void LH_RS485_ReceiveISR(void);

 

#endif

LH_UART.c

//*******************************************************

//作者------LH

//时间------2024.12.08

//模块功能--阻塞发送 中断接收

//*******************************************************

#include "stm32f1xx_hal.h"

#include "LH_UART.h"

#include "LH_RS485.h"

 

extern UART_HandleTypeDef huart1;//485 主从机Modbus通信

extern UART_HandleTypeDef huart2;//串口助手调试

 

//开启UART1接收中断

void LH_UART1_Start(uint8_t *RxBuff, uint16_t length)

{

  HAL_UART_Receive_IT(&huart1, RxBuff, length); //接收够字节长度才触发中断，且每次设置只进入一次中断

}

 

 

//UART1发送数据

void LH_UART1_SendData(uint8_t *TxBuff, uint16_t length)

{

  HAL_UART_Transmit(&huart1, TxBuff, length, 1); //阻塞发送

}

 

 

//UART1接收中断服务函数

void LH_UART1_ReceiveISR(void)

{

  LH_RS485_ReceiveISR();

  //在 LH_RS485_ReceiveISR 里再次开中断

}

 

//UART2发送数据

void LH_UART2_SendData(uint8_t *TxBuff, uint16_t length)

{

  HAL_UART_Transmit(&huart2, TxBuff, length, 1); //阻塞发送

}

LH_UART.h

#ifndef __LH_UART_H

#define __LH_UART_H

 

#include "stdint.h"

 

//开启UART1接收中断

void LH_UART1_Start(uint8_t *RxBuff ,uint16_t length);

//UART1发送数据

void LH_UART1_SendData(uint8_t *TxBuff ,uint16_t length);

//UART1中断接收数据

void LH_UART1_ReceiveISR(void );

 

 

//UART2发送数据

void LH_UART2_SendData(uint8_t *TxBuff ,uint16_t length);

#endif

LH_ISR.c

//*******************************************************

//作者------LH

//时间------2024.12.23

//模块功能--所有中断回调函数

//*******************************************************

#include "stm32f1xx_hal.h"

#include "LH_Delay.h"

#include "LH_AUART.h"

#include "LH_UART.h"

#include "LH_ModbusSlave.h"

#include "LH_ModbusMaster.h"

#include "LH_LED.h"

 

extern TIM_HandleTypeDef htim2;

extern UART_HandleTypeDef huart1;

 

//重写HAL库定时中断回调函数

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)

{

 

  if (htim->Instance == TIM3)

  {

    //主机

    //LH_ModM_RXT35ISR();

    //从机

    LH_ModS_RXT35ISR();

  }

}

 

 

//串口接收中断回调函数

uint8_t guc_RxOneByte[1];

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)

{

  if (huart->Instance == USART1)

  {

    LH_UART1_ReceiveISR();

    //在 LH_UART1_ReceiveISR 里再次开中断

  }

}

 

 

main.c

int main(void)

{

  HAL_Init();

  SystemClock_Config();

  MX_GPIO_Init();

  MX_TIM2_Init();

  MX_USART1_UART_Init();

  MX_TIM3_Init();

  MX_USART2_UART_Init();

  /* USER CODE BEGIN 2 */

  HAL_TIM_Base_Start_IT(&htim3);

  LH_ModM_Init();

  LH_ModS_Init();

  /* USER CODE END 2 */

  while (1)

  {

 

        //主机——1s发送一次指令

        //LH_Delay_Us(1000000);       

        //LH_ModM_ProcessRxData();//处理上一次从机回复数据

        //LH_ModM_SendCmd();//发送下一次报文指令

                

        //从机——10ms检查一次

        LH_Delay_Us(10000);       

        LH_ModS_ExeCmd();         

  }

}

标签
#stm32 #嵌入式硬件 #单片机 #物联网
MODBUS-RTU协议主机和从机代码STM32单片机F103实现
02-24
MODBUS-RTU协议主机和从机代码STM32 含功能码03 05 06 10 包含4个程序代码，主机和从机（代码易懂） 2个主机和从机（stm32f103vet6）2个主机和从机（stm32f103C8T6） 基于温度传感器DS18B20的MODBUS-RTU从机 主机发送指令：01 03 20 00 00 01 8F CA 从机收到指令返回温度数据 06指令修改Add通信地址/站号 主机代码，主动发03指令读其它设备数据并把返回用数码管显示 10写多个寄存器 程序代码包含4个：stm32单片机 2个（stm32f103vet6）2个（stm32f103C8T6） 我的代码是最容易看懂的 很多人想要很多功能号 实现原理就是用if判断数据帧有点区别，所以学会一条功能号，其它自然会了 4位595数码管模块显示
STM32+modbus从站代码
12-13
实现modbus协议通信
stm32基于UART串口实现modbusRTU(软件方式)
qq_50532565的博客
01-07 4530
stm32简单实现modbusRTU协议
Granite-3.0-2B-Base-GGUF：IBM开源2.5B参数多语言AI模型的完整指南 [特殊字符]
最新发布
gitblog_09770的博客
05-29 496
Granite-3.0-2B-Base-GGUF是IBM开源的一款2.5B参数多语言AI模型，采用先进的GGUF格式优化，为开发者和研究者提供了高效、轻量级的大语言模型解决方案。这款开源AI模型支持12种语言，包括英语、德语、西班牙语、法语、日语、中文等，是构建多语言AI应用的理想选择。在本篇完整指南中，我们将深入探讨这款IBM开源AI模型的核心特性、快速上手方法以及实际应用场景。 ## 📊
STM32开发之Modbus协议(主站RTU)
scl8295的博客
02-17 1万+
在单片机方面，针对于通讯常用的协议之一modbus,这里将modbus协议和硬件之间的关系完全独立出来，硬件和协议之间的联系采用的是回调的方式进行一个关联。此头文件定义枚举和回调以及相关的功具类/*** @brief 读线圈状态* @brief 读输入状态* @brief 读保持寄存器* @brief 读输入寄存器* @brief 写一个线圈* @brief 写一个寄存器* @brief 写多个寄存器* @brief 写多个线圈。
STM32 Modbus通信学习笔记—— 代码及示例
qq_41954556的博客
03-06 2万+
STM32 通过modbus与维控屏通信
STM32硬件库（非HAL库）实现MODBUS RTU协议的03，06功能码（读以及与单个发送）
lin5boy的博客
08-01 3887
MODBUS是一种单主站的主/从通讯模式。Modbus网络上只有一个主站，主站在Modbus网络上没有地址，从站的地址范围为0-247，其中0为广播地址，从站的实际地址范围为1-247。通信由主机发起，一问一答式，从机无法主动向主机发送数据。传输过程中，两个字节之间的相邻时间不得大于3.5个字符的时间，否则视为一帧数据传输结束。// 发送内容// 接收内容// modbus寄存器内数据// id号// 功能码// 校验位// 总包计数// CRC校验的结果。
STM32从机Modbus RTU接收全攻略：从RS485电平转换到代码实现
oauth7security的博客
02-23 1036
本文详细解析了STM32作为Modbus RTU从机的完整实现方案。从RS485电平转换电路设计、硬件连接要点出发，深入讲解了基于中断和定时器的软件架构、数据帧解析、CRC校验以及功能码响应的核心代码实现，并提供了实用的调试技巧与进阶优化建议，旨在帮助开发者构建稳定可靠的工业通信从机设备。
【亲测免费】 MODBUS RTU从机实现基于STM32 HAL库
gitblog_09702的博客
09-06 814
MODBUS RTU从机实现基于STM32 HAL库 【下载地址】MODBUSRTU从机实现基于STM32HAL库 - **资源文件名**: MODBUS(RTU).zip- **目标平台**: STM32系列微控制器- **技术栈**: STM32CubeMX， HAL库， MODBUS协议 ...
基于STM32ZET6的Modbus RTU从机实现：高效、稳定、易用
gitblog_09800的博客
10-22 964
基于STM32ZET6的Modbus RTU从机实现：高效、稳定、易用 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 在工业自动化领域，Modbus RTU协议因其简单、高效和广泛兼容性而备受青睐。为了帮助开发者更便捷地在STM32平台上实现Modbus RTU从机功能，我们推出了基于STM32ZET6的Modbus RTU从机实现项目。该项目提供了一个完整的代码库，...
基于STM32以及modbus——RTU的从机程序（STM32作为从机）
weixin_45739317的博客
04-24 1万+
Modbus协议是一种应用层报文传输协议，协议本身并没有定义物理层，所以支持多种电气接口，直接可以理解成他是软件层面的，各种的电气接口比如RS232、RS485、TCP/IP等，他们是硬件层面。他们之间互不影响。3.2 Modbus通讯过程Modbus是一主多从的通信协议Modbus通信中只有一个设备可以发送请求。其他从设备接收主机发送的数据来进行响应，从机是任何外围设备，如I/O传感器，阀门，网络驱动器，或其他测量类型的设备。从站处理信息和使用Modbus将其数据发送给主站。
STM32F103开发的Modbus RTU通信程序源代码.7z
03-29
采用STM32F103编写的Modbus RTU主站与从站源代码程序，内附带电脑模拟客户端与服务端程序用于测试源代码。
STM32H库Modbus-RTU程序
weixin_41226265的博客
12-16 2158
Modbus通讯协议最早由Modicon公司开发，是一种采用主从通信模式，即只有主机可以发起请求，从站设备通过向主机提供请求的数据或执行查询中请求的操作作为响应，广泛应用于工业现场的总线协议。主从查询——响应机制如下图所示。主机可以通过指定节点地址的方式访问从设备，也可以通过发送广播消息访问所有从设备；从设备只响应针对自己的查询，不会响应广播查询。Modbus通信协议是一项应用层报文传输协议，包括RTU、ASCII和TCP，标准的Modbus协议物理层接口包括RS232、RS485和以太网。
MODBUS-RTU协议主机和从机代码STM32
m0_64634370的博客
11-29 4104
MODBUS-RTU协议主机和从机代码STM32 包含2个程序代码，主机和从机（我代码最容易看懂） 基于温度传感器DS18B20的MODBUS-RTU从机 主机发送指令：01 03 20 00 00 01 8F CA 从机收到指令返回温度数据 06指令修改Add通信地址/站号和波特率 主机代码，主动发03指令读其它设备数据并把返回用数码管显示 程序代码包含：stm32单片机（stm32f103vet6） 我的代码是最容易看懂的 很多人想要很多功能号 实现原理就是用if判断数据帧有点区别，所以学会一条功能
Modbus RTU主机代码实现——STM32
l13527971021的博客
01-06 3274
Modbus RTU主机代码实现，基于STM32F1，仅提供一个思路，实际项目怎么写需自己发挥
基于STM32的ModbusRtu通信--ModbusRtu协议(一)
HostID1993的博客
07-03 4492
[--------------点击下面，进入总目录索引--------------]  STM32系列精品Demo集 - 总目录
STM32-modbus rtu 之主机程序
热门推荐
wangzibigan的博客
08-30 3万+
STM32-modbus rtu 之主机程序
基于STM32的MODBUS-RTU框架的实现
zhuzhu的博客
04-15 1万+
基于STM32的MODBUS-RTU框架的实现
stm32 实现 Modbus RTU协议
weixin_65754484的博客
09-11 4787
stm32 实现modbus RTU 的常用功能码实现，详细解释帮你彻底理解
基于STM32 Modbus rtu 从机代码 开源 （附上测试工程）-------------------------2代码风格（偏通用移植）
qq_27762895的博客
05-14 1万+
Modbus rtu 从机代码主要包括五组： modbus.c modbus.h modbus_485.cmodbus_485.h modbus_crc.c modbus_crc.h modbus_time.c modbus_time.h modbus_uart.c modbus_uart.h #include "modbus.h" MODBUS modbus...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值