学习modbus移植串口无法接收数据。

micheal0o0 · 发表于 2020-9-9 11:30:30

打算移植一个modbus协议https://gitee.com/qq1847123212/ModBus-Master 这个是别人用arduino 上移植过来的https://github.com/4-20ma/ModbusMaster 在AVR上用过发现不错。现在移植出了问题。就是接收函数返回超时。参考hal库写了一个也不可以。调试发现无法接受完整数据。大神赐教思路https://www.firebbs.cn/forum.php?mod=attachment&aid=MjgxNTN8YzU4MjNjNzI1Nzg5ZmI1ZmFmYzM2M2RhMmVmZGU4MmV8MTczMjM4OTYwOA%3D%3D&request=yes&_f=.zipattach://28153.zip

STM32F103 modbus.zip (449.24 KB, 下载次数: 29)

ba_wang_mao · 发表于 2020-9-9 22:07:40

FreeRTOS和FreeMODBUS移植到STM32F103傻瓜教程（Keil5）.pdf

https://download.csdn.net/download/ba_wang_mao/12054217

ba_wang_mao · 发表于 2020-9-9 22:16:09

喔！你要的是MODBUS 主站

micheal0o0 · 发表于 2020-9-10 11:04:58

ba_wang_mao 发表于 2020-9-9 22:16
喔！你要的是MODBUS 主站

谢谢，freertos我也会移植，就是modbus master搞来搞去还没有调出来。如果小芯片用上rtos 简直噩梦，所以想搞个无RTOS的modbus master

ba_wang_mao · 发表于 2020-9-10 11:50:55

搞MODBUS MASTER我一般使用队列+状态机实现，效果非常不错

ba_wang_mao · 发表于 2020-9-10 11:51:48

本帖最后由 ba_wang_mao 于 2020-9-10 11:54 编辑

#ifndef __MODBUS_HOSTS_RTU__H
#define __MODBUS_HOSTS_RTU__H
#include "stm32f4xx.h"
#define MODBUS_HOSTS_FUNC_ReadCoil (0x01)
#define MODBUS_HOSTS_FUNC_ReadDiscrete (0x02)
#define MODBUS_HOSTS_FUNC_ReadHoldingRegisters (0x03)
#define MODBUS_HOSTS_FUNC_ReadInputRegisters (0x04)
#define MODBUS_HOSTS_FUNC_ForceSingleCoil (0x05)
#define MODBUS_HOSTS_FUNC_PresetSingleHoldingRegister (0x06)
#define MODBUS_HOSTS_FUNC_ForceMultipleCoil (0x0F)
#define MODBUS_HOSTS_FUNC_PresetMultipleHoldingRegisters (0x10)
//MODBUS主站最大传输254字节，当波特率=115200时，1秒钟最大能够传输11520字节，则50毫秒能传输576字节
//30毫秒能传输345字节，25毫秒能传输288字节，20毫秒能传输234字节
#define MODBUS_HOSTS_POLL_TIME (8)
#define MBHOSTS_MAX_REPEAT_SEND_COUNT (5)
enum MODBUS_HOSTS_STATUS
{
enum_MODBUS_STATUS_READY ,
enum_MODBUS_STATUS_SEND_BEGIN ,
enum_MODBUS_STATUS_SEND_BEGINING ,
enum_MODBUS_STATUS_SEND_OVER ,
enum_MODBUS_STATUS_RECV_OVER ,
enum_MODBUS_STATUS_RECV_ERROR ,
enum_MODBUS_STATUS_TIME_OUT ,
enum_MODBUS_STATUS_DELAY_TO_SEND_BEGIN ,
enum_MODBUS_STATUS_DELAY_TO_READY ,
};
<blockquote>void MBCOM1_MBHosts_Init(void);

复制代码

#endif // MODBUS_HOSTS_RTU_H

micheal0o0 · 发表于 2020-9-10 13:50:40

ba_wang_mao 发表于 2020-9-10 11:51
#endif // MODBUS_HOSTS_RTU_H

我自己写有bug，而且占用空间比较大

ba_wang_mao · 发表于 2020-9-10 15:53:15

1.modbus_queue.h

#ifndef MODBUS_QUEUE_H
#define MODBUS_QUEUE_H
#include "stm32f4xx.h"
#define MODBUS_HOSTS_QUEUE_LEN (20)
#define MODBUS_HOSTS_QUEUE_ELEMEMT_LEN (255)
typedef struct TagMODBUS_HOSTS_QUEUE
{
uint8_t DeviceAddr;
uint8_t Func;
uint8_t CodeFunc;
uint8_t StartAddr;
uint8_t RegisterAmount;
uint8_t ByteCount;
uint8_t SendByteCount;
int8_t RepeatCount;
uint8_t Data[MODBUS_HOSTS_QUEUE_ELEMEMT_LEN];
} MODBUS_HOSTS_QUEUE;
void MBHosts_Queue_Cls(void);
void MBHosts_Queue_Init(void);
uint8_t MBHosts_Queue_Empty(void);
uint8_t MBHosts_Queue_Full(void);
uint8_t MBHosts_In_Queue( MODBUS_HOSTS_QUEUE Queue);
uint8_t MBHosts_Out_Queue(MODBUS_HOSTS_QUEUE *Queue);
#endif // MODBUS_QUEUE_H

复制代码

ba_wang_mao · 发表于 2020-9-10 15:55:35

2、modbus_hosts.h

#ifndef MODBUS_HOSTS_RTU_H
#define MODBUS_HOSTS_RTU_H
#include "stm32f4xx.h"
#include "modbus_queue.h"
#define MODBUS_HOSTS_FUNC_ReadCoil (0x01)
#define MODBUS_HOSTS_FUNC_ReadDiscrete (0x02)
#define MODBUS_HOSTS_FUNC_ReadHoldingRegisters (0x03)
#define MODBUS_HOSTS_FUNC_ReadInputRegisters (0x04)
#define MODBUS_HOSTS_FUNC_ForceSingleCoil (0x05)
#define MODBUS_HOSTS_FUNC_PresetSingleHoldingRegister (0x06)
#define MODBUS_HOSTS_FUNC_ForceMultipleCoil (0x0F)
#define MODBUS_HOSTS_FUNC_PresetMultipleHoldingRegisters (0x10)
#define MODBUS_HOSTS_POLL_TIME (20)
enum MODBUS_HOSTS_STATUS
{
enum_MODBUS_STATUS_READY ,
enum_MODBUS_STATUS_SEND_BEGIN ,
enum_MODBUS_STATUS_SEND_BEGINING ,
enum_MODBUS_STATUS_SEND_OVER ,
enum_MODBUS_STATUS_RECV_OVER ,
enum_MODBUS_STATUS_RECV_ERROR ,
enum_MODBUS_STATUS_TIME_OUT ,
enum_MODBUS_STATUS_DELAY_TO_SEND_BEGIN ,
enum_MODBUS_STATUS_DELAY_TO_READY ,
};
uint16_t CRC16(uint8_t *puchMsg, uint16_t usDataLen);
void MBHosts_Init(void);
void MBHosts_ReadCoilRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint16_t registerAmount , uint8_t RepeatCount , MODBUS_HOSTS_QUEUE *Queue);
void MBHosts_ReadDiscreteRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint16_t registerAmount , uint8_t RepeatCount , MODBUS_HOSTS_QUEUE *Queue);
void MBHosts_ReadInputRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint8_t registerAmount , uint8_t RepeatCount , MODBUS_HOSTS_QUEUE *Queue);
void MBHosts_ReadHoldingRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint8_t registerAmount , uint8_t RepeatCount , MODBUS_HOSTS_QUEUE *Queue);
void MBHosts_ForceSingleCoil(uint8_t DeviceAddr , uint16_t startAddr , uint16_t On_Off , uint8_t RepeatCount , MODBUS_HOSTS_QUEUE *Queue);
void MBHosts_PresetSingleHoldingRegister(uint8_t DeviceAddr , uint16_t startAddr , uint16_t Value , uint8_t RepeatCount , MODBUS_HOSTS_QUEUE *Queue);
void MBHosts_ForceMultipleCoil(uint8_t DeviceAddr , uint16_t startAddr , uint16_t registerAmount , uint8_t Data_Buffer[] , uint8_t RepeatCount , MODBUS_HOSTS_QUEUE *Queue);
void MBHosts_PresetMultipleHoldingRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint8_t registerAmount , int16_t Data_Buffer[] , uint8_t RepeatCount , uint8_t Func , MODBUS_HOSTS_QUEUE *Queue);
#endif // MODBUS_HOSTS_RTU_H

