Loading...
Searching...
No Matches
modbus_slave.c
Go to the documentation of this file.
/**
*******************************************************************************
* @file modbus_slave.c
* @brief Модуль для реализации слейв MODBUS.
*******************************************************************************
* @details
Файл содержит реализацию функций для работы Modbus в режиме слейва.
@section slave Функции и макросы
- MB_Slave_Response() — Ответ на запрос
- MB_Slave_Collect_Message() — Сбор сообщения в режиме слейва.
- MB_Slave_Parse_Message() — Парс сообщения в режиме слейва.
******************************************************************************/
#include "modbus.h"
#ifdef MODBUS_ENABLE_SLAVE
/**
* @brief Ответ на сообщение в режиме слейва.
* @param hmodbus Указатель на хендлер RS.
* @param modbus_msg Указатель на структуру сообщения.
* @return RS_RES Статус о результате ответа на комманду.
*/
RS_StatusTypeDef MB_Slave_Response(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg)
{
RS_StatusTypeDef MB_RES = 0;
hmodbus->f.MessageHandled = 0;
hmodbus->f.EchoResponse = 0;
RS_Reset_TX_Flags(hmodbus); // reset flag for correct transmit
MB_Diagnostics_BusMessageCnt();
if(hmodbus->ID == 0 || modbus_msg->MbAddr == 0)
{
MB_Diagnostics_SlaveNoResponseCnt(); // <-- Устройство не отвечает на широковещательные сообщения
hmodbus->RS_STATUS = RS_SKIP;
return RS_Handle_Receive_Start(hmodbus, modbus_msg);
}
MB_Diagnostics_SlaveMessageCnt();
if(modbus_msg->FuncCode < FC_ERR_VALUES_START)// if no errors after parsing
{
switch (modbus_msg->FuncCode)
{
// Read Coils
case FC_R_COILS:
hmodbus->f.MessageHandled = MB_Process_Read_Coils(hmodbus->pMessagePtr);
break;
// Read Hodling Registers
case FC_R_HOLD_REGS:
hmodbus->f.MessageHandled = MB_Process_Read_Hold_Regs(hmodbus->pMessagePtr);
break;
case FC_R_IN_REGS:
hmodbus->f.MessageHandled = MB_Process_Read_Input_Regs(hmodbus->pMessagePtr);
break;
// Write Single Coils
case FC_W_COIL:
hmodbus->f.MessageHandled = MB_Process_Write_Single_Coil(hmodbus->pMessagePtr);
if(hmodbus->f.MessageHandled)
{
hmodbus->f.DataUpdated = 1;
hmodbus->f.EchoResponse = 1;
hmodbus->RS_Message_Size -= 2; // echo response if write ok (minus 2 cause of two CRC bytes)
}
break;
case FC_W_HOLD_REG:
hmodbus->f.MessageHandled = MB_Process_Write_Single_Reg(hmodbus->pMessagePtr);
if(hmodbus->f.MessageHandled)
{
hmodbus->f.DataUpdated = 1;
hmodbus->f.EchoResponse = 1;
hmodbus->RS_Message_Size -= 2; // echo response if write ok (minus 2 cause of two CRC bytes)
}
break;
// Write Multiple Coils
case FC_W_COILS:
hmodbus->f.MessageHandled = MB_Process_Write_Miltuple_Coils(hmodbus->pMessagePtr);
if(hmodbus->f.MessageHandled)
{
hmodbus->f.DataUpdated = 1;
hmodbus->f.EchoResponse = 1;
hmodbus->RS_Message_Size = 6; // echo response if write ok (withous data bytes)
}
break;
// Write Multiple Registers
case FC_W_HOLD_REGS:
hmodbus->f.MessageHandled = MB_Process_Write_Miltuple_Regs(hmodbus->pMessagePtr);
if(hmodbus->f.MessageHandled)
{
hmodbus->f.DataUpdated = 1;
hmodbus->f.EchoResponse = 1;
hmodbus->RS_Message_Size = 6; // echo response if write ok (withous data bytes)
}
break;
case FC_R_DEVICE_ID:
hmodbus->f.MessageHandled = MB_Process_Read_Device_Identifications(hmodbus->pMessagePtr);
break;
// Добавить в switch-case после других case:
case FC_R_DIAGNOSTICS:
hmodbus->f.MessageHandled = MB_Process_Diagnostics(hmodbus->pMessagePtr);
break;
/* unknown func code */
default:
modbus_msg->Except_Code = 0x01; /* set exception code: illegal function */
}
// Проверяем режим устройства - если Listen Only, не обрабатываем команды
if (MB_GetDeviceMode() == MODBUS_LISTEN_ONLY_MODE)
{
MB_Diagnostics_SlaveNoResponseCnt();
hmodbus->RS_STATUS = RS_SKIP;
return RS_Handle_Receive_Start(hmodbus, modbus_msg);;
}
// Проверяем статус обработки запроса
if(hmodbus->f.MessageHandled == 0)
{
MB_Diagnostics_ExceptionErrorCnt();
TrackerCnt_Warn(hmodbus->rs_err);
modbus_msg->FuncCode |= FC_ERR_VALUES_START;
}
else
{
TrackerCnt_Ok(hmodbus->rs_err);
}
}
// if we need response - check that transmit isnt busy
if( RS_Is_TX_Busy(hmodbus) )
RS_Abort(hmodbus, ABORT_TX); // if tx busy - set it free
// Transmit right there, or sets (fDeferredResponse) to transmit response in main code
if(hmodbus->f.DeferredResponse == 0)
{
MB_RES = RS_Handle_Transmit_Start(hmodbus, modbus_msg);
}
else
{
RS_Handle_Receive_Start(hmodbus, modbus_msg);
hmodbus->f.DeferredResponse = 0;
}
hmodbus->RS_STATUS = MB_RES;
return MB_RES;
}
/**
* @brief Сбор сообщения в буфер UART в режиме слейв (фрейм слейва из msg -> uart).
* @param hmodbus Указатель на хендлер RS.
* @param modbus_msg Указатель на структуру сообщения.
* @param modbus_uart_buff Указатель на буффер UART.
* @return RS_RES Статус о результате заполнения буфера.
*/
RS_StatusTypeDef MB_Slave_Collect_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, uint8_t *modbus_uart_buff)
{
int ind = 0; // ind for modbus-uart buffer
if(hmodbus->f.EchoResponse && hmodbus->f.MessageHandled) // if echo response need
ind = hmodbus->RS_Message_Size;
else
{
//------INFO ABOUT DATA/MESSAGE------
#ifdef MODBUS_PROTOCOL_TCP
modbus_uart_buff[ind++] = modbus_msg->TransactionID >> 8;
modbus_uart_buff[ind++] = modbus_msg->TransactionID& 0xFF;
modbus_uart_buff[ind++] = modbus_msg->ProtocolID >> 8;
modbus_uart_buff[ind++] = modbus_msg->ProtocolID& 0xFF;
modbus_uart_buff[ind++] = modbus_msg->PDULength >> 8;
modbus_uart_buff[ind++] = modbus_msg->PDULength& 0xFF;
#endif
//-----------[first bytes]-----------
// set ID of message/user
modbus_uart_buff[ind++] = modbus_msg->MbAddr;
// set dat or err response
modbus_uart_buff[ind++] = modbus_msg->FuncCode;
if (modbus_msg->FuncCode < FC_ERR_VALUES_START) // if no error occur
{
// fill modbus header
if(0) {}
#ifdef MODBUS_ENABLE_DEVICE_IDENTIFICATIONS
else if(modbus_msg->FuncCode == FC_R_DEVICE_ID) // devide identifications header
{
modbus_uart_buff[ind++] = modbus_msg->DevId.MEI_Type;
modbus_uart_buff[ind++] = modbus_msg->DevId.ReadDevId;
modbus_uart_buff[ind++] = modbus_msg->DevId.Conformity;
modbus_uart_buff[ind++] = modbus_msg->DevId.MoreFollows;
modbus_uart_buff[ind++] = modbus_msg->DevId.NextObjId;
modbus_uart_buff[ind++] = modbus_msg->DevId.NumbOfObj;
if (modbus_msg->ByteCnt > DATA_SIZE*2) // if ByteCnt less than DATA_SIZE
{
TrackerCnt_Err(hmodbus->rs_err);
return RS_COLLECT_MSG_ERR;
}
//---------------DATA----------------
//-----------[data bytes]------------
uint8_t *tmp_data_addr = (uint8_t *)modbus_msg->MbData;
for(int i = 0; i < modbus_msg->ByteCnt; i++) // filling buffer with data
{ // set data
modbus_uart_buff[ind++] = *tmp_data_addr;
tmp_data_addr++;
}
}
#endif //MODBUS_ENABLE_DEVICE_IDENTIFICATIONS
#ifdef MODBUS_ENABLE_DIAGNOSTICS
else if(modbus_msg->FuncCode == FC_R_DIAGNOSTICS)
{
// Diagnostics special format: [SubFunc_HI][SubFunc_LO][Data_HI][Data_LO]
modbus_uart_buff[ind++] = modbus_msg->MbData[0] >> 8; // Sub-function HI
modbus_uart_buff[ind++] = modbus_msg->MbData[0] & 0xFF; // Sub-function LO
modbus_uart_buff[ind++] = modbus_msg->MbData[1] >> 8; // Data HI
modbus_uart_buff[ind++] = modbus_msg->MbData[1] & 0xFF; // Data LO
}
#endif //MODBUS_ENABLE_DIAGNOSTICS
else // modbus data header
{
// set size of received data
if (modbus_msg->ByteCnt <= DATA_SIZE*2) // if ByteCnt less than DATA_SIZE
modbus_uart_buff[ind++] = modbus_msg->ByteCnt;
else // otherwise return data_size err
{
TrackerCnt_Err(hmodbus->rs_err);
return RS_COLLECT_MSG_ERR;
}
//---------------DATA----------------
//-----------[data bytes]------------
uint16_t *tmp_data_addr = (uint16_t *)modbus_msg->MbData;
for(int i = 0; i < modbus_msg->ByteCnt; i++) // filling buffer with data
{ // set data
if (i%2 == 0) // HI byte
modbus_uart_buff[ind++] = (*tmp_data_addr)>>8;
else // LO byte
{
modbus_uart_buff[ind++] = *tmp_data_addr;
tmp_data_addr++;
}
}
}
}
else // if some error occur
{ // send expection code
modbus_uart_buff[ind++] = modbus_msg->Except_Code;
}
}
if(ind < 0)
return RS_COLLECT_MSG_ERR;
//---------------CRC----------------
//---------[last 16 bytes]----------
#ifndef MODBUS_PROTOCOL_TCP
// calc crc of received data
uint16_t CRC_VALUE = crc16(modbus_uart_buff, ind);
// write crc to message structure and modbus-uart buffer
modbus_msg->MbCRC = CRC_VALUE;
modbus_uart_buff[ind++] = CRC_VALUE;
modbus_uart_buff[ind++] = CRC_VALUE >> 8;
#endif
hmodbus->RS_Message_Size = ind;
return RS_OK; // returns ok
}
/**
* @brief Определить размер модбас запроса (СЛЕЙВ версия).
* @param hRS Указатель на хендлер RS.
* @param rx_data_size Указатель на переменную для записи кол-ва байт для принятия.
* @return RS_RES Статус о корректности рассчета кол-ва байт для принятия.
* @details Определение сколько байтов надо принять по протоколу.
*/
static int MB_Define_Size_of_Function(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg)
{
RS_StatusTypeDef MB_RES = 0;
int mb_func_size = 0;
if (modbus_msg->FuncCode == FC_R_DIAGNOSTICS)
{
mb_func_size = 1;
}
else if(modbus_msg->FuncCode == FC_R_DEVICE_ID)
{
mb_func_size = 0;
}
else if ((modbus_msg->FuncCode & ~FC_ERR_VALUES_START) < 0x0F)
{
mb_func_size = 1;
}
else
{
mb_func_size = modbus_msg->ByteCnt + 2;
}
mb_func_size = RX_FIRST_PART_SIZE + mb_func_size; // size of whole message
return mb_func_size;
}
/**
* @brief Парс сообщения в режиме слейв (фрейм мастера из uart -> msg).
* @param hmodbus Указатель на хендлер RS.
* @param modbus_msg Указатель на структуру сообщения.
* @param modbus_uart_buff Указатель на буффер UART.
* @return RS_RES Статус о результате заполнения структуры.
* @details Заполнение структуры сообщения из буффера UART.
*/
RS_StatusTypeDef MB_Slave_Parse_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, uint8_t *modbus_uart_buff)
{
uint32_t check_empty_buff;
int ind = 0; // ind for modbus-uart buffer
hmodbus->f.RX_Continue = 0;
int expected_size = 0;
//-----INFO ABOUT DATA/MESSAGE-------
#ifdef MODBUS_PROTOCOL_TCP
modbus_msg->TransactionID =modbus_uart_buff[ind++]<<8;
modbus_msg->TransactionID |=modbus_uart_buff[ind++];
modbus_msg->ProtocolID =modbus_uart_buff[ind++]<<8;
modbus_msg->ProtocolID |=modbus_uart_buff[ind++];
modbus_msg->PDULength =modbus_uart_buff[ind++]<<8;
modbus_msg->PDULength |=modbus_uart_buff[ind++];
#endif
//-----------[first bits]------------
// get ID of message/user
if(modbus_uart_buff[ind] != hmodbus->ID)
{
modbus_msg->MbAddr = 0;
ind++;
}
else
{
modbus_msg->MbAddr = modbus_uart_buff[ind++];
}
// get func code
modbus_msg->FuncCode = modbus_uart_buff[ind++];
if(modbus_msg->FuncCode & FC_ERR_VALUES_START) // явная херня
{
MB_Diagnostics_SlaveNAKCnt();
modbus_msg->MbAddr = 0;
return RS_SKIP;
}
if(0) {}
#ifdef MODBUS_ENABLE_DEVICE_IDENTIFICATIONS
else if(modbus_msg->FuncCode == FC_R_DEVICE_ID) // if it device identifications request
{
modbus_msg->DevId.MEI_Type = modbus_uart_buff[ind++];
modbus_msg->DevId.ReadDevId = modbus_uart_buff[ind++];
modbus_msg->DevId.NextObjId = modbus_uart_buff[ind++];
modbus_msg->ByteCnt = 0;
}
#endif //MODBUS_ENABLE_DEVICE_IDENTIFICATIONS
#ifdef MODBUS_ENABLE_DIAGNOSTICS
else if(modbus_msg->FuncCode == FC_R_DIAGNOSTICS)
{
// Diagnostics: читаем 4 байта в MbData[0] и MbData[1]
// Sub-function
modbus_msg->MbData[0] = modbus_uart_buff[ind++] << 8;
modbus_msg->MbData[0] |= modbus_uart_buff[ind++];
// Data
modbus_msg->MbData[1] = modbus_uart_buff[ind++] << 8;
modbus_msg->MbData[1] |= modbus_uart_buff[ind++];
modbus_msg->Addr = 0; // не использует Addr
modbus_msg->Qnt = 0; // не использует Qnt
}
#endif //MODBUS_ENABLE_DIAGNOSTICS
else // if its classic modbus request
{
// get address from CMD
modbus_msg->Addr = modbus_uart_buff[ind++] << 8;
modbus_msg->Addr |= modbus_uart_buff[ind++];
// get address from CMD
modbus_msg->Qnt = modbus_uart_buff[ind++] << 8;
modbus_msg->Qnt |= modbus_uart_buff[ind++];
}
if((hmodbus->pMessagePtr->FuncCode == 0x0F) || (hmodbus->pMessagePtr->FuncCode == 0x10))
hmodbus->pMessagePtr->ByteCnt = modbus_uart_buff[ind++];
else
hmodbus->pMessagePtr->ByteCnt = 0;
expected_size = MB_Define_Size_of_Function(hmodbus, modbus_msg);
// если размер меньше ожидаемого - продолжаем принимать
if(hmodbus->RS_Message_Size < expected_size)
{
hmodbus->f.RX_Continue = 1;
return RS_SKIP;
}
// если больше Ошибка
else if (hmodbus->RS_Message_Size > expected_size)
{
MB_Diagnostics_CommunicationErrorCnt();
return RS_PARSE_MSG_ERR;
}
//---------------DATA----------------
// (optional)
if (modbus_msg->ByteCnt != 0)
{
//check that data size is correct
if (modbus_msg->ByteCnt > DATA_SIZE*2)
{
TrackerCnt_Err(hmodbus->rs_err);
modbus_msg->FuncCode |= FC_ERR_VALUES_START;
MB_Diagnostics_CommunicationErrorCnt();
return RS_PARSE_MSG_ERR;
}
uint16_t *tmp_data_addr = (uint16_t *)modbus_msg->MbData;
for(int i = 0; i < modbus_msg->ByteCnt; i++)
{ // set data
if (i%2 == 0)
*tmp_data_addr = ((uint16_t)modbus_uart_buff[ind++] << 8);
else
{
*tmp_data_addr |= modbus_uart_buff[ind++];
tmp_data_addr++;
}
}
}
//---------------CRC----------------
//----------[last 16 bits]----------
#ifndef MODBUS_PROTOCOL_TCP
// calc crc of received data
uint16_t CRC_VALUE = crc16(modbus_uart_buff, ind);
// get crc of received data
modbus_msg->MbCRC = modbus_uart_buff[ind++];
modbus_msg->MbCRC |= modbus_uart_buff[ind++] << 8;
// compare crc
if (modbus_msg->MbCRC != CRC_VALUE)
{
MB_Diagnostics_CommunicationErrorCnt();
TrackerCnt_Err(hmodbus->rs_err);
modbus_msg->FuncCode |= FC_ERR_VALUES_START;
}
#endif
return RS_OK;
}
#endif //MODBUS_ENABLE_SLAVE
MB_Process_Write_Single_Reg
uint8_t MB_Process_Write_Single_Reg(RS_MsgTypeDef *modbus_msg)
Обработать функцию Write Single Register (06 - 0x06).
Definition modbus_holdregs.c:120
MB_Process_Read_Device_Identifications
uint8_t MB_Process_Read_Device_Identifications(RS_MsgTypeDef *modbus_msg)
Обработать функцию Read Device Identifications (43/14 - 0x2B/0E).
Definition modbus_devid.c:112
MB_Process_Read_Coils
uint8_t MB_Process_Read_Coils(RS_MsgTypeDef *modbus_msg)
Обработать функцию Read Coils (01 - 0x01).
Definition modbus_coils.c:103
MB_Process_Diagnostics
uint8_t MB_Process_Diagnostics(RS_MsgTypeDef *modbus_msg)
Обработать функцию Diagnostics (Serial Line only) (0x08)
Definition modbus_diag.c:75
MB_Process_Write_Miltuple_Coils
uint8_t MB_Process_Write_Miltuple_Coils(RS_MsgTypeDef *modbus_msg)
Обработать функцию Write Multiple Coils (15 - 0x0F).
Definition modbus_coils.c:187
MB_Process_Write_Single_Coil
uint8_t MB_Process_Write_Single_Coil(RS_MsgTypeDef *modbus_msg)
Обработать функцию Write Single Coils (05 - 0x05).
Definition modbus_coils.c:156
MB_Process_Write_Miltuple_Regs
uint8_t MB_Process_Write_Miltuple_Regs(RS_MsgTypeDef *modbus_msg)
Обработать функцию Write Multiple Registers (16 - 0x10).
Definition modbus_holdregs.c:139
MB_Process_Read_Hold_Regs
uint8_t MB_Process_Read_Hold_Regs(RS_MsgTypeDef *modbus_msg)
Обработать функцию Read Holding Registers (03 - 0x03).
Definition modbus_holdregs.c:92
MB_Process_Read_Input_Regs
uint8_t MB_Process_Read_Input_Regs(RS_MsgTypeDef *modbus_msg)
Обработать функцию Read Input Registers (04 - 0x04).
Definition modbus_inputregs.c:87
MB_Diagnostics_CommunicationErrorCnt
void MB_Diagnostics_CommunicationErrorCnt(void)
Увеличивает счетчик ошибок связи
Definition modbus_diag.c:223
MB_Diagnostics_SlaveMessageCnt
void MB_Diagnostics_SlaveMessageCnt(void)
Увеличивает счетчик отсутствия ответов
Definition modbus_diag.c:254
MB_Diagnostics_SlaveNAKCnt
void MB_Diagnostics_SlaveNAKCnt(void)
Увеличивает счетчик NAK ответов
Definition modbus_diag.c:272
MB_Diagnostics_ExceptionErrorCnt
void MB_Diagnostics_ExceptionErrorCnt(void)
Увеличивает счетчик исключений
Definition modbus_diag.c:232
MB_Diagnostics_SlaveNoResponseCnt
void MB_Diagnostics_SlaveNoResponseCnt(void)
Увеличивает счетчик отсутствия ответов
Definition modbus_diag.c:263
MB_Diagnostics_BusMessageCnt
void MB_Diagnostics_BusMessageCnt(void)
Увеличивает счетчик сообщений на шине
Definition modbus_diag.c:215
MB_GetDeviceMode
MB_DeviceModeTypeDef MB_GetDeviceMode(void)
Получение текущего режима устройства
Definition modbus_diag.c:291
RX_FIRST_PART_SIZE
#define RX_FIRST_PART_SIZE
Size of first part of message that will be received first receive info part of message,...
Definition modbus_core.h:66
FC_ERR_VALUES_START
#define FC_ERR_VALUES_START
from this value starts error func codes
Definition modbus_core.h:88
DATA_SIZE
#define DATA_SIZE
maximum number of data: DWORD (NOT MESSAGE SIZE)
Definition modbus_core.h:53
FC_W_HOLD_REG
@ FC_W_HOLD_REG
Запись одиночного регистра
Definition modbus_core.h:109
FC_R_DEVICE_ID
@ FC_R_DEVICE_ID
Чтение информации об устройстве
Definition modbus_core.h:114
FC_R_COILS
@ FC_R_COILS
Чтение битовых ячеек
Definition modbus_core.h:97
FC_W_COILS
@ FC_W_COILS
Запись нескольких битовых ячеек
Definition modbus_core.h:110
FC_R_IN_REGS
@ FC_R_IN_REGS
Чтение регистров хранения
Definition modbus_core.h:101
FC_W_COIL
@ FC_W_COIL
Запись битовой ячейки
Definition modbus_core.h:108
FC_R_DIAGNOSTICS
@ FC_R_DIAGNOSTICS
Чтение диагностической информации устройства
Definition modbus_core.h:113
FC_R_HOLD_REGS
@ FC_R_HOLD_REGS
Чтение входных регистров
Definition modbus_core.h:100
FC_W_HOLD_REGS
@ FC_W_HOLD_REGS
Запись нескольких регистров
Definition modbus_core.h:111
MB_Slave_Collect_Message
RS_StatusTypeDef MB_Slave_Collect_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, uint8_t *modbus_uart_buff)
Сбор сообщения в буфер UART в режиме слейв (фрейм слейва из msg -> uart).
Definition modbus_slave.c:167
MB_Slave_Response
RS_StatusTypeDef MB_Slave_Response(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg)
Ответ на сообщение в режиме слейва.
Definition modbus_slave.c:24
MB_Slave_Parse_Message
RS_StatusTypeDef MB_Slave_Parse_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg, uint8_t *modbus_uart_buff)
Парс сообщения в режиме слейв (фрейм мастера из uart -> msg).
Definition modbus_slave.c:330
TrackerCnt_Ok
#define TrackerCnt_Ok(_cntstruct_)
Инкрементировать переменную - успешных событий
Definition rs_message.h:106
TrackerCnt_Err
#define TrackerCnt_Err(_cntstruct_)
Инкрементировать переменную - ошибок
Definition rs_message.h:108
TrackerCnt_Warn
#define TrackerCnt_Warn(_cntstruct_)
Инкрементировать переменную - предупреждений
Definition rs_message.h:110
RS_Abort
RS_StatusTypeDef RS_Abort(RS_HandleTypeDef *hRS, RS_AbortTypeDef AbortMode)
Отменить прием/передачу RS/UART.
Definition rs_message.c:193
RS_Handle_Transmit_Start
RS_StatusTypeDef RS_Handle_Transmit_Start(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg)
Обработчик для начала передачи.
Definition rs_message.c:269
RS_StatusTypeDef
RS_StatusTypeDef
Enums for respond CMD about RS status.
Definition rs_message.h:164
RS_Handle_Receive_Start
RS_StatusTypeDef RS_Handle_Receive_Start(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg)
Обработчик для начала приема.
Definition rs_message.c:237
ABORT_TX
@ ABORT_TX
Отменить передачу
Definition rs_message.h:194
modbus.h
Главный заголовочный файл Modbus библиотеки
MB_Define_Size_of_Function
static int MB_Define_Size_of_Function(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_msg)
Определить размер модбас запроса (СЛЕЙВ версия).
Definition modbus_slave.c:294
MB_DevIdMsgTypeDef::Conformity
uint8_t Conformity
Identification conformity level of the device and type of supported access MODBUS_DEVICE_CONFORMITY.
Definition modbus_core.h:168
MB_DevIdMsgTypeDef::MEI_Type
MB_MEITypeDef MEI_Type
MEI Type assigned number for Device Identifications Interface.
Definition modbus_core.h:166
RS_FlagsTypeDef::RX_Continue
unsigned RX_Continue
0 - Продолжить принимать, 0 - Начать прием сначала
Definition rs_message.h:214
RS_FlagsTypeDef::DataUpdated
unsigned DataUpdated
1 - Данные были обновлены
Definition rs_message.h:218
RS_FlagsTypeDef::EchoResponse
unsigned EchoResponse
1 - Ответить эхом, 0 - Ответить своим сообщением
Definition rs_message.h:216
RS_FlagsTypeDef::DeferredResponse
unsigned DeferredResponse
1 - Не начинать передачу в IT, 0 - Ответить в прерывании
Definition rs_message.h:217
RS_FlagsTypeDef::MessageHandled
unsigned MessageHandled
1 - Обработка запроса успешна, 0 - Обработка запроса в процессе или ошибка
Definition rs_message.h:215
RS_HandleTypeDef
Handle for RS communication.
Definition rs_message.h:228
RS_HandleTypeDef::ID
uint8_t ID
ID хендла
Definition rs_message.h:230
RS_HandleTypeDef::RS_Message_Size
int32_t RS_Message_Size
size of whole message, not only data
Definition rs_message.h:233
RS_HandleTypeDef::pMessagePtr
RS_MsgTypeDef * pMessagePtr
Указатель на структуру протокола
Definition rs_message.h:231
RS_HandleTypeDef::f
RS_FlagsTypeDef f
Флаги для контроля приема/передачи
Definition rs_message.h:243
RS_HandleTypeDef::RS_STATUS
RS_StatusTypeDef RS_STATUS
Статус RS.
Definition rs_message.h:247
RS_MsgTypeDef
Structure for modbus messsage.
Definition modbus_core.h:177
RS_MsgTypeDef::FuncCode
MB_FunctonTypeDef FuncCode
Modbus Function Code.
Definition modbus_core.h:185
RS_MsgTypeDef::Qnt
uint16_t Qnt
Quantity of modbus data.
Definition modbus_core.h:188
RS_MsgTypeDef::MbAddr
uint8_t MbAddr
Modbus Slave Address.
Definition modbus_core.h:184
RS_MsgTypeDef::Except_Code
MB_ExceptionTypeDef Except_Code
Exception Code for the command.
Definition modbus_core.h:192
RS_MsgTypeDef::MbCRC
uint16_t MbCRC
Modbus CRC.
Definition modbus_core.h:194
RS_MsgTypeDef::DevId
MB_DevIdMsgTypeDef DevId
Read Device Identifications Header struct.
Definition modbus_core.h:186
RS_MsgTypeDef::ByteCnt
uint8_t ByteCnt
Quantity of bytes of data in message to transmit/receive.
Definition modbus_core.h:189
RS_MsgTypeDef::MbData
uint16_t MbData[DATA_SIZE]
Modbus Data.
Definition modbus_core.h:191
RS_MsgTypeDef::Addr
uint16_t Addr
Modbus Address of data.
Definition modbus_core.h:187