jeans/Tasmota
jeans/Tasmota
1
0
Fork 0
mirror of https://github.com/arendst/Tasmota.git synced 2025-07-17 15:56:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #16245 from jeroenst/ModbusBridgeWrite

Browse Source 
Added Modbus bridge write and solved bugs reported
This commit is contained in:
Theo Arends 2022-08-17 22:07:31 +02:00 committed by GitHub
commit d491724d7f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 407 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp
View File

@ -1,4 +1,4 @@
/* /*
TasmotaModbus.cpp - Basic modbus wrapper for TasmotaSerial for Tasmota TasmotaModbus.cpp - Basic modbus wrapper for TasmotaSerial for Tasmota
Copyright (C) 2021 Theo Arends Copyright (C) 2021 Theo Arends
@ -15,6 +15,8 @@
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
Documentation about modbus protocol: https://www.modbustools.com/modbus.html
*/ */
#include "TasmotaModbus.h" #include "TasmotaModbus.h"
@ -53,24 +55,81 @@ int TasmotaModbus::Begin(long speed, uint32_t config)
return result; return result;
} }
void TasmotaModbus::Send(uint8_t device_address, uint8_t function_code, uint16_t start_address, uint16_t register_count) uint8_t TasmotaModbus::Send(uint8_t device_address, uint8_t function_code, uint16_t start_address, uint16_t register_count, uint16_t *registers)
{ {
uint8_t frame[8]; uint8_t *frame;
uint8_t framepointer = 0;
if (function_code < 7)
{
frame = (uint8_t *)malloc(8); // Addres(1), Function(1), Start/Coil Address(2), Registercount or Data (2), CRC(2)
}
else
{
frame = (uint8_t *)malloc(9 + (register_count * 2)); // Addres(1), Function(1), Start/Coil Address(2),Quantity of registers (2), Bytecount(1), Data(1..n), CRC(2)
}
mb_address = device_address; // Save address for receipt check mb_address = device_address; // Save address for receipt check
frame[0] = mb_address; // 0xFE default device address or dedicated like 0x01 frame[framepointer++] = mb_address; // 0xFE default device address or dedicated like 0x01
frame[1] = function_code; frame[framepointer++] = function_code;
frame[2] = (uint8_t)(start_address >> 8); // MSB frame[framepointer++] = (uint8_t)(start_address >> 8); // MSB
frame[3] = (uint8_t)(start_address); // LSB frame[framepointer++] = (uint8_t)(start_address); // LSB
frame[4] = (uint8_t)(register_count >> 8); // MSB if (function_code < 5)
frame[5] = (uint8_t)(register_count); // LSB {
uint16_t crc = CalculateCRC(frame, 6); frame[framepointer++] = (uint8_t)(register_count >> 8); // MSB
frame[6] = (uint8_t)(crc); frame[framepointer++] = (uint8_t)(register_count); // LSB
frame[7] = (uint8_t)(crc >> 8); }
else if ((function_code == 5) || (function_code == 6))
{
if (registers == NULL)
{
free(frame);
return 13; // Register data not specified
}
if (register_count != 1)
{
free(frame);
return 12; // Wrong register count
}
frame[framepointer++] = (uint8_t)(registers[0] >> 8); // MSB
frame[framepointer++] = (uint8_t)(registers[0]); // LSB
}
else if ((function_code == 15) || (function_code == 16))
{
frame[framepointer++] = (uint8_t)(register_count >> 8); // MSB
frame[framepointer++] = (uint8_t)(register_count); // LSB
frame[framepointer++] = register_count * 2;
if (registers == NULL)
{
free(frame);
return 13; // Register data not specified
}
if (register_count == 0)
{
free(frame);
return 12; // Wrong register count
}
for (int registerpointer = 0; registerpointer < register_count; registerpointer++)
{
frame[framepointer++] = (uint8_t)(registers[registerpointer] >> 8); // MSB
frame[framepointer++] = (uint8_t)(registers[registerpointer]); // LSB
}
}
else
{
free(frame);
return 1; // Wrong function code
}
uint16_t crc = CalculateCRC(frame, framepointer);
frame[framepointer++] = (uint8_t)(crc);
frame[framepointer++] = (uint8_t)(crc >> 8);
flush(); flush();
write(frame, sizeof(frame)); write(frame, framepointer);
free(frame);
return 0;
} }
bool TasmotaModbus::ReceiveReady() bool TasmotaModbus::ReceiveReady()
@ -78,11 +137,12 @@ bool TasmotaModbus::ReceiveReady()
return (available() > 4); return (available() > 4);
} }
uint8_t TasmotaModbus::ReceiveBuffer(uint8_t *buffer, uint8_t register_count) uint8_t TasmotaModbus::ReceiveBuffer(uint8_t *buffer, uint8_t data_count)
{ {
mb_len = 0; mb_len = 0;
uint32_t timeout = millis() + 10; uint32_t timeout = millis() + 10;
while ((mb_len < (register_count *2) + 5) && (millis() < timeout)) { uint8_t header_length = 3;
while ((mb_len < (data_count * 2) + header_length + 2) && (millis() < timeout)) {
if (available()) { if (available()) {
uint8_t data = (uint8_t)read(); uint8_t data = (uint8_t)read();
if (!mb_len) { // Skip leading data as provided by hardware serial if (!mb_len) { // Skip leading data as provided by hardware serial
@ -106,6 +166,7 @@ uint8_t TasmotaModbus::ReceiveBuffer(uint8_t *buffer, uint8_t register_count)
// 10 = Gateway Path Unavailable // 10 = Gateway Path Unavailable
// 11 = Gateway Target device failed to respond // 11 = Gateway Target device failed to respond
} }
if ((buffer[1] == 5) || (buffer[1] == 6) || (buffer[1] == 15) || (buffer[1] == 16)) header_length = 4; // Addr, Func, StartAddr
} }
} }
@ -114,7 +175,7 @@ uint8_t TasmotaModbus::ReceiveBuffer(uint8_t *buffer, uint8_t register_count)
} }
} }
if (mb_len < 7) { return 7; } // 7 = Not enough data if (mb_len < 6) { return 7; } // 7 = Not enough data
/* /*
if (mb_len != buffer[2] + 5) { if (mb_len != buffer[2] + 5) {
@ -131,6 +192,22 @@ uint8_t TasmotaModbus::ReceiveBuffer(uint8_t *buffer, uint8_t register_count)
return 0; // 0 = No error return 0; // 0 = No error
} }
uint8_t TasmotaModbus::Receive8BitRegister(uint8_t *value)
{
// 0 1 2 3 4 5
// 01 04 02 43 HH LL
// Id Cc Sz Regis Crc--
uint8_t buffer[6];
uint8_t error = ReceiveBuffer(buffer, 1); // 1 x 16bit register
if (!error) {
*value = buffer[3];
}
return error;
}
uint8_t TasmotaModbus::Receive16BitRegister(uint16_t *value) uint8_t TasmotaModbus::Receive16BitRegister(uint16_t *value)
{ {
// 0 1 2 3 4 5 6 // 0 1 2 3 4 5 6

7
lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.h
View File

@ -34,8 +34,6 @@ class TasmotaModbus : public TasmotaSerial {
uint16_t CalculateCRC(uint8_t *frame, uint8_t num); uint16_t CalculateCRC(uint8_t *frame, uint8_t num);
void Send(uint8_t device_address, uint8_t function_code, uint16_t start_address, uint16_t register_count);
bool ReceiveReady(); bool ReceiveReady();
/* Return codes: /* Return codes:
@ -51,8 +49,13 @@ class TasmotaModbus : public TasmotaSerial {
* 9 = Crc error * 9 = Crc error
* 10 = Gateway Path Unavailable * 10 = Gateway Path Unavailable
* 11 = Gateway Target device failed to respond * 11 = Gateway Target device failed to respond
* 12 = Wrong number of registers
* 13 = Register data not specified
* 14 = To many registers
*/ */
uint8_t Send(uint8_t device_address, uint8_t function_code, uint16_t start_address, uint16_t register_count, uint16_t *registers = NULL);
uint8_t ReceiveBuffer(uint8_t *buffer, uint8_t register_count); uint8_t ReceiveBuffer(uint8_t *buffer, uint8_t register_count);
uint8_t Receive8BitRegister(uint8_t *value);
uint8_t Receive16BitRegister(uint16_t *value); uint8_t Receive16BitRegister(uint16_t *value);
uint8_t Receive32BitRegister(float *value); uint8_t Receive32BitRegister(float *value);