复制代码

ba_wang_mao · 发表于 2020-9-10 15:58:13

本帖最后由 ba_wang_mao 于 2020-9-12 15:13 编辑

3.modbus_hosts.c

#include "modbus_hosts.h"
const uint8_t auchCRCHi[] = {
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
};
const uint8_t auchCRCLo[] = {
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
};
uint16_t CRC16(uint8_t *puchMsg, uint16_t usDataLen)
{
uint8_t uchCRCHi = 0xFF;
uint8_t uchCRCLo = 0xFF;
uint32_t uIndex;
while (usDataLen--)
{
uIndex = uchCRCHi ^ *puchMsg++;
uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex];
uchCRCLo = auchCRCLo[uIndex];
}
return (uchCRCHi << 8 | uchCRCLo);
}
//void MBHosts_Init(void)
//{
// MBHosts_Queue_Init();
//}
void MBHosts_ReadCoilRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint16_t registerAmount , uint8_t RepeatCount , MODBUS_HOSTS_QUEUE *Queue)
{
uint8_t i;
uint8_t ByteCount;
uint16_t crcData;
for (i = 0; i < MODBUS_HOSTS_QUEUE_ELEMEMT_LEN ; i++)
Queue->Data[i] = 0x00;
Queue->Data[0] = DeviceAddr;
Queue->Data[1] = MODBUS_HOSTS_FUNC_ReadCoil;
Queue->Data[2] = startAddr >> 0x08;
Queue->Data[3] = startAddr & 0xFF;
Queue->Data[4] = registerAmount >> 0x08;
Queue->Data[5] = registerAmount & 0xFF;
crcData = CRC16(Queue->Data , 6);
Queue->Data[6] = crcData >> 0x08;
Queue->Data[7] = crcData & 0xFF;
ByteCount = registerAmount >> 0x03;
if (registerAmount & 0x07)
ByteCount++;
Queue->DeviceAddr = DeviceAddr;
Queue->Func = MODBUS_HOSTS_FUNC_ReadCoil;
Queue->StartAddr = startAddr;
Queue->RegisterAmount = registerAmount;
Queue->ByteCount = ByteCount;
Queue->SendByteCount = 0x08;
Queue->RepeatCount = RepeatCount;
}
void MBHosts_ReadDiscreteRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint16_t registerAmount , uint8_t RepeatCount , MODBUS_HOSTS_QUEUE *Queue)
{
uint8_t i;
uint8_t ByteCount;
uint16_t crcData;
for (i = 0; i < MODBUS_HOSTS_QUEUE_ELEMEMT_LEN ; i++)
Queue->Data[i] = 0x00;
Queue->Data[0] = DeviceAddr;
Queue->Data[1] = MODBUS_HOSTS_FUNC_ReadDiscrete;
Queue->Data[2] = startAddr >> 0x08;
Queue->Data[3] = startAddr & 0xFF;
Queue->Data[4] = registerAmount >> 0x08;
Queue->Data[5] = registerAmount & 0xFF;
crcData = CRC16(Queue->Data , 6);
Queue->Data[6] = crcData >> 0x08;
Queue->Data[7] = crcData & 0xFF;
ByteCount = registerAmount >> 0x03;
if (registerAmount & 0x07)
ByteCount++;
Queue->DeviceAddr = DeviceAddr;
Queue->Func = MODBUS_HOSTS_FUNC_ReadDiscrete;
Queue->StartAddr = startAddr;
Queue->RegisterAmount = registerAmount;
Queue->ByteCount = ByteCount;
Queue->SendByteCount = 0x08;
Queue->RepeatCount = RepeatCount;
}
void MBHosts_ReadInputRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint8_t registerAmount , uint8_t RepeatCount , MODBUS_HOSTS_QUEUE *Queue)
{
uint8_t i;
uint16_t crcData;
for (i = 0; i < MODBUS_HOSTS_QUEUE_ELEMEMT_LEN ; i++)
Queue->Data[i] = 0x00;
Queue->Data[0] = DeviceAddr;
Queue->Data[1] = MODBUS_HOSTS_FUNC_ReadInputRegisters;
Queue->Data[2] = startAddr >> 0x08;
Queue->Data[3] = startAddr & 0xFF;
Queue->Data[4] = registerAmount >> 0x08;
Queue->Data[5] = registerAmount & 0xFF;
crcData = CRC16(Queue->Data , 6);
Queue->Data[6] = crcData >> 0x08;
Queue->Data[7] = crcData & 0xFF;
Queue->DeviceAddr = DeviceAddr;
Queue->Func = MODBUS_HOSTS_FUNC_ReadInputRegisters;
Queue->StartAddr = startAddr;
Queue->RegisterAmount = registerAmount;
Queue->ByteCount = registerAmount << 0x01;
Queue->SendByteCount = 0x08;
Queue->RepeatCount = RepeatCount;
}
void MBHosts_ReadHoldingRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint8_t registerAmount , uint8_t RepeatCount , MODBUS_HOSTS_QUEUE *Queue)
{
uint8_t i;
uint16_t crcData;
for (i = 0; i < MODBUS_HOSTS_QUEUE_ELEMEMT_LEN ; i++)
Queue->Data[i] = 0x00;
Queue->Data[0] = DeviceAddr;
Queue->Data[1] = MODBUS_HOSTS_FUNC_ReadHoldingRegisters;
Queue->Data[2] = startAddr >> 0x08;
Queue->Data[3] = startAddr & 0xFF;
Queue->Data[4] = registerAmount >> 0x08;
Queue->Data[5] = registerAmount & 0xFF;
crcData = CRC16(Queue->Data , 6);
Queue->Data[6] = crcData >> 0x08;
Queue->Data[7] = crcData & 0xFF;
Queue->DeviceAddr = DeviceAddr;
Queue->Func = MODBUS_HOSTS_FUNC_ReadHoldingRegisters;
Queue->StartAddr = startAddr;
Queue->RegisterAmount = registerAmount;
Queue->ByteCount = registerAmount << 0x01;
Queue->SendByteCount = 0x08;
Queue->RepeatCount = RepeatCount;
//In_Queue(*Queue);
}
void MBHosts_ForceSingleCoil(uint8_t DeviceAddr , uint16_t startAddr , uint16_t On_Off , uint8_t RepeatCount , MODBUS_HOSTS_QUEUE *Queue)
{
uint8_t i;
uint16_t crcData;
for (i = 0; i < MODBUS_HOSTS_QUEUE_ELEMEMT_LEN ; i++)
Queue->Data[i] = 0x00;
Queue->Data[0] = DeviceAddr;
Queue->Data[1] = MODBUS_HOSTS_FUNC_ForceSingleCoil;
Queue->Data[2] = startAddr >> 0x08;
Queue->Data[3] = startAddr & 0xFF;
if (On_Off)
Queue->Data[4] = 0xFF; // (4,5) = 0x0000/0xFF00
else
Queue->Data[4] = 0x00; // (4,5) = 0x0000/0xFF00
Queue->Data[5] = 0x00;
crcData = CRC16(Queue->Data , 6);
Queue->Data[6] = crcData >> 0x08;
Queue->Data[7] = crcData & 0xFF;
Queue->DeviceAddr = DeviceAddr;
Queue->Func = MODBUS_HOSTS_FUNC_ForceSingleCoil;
Queue->StartAddr = startAddr;
Queue->RegisterAmount = 1; // 无意义
Queue->ByteCount = Queue->RegisterAmount << 0x01; // 无意义
Queue->SendByteCount = 0x08;
Queue->RepeatCount = RepeatCount;
//In_Queue(*Queue);
}
void MBHosts_PresetSingleHoldingRegister(uint8_t DeviceAddr , uint16_t startAddr , uint16_t Value , uint8_t RepeatCount , MODBUS_HOSTS_QUEUE *Queue)
{
uint8_t i;
uint16_t crcData;
for (i = 0; i < MODBUS_HOSTS_QUEUE_ELEMEMT_LEN ; i++)
Queue->Data[i] = 0x00;
Queue->Data[0] = DeviceAddr;
Queue->Data[1] = MODBUS_HOSTS_FUNC_PresetSingleHoldingRegister;
Queue->Data[2] = startAddr >> 0x08;
Queue->Data[3] = startAddr & 0xFF;
Queue->Data[4] = Value >> 0x08;
Queue->Data[5] = Value & 0xFF;
crcData = CRC16(Queue->Data , 6);
Queue->Data[6] = crcData >> 0x08;
Queue->Data[7] = crcData & 0xFF;
Queue->DeviceAddr = DeviceAddr;
Queue->Func = MODBUS_HOSTS_FUNC_PresetSingleHoldingRegister;
Queue->StartAddr = startAddr;
Queue->RegisterAmount = 1;
Queue->ByteCount = Queue->RegisterAmount << 0x01;
Queue->SendByteCount = 0x08;
Queue->RepeatCount = RepeatCount;
//In_Queue(*Queue);
}
void MBHosts_ForceMultipleCoil(uint8_t DeviceAddr , uint16_t startAddr , uint16_t registerAmount , uint8_t Data_Buffer[] , uint8_t RepeatCount , MODBUS_HOSTS_QUEUE *Queue)
{
uint8_t i;
uint8_t j;
uint16_t k;
uint8_t ByteCount;
uint16_t crcData;
for (i = 0; i < MODBUS_HOSTS_QUEUE_ELEMEMT_LEN ; i++)
Queue->Data[i] = 0x00;
Queue->Data[0] = DeviceAddr;
Queue->Data[1] = MODBUS_HOSTS_FUNC_ForceMultipleCoil;
Queue->Data[2] = startAddr >> 0x08;
Queue->Data[3] = startAddr & 0xFF;
Queue->Data[4] = registerAmount >> 0x08;
Queue->Data[5] = registerAmount & 0xFF;
ByteCount = registerAmount >> 3;
if (registerAmount & 0x07)
ByteCount++;
Queue->Data[6] = ByteCount;
k = 0x00;
for (i = 0 ; i < ByteCount ; i++)
{
Queue->Data[i + 7] = 0x00;
for (j = 0 ; j < 8 ; j++ )
{
Queue->Data[i + 7] |= (Data_Buffer[k] << j);
k++;
if (k >= registerAmount)
break;
}
}
crcData = CRC16(Queue->Data , (ByteCount + 9) - 2);
Queue->Data[(ByteCount + 9) - 2] = crcData >> 0x08;
Queue->Data[(ByteCount + 9) - 1] = crcData & 0xFF;
Queue->DeviceAddr = DeviceAddr;
Queue->Func = MODBUS_HOSTS_FUNC_ForceMultipleCoil;
Queue->StartAddr = startAddr;
Queue->RegisterAmount = registerAmount;
Queue->ByteCount = ByteCount;
Queue->SendByteCount = ByteCount + 9;
Queue->RepeatCount = RepeatCount;
//In_Queue(*Queue);
}
void MBHosts_PresetMultipleHoldingRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint8_t registerAmount , int16_t Data_Buffer[] , uint8_t RepeatCount , uint8_t Func , MODBUS_HOSTS_QUEUE *Queue)
{
uint8_t i;
uint8_t k;
uint8_t ByteCount;
uint16_t crcData;
for (i = 0; i < MODBUS_HOSTS_QUEUE_ELEMEMT_LEN ; i++)
Queue->Data[i] = 0x00;
Queue->Data[0] = DeviceAddr;
Queue->Data[1] = MODBUS_HOSTS_FUNC_PresetMultipleHoldingRegisters;
Queue->Data[2] = startAddr >> 0x08;
Queue->Data[3] = startAddr & 0xFF;
Queue->Data[4] = registerAmount >> 0x08;
Queue->Data[5] = registerAmount & 0xFF;
ByteCount = registerAmount << 0x01;
Queue->Data[6] = ByteCount;
for (k = 0 ; k < ByteCount ; k++)
{
Queue->Data[7+2*k] = Data_Buffer[k] >> 0x08;
Queue->Data[7+2*k+1] = Data_Buffer[k] & 0xFF;
}
crcData = CRC16(Queue->Data , (ByteCount + 9) - 2);
Queue->Data[(ByteCount + 9) - 2] = crcData >> 0x08;
Queue->Data[(ByteCount + 9) - 1] = crcData & 0xFF;
Queue->DeviceAddr = DeviceAddr;
Queue->Func = MODBUS_HOSTS_FUNC_PresetMultipleHoldingRegisters;
Queue->CodeFunc = Func;
Queue->StartAddr = startAddr;
Queue->RegisterAmount = registerAmount;
Queue->ByteCount = ByteCount;
Queue->SendByteCount = ByteCount + 9;
Queue->RepeatCount = RepeatCount;
//In_Queue(*Queue);
}

