1.RS485的定义
相信做自动化或者智能设备的朋友都听说过RS485协议，RS485通信协议是一种多点通信协议，它允许多个设备在同一总线上进行通信，且每个设备都可以发送和接收数据。RS485通讯协议采用差分信号传输，具有高速、远距离、可靠性强等特点，可实现长距离的数据传输。
RS485通信协议支持半双工通信模式，在同一总线上可以连接多个驱动器和接收器，方便建立设备网络。此外，RS485通信协议的接口电平低，不易损坏芯片，电平与TTL电平兼容，方便与TTL电路连接。RS485通信协议是一种适用于工业控制系统和智能家居等领域的通信协议，具有高速、远距离、可靠性强等优点，能够满足大量数据传输的需求，并提高数据传输的效率和实时性。
2.RS485与Modbus区别
协议性质：RS485是一种物理层通信标准，主要定义了电气特性、信号传输方式和连接方式等，而Modbus是一种通信协议，定义了一种常用的通信格式和规则，用于在主设备和从设备之间进行数据交换。
应用范围：RS485通常用作物理层协议，支持Modbus协议，而Modbus更常用于工业控制领域，是一种通用的通信数据格式，支持RS485、RS232等串口。
所以，RS485和Modbus在协议性质、应用范围和功能特性方面存在明显的区别。在工业控制和智能设备通信领域，二者常常被结合使用，以实现高效、稳定的数据传输。
在物联网中，RS485协议被广泛应用于各种领域，如工业控制、智能家居、城市管理、智能交通等。在这些领域中，RS485协议可以实现设备之间的快速、稳定、可靠的数据传输，提高设备的智能化程度和用户体验。例如，在智能家居中，RS485协议可以用于家庭内部的各种设备之间的通信，包括智能电视、智能音响、智能照明、智能安防等，实现设备的互联互通和集中控制。
3.MODBUS通讯协议及编程
MODBUS通讯协议大致分为以下几种
Modbus-RTU+Modbus-ASCII
Modbus-TCP
Modbus-Plus
Modbus是主从方式通信,也就是说,不能同步进行通信,总线上每次只有一个数据进行传输,即主机发送,从机应答,主机不发送,总线上就没有数据通信.，本文主要讲解RTU协议
3.1. Modbus-RTU协议
这种协议是基于异步串行通信上,一般的介质有:RS-232,RS485,RS-422上,这也是工业上使用的最多的。
3.1.1. 帧结构
帧结构 = 地址 + 功能吗 + 数据 + 校验
地址: 占用一个字节,范围0-255,其中有效范围是1-247,其他有特殊用途,比如255是广播地址(广播地址就是应答所有地址,正常的需要两个设备的地址一样才能进行查询和回复)
功能码:" 占用一个字节,功能码的意义就是,知道这个指令是干啥的,比如你可以查询从机的数据,也可以修改数据,所以不同功能码对应不同功能.
数据: 根据功能码不同,有不同结构,在后续的实例中有说明;
校验: 为了保证数据不错误,增加这个,然后再把前面的数据进行计算看数据是否一致,如果一致,就说明这帧数据是正确的,我再回复;如果不一样,说明你这个数据在传输的时候出了问题,数据不对的,所以就抛弃了;
字符结构
通讯数据结构
3.1.2.常用功能码
03-主机需要发送起始地址+寄存器数量，从机回复总字节数+数据；
06-主机发送起始地址+数据内容（因为你只需要修改一个，所以起始地址就是所要修改的地址），从机返回起始地址+数据内容（发现居然一样！）
10-主机发送起始地址+寄存器个数+总字节数+数据，从机返回起始地址+寄存器数量
.3常用功能码使用举例分析
1.3.1 功能码-0x03读保持寄存器
测试功能描述:
现在我是主机,我要查询从机地址为1的数据
主机发送: 01 03 00 00 00 01 84 0A
从机回复: 01 03 02 12 34 B5 33
3.2.C语言实现
mbrtu_master.h
#ifndef MBRTU_MASTER_H_
#define MBRTU_MASTER_H_
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include "mbrtu_master.h"
#include "usart.h"
#include "tim.h"
#include "main.h"
#include "usart.h"
#include "stdio.h"
///
/// MODBUS RTU 主机控制结构
///
///
typedef struct
{
//
// 收发数据缓存
//
uint8_t ucBuf[8];//读取可能是4个字节
//
// 收发数据状态
//
uint16_t usStatus;
//
// 如果使用了RTOS需要进行互斥,那么需要实现以下两个函数的绑定
//
void (*lock)(void);
void (*unlock)(void);
//
// 微秒延时函数,用于等待超时
//
void (*delayms)(uint32_t nms);
//
// 定时器启动和停止函数
//
void (*timerStop)(void);
void (*timerStart)(void);
//
// 发送数据函数,可以是串口、TCP等
//
uint32_t (*sendData)(const void* buf, uint32_t len);
//把接受的数
uint32_t (*sendDataLog)(const void *buf, uint32_t len);
//
// 以下四个回调函数分别是:读线圈、读离散量输入、读保持寄存器、读输入寄存器
//
void (*readCoilsCallback)(uint16_t usStartAddr, uint16_t usNum, const uint8_t* pucBitsOfCoilsState, uint16_t usLen);
void (*readDiscreteInputsCallback)(uint16_t usStartAddr, uint16_t usNum, const uint8_t* pucBitsOfDiscreteInputsState, uint16_t usLen);
void (*readHoldingRegistersCallback)(uint16_t usStartAddr, uint16_t usNum, const uint8_t* pusHoldingRegistersVal, uint8_t usLen);
void (*readInputRegistersCallback)(uint16_t usStartAddr, uint16_t usNum, const uint16_t* pusInputRegistersVal, uint16_t usLen);
}MBRTUMaterTypeDef;
static void timerStop(void);
static void timerStart(void);
static void delayms(uint32_t nms);
static uint32_t sendData(const void *buf, uint32_t len);
static uint32_t sendDataLog(const void *buf, uint32_t len);
static void readCoilsCallback(uint16_t usStartAddr, uint16_t usNum, const uint8_t *pucBitsOfCoilsState, uint16_t usLen);
static void readDiscreteInputsCallback(uint16_t usStartAddr, uint16_t usNum, const uint8_t *pucBitsOfDiscreteInputsState, uint16_t usLen);
static void readHoldingRegistersCallback(uint16_t usStartAddr, uint16_t usNum, const uint8_t *pusHoldingRegistersVal, uint8_t usLen);
static void readInputRegistersCallback(uint16_t usStartAddr, uint16_t usNum, const uint16_t *pusInputRegistersVal, uint16_t usLen);
///
/// MODBUS RTU 主机 API
///
///
int MBRTUMasterReadCoils(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout);
int MBRTUMasterReadDiscreteInputs(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout);
int MBRTUMasterReadHoldingRegisters(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout);
int MBRTUMasterReadInputRegisters(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout);
int MBRTUMasterWriteSingleCoil(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint8_t ucState, uint16_t usTimeout);
int MBRTUMasterWriteSingleRegister(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usRegVal, uint16_t usTimeout);
int MBRTUMasterWriteMultipleCoils(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, const uint8_t* pucStateBitsBuf, uint16_t usTimeout);
int MBRTUMasterWriteMultipleRegisters(MBRTUMaterTypeDef* psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, const uint16_t* pusRegVal, uint16_t usTimeout);
///
/// MODBUS RTU 主机接收数据回调函数和超时回调函数
///
/// MBRTUMasterRecvByteISRCallback：放置于串口接收中断中
/// MBRTUMasterTimerISRCallback：放置于定时器超时中断中
///
void MBRTUMasterRecvByteISRCallback(MBRTUMaterTypeDef* psModbus, uint8_t ucByte);
void MBRTUMasterTimerISRCallback(MBRTUMaterTypeDef* psModbus);
//发送日志显示报文
void MBRTUMasterSendDataLog(MBRTUMaterTypeDef *pMaster);
int16_t GetModbusCRC16_Cal(uint8_t *data, uint32_t len);
#endif /* MBRTU_MASTER_H_ */
mbrtu_master.c
/*
* mbrtu_master.c
*/
#include "mbrtu_master.h"
#include "inttypes.h"
char str[50] = {0};
char str1[50] = {0};
static uint16_t usMBCRC16(uint8_t *pucFrame, uint16_t usLen)
{
static const uint8_t aucCRCHi[] =
{
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40};
static const uint8_t aucCRCLo[] =
{
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7,
0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E,
0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9,
0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC,
0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32,
0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D,
0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38,
0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF,
0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1,
0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4,
0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB,
0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA,
0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0,
0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97,
0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E,
0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89,
0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83,
0x41, 0x81, 0x80, 0x40};
uint8_t ucCRCHi = 0xFF;
uint8_t ucCRCLo = 0xFF;
int iIndex;
while (usLen--)
{
iIndex = ucCRCLo ^ *(pucFrame++);
ucCRCLo = (uint8_t)(ucCRCHi ^ aucCRCHi[iIndex]);
ucCRCHi = aucCRCLo[iIndex];
}
return (uint16_t)(ucCRCHi << 8 | ucCRCLo);
}
int16_t GetModbusCRC16_Cal(uint8_t *data, uint32_t len)//Modbus-CRC校验-----计算法
{
uint8_t temp;
uint16_t wcrc = 0XFFFF;//16位crc寄存器预置
uint32_t i = 0, j = 0;//计数
for (i = 0; i < len; i++)//循环计算每个数据
{
temp = data[i] & 0X00FF;//将八位数据与crc寄存器亦或
wcrc ^= temp; //将数据存入crc寄存器
for (j = 0; j < 8; j++) //循环计算数据的
{
if (wcrc & 0X0001)//判断右移出的是不是1，如果是1则与多项式进行异或。
{
wcrc >>= 1;//先将数据右移一位
wcrc ^= 0XA001;//与上面的多项式进行异或
}
else//如果不是1，则直接移出
{
wcrc >>= 1;//直接移出
}
}
}
return ((wcrc << 8)|(wcrc>>8));//高低位置换
}
//读取数据
static uint32_t MBRTUMasterRead(MBRTUMaterTypeDef *pMaster, uint8_t ucSlaveAddr, uint8_t ucCmd, uint16_t usStartAddr, uint16_t usNum)
{
uint16_t crc;
pMaster->ucBuf[0] = ucSlaveAddr;
pMaster->ucBuf[1] = ucCmd;
pMaster->ucBuf[2] = ((usStartAddr & 0XFF00) >> 8);
pMaster->ucBuf[3] = (usStartAddr & 0XFF);
pMaster->ucBuf[4] = ((usNum & 0XFF00) >> 8);
pMaster->ucBuf[5] = (usNum & 0XFF);
crc = usMBCRC16((uint8_t *)pMaster->ucBuf, 6);
pMaster->ucBuf[6] = (uint8_t)(crc & 0xFF);
pMaster->ucBuf[7] = (uint8_t)(crc >> 8);
//pMaster->sendDataLog(pMaster->ucBuf, 8);//发送日志
//char str[40] = {0};
//sprintf(str,"%s0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\r\n","发送：",pMaster->ucBuf[0],pMaster->ucBuf[1],pMaster->ucBuf[2],pMaster->ucBuf[3],pMaster->ucBuf[4],pMaster->ucBuf[5],pMaster->ucBuf[6],pMaster->ucBuf[7]);
//sendLOGStr(str);
return pMaster->sendData(pMaster->ucBuf, 8);
}
void MBRTUMasterSendDataLog(MBRTUMaterTypeDef *pMaster)
{
//pMaster->sendDataLog(pMaster->ucBuf, 8);
//if(pMaster->ucBuf[0] != '\0')
//{//接受485数据
// sendLOGStr(pMaster->ucBuf);
// pMaster->ucBuf[0] = 0;
// }
}
/**
* 主机读取线圈状态
* @param ucSlaveAddress 从机地址
* @param usAddress 要读取的线圈起始地址
* @param usCmd 0x01
* @param usNum 要读取的线圈数量
* @param usTimeout 超时时间,单位毫秒
* @return 0:成功 <0:执行失败
*/
int MBRTUMasterReadCoils(MBRTUMaterTypeDef *psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout)
{
int ret = -1;
int delay;
if (psModbus->lock != NULL)
{
psModbus->lock();
}
psModbus->usStatus = 0;
MBRTUMasterRead(psModbus, ucSlaveAddress, 0X01, usAddress, usNum);
while (usTimeout != 0)
{
if (psModbus->usStatus & 0X8000)
{
if (psModbus->ucBuf[0] == ucSlaveAddress && psModbus->ucBuf[1] == 0X01)
{
psModbus->readCoilsCallback(usAddress, usNum, &psModbus->ucBuf[3], psModbus->ucBuf[2]);
ret = 0;
}
else
{
ret = -2;
}
psModbus->usStatus = 0;
break;
}
delay = usTimeout > 5 ? 5 : usTimeout;
usTimeout -= delay;
psModbus->delayms(delay);
}
if (psModbus->unlock != NULL)
{
psModbus->unlock();
}
return ret;
}
/**
* 主机读取离散量输入
* @param ucSlaveAddress 从机地址
* @param usAddress 要读取的离散量起始地址
* @param usCmd 0x02
* @param usNum 要读取的离散量数量
* @param usTimeout 超时时间,单位毫秒
* @return 0:成功 <0:执行失败
*/
int MBRTUMasterReadDiscreteInputs(MBRTUMaterTypeDef *psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout)
{
int ret = -1;
int delay;
if (psModbus->lock != NULL)
{
psModbus->lock();
}
psModbus->usStatus = 0;
MBRTUMasterRead(psModbus, ucSlaveAddress, 0X02, usAddress, usNum);
while (usTimeout != 0)
{
if (psModbus->usStatus & 0X8000)
{
if (psModbus->ucBuf[0] == ucSlaveAddress && psModbus->ucBuf[1] == 0X02)
{
psModbus->readDiscreteInputsCallback(usAddress, usNum, &psModbus->ucBuf[3], psModbus->ucBuf[2]);
ret = 0;
}
else
{
ret = -2;
}
psModbus->usStatus = 0;
break;
}
delay = usTimeout > 5 ? 5 : usTimeout;
usTimeout -= delay;
psModbus->delayms(delay);
}
if (psModbus->unlock != NULL)
{
psModbus->unlock();
}
return ret;
}
/**
* 主机读取保持寄存器!!!!!!!!!!!!
* @param ucSlaveAddress 从机地址
* @param usAddress 要读取的保持寄存器起始地址
* @param usCmd 0x03
* @param usNum 要读取的保持寄存器数量
* @param usTimeout 超时时间,单位毫秒
* @return 0:成功 <0:执行失败
*/
int MBRTUMasterReadHoldingRegisters(MBRTUMaterTypeDef *psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout)
{
int ret = -1;
int delay;
if (psModbus->lock != NULL)
{
psModbus->lock();
}
psModbus->usStatus = 0;
MBRTUMasterRead(psModbus, ucSlaveAddress, 0X03, usAddress, usNum);
while (usTimeout != 0)
{
if (psModbus->usStatus & 0X8000)
{
if (psModbus->ucBuf[0] == ucSlaveAddress && psModbus->ucBuf[1] == 0X03)
{
psModbus->readHoldingRegistersCallback(usAddress, usNum, (const uint8_t *)&psModbus->ucBuf[3], psModbus->ucBuf[2]);
ret = 0;
}
else
{
ret = -2;
}
psModbus->usStatus = 0;
break;
}
delay = usTimeout > 5 ? 5 : usTimeout;
usTimeout -= delay;
psModbus->delayms(delay);
}
if (psModbus->unlock != NULL)
{
psModbus->unlock();
}
char str1[40] = {0};
sprintf(str1,"%02X%s%d\r\n",psModbus->ucBuf[0],"号伺服电机查询状态：",ret);
sendLOGStr(str1);
return ret;
}
/**
* 主机读取输入寄存器
* @param ucSlaveAddress 从机地址
* @param usAddress 要读取的输入寄存器起始地址
* @param usCmd 0x04
* @param usNum 要读取的输入寄存器数量
* @param usTimeout 超时时间,单位毫秒
* @return 0:成功 <0:执行失败
*/
int MBRTUMasterReadInputRegisters(MBRTUMaterTypeDef *psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, uint16_t usTimeout)
{
int ret = -1;
int delay;
if (psModbus->lock != NULL)
{
psModbus->lock();
}
psModbus->usStatus = 0;
MBRTUMasterRead(psModbus, ucSlaveAddress, 0X04, usAddress, usNum);
while (usTimeout != 0)
{
if (psModbus->usStatus & 0X8000)
{
if (psModbus->ucBuf[0] == ucSlaveAddress && psModbus->ucBuf[1] == 0X04)
{
psModbus->readInputRegistersCallback(usAddress, usNum, (const uint16_t *)&psModbus->ucBuf[3], psModbus->ucBuf[2] >> 1);
ret = 0;
}
else
{
ret = -2;
}
psModbus->usStatus = 0;
break;
}
delay = usTimeout > 5 ? 5 : usTimeout;
usTimeout -= delay;
psModbus->delayms(delay);
}
if (psModbus->unlock != NULL)
{
psModbus->unlock();
}
return ret;
}
/**
* 主机写单个线圈
* @param ucSlaveAddress 从机地址
* @param usAddress 线圈地址
* @param usCmd 0x05
* @param ucState 要设置的线圈状态，1或者0
* @param usTimeout 超时时间,单位毫秒
* @return 0:成功 <0:执行失败
*/
int MBRTUMasterWriteSingleCoil(MBRTUMaterTypeDef *psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint8_t ucState, uint16_t usTimeout)
{
int ret = -1;
int delay;
uint16_t crc;
if (psModbus->lock != NULL)
{
psModbus->lock();
}
psModbus->ucBuf[0] = ucSlaveAddress;
psModbus->ucBuf[1] = 0X05;
psModbus->ucBuf[2] = usAddress & 0XFF;
psModbus->ucBuf[3] = usAddress >> 8;
psModbus->ucBuf[4] = ucState ? 0XFF : 0X00;
psModbus->ucBuf[5] = 0X00;
crc = usMBCRC16((uint8_t *)psModbus->ucBuf, 6);
psModbus->ucBuf[6] = (uint8_t)(crc & 0xFF);
psModbus->ucBuf[7] = (uint8_t)(crc >> 8);
psModbus->usStatus = 0;
psModbus->sendData(psModbus->ucBuf, 8);
while (usTimeout != 0)
{
if (psModbus->usStatus & 0X8000)
{
if (psModbus->ucBuf[0] == ucSlaveAddress && psModbus->ucBuf[1] == 0X05)
{
ret = 0;
}
else
{
ret = -2;
}
psModbus->usStatus = 0;
break;
}
delay = usTimeout > 5 ? 5 : usTimeout;
usTimeout -= delay;
psModbus->delayms(delay);
}
if (psModbus->unlock != NULL)
{
psModbus->unlock();
}
return ret;
}
/**
* 主机写单个寄存器!!!!!!!!!!!
* @param ucSlaveAddress 从机地址
* @param usAddress 寄存器地址(通信地址)
* @param usCmd 0x06
* @param usRegVal 寄存器值
* @param usTimeout 超时时间,单位毫秒
* @return 0:成功 <0:执行失败
*/
// MBRTUMasterWriteSingleRegister(&MBRTUHandle, 1, RUN_MODE_ADDR, 0x0003, 100);
int MBRTUMasterWriteSingleRegister(MBRTUMaterTypeDef *psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usRegVal, uint16_t usTimeout)
{
int ret = -1;
int delay;
uint16_t crc;
if (psModbus->lock != NULL)
{
psModbus->lock();
}
psModbus->ucBuf[0] = ucSlaveAddress;
psModbus->ucBuf[1] = 0X06;
psModbus->ucBuf[2] = usAddress >> 8;
psModbus->ucBuf[3] = usAddress & 0XFF;
psModbus->ucBuf[4] = usRegVal >> 8;
psModbus->ucBuf[5] = usRegVal & 0XFF;
crc = GetModbusCRC16_Cal((uint8_t *)psModbus->ucBuf, 6);
psModbus->ucBuf[6] = (uint8_t)(crc >> 8);
psModbus->ucBuf[7] = (uint8_t)(crc & 0xFF);
psModbus->usStatus = 0;
psModbus->sendData(psModbus->ucBuf, 8);
while (usTimeout != 0)
{
if (psModbus->usStatus & 0X8000)
{
if (psModbus->ucBuf[0] == ucSlaveAddress && psModbus->ucBuf[1] == 0X06)
{
ret = 0;
}
else
{
ret = -2;
}
psModbus->usStatus = 0;
break;
}
delay = usTimeout > 1 ? 1 : usTimeout;
usTimeout -= delay;
psModbus->delayms(delay);
}
if (psModbus->unlock != NULL)
{
psModbus->unlock();
}
//sprintf(str,"%s0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\r\n","响应指令",psModbus->ucBuf[0],psModbus->ucBuf[1],psModbus->ucBuf[2],psModbus->ucBuf[3],psModbus->ucBuf[4],psModbus->ucBuf[5],psModbus->ucBuf[6],psModbus->ucBuf[7]);
sprintf(str1,"%02X%s%s\r\n",psModbus->ucBuf[0],"号伺服电机返回：",(ret==0?"成功":"失败"));
sendLOGStr(str1);
return ret;
}
/**
* 主机写多个线圈状态
* @param ucSlaveAddress 从机地址
* @param usAddress 线圈起始地址
* @param usNum 要写的线圈数量
* @param pucStateBitsBuf 存放线圈状态，1比特代表一个线圈状态
* @param usTimeout 超时时间,单位毫秒
* @return 0:成功 <0:执行失败
*/
int MBRTUMasterWriteMultipleCoils(MBRTUMaterTypeDef *psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, const uint8_t *pucStateBitsBuf, uint16_t usTimeout)
{
int ret = -1;
int delay;
uint16_t crc;
uint16_t usIndex = 0, usBytes = 0;
if (psModbus->lock != NULL)
{
psModbus->lock();
}
psModbus->ucBuf[usIndex++] = ucSlaveAddress;
psModbus->ucBuf[usIndex++] = 0X0F;
psModbus->ucBuf[usIndex++] = usAddress & 0XFF;
psModbus->ucBuf[usIndex++] = usAddress >> 8;
psModbus->ucBuf[usIndex++] = usNum >> 8;
psModbus->ucBuf[usIndex++] = usNum & 0XFF;
usBytes = (usNum - 1) / 8 + 1;
psModbus->ucBuf[usIndex++] = usBytes;
while (usBytes--)
{
psModbus->ucBuf[usIndex++] = *pucStateBitsBuf++;
}
crc = usMBCRC16((uint8_t *)psModbus->ucBuf, usIndex);
psModbus->ucBuf[usIndex++] = (uint8_t)(crc & 0xFF);
psModbus->ucBuf[usIndex++] = (uint8_t)(crc >> 8);
psModbus->usStatus = 0;
psModbus->sendData(psModbus->ucBuf, usIndex);
while (usTimeout != 0)
{
if (psModbus->usStatus & 0X8000)
{
if (psModbus->ucBuf[0] == ucSlaveAddress && psModbus->ucBuf[1] == 0X0F)
{
ret = 0;
}
else
{
ret = -2;
}
psModbus->usStatus = 0;
break;
}
delay = usTimeout > 5 ? 5 : usTimeout;
usTimeout -= delay;
psModbus->delayms(delay);
}
if (psModbus->unlock != NULL)
{
psModbus->unlock();
}
return ret;
}
/**
* 主机写多个寄存器!!!!!!!!!!!
* @param ucSlaveAddress 从机地址
* @param usAddress 要写的寄存器起始地址
* @param usCmd 0x10
* @param usNum 要写的寄存器数量
* @param pusRegVal 存放要写的寄存器值
* @param usTimeout 超时时间,单位毫秒
* @return 0:成功 <0:执行失败
*/
int MBRTUMasterWriteMultipleRegisters(MBRTUMaterTypeDef *psModbus, uint8_t ucSlaveAddress, uint16_t usAddress, uint16_t usNum, const uint16_t *pusRegVal, uint16_t usTimeout)
{
int ret = -1;
int delay;
uint16_t crc;
uint16_t usIndex = 0;
if (psModbus->lock != NULL)
{
psModbus->lock();
}
psModbus->ucBuf[usIndex++] = ucSlaveAddress;
psModbus->ucBuf[usIndex++] = 0X10;
psModbus->ucBuf[usIndex++] = usAddress & 0XFF;
psModbus->ucBuf[usIndex++] = usAddress >> 8;
psModbus->ucBuf[usIndex++] = usNum >> 8;
psModbus->ucBuf[usIndex++] = usNum & 0XFF;
psModbus->ucBuf[usIndex++] = usNum << 1;
while (usNum--)
{
psModbus->ucBuf[usIndex++] = *pusRegVal >> 8;
psModbus->ucBuf[usIndex++] = *pusRegVal & 0XFF;
pusRegVal++;
}
crc = usMBCRC16((uint8_t *)psModbus->ucBuf, usIndex);
psModbus->ucBuf[usIndex++] = (uint8_t)(crc & 0xFF);
psModbus->ucBuf[usIndex++] = (uint8_t)(crc >> 8);
psModbus->usStatus = 0;
psModbus->sendData(psModbus->ucBuf, usIndex);
while (usTimeout != 0)
{
if (psModbus->usStatus & 0X8000)
{
if (psModbus->ucBuf[0] == ucSlaveAddress && psModbus->ucBuf[1] == 0X10)
{
ret = 0;
}
else
{
ret = -2;
}
psModbus->usStatus = 0;
break;
}
delay = usTimeout > 5 ? 5 : usTimeout;
usTimeout -= delay;
psModbus->delayms(delay);
}
if (psModbus->unlock != NULL)
{
psModbus->unlock();
}
return ret;
}
void MBRTUMasterRecvByteISRCallback(MBRTUMaterTypeDef *psModbus, uint8_t ucByte)
{
psModbus->timerStop();
if (psModbus->usStatus < (sizeof(psModbus->ucBuf)-1))
{
psModbus->ucBuf[psModbus->usStatus++] = ucByte;
psModbus->timerStart();
}
else
{
psModbus->usStatus |= 0X8000;
}
}
void MBRTUMasterTimerISRCallback(MBRTUMaterTypeDef *psModbus)
{
psModbus->timerStop();
psModbus->usStatus |= 0X8000;
}
#ifdef USE_RTOS
static void mutex_lock(void)
{
}
static void mutex_unlock(void)
{
}
#endif
static void timerStop(void)
{
// HAL_TIM_Base_Stop_IT(&htim2);
}
static void timerStart(void)
{
// __HAL_TIM_SET_COUNTER(&htim2, 0);
// HAL_TIM_Base_Start_IT(&htim2);
}
static void delayms(uint32_t nms)
{
HAL_Delay(nms);
}
static uint32_t sendData(const void *buf, uint32_t len)
{
if (HAL_UART_Transmit(&huart2, (uint8_t *)buf, len, 100) != HAL_OK)
{
len = 0;
}
return len;
}
static uint32_t sendDataLog(const void *buf, uint32_t len)
{
if (HAL_UART_Transmit(&huart1, (uint8_t *)buf, len, 100) != HAL_OK)
{
len = 0;
}
return len;
}
static void readCoilsCallback(uint16_t usStartAddr, uint16_t usNum, const uint8_t *pucBitsOfCoilsState, uint16_t usLen)
{
uint8_t ucLoops = (usNum - 1) / 8 + 1;
uint8_t ucState, ucBits;
printf(" Read %d coils starting at start address %d: ", usNum, usStartAddr);
while (ucLoops != 0)
{
ucState = *pucBitsOfCoilsState++;
ucBits = 0;
while (usNum != 0 && ucBits < 8)
{
printf("%d ", ucState & 0X01 ? 1 : 0);
ucState >>= 1;
usNum--;
ucBits++;
}
ucLoops--;
}
printf("\r\n");
}
static void readDiscreteInputsCallback(uint16_t usStartAddr, uint16_t usNum, const uint8_t *pucBitsOfDiscreteInputsState, uint16_t usLen)
{
uint8_t ucLoops = (usNum - 1) / 8 + 1;
uint8_t ucState, ucBits;
printf(" Read %d discrete inputs starting at start address %d: ", usNum, usStartAddr);
while (ucLoops != 0)
{
ucState = *pucBitsOfDiscreteInputsState++;
ucBits = 0;
while (usNum != 0 && ucBits < 8)
{
printf("%d ", ucState & 0X01 ? 1 : 0);
ucState >>= 1;
usNum--;
ucBits++;
}
ucLoops--;
}
printf("\r\n");
}
static void readHoldingRegistersCallback(uint16_t usStartAddr, uint16_t usNum, const uint8_t *pusHoldingRegistersVal, uint8_t usLen)
{
uint8_t val[4] = {0};
// printf(" Read %d hold registers starting at start address %d: ", usNum, usStartAddr);
while (usLen--)
{
val[usLen] = *pusHoldingRegistersVal++;
printf("%02X ", val[usLen]);
}
printf("\r\n");
}
static void readInputRegistersCallback(uint16_t usStartAddr, uint16_t usNum, const uint16_t *pusInputRegistersVal, uint16_t usLen)
{
uint16_t val;
printf(" Read %d input registers starting at start address %d: ", usNum, usStartAddr);
while (usLen--)
{
val = *pusInputRegistersVal++;
val = ((val & 0X00FF) << 8) | ((val & 0XFF00) >> 8); // 转换大小端
printf("%04X ", val);
}
printf("\r\n");
}
MBRTUMaterTypeDef MBRTUHandle =
{
.delayms = delayms,
.timerStart = timerStart,
.timerStop = timerStop,
.sendData = sendData,
.sendDataLog = sendDataLog,
.readCoilsCallback = readCoilsCallback,
.readDiscreteInputsCallback = readDiscreteInputsCallback,
.readHoldingRegistersCallback = readHoldingRegistersCallback,
.readInputRegistersCallback = readInputRegistersCallback,
#ifdef USE_RTOS // 使用了RTOS那么需要实现互斥
.lock = mutex_lock,
.unlock = mutex_unlock,
#endif
};
接受数据的时候只需要在串口回调中调用如下代码即可
uint8_t RS485P[1];
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
while(HAL_UART_Receive_IT(&huart2, (uint8_t *)&RS485P, 1)!=HAL_OK);
MBRTUMasterRecvByteISRCallback(&MBRTUHandle,RS485P[0]);
}
2758
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