371
tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino
View File

@ -22,12 +22,16 @@
* Modbus Bridge using Modbus library (TasmotaModbus) * Modbus Bridge using Modbus library (TasmotaModbus)
* *
* Can be used trough web/mqtt commands and also via direct TCP connection (when defined) * Can be used trough web/mqtt commands and also via direct TCP connection (when defined)
* *
* When USE_MODBUS_BRIDGE_TCP is also defined, this bridge can also be used as an ModbusTCP * When USE_MODBUS_BRIDGE_TCP is also defined, this bridge can also be used as an ModbusTCP
* bridge. * bridge.
* *
* Example Command: * Example Command:
* -- Read Input Register --
* ModbusSend {"deviceaddress": 1, "functioncode": 3, "startaddress": 1, "type":"uint16", "count":2} * ModbusSend {"deviceaddress": 1, "functioncode": 3, "startaddress": 1, "type":"uint16", "count":2}
*
* -- Write multiple coils --
* ModbusSend {"deviceaddress": 1, "functioncode": 15, "startaddress": 1, "type":"uint16", "count":4, "values":[1,2,3,4]}
\*********************************************************************************************/ \*********************************************************************************************/
#define XDRV_63 63 #define XDRV_63 63
@ -97,30 +101,36 @@ enum class ModbusBridgeError
wrongfunctioncode = 3, wrongfunctioncode = 3,
wrongstartaddress = 4, wrongstartaddress = 4,
wrongtype = 5, wrongtype = 5,
wrongregistercount = 6, wrongdataCount = 6,
wrongcount = 7 wrongcount = 7,
tomanydata = 8
}; };
enum class ModbusBridgeFunctionCode enum class ModbusBridgeFunctionCode
{ {
mb_undefined = 0, mb_undefined = 0,
mb_readCoilstartregister = 1, mb_readCoilStatus = 1,
mb_readContactstartregister = 2, mb_readContactStatus = 2,
mb_readHoldingstartregister = 3, mb_readHoldingRegisters = 3,
mb_readInputstartregister = 4, mb_readInputRegisters = 4,
mb_writeSingleCoil = 5, mb_writeSingleCoil = 5,
mb_writeSinglestartregister = 6 mb_writeSingleRegister = 6,
mb_writeMultipleCoils = 15,
mb_writeMultipleRegisters = 16
}; };
enum class ModbusBridgeType enum class ModbusBridgeType
{ {
mb_undefined, mb_undefined,
mb_uint8,
mb_uint16, mb_uint16,
mb_uint32, mb_uint32,
mb_int8,
mb_int16, mb_int16,
mb_int32, mb_int32,
mb_float, mb_float,
mb_raw, mb_raw,
mb_hex,
mb_bit mb_bit
}; };
@ -139,7 +149,7 @@ struct ModbusBridge
ModbusBridgeFunctionCode functionCode = ModbusBridgeFunctionCode::mb_undefined; ModbusBridgeFunctionCode functionCode = ModbusBridgeFunctionCode::mb_undefined;
ModbusBridgeType type = ModbusBridgeType::mb_undefined; ModbusBridgeType type = ModbusBridgeType::mb_undefined;
uint16_t registerCount = 0; uint16_t dataCount = 0;
uint16_t startAddress = 0; uint16_t startAddress = 0;
uint8_t deviceAddress = 0; uint8_t deviceAddress = 0;
uint8_t count = 0; uint8_t count = 0;
@ -154,8 +164,10 @@ ModbusBridge modbusBridge;
// //
bool ModbusBridgeBegin(void) bool ModbusBridgeBegin(void)
{ {
if ((Settings->modbus_sbaudrate < 300 / 300) || (Settings->modbus_sbaudrate > 115200 / 300)) Settings->modbus_sbaudrate = (uint8_t)((uint32_t)MBR_BAUDRATE / 300); if ((Settings->modbus_sbaudrate < 1) || (Settings->modbus_sbaudrate > (115200 / 300)))
if (Settings->modbus_sconfig > TS_SERIAL_8O2) Settings->modbus_sconfig = TS_SERIAL_8N1; Settings->modbus_sbaudrate = (uint8_t)((uint32_t)MBR_BAUDRATE / 300);
if (Settings->modbus_sconfig > TS_SERIAL_8O2)
Settings->modbus_sconfig = TS_SERIAL_8N1;
int result = tasmotaModbus->Begin(Settings->modbus_sbaudrate * 300, ConvertSerialConfig(Settings->modbus_sconfig)); // Reinitialize modbus port with new baud rate int result = tasmotaModbus->Begin(Settings->modbus_sbaudrate * 300, ConvertSerialConfig(Settings->modbus_sconfig)); // Reinitialize modbus port with new baud rate
if (result) if (result)
@ -186,7 +198,7 @@ void SetModbusBridgeBaudrate(uint32_t baudrate)
{ {
if ((baudrate >= 300) && (baudrate <= 115200)) if ((baudrate >= 300) && (baudrate <= 115200))
{ {
if (baudrate / 300 != Settings->modbus_sbaudrate) if (baudrate / 300 != Settings->modbus_sbaudrate)
{ {
Settings->modbus_sbaudrate = baudrate / 300; Settings->modbus_sbaudrate = baudrate / 300;
ModbusBridgeBegin(); ModbusBridgeBegin();
@ -204,12 +216,12 @@ void ModbusBridgeHandle(void)
if (data_ready) if (data_ready)
{ {
uint8_t *buffer; uint8_t *buffer;
buffer = (uint8_t *)malloc(5 + (modbusBridge.registerCount * 2)); // Addres(1), Function(1), Length(1), Data(1..n), CRC(2) buffer = (uint8_t *)malloc(9 + (modbusBridge.dataCount * 2)); // Addres(1), Function(1), Length(1), Data(1..n), CRC(2)
uint32_t error = tasmotaModbus->ReceiveBuffer(buffer, modbusBridge.registerCount); uint32_t error = tasmotaModbus->ReceiveBuffer(buffer, modbusBridge.dataCount);
if (error) if (error)
{ {
AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: MBR Driver error %d"), error); AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: MBR Driver receive error %d"), error);
free(buffer); free(buffer);
return; return;
} }
@ -225,17 +237,17 @@ void ModbusBridgeHandle(void)
MBAP_Header[1] = modbusBridgeTCP.tcp_transaction_id; MBAP_Header[1] = modbusBridgeTCP.tcp_transaction_id;
MBAP_Header[2] = 0; MBAP_Header[2] = 0;
MBAP_Header[3] = 0; MBAP_Header[3] = 0;
MBAP_Header[4] = ((modbusBridge.registerCount * 2) + 3) >> 8; MBAP_Header[4] = ((modbusBridge.dataCount * 2) + 3) >> 8;
MBAP_Header[5] = (modbusBridge.registerCount * 2) + 3; MBAP_Header[5] = (modbusBridge.dataCount * 2) + 3;
MBAP_Header[6] = buffer[0]; // Send slave address MBAP_Header[6] = buffer[0]; // Send slave address
client.write(MBAP_Header, 7); client.write(MBAP_Header, 7);
client.write(buffer + 1, 1); // Send Functioncode client.write(buffer + 1, 1); // Send Functioncode
uint8_t bytecount[1]; uint8_t bytecount[1];
bytecount[0] = modbusBridge.registerCount * 2; bytecount[0] = modbusBridge.dataCount * 2;
client.write(bytecount, 1); // Send length of rtu data client.write(bytecount, 1); // Send length of rtu data
client.write(buffer + 3, (modbusBridge.registerCount * 2)); // Don't send CRC client.write(buffer + 3, (modbusBridge.dataCount * 2)); // Don't send CRC
client.flush(); client.flush();
AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: MBRTCP from Modbus deviceAddress %d, writing %d bytes to client"), buffer[0], (modbusBridge.registerCount * 2) + 9); AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: MBRTCP from Modbus deviceAddress %d, writing %d bytes to client"), buffer[0], (modbusBridge.dataCount * 2) + 9);
} }
} }
#endif #endif
@ -257,13 +269,34 @@ void ModbusBridgeHandle(void)
errorcode = ModbusBridgeError::wrongdeviceaddress; errorcode = ModbusBridgeError::wrongdeviceaddress;
else if ((uint8_t)modbusBridge.functionCode != (uint8_t)buffer[1]) else if ((uint8_t)modbusBridge.functionCode != (uint8_t)buffer[1])
errorcode = ModbusBridgeError::wrongfunctioncode; errorcode = ModbusBridgeError::wrongfunctioncode;
else if ((uint8_t)modbusBridge.registerCount * 2 != (uint8_t)buffer[2]) else if ((uint8_t)modbusBridge.functionCode < 5)
errorcode = ModbusBridgeError::wrongregistercount; {
else if ((uint8_t)modbusBridge.functionCode < 3)
{
if ((uint8_t)(((modbusBridge.dataCount - 1) >> 3) + 1) != (uint8_t)buffer[2])
errorcode = ModbusBridgeError::wrongdataCount;
}
else
{
if ((modbusBridge.type == ModbusBridgeType::mb_int8 || modbusBridge.type == ModbusBridgeType::mb_uint8)
&& ((uint8_t)modbusBridge.dataCount * 2 != (uint8_t)buffer[2]))
errorcode = ModbusBridgeError::wrongdataCount;
else if ((modbusBridge.type == ModbusBridgeType::mb_bit)
&& ((uint8_t)modbusBridge.dataCount * 2 != (uint8_t)buffer[2]))
errorcode = ModbusBridgeError::wrongdataCount;
else if ((modbusBridge.type == ModbusBridgeType::mb_int16 || modbusBridge.type == ModbusBridgeType::mb_uint16)
&& ((uint8_t)modbusBridge.dataCount * 2 != (uint8_t)buffer[2]))
errorcode = ModbusBridgeError::wrongdataCount;
else if ((modbusBridge.type == ModbusBridgeType::mb_int32 || modbusBridge.type == ModbusBridgeType::mb_uint32 || modbusBridge.type == ModbusBridgeType::mb_float)
&& ((uint8_t)modbusBridge.dataCount * 2 != (uint8_t)buffer[2]))
errorcode = ModbusBridgeError::wrongdataCount;
}
}
if (errorcode == ModbusBridgeError::noerror)
{ {
if (modbusBridge.type == ModbusBridgeType::mb_raw) if (modbusBridge.type == ModbusBridgeType::mb_raw)
{ {
Response_P(PSTR("{\"" D_JSON_MODBUS_RECEIVED "\":[")); Response_P(PSTR("{\"" D_JSON_MODBUS_RECEIVED "\":{\"RAW\":["));
for (uint8_t i = 0; i < tasmotaModbus->ReceiveCount(); i++) for (uint8_t i = 0; i < tasmotaModbus->ReceiveCount(); i++)
{ {
ResponseAppend_P(PSTR("%d"), buffer[i]); ResponseAppend_P(PSTR("%d"), buffer[i]);
@ -274,38 +307,103 @@ void ModbusBridgeHandle(void)
ResponseJsonEnd(); ResponseJsonEnd();
MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_JSON_MODBUS_RECEIVED)); MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_JSON_MODBUS_RECEIVED));
} }
else if ((buffer[1] > 0) && (buffer[1] < 5)) // Read Registers, writing is not supported at this moment else if (modbusBridge.type == ModbusBridgeType::mb_hex)
{ {
Response_P(PSTR("{\"" D_JSON_MODBUS_RECEIVED "\":{\"HEX\":["));
for (uint8_t i = 0; i < tasmotaModbus->ReceiveCount(); i++)
{
ResponseAppend_P(PSTR("0x%02X"), buffer[i]);
if (i < tasmotaModbus->ReceiveCount() - 1)
ResponseAppend_P(PSTR(","));
}
ResponseAppend_P(PSTR("]}"));
ResponseJsonEnd();
MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_JSON_MODBUS_RECEIVED));
}
else if ((buffer[1] > 0) && (buffer[1] < 7)) // Read Registers
{
uint8_t dataOffset = 3;
Response_P(PSTR("{\"" D_JSON_MODBUS_RECEIVED "\":{")); Response_P(PSTR("{\"" D_JSON_MODBUS_RECEIVED "\":{"));
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_DEVICE_ADDRESS "\":%d,"), buffer[0]); ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_DEVICE_ADDRESS "\":%d,"), buffer[0]);
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_FUNCTION_CODE "\":%d,"), buffer[1]); ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_FUNCTION_CODE "\":%d,"), buffer[1]);
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_START_ADDRESS "\":%d,"), modbusBridge.startAddress); if (buffer[1] < 5)
{
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_START_ADDRESS "\":%d,"), modbusBridge.startAddress);
}
else
{
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_START_ADDRESS "\":%d,"), (buffer[2] << 8) + buffer[3]);
dataOffset = 4;
}
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_LENGTH "\":%d,"), tasmotaModbus->ReceiveCount()); ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_LENGTH "\":%d,"), tasmotaModbus->ReceiveCount());
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_COUNT "\":%d,"), modbusBridge.count); ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_COUNT "\":%d,"), modbusBridge.count);
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_VALUES "\":[")); ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_VALUES "\":["));
for (uint8_t count = 0; count < modbusBridge.count; count++) uint8_t data_count = modbusBridge.count;
if ((uint8_t)modbusBridge.functionCode < 3)
{
if (modbusBridge.type == ModbusBridgeType::mb_int8 || modbusBridge.type == ModbusBridgeType::mb_uint8)
data_count = (uint8_t)(((modbusBridge.count - 1) >> 3) + 1);
else if (modbusBridge.type == ModbusBridgeType::mb_int16 || modbusBridge.type == ModbusBridgeType::mb_uint16)
data_count = (uint8_t)(((modbusBridge.count - 1) >> 4) + 1);
else if (modbusBridge.type == ModbusBridgeType::mb_int32 || modbusBridge.type == ModbusBridgeType::mb_uint32 || modbusBridge.type == ModbusBridgeType::mb_float)
data_count = (uint8_t)(((modbusBridge.count - 1) >> 5) + 1);
}
for (uint8_t count = 0; count < data_count; count++)
{ {
char svalue[MBR_MAX_VALUE_LENGTH + 1] = ""; char svalue[MBR_MAX_VALUE_LENGTH + 1] = "";
if (modbusBridge.type == ModbusBridgeType::mb_float) if (modbusBridge.type == ModbusBridgeType::mb_float)
{ {
float value = 0; float value = 0;
((uint8_t *)&value)[3] = buffer[3 + (count * 4)]; // Get float values if (buffer[1] < 3)
((uint8_t *)&value)[2] = buffer[4 + (count * 4)]; {
((uint8_t *)&value)[1] = buffer[5 + (count * 4)]; if (buffer[2] - (count * 4))
((uint8_t *)&value)[0] = buffer[6 + (count * 4)]; ((uint8_t *)&value)[0] = buffer[dataOffset + (count * 4)]; // Get int values
if ((buffer[2] - (count * 4)) >> 1)
((uint8_t *)&value)[1] = buffer[dataOffset + 1 + (count * 4)];
if ((buffer[2] - (count * 4) - 1) >> 1)
((uint8_t *)&value)[2] = buffer[dataOffset + 2 + (count * 4)];
if ((buffer[2] - (count * 4)) >> 2)
((uint8_t *)&value)[3] = buffer[dataOffset + 3 + (count * 4)];
}
else
{
((uint8_t *)&value)[3] = buffer[dataOffset + (count * 4)]; // Get float values
((uint8_t *)&value)[2] = buffer[dataOffset + 1 + (count * 4)];
((uint8_t *)&value)[1] = buffer[dataOffset + 2 + (count * 4)];
((uint8_t *)&value)[0] = buffer[dataOffset + 3 + (count * 4)];
}
ext_snprintf_P(svalue, sizeof(svalue), "%*_f", 10, &value); ext_snprintf_P(svalue, sizeof(svalue), "%*_f", 10, &value);
} }
else if (modbusBridge.type == ModbusBridgeType::mb_bit)
{
uint8_t value = (uint8_t)(buffer[dataOffset + (count >> 3)]);
snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", ((value >> (count & 7)) & 1));
}
else else
{ {
if ((modbusBridge.type == ModbusBridgeType::mb_int32) || if ((modbusBridge.type == ModbusBridgeType::mb_int32) ||
(modbusBridge.type == ModbusBridgeType::mb_uint32)) (modbusBridge.type == ModbusBridgeType::mb_uint32))
{ {
uint32_t value = 0; uint32_t value = 0;
((uint8_t *)&value)[3] = buffer[3 + (count * 4)]; // Get int values if (buffer[1] < 3)
((uint8_t *)&value)[2] = buffer[4 + (count * 4)]; {
((uint8_t *)&value)[1] = buffer[5 + (count * 4)]; if (buffer[2] - (count * 4))
((uint8_t *)&value)[0] = buffer[6 + (count * 4)]; ((uint8_t *)&value)[0] = buffer[dataOffset + (count * 4)]; // Get int values
if ((buffer[2] - (count * 4)) >> 1)
((uint8_t *)&value)[1] = buffer[dataOffset + 1 + (count * 4)];
if ((buffer[2] - (count * 4) - 1) >> 1)
((uint8_t *)&value)[2] = buffer[dataOffset + 2 + (count * 4)];
if ((buffer[2] - (count * 4)) >> 2)
((uint8_t *)&value)[3] = buffer[dataOffset + 3 + (count * 4)];
}
else
{
((uint8_t *)&value)[3] = buffer[dataOffset + (count * 4)]; // Get int values
((uint8_t *)&value)[2] = buffer[dataOffset + 1 + (count * 4)];
((uint8_t *)&value)[1] = buffer[dataOffset + 2 + (count * 4)];
((uint8_t *)&value)[0] = buffer[dataOffset + 3 + (count * 4)];
}
if (modbusBridge.type == ModbusBridgeType::mb_int32) if (modbusBridge.type == ModbusBridgeType::mb_int32)
snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", value); snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", value);
else else
@ -315,21 +413,41 @@ void ModbusBridgeHandle(void)
(modbusBridge.type == ModbusBridgeType::mb_uint16)) (modbusBridge.type == ModbusBridgeType::mb_uint16))
{ {
uint16_t value = 0; uint16_t value = 0;
((uint8_t *)&value)[1] = buffer[3 + (count * 2)]; if (buffer[1] < 3)
((uint8_t *)&value)[0] = buffer[4 + (count * 2)]; {
if (buffer[2] - (count * 2))
((uint8_t *)&value)[0] = buffer[dataOffset + (count * 2)];
if ((buffer[2] - (count * 2)) >> 1)
((uint8_t *)&value)[1] = buffer[dataOffset + 1 + (count * 2)];
}
else
{
((uint8_t *)&value)[1] = buffer[dataOffset + (count * 2)];
((uint8_t *)&value)[0] = buffer[dataOffset + 1 + (count * 2)];
}
if (modbusBridge.type == ModbusBridgeType::mb_int16) if (modbusBridge.type == ModbusBridgeType::mb_int16)
snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", value); snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", value);
else else
snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%u", value); snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%u", value);
} }
else if ((modbusBridge.type == ModbusBridgeType::mb_int8) ||
(modbusBridge.type == ModbusBridgeType::mb_uint8))
{
uint8_t value = buffer[dataOffset + (count * 1)];
if (modbusBridge.type == ModbusBridgeType::mb_int8)
snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", value);
else
snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%u", value);
}
/*
else if (modbusBridge.type == ModbusBridgeType::mb_bit) else if (modbusBridge.type == ModbusBridgeType::mb_bit)
{ {
uint8_t value = (uint8_t)(buffer[3 + count]); uint8_t value = (uint8_t)(buffer[dataOffset + count]);
snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d%d%d%d%d%d%d%d", ((value >> 7) & 1), ((value >> 6) & 1), ((value >> 5) & 1), ((value >> 4) & 1), ((value >> 3) & 1), ((value >> 2) & 1), ((value >> 1) & 1), (value & 1)); snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d%d%d%d%d%d%d%d", ((value >> 7) & 1), ((value >> 6) & 1), ((value >> 5) & 1), ((value >> 4) & 1), ((value >> 3) & 1), ((value >> 2) & 1), ((value >> 1) & 1), (value & 1));
} }*/
} }
ResponseAppend_P(PSTR("%s"), svalue); ResponseAppend_P(PSTR("%s"), svalue);
if (count < modbusBridge.count - 1) if (count < data_count - 1)
ResponseAppend_P(PSTR(",")); ResponseAppend_P(PSTR(","));
} }
@ -339,6 +457,19 @@ void ModbusBridgeHandle(void)
if (errorcode == ModbusBridgeError::noerror) if (errorcode == ModbusBridgeError::noerror)
MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_JSON_MODBUS_RECEIVED)); MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_JSON_MODBUS_RECEIVED));
} }
else if ((buffer[1] == 15) || (buffer[1] == 16)) // Write Multiple Registers
{
Response_P(PSTR("{\"" D_JSON_MODBUS_RECEIVED "\":{"));
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_DEVICE_ADDRESS "\":%d,"), buffer[0]);
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_FUNCTION_CODE "\":%d,"), buffer[1]);
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_START_ADDRESS "\":%d,"), (buffer[2] << 8) + buffer[3]);
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_LENGTH "\":%d,"), tasmotaModbus->ReceiveCount());
ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_COUNT "\":%d"), (buffer[4] << 8) + buffer[5]);
ResponseAppend_P(PSTR("}"));
ResponseJsonEnd();
if (errorcode == ModbusBridgeError::noerror)
MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_JSON_MODBUS_RECEIVED));
}
else else
errorcode = ModbusBridgeError::wrongfunctioncode; errorcode = ModbusBridgeError::wrongfunctioncode;
} }
@ -450,13 +581,13 @@ void ModbusTCPHandle(void)
uint8_t mbdeviceaddress = (uint8_t)modbusBridgeTCP.tcp_buf[6]; uint8_t mbdeviceaddress = (uint8_t)modbusBridgeTCP.tcp_buf[6];
uint8_t mbfunctioncode = (uint8_t)modbusBridgeTCP.tcp_buf[7]; uint8_t mbfunctioncode = (uint8_t)modbusBridgeTCP.tcp_buf[7];
uint16_t mbstartaddress = (uint16_t)((((uint16_t)modbusBridgeTCP.tcp_buf[8]) << 8) | ((uint16_t)modbusBridgeTCP.tcp_buf[9])); uint16_t mbstartaddress = (uint16_t)((((uint16_t)modbusBridgeTCP.tcp_buf[8]) << 8) | ((uint16_t)modbusBridgeTCP.tcp_buf[9]));
modbusBridge.registerCount = (uint16_t)((((uint16_t)modbusBridgeTCP.tcp_buf[10]) << 8) | ((uint16_t)modbusBridgeTCP.tcp_buf[11])); modbusBridge.dataCount = (uint16_t)((((uint16_t)modbusBridgeTCP.tcp_buf[10]) << 8) | ((uint16_t)modbusBridgeTCP.tcp_buf[11]));
modbusBridgeTCP.tcp_transaction_id = (uint16_t)((((uint16_t)modbusBridgeTCP.tcp_buf[0]) << 8) | ((uint16_t)modbusBridgeTCP.tcp_buf[1])); modbusBridgeTCP.tcp_transaction_id = (uint16_t)((((uint16_t)modbusBridgeTCP.tcp_buf[0]) << 8) | ((uint16_t)modbusBridgeTCP.tcp_buf[1]));
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("MBS: MBRTCP to Modbus Transactionid:%d, deviceAddress:%d, functionCode:%d, startAddress:%d, Count:%d"), AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("MBS: MBRTCP to Modbus Transactionid:%d, deviceAddress:%d, functionCode:%d, startAddress:%d, Count:%d"),
modbusBridgeTCP.tcp_transaction_id, mbdeviceaddress, mbfunctioncode, mbstartaddress, modbusBridge.registerCount); modbusBridgeTCP.tcp_transaction_id, mbdeviceaddress, mbfunctioncode, mbstartaddress, modbusBridge.dataCount);
tasmotaModbus->Send(mbdeviceaddress, mbfunctioncode, mbstartaddress, modbusBridge.registerCount); tasmotaModbus->Send(mbdeviceaddress, mbfunctioncode, mbstartaddress, modbusBridge.dataCount);
} }
} }
yield(); // avoid WDT if heavy traffic yield(); // avoid WDT if heavy traffic
@ -470,6 +601,10 @@ void ModbusTCPHandle(void)
void CmndModbusBridgeSend(void) void CmndModbusBridgeSend(void)
{ {
uint16_t *writeData = NULL;
uint8_t writeDataSize = 0;
ModbusBridgeError errorcode = ModbusBridgeError::noerror;
JsonParser parser(XdrvMailbox.data); JsonParser parser(XdrvMailbox.data);
JsonParserObject root = parser.getRootObject(); JsonParserObject root = parser.getRootObject();
if (!root) if (!root)
@ -478,16 +613,16 @@ void CmndModbusBridgeSend(void)
modbusBridge.deviceAddress = root.getUInt(PSTR(D_JSON_MODBUS_DEVICE_ADDRESS), 0); modbusBridge.deviceAddress = root.getUInt(PSTR(D_JSON_MODBUS_DEVICE_ADDRESS), 0);
uint8_t functionCode = root.getUInt(PSTR(D_JSON_MODBUS_FUNCTION_CODE), 0); uint8_t functionCode = root.getUInt(PSTR(D_JSON_MODBUS_FUNCTION_CODE), 0);
modbusBridge.startAddress = root.getULong(PSTR(D_JSON_MODBUS_START_ADDRESS), 0); modbusBridge.startAddress = root.getULong(PSTR(D_JSON_MODBUS_START_ADDRESS), 0);
const char *stype = root.getStr(PSTR(D_JSON_MODBUS_TYPE), "uint8"); const char *stype = root.getStr(PSTR(D_JSON_MODBUS_TYPE), "uint8");
modbusBridge.count = root.getUInt(PSTR(D_JSON_MODBUS_COUNT), 1); modbusBridge.count = root.getUInt(PSTR(D_JSON_MODBUS_COUNT), 1);
ModbusBridgeError errorcode = ModbusBridgeError::noerror;
if (modbusBridge.deviceAddress == 0) if (modbusBridge.deviceAddress == 0)
errorcode = ModbusBridgeError::wrongdeviceaddress; errorcode = ModbusBridgeError::wrongdeviceaddress;
else if (modbusBridge.startAddress == 0) else if ((functionCode > (uint8_t)ModbusBridgeFunctionCode::mb_writeSingleRegister) &&
; (functionCode != (uint8_t)ModbusBridgeFunctionCode::mb_writeMultipleCoils) &&
else if (functionCode > 4) (functionCode != (uint8_t)ModbusBridgeFunctionCode::mb_writeMultipleRegisters))
errorcode = ModbusBridgeError::wrongfunctioncode; // Writing is not supported errorcode = ModbusBridgeError::wrongfunctioncode; // Invalid function code
else else
{ {
modbusBridge.functionCode = static_cast<ModbusBridgeFunctionCode>(functionCode); modbusBridge.functionCode = static_cast<ModbusBridgeFunctionCode>(functionCode);
@ -496,54 +631,166 @@ void CmndModbusBridgeSend(void)
} }
modbusBridge.type = ModbusBridgeType::mb_undefined; modbusBridge.type = ModbusBridgeType::mb_undefined;
if (strcmp(stype, "int16") == 0) if (strcmp(stype, "int8") == 0)
{
modbusBridge.type = ModbusBridgeType::mb_int8;
modbusBridge.dataCount = ((modbusBridge.count - 1)/ 2) + 1;
}
else if (strcmp(stype, "int16") == 0)
{ {
modbusBridge.type = ModbusBridgeType::mb_int16; modbusBridge.type = ModbusBridgeType::mb_int16;
modbusBridge.registerCount = modbusBridge.count; modbusBridge.dataCount = modbusBridge.count;
} }
else if (strcmp(stype, "int32") == 0) else if (strcmp(stype, "int32") == 0)
{ {
modbusBridge.type = ModbusBridgeType::mb_int32; modbusBridge.type = ModbusBridgeType::mb_int32;
modbusBridge.registerCount = 2 * modbusBridge.count; modbusBridge.dataCount = 2 * modbusBridge.count;
} }
else if (strcmp(stype, "uint16") == 0) else if ((strcmp(stype, "uint8") == 0))
{
modbusBridge.type = ModbusBridgeType::mb_uint8;
modbusBridge.dataCount = ((modbusBridge.count - 1)/ 2) + 1;
}
else if ((strcmp(stype, "uint16") == 0) || (strcmp(stype, "") == 0)) // Default is uint16
{ {
modbusBridge.type = ModbusBridgeType::mb_uint16; modbusBridge.type = ModbusBridgeType::mb_uint16;
modbusBridge.registerCount = modbusBridge.count; modbusBridge.dataCount = modbusBridge.count;
} }
else if (strcmp(stype, "uint32") == 0) else if (strcmp(stype, "uint32") == 0)
{ {
modbusBridge.type = ModbusBridgeType::mb_uint32; modbusBridge.type = ModbusBridgeType::mb_uint32;
modbusBridge.registerCount = 2 * modbusBridge.count; modbusBridge.dataCount = 2 * modbusBridge.count;
} }
else if (strcmp(stype, "float") == 0) else if (strcmp(stype, "float") == 0)
{ {
modbusBridge.type = ModbusBridgeType::mb_float; modbusBridge.type = ModbusBridgeType::mb_float;
modbusBridge.registerCount = 2 * modbusBridge.count; modbusBridge.dataCount = 2 * modbusBridge.count;
} }
else if (strcmp(stype, "raw") == 0) else if (strcmp(stype, "raw") == 0)
{ {
modbusBridge.type = ModbusBridgeType::mb_raw; modbusBridge.type = ModbusBridgeType::mb_raw;
modbusBridge.registerCount = modbusBridge.count; modbusBridge.dataCount = modbusBridge.count;
}
else if (strcmp(stype, "hex") == 0)
{
modbusBridge.type = ModbusBridgeType::mb_hex;
modbusBridge.dataCount = modbusBridge.count;
} }
else if (strcmp(stype, "bit") == 0) else if (strcmp(stype, "bit") == 0)
{ {
modbusBridge.type = ModbusBridgeType::mb_bit; modbusBridge.type = ModbusBridgeType::mb_bit;
modbusBridge.registerCount = modbusBridge.count; modbusBridge.dataCount = ((modbusBridge.count - 1) / 16) + 1;
} }
else else
errorcode = ModbusBridgeError::wrongtype; errorcode = ModbusBridgeError::wrongtype;
if (modbusBridge.registerCount > MBR_MAX_REGISTERS) if (modbusBridge.dataCount > MBR_MAX_REGISTERS)
errorcode = ModbusBridgeError::wrongcount; errorcode = ModbusBridgeError::wrongcount;
// If write data is specified in JSON copy it into writeData array
JsonParserArray jsonDataArray = root[PSTR(D_JSON_MODBUS_VALUES)].getArray();
if (jsonDataArray.isArray())
{
if (modbusBridge.dataCount > 40)
{
errorcode = ModbusBridgeError::tomanydata;
}
else
{
writeDataSize = jsonDataArray.size();
if (modbusBridge.count != writeDataSize)
{
errorcode = ModbusBridgeError::wrongcount;
}
else
{
writeData = (uint16_t *)malloc(writeDataSize * 2);
for (uint8_t jsonDataArrayPointer = 0; jsonDataArrayPointer < writeDataSize; jsonDataArrayPointer++)
{
switch (modbusBridge.type)
{
case ModbusBridgeType::mb_bit:
{
// Set 2 following bytes to 0
if (jsonDataArrayPointer % 16 == 0)
{
writeData[jsonDataArrayPointer/15] = 0;
}
// Swap low and high bytes according to modbus specification
uint16_t bitValue = (jsonDataArray[jsonDataArrayPointer].getUInt(0) == 1) ? 1 : 0;
uint8_t bitPointer = (jsonDataArrayPointer % 15) + 8;
if (bitPointer > 15) bitPointer -= 16;
writeData[jsonDataArrayPointer/15] += bitValue << bitPointer;
}
break;
case ModbusBridgeType::mb_int8:
if (jsonDataArrayPointer % 2) writeData[jsonDataArrayPointer / 2] += (int8_t)jsonDataArray[jsonDataArrayPointer].getInt(0);
else writeData[jsonDataArrayPointer] = (int8_t)jsonDataArray[jsonDataArrayPointer / 2].getInt(0) << 8;
break;
case ModbusBridgeType::mb_uint8:
if (jsonDataArrayPointer % 2) writeData[jsonDataArrayPointer / 2] += (uint8_t)jsonDataArray[jsonDataArrayPointer].getInt(0);
else writeData[jsonDataArrayPointer / 2] = (uint8_t)jsonDataArray[jsonDataArrayPointer].getInt(0) << 8;
break;
case ModbusBridgeType::mb_int16:
writeData[jsonDataArrayPointer] = (int16_t)jsonDataArray[jsonDataArrayPointer].getInt(0);
break;
case ModbusBridgeType::mb_uint16:
writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getUInt(0);
break;
case ModbusBridgeType::mb_float:
// TODO
errorcode = ModbusBridgeError::wrongtype;
break;
case ModbusBridgeType::mb_int32:
writeData[jsonDataArrayPointer++] = (int16_t)(jsonDataArray[jsonDataArrayPointer].getInt(0) >> 16);
writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getInt(0);
break;
case ModbusBridgeType::mb_uint32:
writeData[jsonDataArrayPointer++] = (uint16_t)(jsonDataArray[jsonDataArrayPointer].getUInt(0) >> 16);
writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getUInt(0);
break;
case ModbusBridgeType::mb_raw:
writeData[jsonDataArrayPointer] = (uint8_t)jsonDataArray[jsonDataArrayPointer*2].getUInt(0) << 8 + (uint8_t)jsonDataArray[(jsonDataArrayPointer*2)+1].getUInt(0);
break;
case ModbusBridgeType::mb_hex:
writeData[jsonDataArrayPointer] = (uint8_t)jsonDataArray[jsonDataArrayPointer*2].getUInt(0) << 8 + (uint8_t)jsonDataArray[(jsonDataArrayPointer*2)+1].getUInt(0);
break;
default:
errorcode = ModbusBridgeError::wrongtype;
break;
}
}
}
}
}
// Handle errorcode and exit function when an error has occured
if (errorcode != ModbusBridgeError::noerror) if (errorcode != ModbusBridgeError::noerror)
{ {
AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: MBR Send Error %d"), (uint8_t)errorcode); AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: MBR Send Error %u"), (uint8_t)errorcode);
free(writeData);
return; return;
} }
tasmotaModbus->Send(modbusBridge.deviceAddress, (uint8_t)modbusBridge.functionCode, modbusBridge.startAddress, modbusBridge.registerCount); // Adapt data according to modbus protocol
for (uint8_t writeDataPointer = 0; writeDataPointer < modbusBridge.dataCount; writeDataPointer++)
{
// For function code 5, on and off are 0xFF00 and 0x0000, not 1 and 0
if (modbusBridge.functionCode == ModbusBridgeFunctionCode::mb_writeSingleCoil)
{
writeData[writeDataPointer] = writeData[writeDataPointer] ? 0xFF00 : 0x0000;
}
}
// If writing a single coil or single register, the register count is always 1. We also prevent writing data out of range
if ((modbusBridge.functionCode == ModbusBridgeFunctionCode::mb_writeSingleCoil) || (modbusBridge.functionCode == ModbusBridgeFunctionCode::mb_writeSingleRegister))
modbusBridge.dataCount = 1;
uint8_t error = tasmotaModbus->Send(modbusBridge.deviceAddress, (uint8_t)modbusBridge.functionCode, modbusBridge.startAddress, modbusBridge.dataCount, writeData);
if (error) AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: MBR Driver send error %u"), error);
free(writeData);
ResponseCmndDone(); ResponseCmndDone();
} }