复制代码

ba_wang_mao · 发表于 2020-9-10 16:02:03

4.modbus_queue.c

#include "modbus_queue.h"
uint16_t MBHosts_front = 0x00;
uint16_t MBHosts_rear = 0x00;
MODBUS_HOSTS_QUEUE MBHosts_Element[MODBUS_HOSTS_QUEUE_LEN];
void MBHosts_Queue_Cls(void)
{
MBHosts_front = 0x00;
MBHosts_rear = 0x00;
}
void MBHosts_Queue_Init(void)
{
uint16_t i;
MBHosts_Queue_Cls();
for (i = 0; i < MODBUS_HOSTS_QUEUE_LEN; i++)
{
MBHosts_Element[i].DeviceAddr = 0x00;
MBHosts_Element[i].Func = 0x00;
MBHosts_Element[i].CodeFunc = 0x00;//自己定义的内部编码
MBHosts_Element[i].StartAddr = 0x00;
MBHosts_Element[i].RegisterAmount = 0x00;
MBHosts_Element[i].ByteCount = 0x00;
MBHosts_Element[i].SendByteCount = 0x00;
MBHosts_Element[i].RepeatCount = 0x00;
memset(MBHosts_Element[i].Data , 0x00 , MODBUS_HOSTS_QUEUE_ELEMEMT_LEN);
}
}
BOOL MBHosts_Queue_Empty(void)
{
return (MBHosts_rear == MBHosts_front);
}
BOOL MBHosts_Queue_Full(void)
{
return ((MBHosts_rear + 1) % MODBUS_HOSTS_QUEUE_LEN == MBHosts_front);
}
BOOL MBHosts_In_Queue( MODBUS_HOSTS_QUEUE Queue)
{
if (!MBHosts_Queue_Full())
{
MBHosts_rear = (MBHosts_rear + 1) % MODBUS_HOSTS_QUEUE_LEN;
MBHosts_Element[MBHosts_rear].DeviceAddr = Queue.DeviceAddr;
MBHosts_Element[MBHosts_rear].Func = Queue.Func;
MBHosts_Element[MBHosts_rear].CodeFunc = Queue.CodeFunc;
MBHosts_Element[MBHosts_rear].StartAddr = Queue.StartAddr;
MBHosts_Element[MBHosts_rear].RegisterAmount = Queue.RegisterAmount;
MBHosts_Element[MBHosts_rear].ByteCount = Queue.ByteCount;
MBHosts_Element[MBHosts_rear].SendByteCount = Queue.SendByteCount;
MBHosts_Element[MBHosts_rear].RepeatCount = Queue.RepeatCount;
memcpy(MBHosts_Element[MBHosts_rear].Data , Queue.Data , MODBUS_HOSTS_QUEUE_ELEMEMT_LEN);
return (TRUE);
}
return (FALSE);
}
BOOL MBHosts_Out_Queue(MODBUS_HOSTS_QUEUE *Queue)
{
if (!MBHosts_Queue_Empty())
{
MBHosts_front = (MBHosts_front + 1) % MODBUS_HOSTS_QUEUE_LEN;
Queue->DeviceAddr = MBHosts_Element[MBHosts_front].DeviceAddr;
Queue->Func = MBHosts_Element[MBHosts_front].Func;
Queue->CodeFunc = MBHosts_Element[MBHosts_front].CodeFunc;
Queue->StartAddr = MBHosts_Element[MBHosts_front].StartAddr;
Queue->RegisterAmount = MBHosts_Element[MBHosts_front].RegisterAmount;
Queue->ByteCount = MBHosts_Element[MBHosts_front].ByteCount;
Queue->SendByteCount = MBHosts_Element[MBHosts_front].SendByteCount;
Queue->RepeatCount = MBHosts_Element[MBHosts_front].RepeatCount;
memcpy(Queue->Data , MBHosts_Element[MBHosts_front].Data , MODBUS_HOSTS_QUEUE_ELEMEMT_LEN);
return (TRUE);
}
return (FALSE);
}

复制代码

micheal0o0 · 发表于 2020-9-10 17:54:44

向大神学习

ba_wang_mao · 发表于 2020-9-10 20:39:24

本帖最后由 ba_wang_mao 于 2020-9-10 20:40 编辑

5、串口缓冲区结构体

typedef struct
{
BOOL volatile Outtime_mark;
uint8_t volatile MBHosts_Query_isr;
uint16_t volatile MBHosts_Poll_Time;
uint16_t volatile sendCount;
uint16_t volatile sendPosi;
uint16_t volatile receCount;
uint8_t send_buffer[MSCOMM_BUFFER_LENGTH];
uint8_t mscomm_buffer[MSCOMM_BUFFER_LENGTH];
} USART_DataType;

复制代码

ba_wang_mao · 发表于 2020-9-10 20:42:14

6、定时器T1用做主站超时定时器（主站一条报文发送出去后，不能无限制等待，必须在规定的时间内等待人机应答；如果从机没有在规定的时间应答，则认为超时）

USART_DataType MB_USART2;
//1000ms=11520byte , 100ms = 1152byte , 35ms = 403byte
void TIM1_Configuration(void)
{
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1,ENABLE);
TIM_DeInit(TIM1);
TIM_InternalClockConfig(TIM1);
TIM_TimeBaseStructure.TIM_Period = 10000 - 1;
TIM_TimeBaseStructure.TIM_Prescaler = 588;//（168=10ms，84=5ms，504=30ms，588=35ms,839=50ms,1679=100ms）
TIM_TimeBaseStructure.TIM_ClockDivision=TIM_CKD_DIV1;
TIM_TimeBaseStructure.TIM_CounterMode=TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);
TIM_ClearFlag(TIM1, TIM_FLAG_Update);
TIM_ITConfig(TIM1,TIM_IT_Update,ENABLE);
TIM_Cmd(TIM1, DISABLE);
}
void TIM1_UP_TIM10_IRQHandler(void)
{
if (TIM_GetITStatus(TIM1,TIM_IT_Update) != RESET)
{
TIM_ClearITPendingBit(TIM1,TIM_IT_Update);
TIM_Cmd(TIM1, DISABLE);
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_TIME_OUT; //超时
}
}

复制代码

ba_wang_mao · 发表于 2020-9-10 20:44:27

7、串口+DMA接收MODBUS从机报文

void USART2_IRQHandler(void)
{
int16_t ch;
if (USART_GetITStatus(USART2,USART_IT_IDLE) != RESET)
{
USART_ClearITPendingBit(USART2 , USART_IT_IDLE); //必须先清除总线空闲中断标识，然后读一下数据寄存器，DMA接收才会正确（先读SR，然后读DR才能清除空闲中断标识）注意：这句必须要，否则不能够清除中断标志位。
ch = USART_ReceiveData(USART2);
DMA_Cmd(DMA1_Stream5 , DISABLE); //关闭DMA,防止处理其间有数据
DMA_ClearFlag(DMA1_Stream5 , DMA_FLAG_TCIF5 | DMA_FLAG_FEIF5 | DMA_FLAG_DMEIF5 | DMA_FLAG_TEIF5 | DMA_FLAG_HTIF5);//清零标志位
ch = USART2_DMA_RX_BUFFER_MAX_LENGTH - DMA_GetCurrDataCounter(DMA1_Stream5);
if (ch > 0)
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
{
MB_USART2.Outtime_mark = TRUE;
MB_USART2.receCount = ch;
memcpy(MB_USART2.mscomm_buffer , USART2_DMA_RX_Buffer , MB_USART2.receCount);
}
}
DMA_SetCurrDataCounter(DMA1_Stream5 , USART2_DMA_RX_BUFFER_MAX_LENGTH);
DMA_Cmd(DMA1_Stream5, ENABLE);
}
else if (USART_GetITStatus(USART2,USART_IT_TC)!= RESET)
{
USART_ClearITPendingBit(USART2, USART_IT_TC);
DMA_ClearFlag(DMA1_Stream6 , DMA_FLAG_TCIF6 | DMA_FLAG_FEIF6 | DMA_FLAG_DMEIF6 | DMA_FLAG_TEIF6 | DMA_FLAG_HTIF6);
DMA_SetCurrDataCounter(DMA1_Stream6 , 0); //清除数据长度
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_BEGINING)
{
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_SEND_OVER;
TIM_Cmd(TIM1, DISABLE);
TIM_SetCounter(TIM1, 0x00);
TIM_Cmd(TIM1, ENABLE);
}
GPIO_USART2_RS485_RECIVE_enable();
}
}

复制代码

ba_wang_mao · 发表于 2020-9-10 20:46:24

8. STM32F407 DMA程序

uint8_t USART1_DMA_RX_Buffer[USART1_DMA_RX_BUFFER_MAX_LENGTH];
uint8_t USART1_DMA_TX_Buffer[USART1_DMA_TX_BUFFER_MAX_LENGTH];
uint8_t USART2_DMA_RX_Buffer[USART2_DMA_RX_BUFFER_MAX_LENGTH];
uint8_t USART2_DMA_TX_Buffer[USART2_DMA_TX_BUFFER_MAX_LENGTH];
uint8_t USART3_DMA_RX_Buffer[USART3_DMA_RX_BUFFER_MAX_LENGTH];
uint8_t USART3_DMA_TX_Buffer[USART3_DMA_TX_BUFFER_MAX_LENGTH];
uint8_t UART4_DMA_RX_Buffer[UART4_DMA_RX_BUFFER_MAX_LENGTH];
uint8_t UART4_DMA_TX_Buffer[UART4_DMA_TX_BUFFER_MAX_LENGTH];
uint8_t UART5_DMA_RX_Buffer[UART5_DMA_RX_BUFFER_MAX_LENGTH];
uint8_t UART5_DMA_TX_Buffer[UART5_DMA_TX_BUFFER_MAX_LENGTH];
uint8_t USART6_DMA_RX_Buffer[USART6_DMA_RX_BUFFER_MAX_LENGTH];
uint8_t USART6_DMA_TX_Buffer[USART6_DMA_TX_BUFFER_MAX_LENGTH];
//DMA是高速传输模式，一般是ns级的速度，485是慢速传输，一般是ms级最多是us级的传输
void USART1_DMA_Tx_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2 , ENABLE); //DMA2时钟使能
DMA_DeInit(DMA2_Stream7);
while (DMA_GetCmdStatus(DMA2_Stream7) != DISABLE); //等待DMA可配置
DMA_InitStructure.DMA_Channel = DMA_Channel_4; //DMA通道配置
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART1->DR; //DMA外设地址
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)USART1_DMA_TX_Buffer; //发送缓存指针
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral; //DMA传输方向：内存--->外设
DMA_InitStructure.DMA_BufferSize = USART1_DMA_TX_BUFFER_MAX_LENGTH; //数据传输字节数量
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //外设非增量模式
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //存储器增量模式
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //外设数据长度:8位
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; //存储器数据长度:8位
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; //使用普通模式
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium; //中等优先级 DMA_Priority_High
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; //存储器突发单次传输
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; //外设突发单次传输
DMA_Init(DMA2_Stream7, &DMA_InitStructure); //初始化DMA Stream
DMA_Cmd(DMA2_Stream7, DISABLE); //开启DMA传输
}
void USART1_DMA_Rx_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2 , ENABLE); //DMA2时钟使能
DMA_DeInit(DMA2_Stream5);
while (DMA_GetCmdStatus(DMA2_Stream5) != DISABLE); //等待DMA可配置
DMA_InitStructure.DMA_Channel = DMA_Channel_4; //通道选择
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART1->DR; //DMA外设地址
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)USART1_DMA_RX_Buffer; //接收缓存指针
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory ; //DMA传输方向：外设到存储器模式：外设--->内存
DMA_InitStructure.DMA_BufferSize = USART1_DMA_RX_BUFFER_MAX_LENGTH; //缓冲大小
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //外设非增量模式
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //存储器增量模式
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //外设数据长度:8位
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; //存储器数据长度:8位
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; //使用普通模式
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium; //中等优先级 DMA_Priority_VeryHigh
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; //存储器突发单次传输
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; //外设突发单次传输
DMA_Init(DMA2_Stream5 , &DMA_InitStructure); //初始化DMA_Stream5
DMA_Cmd(DMA2_Stream5, ENABLE); //开启DMA传输
}
void USART2_DMA_Tx_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1 , ENABLE); //DMA1时钟使能
DMA_DeInit(DMA1_Stream6);
while (DMA_GetCmdStatus(DMA1_Stream6) != DISABLE); //等待DMA可配置
DMA_InitStructure.DMA_Channel = DMA_Channel_4; //DMA通道配置
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART2->DR; //DMA外设地址
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)USART2_DMA_TX_Buffer; //发送缓存指针
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral; //DMA传输方向：内存--->外设
DMA_InitStructure.DMA_BufferSize = USART2_DMA_TX_BUFFER_MAX_LENGTH; //数据传输字节数量
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //外设非增量模式
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //存储器增量模式
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //外设数据长度:8位
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; //存储器数据长度:8位
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; //使用普通模式
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium; //中等优先级 DMA_Priority_High
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; //存储器突发单次传输
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; //外设突发单次传输
DMA_Init(DMA1_Stream6, &DMA_InitStructure); //初始化DMA Stream
DMA_Cmd(DMA1_Stream6, DISABLE); //开启DMA传输
}
void USART2_DMA_Rx_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1 , ENABLE); //DMA1时钟使能
DMA_DeInit(DMA1_Stream5);
while (DMA_GetCmdStatus(DMA1_Stream5) != DISABLE); //等待DMA可配置
DMA_InitStructure.DMA_Channel = DMA_Channel_4; //通道选择
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART2->DR; //DMA外设地址
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)USART2_DMA_RX_Buffer; //接收缓存指针
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory ; //DMA传输方向：外设到存储器模式：外设--->内存
DMA_InitStructure.DMA_BufferSize = USART2_DMA_RX_BUFFER_MAX_LENGTH; //缓冲大小
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //外设非增量模式
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //存储器增量模式
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //外设数据长度:8位
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; //存储器数据长度:8位
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; //使用普通模式
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium; //中等优先级 DMA_Priority_VeryHigh
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; //存储器突发单次传输
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; //外设突发单次传输
DMA_Init(DMA1_Stream5 , &DMA_InitStructure); //初始化DMA_Stream
DMA_Cmd(DMA1_Stream5, ENABLE); //开启DMA传输
}
void USART3_DMA_Tx_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1 , ENABLE); //DMA2时钟使能
DMA_DeInit(DMA1_Stream3);
while (DMA_GetCmdStatus(DMA1_Stream3) != DISABLE); //等待DMA可配置
DMA_InitStructure.DMA_Channel = DMA_Channel_4; //DMA通道配置
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART3->DR; //DMA外设地址
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)USART3_DMA_TX_Buffer; //发送缓存指针
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral; //DMA传输方向：内存--->外设
DMA_InitStructure.DMA_BufferSize = USART3_DMA_TX_BUFFER_MAX_LENGTH; //数据传输字节数量
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //外设非增量模式
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //存储器增量模式
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //外设数据长度:8位
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; //存储器数据长度:8位
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; //使用普通模式
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium; //中等优先级 DMA_Priority_High
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; //存储器突发单次传输
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; //外设突发单次传输
DMA_Init(DMA1_Stream3, &DMA_InitStructure); //初始化DMA Stream
DMA_Cmd(DMA1_Stream3, DISABLE); //开启DMA传输
}
void USART3_DMA_Rx_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1 , ENABLE); //DMA2时钟使能
DMA_DeInit(DMA1_Stream1);
while (DMA_GetCmdStatus(DMA1_Stream1) != DISABLE); //等待DMA可配置
DMA_InitStructure.DMA_Channel = DMA_Channel_4; //通道选择
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART3->DR; //DMA外设地址
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)USART3_DMA_RX_Buffer; //接收缓存指针
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory ; //DMA传输方向：外设到存储器模式：外设--->内存
DMA_InitStructure.DMA_BufferSize = USART3_DMA_RX_BUFFER_MAX_LENGTH; //缓冲大小
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //外设非增量模式
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //存储器增量模式
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //外设数据长度:8位
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; //存储器数据长度:8位
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; //使用普通模式
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium; //中等优先级 DMA_Priority_VeryHigh
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; //存储器突发单次传输
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; //外设突发单次传输
DMA_Init(DMA1_Stream1 , &DMA_InitStructure); //初始化DMA_Stream
DMA_Cmd(DMA1_Stream1, ENABLE); //开启DMA传输
}
void UART4_DMA_Tx_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1 , ENABLE); //DMA1时钟使能
DMA_DeInit(DMA1_Stream4);
while (DMA_GetCmdStatus(DMA1_Stream4) != DISABLE); //等待DMA可配置
DMA_InitStructure.DMA_Channel = DMA_Channel_4; //DMA通道配置
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&UART4->DR; //DMA外设地址
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)UART4_DMA_TX_Buffer; //发送缓存指针
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral; //DMA传输方向：内存--->外设
DMA_InitStructure.DMA_BufferSize = UART4_DMA_TX_BUFFER_MAX_LENGTH; //数据传输字节数量
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //外设非增量模式
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //存储器增量模式
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //外设数据长度:8位
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; //存储器数据长度:8位
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; //使用普通模式
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium; //中等优先级 DMA_Priority_High
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; //存储器突发单次传输
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; //外设突发单次传输
DMA_Init(DMA1_Stream4, &DMA_InitStructure); //初始化DMA Stream
DMA_Cmd(DMA1_Stream4, DISABLE); //开启DMA传输
}
void UART4_DMA_Rx_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1 , ENABLE); //DMA1时钟使能
DMA_DeInit(DMA1_Stream2);
while (DMA_GetCmdStatus(DMA1_Stream2) != DISABLE); //等待DMA可配置
DMA_InitStructure.DMA_Channel = DMA_Channel_4; //通道选择
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&UART4->DR; //DMA外设地址
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)UART4_DMA_RX_Buffer; //接收缓存指针
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory ; //DMA传输方向：外设到存储器模式：外设--->内存
DMA_InitStructure.DMA_BufferSize = UART4_DMA_RX_BUFFER_MAX_LENGTH; //缓冲大小
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //外设非增量模式
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //存储器增量模式
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //外设数据长度:8位
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; //存储器数据长度:8位
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; //使用普通模式
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium; //中等优先级 DMA_Priority_VeryHigh
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; //存储器突发单次传输
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; //外设突发单次传输
DMA_Init(DMA1_Stream2 , &DMA_InitStructure); //初始化DMA_Stream
DMA_Cmd(DMA1_Stream2, ENABLE); //开启DMA传输
}
void UART5_DMA_Tx_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1 , ENABLE); //DMA1时钟使能
DMA_DeInit(DMA1_Stream7);
while (DMA_GetCmdStatus(DMA1_Stream7) != DISABLE); //等待DMA可配置
DMA_InitStructure.DMA_Channel = DMA_Channel_4; //DMA通道配置
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&UART5->DR; //DMA外设地址
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)UART5_DMA_TX_Buffer; //发送缓存指针
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral; //DMA传输方向：内存--->外设
DMA_InitStructure.DMA_BufferSize = UART5_DMA_TX_BUFFER_MAX_LENGTH; //数据传输字节数量
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //外设非增量模式
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //存储器增量模式
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //外设数据长度:8位
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; //存储器数据长度:8位
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; //使用普通模式
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium; //中等优先级 DMA_Priority_High
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; //存储器突发单次传输
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; //外设突发单次传输
DMA_Init(DMA1_Stream7, &DMA_InitStructure); //初始化DMA Stream
DMA_Cmd(DMA1_Stream7, DISABLE); //关闭DMA传输
}
void UART5_DMA_Rx_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1 , ENABLE); //DMA1时钟使能
DMA_DeInit(DMA1_Stream0);
while (DMA_GetCmdStatus(DMA1_Stream0) != DISABLE); //等待DMA可配置
DMA_InitStructure.DMA_Channel = DMA_Channel_4; //通道选择
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&UART5->DR; //DMA外设地址
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)UART5_DMA_RX_Buffer; //接收缓存指针
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory ; //DMA传输方向：外设到存储器模式：外设--->内存
DMA_InitStructure.DMA_BufferSize = UART5_DMA_RX_BUFFER_MAX_LENGTH; //缓冲大小
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //外设非增量模式
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //存储器增量模式
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //外设数据长度:8位
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; //存储器数据长度:8位
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; //使用普通模式
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium; //中等优先级 DMA_Priority_VeryHigh
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; //存储器突发单次传输
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; //外设突发单次传输
DMA_Init(DMA1_Stream0 , &DMA_InitStructure);
DMA_Cmd(DMA1_Stream0, ENABLE); //开启DMA传输
}
////////////////////////////////////////////////////////////////////////////////////////////
//是否可以这么认为，USART6如果DMA的TX使用DMA2_Stream6，则USART6如果DMA的RX必须使用DMA2_Stream1
// USART6如果DMA的TX使用DMA2_Stream7，则USART6如果DMA的RX必须使用DMA2_Stream2
////////////////////////////////////////////////////////////////////////////////////////////
void USART6_DMA_Tx_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2 , ENABLE); //DMA2时钟使能
DMA_DeInit(DMA2_Stream6);
while (DMA_GetCmdStatus(DMA2_Stream6) != DISABLE); //等待DMA可配置
DMA_InitStructure.DMA_Channel = DMA_Channel_5; //DMA通道配置
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART6->DR; //DMA外设地址
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)USART6_DMA_TX_Buffer; //发送缓存指针
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral; //DMA传输方向：内存--->外设
DMA_InitStructure.DMA_BufferSize = USART6_DMA_TX_BUFFER_MAX_LENGTH; //数据传输字节数量
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //外设非增量模式
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //存储器增量模式
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //外设数据长度:8位
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; //存储器数据长度:8位
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; //使用普通模式
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium; //中等优先级 DMA_Priority_High
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; //存储器突发单次传输
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; //外设突发单次传输
DMA_Init(DMA2_Stream6 , &DMA_InitStructure); //初始化DMA Stream
DMA_Cmd(DMA2_Stream6 , DISABLE); //开启DMA传输
}
void USART6_DMA_Rx_Configuration(void)
{
DMA_InitTypeDef DMA_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2 , ENABLE); //DMA2时钟使能
DMA_DeInit(DMA2_Stream1);
while (DMA_GetCmdStatus(DMA2_Stream1) != DISABLE); //等待DMA可配置
DMA_InitStructure.DMA_Channel = DMA_Channel_5; //通道选择
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART6->DR; //DMA外设地址
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)USART6_DMA_RX_Buffer; //接收缓存指针
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory ; //DMA传输方向：外设到存储器模式：外设--->内存
DMA_InitStructure.DMA_BufferSize = USART6_DMA_RX_BUFFER_MAX_LENGTH; //缓冲大小
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //外设非增量模式
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; //存储器增量模式
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; //外设数据长度:8位
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; //存储器数据长度:8位
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; //使用普通模式
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium; //中等优先级 DMA_Priority_VeryHigh
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single; //存储器突发单次传输
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single; //外设突发单次传输
DMA_Init(DMA2_Stream1 , &DMA_InitStructure); //初始化DMA_Stream5
DMA_Cmd(DMA2_Stream1 , ENABLE); //开启DMA传输
}
void USART1_DMA_Begin_Send(uint8_t *send_buffer , uint16_t nSendCount)
{
if (nSendCount < USART1_DMA_TX_BUFFER_MAX_LENGTH)
{
memcpy(USART1_DMA_TX_Buffer , send_buffer , nSendCount);
DMA_Cmd(DMA2_Stream7 , DISABLE); //关闭DMA传输
while (DMA_GetCmdStatus(DMA2_Stream7) != DISABLE); //确保DMA可以被设置
DMA_SetCurrDataCounter(DMA2_Stream7 , nSendCount); //数据传输量
DMA_Cmd(DMA2_Stream7 , ENABLE); //开启DMA传输
}
}
void USART2_DMA_Begin_Send(uint8_t *send_buffer , uint16_t nSendCount)
{
if (nSendCount < USART2_DMA_TX_BUFFER_MAX_LENGTH)
{
memcpy(USART2_DMA_TX_Buffer , send_buffer , nSendCount);
DMA_Cmd(DMA1_Stream6 , DISABLE); //关闭DMA传输
while (DMA_GetCmdStatus(DMA1_Stream6) != DISABLE); //确保DMA可以被设置
DMA_SetCurrDataCounter(DMA1_Stream6 , nSendCount); //数据传输量
DMA_Cmd(DMA1_Stream6 , ENABLE); //开启DMA传输
}
}
void USART3_DMA_Begin_Send(uint8_t *send_buffer , uint16_t nSendCount)
{
if (nSendCount < USART3_DMA_TX_BUFFER_MAX_LENGTH)
{
memcpy(USART3_DMA_TX_Buffer , send_buffer , nSendCount);
DMA_Cmd(DMA1_Stream3 , DISABLE); //关闭DMA传输
while (DMA_GetCmdStatus(DMA1_Stream3) != DISABLE); //确保DMA可以被设置
DMA_SetCurrDataCounter(DMA1_Stream3 , nSendCount); //数据传输量
DMA_Cmd(DMA1_Stream3 , ENABLE); //开启DMA传输
}
}
void UART4_DMA_Begin_Send(uint8_t *send_buffer , uint16_t nSendCount)
{
GPIO_UART4_RS485_SEND_enable();
if (nSendCount < UART4_DMA_TX_BUFFER_MAX_LENGTH)
{
memcpy(UART4_DMA_TX_Buffer , send_buffer , nSendCount);
DMA_Cmd(DMA1_Stream4 , DISABLE); //关闭DMA传输
while (DMA_GetCmdStatus(DMA1_Stream4) != DISABLE); //确保DMA可以被设置
DMA_SetCurrDataCounter(DMA1_Stream4 , nSendCount); //数据传输量
DMA_Cmd(DMA1_Stream4 , ENABLE); //开启DMA传输
}
}
void UART5_DMA_Begin_Send(uint8_t *send_buffer , uint16_t nSendCount)
{
if (nSendCount < UART5_DMA_TX_BUFFER_MAX_LENGTH)
{
memcpy(UART5_DMA_TX_Buffer , send_buffer , nSendCount);
DMA_Cmd(DMA1_Stream7 , DISABLE); //关闭DMA传输
while (DMA_GetCmdStatus(DMA1_Stream7) != DISABLE); //确保DMA可以被设置
DMA_SetCurrDataCounter(DMA1_Stream7 , nSendCount); //数据传输量
DMA_Cmd(DMA1_Stream7 , ENABLE); //开启DMA传输
}
}
void USART6_DMA_Begin_Send(uint8_t *send_buffer , uint16_t nSendCount)
{
if (nSendCount < USART6_DMA_TX_BUFFER_MAX_LENGTH)
{
memcpy(USART6_DMA_TX_Buffer , send_buffer , nSendCount);
DMA_Cmd(DMA2_Stream6 , DISABLE); //关闭DMA传输
while (DMA_GetCmdStatus(DMA2_Stream6) != DISABLE); //确保DMA可以被设置
DMA_SetCurrDataCounter(DMA2_Stream6 , nSendCount); //数据传输量
DMA_Cmd(DMA2_Stream6 , ENABLE); //开启DMA传输
}
}

复制代码

ba_wang_mao · 发表于 2020-9-10 20:48:14

9. 串口2+DMA配置初始化程序

void USART2_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2 , ENABLE); //for USART2, USART3, UART4 or UART5.
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_USART2);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource3, GPIO_AF_USART2);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
GPIO_Init(GPIOA, &GPIO_InitStructure);
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No ;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_Init(USART2, &USART_InitStructure);
USART_Cmd(USART2, ENABLE);
USART_ClearFlag(USART2, USART_FLAG_TC); //清除发送完成标志
while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET); //等待空闲帧发送完成后再清零发送完成标志（警告：如果不使能USART_Mode_Tx，会导致单片机在这里死机）
USART_ClearFlag(USART2, USART_FLAG_TC); //清除发送完成标志
USART_ITConfig(USART2, USART_IT_RXNE, DISABLE); //禁止USART1接收不为空中断
USART_ITConfig(USART2, USART_IT_TXE, DISABLE); //禁止USART1发送空中断
USART_ITConfig(USART2, USART_IT_IDLE, ENABLE); //开启USART1空闲中断
USART_ITConfig(USART2, USART_IT_TC, ENABLE); //开启USART1传输完成中断
USART_DMACmd(USART2 , USART_DMAReq_Tx,ENABLE); //使能串口的DMA发送
USART_DMACmd(USART2 , USART_DMAReq_Rx,ENABLE); //使能串口的DMA接收
}

复制代码

ba_wang_mao · 发表于 2020-9-10 20:50:23

9、串口2变量初始化和串口2启动发送

void MB_USART2_Init(void)
{
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_READY;
MB_USART2.MBHosts_Poll_Time = 0x00;
MB_USART2.Outtime_mark = FALSE;
MB_USART2.sendCount = 0x00;
MB_USART2.sendPosi = 0x00;
MB_USART2.receCount = 0x00;
memset(MB_USART2.send_buffer , 0x00 , MSCOMM_BUFFER_LENGTH);
memset(MB_USART2.mscomm_buffer , 0x00 , MSCOMM_BUFFER_LENGTH);
}
void USART2_Begin_Send(void)
{
GPIO_USART2_RS485_SEND_enable();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
__NOP();
USART2_DMA_Begin_Send(MB_USART2.send_buffer , MB_USART2.sendCount);
}

复制代码

ba_wang_mao · 发表于 2020-9-10 20:53:48

10. modbus主站解析从站

void MODBUS_Hosts_Analysize(void)
{
uint16_t i,j,k;
uint16_t startAddr;
uint16_t registerAmount;
uint16_t tempData;
uint16_t crcData;
if (MB_USART2.Outtime_mark)
{
MB_USART2.Outtime_mark = FALSE;
if (MB_USART2.receCount >= 5)
{
switch (MB_USART2.mscomm_buffer[1])
{
case MODBUS_HOSTS_FUNC_ReadCoil:
if (MB_USART2.mscomm_buffer[0] == USART2_MBHOSTS_Wait_Queue.DeviceAddr && MB_USART2.mscomm_buffer[1] == USART2_MBHOSTS_Wait_Queue.Func && MB_USART2.mscomm_buffer[2] == USART2_MBHOSTS_Wait_Queue.ByteCount)
{
tempData = MB_USART2.mscomm_buffer[2] + 5;
if (MB_USART2.receCount == tempData)
{
crcData = CRC16(MB_USART2.mscomm_buffer , tempData - 2);
if (crcData == (uint16_t)(MB_USART2.mscomm_buffer[tempData - 2] << 8) + (uint16_t)MB_USART2.mscomm_buffer[tempData - 1])
{
k = 0;
for (i = 0 ; i < USART2_MBHOSTS_Wait_Queue.ByteCount ; i++)
{
for (j = 0 ; j < 8 ; j++)
{
if (MB_USART2.mscomm_buffer[3+i] & (0x01 << j))
{
;//reg0x_buffer[k++] = 0x01;
}
else
{
;//reg0x_buffer[k++] = 0x00;
}
if (k >= USART2_MBHOSTS_Wait_Queue.RegisterAmount)
break;
}
}
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
}
else
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
}
}
}
break;
case MODBUS_HOSTS_FUNC_ReadDiscrete:
if (MB_USART2.mscomm_buffer[0] == USART2_MBHOSTS_Wait_Queue.DeviceAddr && MB_USART2.mscomm_buffer[1] == USART2_MBHOSTS_Wait_Queue.Func && MB_USART2.mscomm_buffer[2] == USART2_MBHOSTS_Wait_Queue.ByteCount)
{
tempData = MB_USART2.mscomm_buffer[2] + 5;
if (MB_USART2.receCount == tempData)
{
crcData = CRC16(MB_USART2.mscomm_buffer , tempData - 2);
if (crcData ==(((uint16_t)MB_USART2.mscomm_buffer[tempData - 2]) << 8) + (uint16_t)MB_USART2.mscomm_buffer[tempData - 1])
{
k = 0;
for (i = 0 ; i < USART2_MBHOSTS_Wait_Queue.ByteCount ; i++)
{
for (j = 0 ; j < 8 ; j++)
{
if (MB_USART2.mscomm_buffer[3+i] & (0x01 << j))
{
;//reg1x_buffer[k++] = 0x01;
}
else
{
;//reg1x_buffer[k++] = 0x00;
}
if (k >= USART2_MBHOSTS_Wait_Queue.RegisterAmount)
break;
}
}
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
}
else
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
}
}
}
break;
case MODBUS_HOSTS_FUNC_ReadHoldingRegisters:
if (MB_USART2.mscomm_buffer[0] == USART2_MBHOSTS_Wait_Queue.DeviceAddr && MB_USART2.mscomm_buffer[1] == USART2_MBHOSTS_Wait_Queue.Func && MB_USART2.mscomm_buffer[2] == USART2_MBHOSTS_Wait_Queue.ByteCount)
{
tempData = MB_USART2.mscomm_buffer[2] + 5;
if (MB_USART2.receCount == tempData)
{
crcData = CRC16(MB_USART2.mscomm_buffer , tempData - 2);
if (crcData ==(((uint16_t)MB_USART2.mscomm_buffer[tempData - 2]) << 8) + (uint16_t)MB_USART2.mscomm_buffer[tempData - 1])
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
}
else
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
}
}
}
break;
case MODBUS_HOSTS_FUNC_ReadInputRegisters:
if (MB_USART2.mscomm_buffer[0] == USART2_MBHOSTS_Wait_Queue.DeviceAddr && MB_USART2.mscomm_buffer[1] == USART2_MBHOSTS_Wait_Queue.Func && MB_USART2.mscomm_buffer[2] == USART2_MBHOSTS_Wait_Queue.ByteCount)
{
tempData = MB_USART2.mscomm_buffer[2] + 5;
if (MB_USART2.receCount == tempData)
{
crcData = CRC16(MB_USART2.mscomm_buffer , tempData - 2);
if (crcData ==(((uint16_t)MB_USART2.mscomm_buffer[tempData - 2]) << 8) + (uint16_t)MB_USART2.mscomm_buffer[tempData - 1])
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
}
else
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
}
}
}
break;
case MODBUS_HOSTS_FUNC_ForceSingleCoil:
if (MB_USART2.mscomm_buffer[0] == USART2_MBHOSTS_Wait_Queue.DeviceAddr && MB_USART2.mscomm_buffer[1] == USART2_MBHOSTS_Wait_Queue.Func)
{
startAddr = (uint16_t)(MB_USART2.mscomm_buffer[2] << 8) + (uint16_t)MB_USART2.mscomm_buffer[3];
if (MB_USART2.receCount == 8 && startAddr == USART2_MBHOSTS_Wait_Queue.StartAddr)
{
crcData = CRC16(MB_USART2.mscomm_buffer , 6);
if (crcData == (((uint16_t)MB_USART2.mscomm_buffer[6]) << 8) + (uint16_t)MB_USART2.mscomm_buffer[7])
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
}
else
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
}
}
}
break;
case MODBUS_HOSTS_FUNC_PresetSingleHoldingRegister:
if (MB_USART2.mscomm_buffer[0] == USART2_MBHOSTS_Wait_Queue.DeviceAddr && MB_USART2.mscomm_buffer[1] == USART2_MBHOSTS_Wait_Queue.Func)
{
startAddr = (uint16_t)(MB_USART2.mscomm_buffer[2] << 8) + (uint16_t)MB_USART2.mscomm_buffer[3];
if (MB_USART2.receCount == 8 && startAddr == USART2_MBHOSTS_Wait_Queue.StartAddr)
{
crcData = CRC16(MB_USART2.mscomm_buffer , 6);
if (crcData == (((uint16_t)MB_USART2.mscomm_buffer[6]) << 8) + (uint16_t)MB_USART2.mscomm_buffer[7])
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
#ifdef __DEBUG_stm32f407__
USART2_MODBUS_recv_count++;
#endif
}
else
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
}
}
}
break;
case MODBUS_HOSTS_FUNC_ForceMultipleCoil:
if (MB_USART2.mscomm_buffer[0] == USART2_MBHOSTS_Wait_Queue.DeviceAddr && MB_USART2.mscomm_buffer[1] == USART2_MBHOSTS_Wait_Queue.Func)
{
startAddr = (uint16_t)(MB_USART2.mscomm_buffer[2] << 8) + (uint16_t)MB_USART2.mscomm_buffer[3];
registerAmount = (uint16_t)(MB_USART2.mscomm_buffer[4] << 8) + (uint16_t)MB_USART2.mscomm_buffer[5];
if (MB_USART2.receCount == 8 && startAddr == USART2_MBHOSTS_Wait_Queue.StartAddr && registerAmount == USART2_MBHOSTS_Wait_Queue.RegisterAmount)
{
crcData = CRC16(MB_USART2.mscomm_buffer , 6);
if (crcData == (((uint16_t)MB_USART2.mscomm_buffer[6]) << 8) + (uint16_t)MB_USART2.mscomm_buffer[7])
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
#ifdef __DEBUG_stm32f407__
USART2_MODBUS_recv_count++;
#endif
}
else
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
}
}
}
break;
case MODBUS_HOSTS_FUNC_PresetMultipleHoldingRegisters:
if (MB_USART2.mscomm_buffer[0] == USART2_MBHOSTS_Wait_Queue.DeviceAddr && MB_USART2.mscomm_buffer[1] == USART2_MBHOSTS_Wait_Queue.Func)
{
startAddr = (uint16_t)(MB_USART2.mscomm_buffer[2] << 8) + (uint16_t)MB_USART2.mscomm_buffer[3];
registerAmount = (uint16_t)(MB_USART2.mscomm_buffer[4] << 8) + (uint16_t)MB_USART2.mscomm_buffer[5];
if (MB_USART2.receCount == 8 && startAddr == USART2_MBHOSTS_Wait_Queue.StartAddr && registerAmount == USART2_MBHOSTS_Wait_Queue.RegisterAmount)
{
crcData = CRC16(MB_USART2.mscomm_buffer , 6);
if (crcData == (((uint16_t)MB_USART2.mscomm_buffer[6]) << 8) + (uint16_t)MB_USART2.mscomm_buffer[7])
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
#ifdef __DEBUG_stm32f407__
USART2_MODBUS_recv_count++;
#endif
}
else
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
}
}
}
break;
case 0x81:
case 0x82:
case 0x83:
case 0x84:
case 0x85:
case 0x8F:
case 0x90:
if ((MB_USART2.mscomm_buffer[0] - 0x80) == USART2_MBHOSTS_Wait_Queue.DeviceAddr && MB_USART2.mscomm_buffer[1] == USART2_MBHOSTS_Wait_Queue.Func)
{
if (MB_USART2.receCount == 5)
{
crcData = CRC16(MB_USART2.mscomm_buffer , 3);
if (crcData == (((uint16_t)MB_USART2.mscomm_buffer[3]) << 8) + (uint16_t)MB_USART2.mscomm_buffer[4])
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
}
else
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
}
}
}
break;
default:
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
break;
}//switch (MB_USART2.mscomm_buffer[1])
//USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//DMA通信，则删除
}//if (MB_USART2.receCount >= 5)
else
{
if (MB_USART2.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
MB_USART2.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
}
}//if (MB_USART2.Outtime_mark)
}

复制代码

程序

ba_wang_mao · 发表于 2020-9-10 20:57:18

比较复杂呀！用了串口+DMA接收不定长报文，用了超时定时器T1，用了队列装载要发送的报文，用了状态机进行主站状态切换

micheal0o0 · 发表于 2020-9-12 10:30:18

ba_wang_mao 发表于 2020-9-10 20:57
比较复杂呀！用了串口+DMA接收不定长报文，用了超时定时器T1，用了队列装载要发送的报文，用了状态机进行主 ...

freemodbus 也是状态机不过你这么写优化起来就比freemodbus 简单了

账号		自动登录	找回密码
密码			注册

学习modbus移植串口无法接收数据。

主题推荐