From 988118372607679673b9f1749101f3e12aca0086 Mon Sep 17 00:00:00 2001 From: JeroenSt Date: Wed, 17 Aug 2022 19:55:41 +0200 Subject: [PATCH 01/15] In progess: Developping modbus write functionality --- .../TasmotaModbus-3.4.0/src/TasmotaModbus.cpp | 84 ++++++++++++++++--- .../TasmotaModbus-3.4.0/src/TasmotaModbus.h | 6 +- .../xdrv_63_modbus_bridge.ino | 67 +++++++++++---- 3 files changed, 129 insertions(+), 28 deletions(-) diff --git a/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp b/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp index bd9b7a06b..d6319beb0 100644 --- a/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp +++ b/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp @@ -15,6 +15,8 @@ You should have received a copy of the GNU General Public License along with this program. If not, see . + + Documentation about modbus protocol: https://www.modbustools.com/modbus.html */ #include "TasmotaModbus.h" @@ -53,24 +55,82 @@ int TasmotaModbus::Begin(long speed, uint32_t config) 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 < 5) + { + frame = (uint8_t *)malloc(8); // Addres(1), Function(1), Start Address(2), Registercount (2) or Data(2), CRC(2) + } + else + { + if (register_count > 40) return 14; // Prevent to many allocation of memory while writing data + frame = (uint8_t *)malloc(9 + (register_count * 2)); // Addres(1), Function(1), Start Address(2), Quantity of registers (2), Bytecount(1), Data(2..n), CRC(2) + } mb_address = device_address; // Save address for receipt check - frame[0] = mb_address; // 0xFE default device address or dedicated like 0x01 - frame[1] = function_code; - frame[2] = (uint8_t)(start_address >> 8); // MSB - frame[3] = (uint8_t)(start_address); // LSB - frame[4] = (uint8_t)(register_count >> 8); // MSB - frame[5] = (uint8_t)(register_count); // LSB - uint16_t crc = CalculateCRC(frame, 6); - frame[6] = (uint8_t)(crc); - frame[7] = (uint8_t)(crc >> 8); + frame[framepointer++] = mb_address; // 0xFE default device address or dedicated like 0x01 + frame[framepointer++] = function_code; + frame[framepointer++] = (uint8_t)(start_address >> 8); // MSB + frame[framepointer++] = (uint8_t)(start_address); // LSB + if ((function_code < 5) || (function_code == 15) || (function_code == 16)) + { + frame[framepointer++] = (uint8_t)(register_count >> 8); // MSB + frame[framepointer++] = (uint8_t)(register_count); // LSB + } + + 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 + } + + if ((function_code == 15) || (function_code == 16)) + { + 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(); - write(frame, sizeof(frame)); + write(frame, framepointer); + free(frame); + return 0; } bool TasmotaModbus::ReceiveReady() diff --git a/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.h b/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.h index 78fc3d50b..a4c5b9629 100644 --- a/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.h +++ b/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.h @@ -34,8 +34,6 @@ class TasmotaModbus : public TasmotaSerial { 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(); /* Return codes: @@ -51,7 +49,11 @@ class TasmotaModbus : public TasmotaSerial { * 9 = Crc error * 10 = Gateway Path Unavailable * 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 Receive16BitRegister(uint16_t *value); uint8_t Receive32BitRegister(float *value); diff --git a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino index b5127deb2..1b4f8027b 100644 --- a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino +++ b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino @@ -27,7 +27,10 @@ * bridge. * * Example Command: + * -- Read Input Register -- * ModbusSend {"deviceaddress": 1, "functioncode": 3, "startaddress": 1, "type":"uint16", "count":2} + * -- Write multiple coils -- + * ModbusSend {"deviceaddress": 1, "functioncode": 15, "startaddress": 1, "type":"uint16", "count":14, "data":[1,2,3,4,5,6,7,8,9,10,11,12,13,14]} \*********************************************************************************************/ #define XDRV_63 63 @@ -49,6 +52,7 @@ #define D_JSON_MODBUS_TYPE "Type" // allready defined #define D_JSON_MODBUS_VALUES "Values" #define D_JSON_MODBUS_LENGTH "Length" +#define D_JSON_MODBUS_DATA "Data" #ifndef USE_MODBUS_BRIDGE_TCP const char kModbusBridgeCommands[] PROGMEM = "Modbus|" // Prefix @@ -104,12 +108,14 @@ enum class ModbusBridgeError enum class ModbusBridgeFunctionCode { mb_undefined = 0, - mb_readCoilstartregister = 1, - mb_readContactstartregister = 2, - mb_readHoldingstartregister = 3, - mb_readInputstartregister = 4, + mb_readCoilStatus = 1, + mb_readContactStatus = 2, + mb_readHoldingRegisters = 3, + mb_readInputRegisters = 4, mb_writeSingleCoil = 5, - mb_writeSinglestartregister = 6 + mb_writeSingleRegister = 6, + mb_writeMultipleCoils = 15, + mb_writeMultipleRegisters = 16 }; enum class ModbusBridgeType @@ -144,6 +150,7 @@ struct ModbusBridge uint8_t deviceAddress = 0; uint8_t count = 0; bool raw = false; + }; ModbusBridge modbusBridge; @@ -154,7 +161,7 @@ ModbusBridge modbusBridge; // 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))) 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 @@ -257,8 +264,10 @@ void ModbusBridgeHandle(void) errorcode = ModbusBridgeError::wrongdeviceaddress; else if ((uint8_t)modbusBridge.functionCode != (uint8_t)buffer[1]) errorcode = ModbusBridgeError::wrongfunctioncode; - else if ((uint8_t)modbusBridge.registerCount * 2 != (uint8_t)buffer[2]) + else if (((uint8_t)modbusBridge.functionCode < 5) && ((uint8_t)modbusBridge.registerCount * 2 != (uint8_t)buffer[2])) + { errorcode = ModbusBridgeError::wrongregistercount; + } else { if (modbusBridge.type == ModbusBridgeType::mb_raw) @@ -470,6 +479,10 @@ void ModbusTCPHandle(void) void CmndModbusBridgeSend(void) { + uint16_t *writeData = NULL; + uint8_t writeDataSize = 0; + ModbusBridgeError errorcode = ModbusBridgeError::noerror; + JsonParser parser(XdrvMailbox.data); JsonParserObject root = parser.getRootObject(); if (!root) @@ -478,16 +491,16 @@ void CmndModbusBridgeSend(void) modbusBridge.deviceAddress = root.getUInt(PSTR(D_JSON_MODBUS_DEVICE_ADDRESS), 0); uint8_t functionCode = root.getUInt(PSTR(D_JSON_MODBUS_FUNCTION_CODE), 0); modbusBridge.startAddress = root.getULong(PSTR(D_JSON_MODBUS_START_ADDRESS), 0); + const char *stype = root.getStr(PSTR(D_JSON_MODBUS_TYPE), "uint8"); modbusBridge.count = root.getUInt(PSTR(D_JSON_MODBUS_COUNT), 1); - ModbusBridgeError errorcode = ModbusBridgeError::noerror; if (modbusBridge.deviceAddress == 0) errorcode = ModbusBridgeError::wrongdeviceaddress; - else if (modbusBridge.startAddress == 0) - ; - else if (functionCode > 4) - errorcode = ModbusBridgeError::wrongfunctioncode; // Writing is not supported + else if ((functionCode > (uint8_t)ModbusBridgeFunctionCode::mb_writeSingleRegister) && + (functionCode != (uint8_t)ModbusBridgeFunctionCode::mb_writeMultipleCoils) && + (functionCode != (uint8_t)ModbusBridgeFunctionCode::mb_writeMultipleRegisters)) + errorcode = ModbusBridgeError::wrongfunctioncode; // Invalid function code else { modbusBridge.functionCode = static_cast(functionCode); @@ -506,7 +519,7 @@ void CmndModbusBridgeSend(void) modbusBridge.type = ModbusBridgeType::mb_int32; modbusBridge.registerCount = 2 * modbusBridge.count; } - else if (strcmp(stype, "uint16") == 0) + else if ((strcmp(stype, "uint16") == 0) || (strcmp(stype, "") == 0)) // Default is uint16 { modbusBridge.type = ModbusBridgeType::mb_uint16; modbusBridge.registerCount = modbusBridge.count; @@ -537,13 +550,39 @@ void CmndModbusBridgeSend(void) if (modbusBridge.registerCount > MBR_MAX_REGISTERS) errorcode = ModbusBridgeError::wrongcount; + // If write data is specified in JSON copy it into writeData array + JsonParserArray jsonDataArray = root[PSTR(D_JSON_MODBUS_DATA)].getArray(); + if (jsonDataArray.isArray()) + { + writeDataSize = jsonDataArray.size(); + + if (modbusBridge.registerCount != writeDataSize) + { + errorcode = ModbusBridgeError::wrongcount; + } + else + { + writeData = (uint16_t *)malloc(writeDataSize); + for (uint8_t jsonDataArrayPointer = 0; jsonDataArrayPointer < writeDataSize; jsonDataArrayPointer++) + { + writeData[jsonDataArrayPointer] = jsonDataArray[jsonDataArrayPointer].getUInt(0); + } + } + } + + // Handle errorcode and exit function when an error has occured if (errorcode != ModbusBridgeError::noerror) { AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: MBR Send Error %d"), (uint8_t)errorcode); + free(writeData); return; } - tasmotaModbus->Send(modbusBridge.deviceAddress, (uint8_t)modbusBridge.functionCode, modbusBridge.startAddress, modbusBridge.registerCount); + // 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.registerCount = 1; + + tasmotaModbus->Send(modbusBridge.deviceAddress, (uint8_t)modbusBridge.functionCode, modbusBridge.startAddress, modbusBridge.registerCount, writeData); + free(writeData); ResponseCmndDone(); } From 2c2a73506db39f424f5c004f98275f37bdec60dd Mon Sep 17 00:00:00 2001 From: JeroenSt Date: Wed, 17 Aug 2022 19:55:41 +0200 Subject: [PATCH 02/15] Work in progress. --- tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino index 1b4f8027b..7958fe388 100644 --- a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino +++ b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino @@ -562,7 +562,7 @@ void CmndModbusBridgeSend(void) } else { - writeData = (uint16_t *)malloc(writeDataSize); + writeData = (uint16_t *)malloc(writeDataSize*2); for (uint8_t jsonDataArrayPointer = 0; jsonDataArrayPointer < writeDataSize; jsonDataArrayPointer++) { writeData[jsonDataArrayPointer] = jsonDataArray[jsonDataArrayPointer].getUInt(0); From 92319eedd2cc7495ffb5c01ecb30c0e431bafdc4 Mon Sep 17 00:00:00 2001 From: JeroenSt Date: Wed, 17 Aug 2022 19:55:41 +0200 Subject: [PATCH 03/15] Work in progress... --- .../xdrv_63_modbus_bridge.ino | 42 ++++++++++++------- 1 file changed, 26 insertions(+), 16 deletions(-) diff --git a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino index 7958fe388..b93fa2d19 100644 --- a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino +++ b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino @@ -22,7 +22,7 @@ * Modbus Bridge using Modbus library (TasmotaModbus) * * 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 * bridge. * @@ -102,7 +102,8 @@ enum class ModbusBridgeError wrongstartaddress = 4, wrongtype = 5, wrongregistercount = 6, - wrongcount = 7 + wrongcount = 7, + tomanydata = 8 }; enum class ModbusBridgeFunctionCode @@ -150,7 +151,6 @@ struct ModbusBridge uint8_t deviceAddress = 0; uint8_t count = 0; bool raw = false; - }; ModbusBridge modbusBridge; @@ -161,8 +161,10 @@ ModbusBridge modbusBridge; // bool ModbusBridgeBegin(void) { - if ((Settings->modbus_sbaudrate < 1) || (Settings->modbus_sbaudrate > (115200 / 300))) Settings->modbus_sbaudrate = (uint8_t)((uint32_t)MBR_BAUDRATE / 300); - if (Settings->modbus_sconfig > TS_SERIAL_8O2) Settings->modbus_sconfig = TS_SERIAL_8N1; + if ((Settings->modbus_sbaudrate < 1) || (Settings->modbus_sbaudrate > (115200 / 300))) + 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 if (result) @@ -193,7 +195,7 @@ void SetModbusBridgeBaudrate(uint32_t baudrate) { if ((baudrate >= 300) && (baudrate <= 115200)) { - if (baudrate / 300 != Settings->modbus_sbaudrate) + if (baudrate / 300 != Settings->modbus_sbaudrate) { Settings->modbus_sbaudrate = baudrate / 300; ModbusBridgeBegin(); @@ -236,10 +238,10 @@ void ModbusBridgeHandle(void) MBAP_Header[5] = (modbusBridge.registerCount * 2) + 3; MBAP_Header[6] = buffer[0]; // Send slave address client.write(MBAP_Header, 7); - client.write(buffer + 1, 1); // Send Functioncode + client.write(buffer + 1, 1); // Send Functioncode uint8_t bytecount[1]; bytecount[0] = modbusBridge.registerCount * 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.flush(); AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: MBRTCP from Modbus deviceAddress %d, writing %d bytes to client"), buffer[0], (modbusBridge.registerCount * 2) + 9); @@ -554,18 +556,25 @@ void CmndModbusBridgeSend(void) JsonParserArray jsonDataArray = root[PSTR(D_JSON_MODBUS_DATA)].getArray(); if (jsonDataArray.isArray()) { - writeDataSize = jsonDataArray.size(); - - if (modbusBridge.registerCount != writeDataSize) + if (modbusBridge.registerCount > 40) { - errorcode = ModbusBridgeError::wrongcount; + errorcode = ModbusBridgeError::tomanydata; } else { - writeData = (uint16_t *)malloc(writeDataSize*2); - for (uint8_t jsonDataArrayPointer = 0; jsonDataArrayPointer < writeDataSize; jsonDataArrayPointer++) + writeDataSize = jsonDataArray.size(); + + if (modbusBridge.registerCount != writeDataSize) { - writeData[jsonDataArrayPointer] = jsonDataArray[jsonDataArrayPointer].getUInt(0); + errorcode = ModbusBridgeError::wrongcount; + } + else + { + writeData = (uint16_t *)malloc(writeDataSize * 2); + for (uint8_t jsonDataArrayPointer = 0; jsonDataArrayPointer < writeDataSize; jsonDataArrayPointer++) + { + writeData[jsonDataArrayPointer] = jsonDataArray[jsonDataArrayPointer].getUInt(0); + } } } } @@ -579,7 +588,8 @@ void CmndModbusBridgeSend(void) } // 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.registerCount = 1; + if ((modbusBridge.functionCode == ModbusBridgeFunctionCode::mb_writeSingleCoil) || (modbusBridge.functionCode == ModbusBridgeFunctionCode::mb_writeSingleRegister)) + modbusBridge.registerCount = 1; tasmotaModbus->Send(modbusBridge.deviceAddress, (uint8_t)modbusBridge.functionCode, modbusBridge.startAddress, modbusBridge.registerCount, writeData); free(writeData); From 355e31ff2edc72060db788db10e2cee5ddc8f5fd Mon Sep 17 00:00:00 2001 From: JeroenSt Date: Wed, 17 Aug 2022 19:55:41 +0200 Subject: [PATCH 04/15] Work in progress... --- .../TasmotaModbus-3.4.0/src/TasmotaModbus.cpp | 7 +- .../xdrv_63_modbus_bridge.ino | 118 +++++++++++++----- 2 files changed, 93 insertions(+), 32 deletions(-) diff --git a/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp b/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp index d6319beb0..f7193674c 100644 --- a/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp +++ b/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp @@ -66,7 +66,6 @@ uint8_t TasmotaModbus::Send(uint8_t device_address, uint8_t function_code, uint1 } else { - if (register_count > 40) return 14; // Prevent to many allocation of memory while writing data frame = (uint8_t *)malloc(9 + (register_count * 2)); // Addres(1), Function(1), Start Address(2), Quantity of registers (2), Bytecount(1), Data(2..n), CRC(2) } @@ -138,11 +137,12 @@ bool TasmotaModbus::ReceiveReady() 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; 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()) { uint8_t data = (uint8_t)read(); if (!mb_len) { // Skip leading data as provided by hardware serial @@ -166,6 +166,7 @@ uint8_t TasmotaModbus::ReceiveBuffer(uint8_t *buffer, uint8_t register_count) // 10 = Gateway Path Unavailable // 11 = Gateway Target device failed to respond } + if ((buffer[2] == 5) || (buffer[2] == 6) || (buffer[2] == 15) || (buffer[2] == 16)) header_length = 2; // Addr, Func } } diff --git a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino index b93fa2d19..86048d723 100644 --- a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino +++ b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino @@ -101,7 +101,7 @@ enum class ModbusBridgeError wrongfunctioncode = 3, wrongstartaddress = 4, wrongtype = 5, - wrongregistercount = 6, + wrongdataCount = 6, wrongcount = 7, tomanydata = 8 }; @@ -146,7 +146,7 @@ struct ModbusBridge ModbusBridgeFunctionCode functionCode = ModbusBridgeFunctionCode::mb_undefined; ModbusBridgeType type = ModbusBridgeType::mb_undefined; - uint16_t registerCount = 0; + uint16_t dataCount = 0; uint16_t startAddress = 0; uint8_t deviceAddress = 0; uint8_t count = 0; @@ -213,8 +213,8 @@ void ModbusBridgeHandle(void) if (data_ready) { uint8_t *buffer; - buffer = (uint8_t *)malloc(5 + (modbusBridge.registerCount * 2)); // Addres(1), Function(1), Length(1), Data(1..n), CRC(2) - uint32_t error = tasmotaModbus->ReceiveBuffer(buffer, modbusBridge.registerCount); + 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.dataCount); if (error) { @@ -234,17 +234,17 @@ void ModbusBridgeHandle(void) MBAP_Header[1] = modbusBridgeTCP.tcp_transaction_id; MBAP_Header[2] = 0; MBAP_Header[3] = 0; - MBAP_Header[4] = ((modbusBridge.registerCount * 2) + 3) >> 8; - MBAP_Header[5] = (modbusBridge.registerCount * 2) + 3; + MBAP_Header[4] = ((modbusBridge.dataCount * 2) + 3) >> 8; + MBAP_Header[5] = (modbusBridge.dataCount * 2) + 3; MBAP_Header[6] = buffer[0]; // Send slave address client.write(MBAP_Header, 7); client.write(buffer + 1, 1); // Send Functioncode uint8_t bytecount[1]; - bytecount[0] = modbusBridge.registerCount * 2; - client.write(bytecount, 1); // Send length of rtu data - client.write(buffer + 3, (modbusBridge.registerCount * 2)); // Don't send CRC + bytecount[0] = modbusBridge.dataCount * 2; + client.write(bytecount, 1); // Send length of rtu data + client.write(buffer + 3, (modbusBridge.dataCount * 2)); // Don't send CRC 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 @@ -266,9 +266,9 @@ void ModbusBridgeHandle(void) errorcode = ModbusBridgeError::wrongdeviceaddress; else if ((uint8_t)modbusBridge.functionCode != (uint8_t)buffer[1]) errorcode = ModbusBridgeError::wrongfunctioncode; - else if (((uint8_t)modbusBridge.functionCode < 5) && ((uint8_t)modbusBridge.registerCount * 2 != (uint8_t)buffer[2])) + else if (((uint8_t)modbusBridge.functionCode < 5) && ((uint8_t)modbusBridge.dataCount * 2 != (uint8_t)buffer[2])) { - errorcode = ModbusBridgeError::wrongregistercount; + errorcode = ModbusBridgeError::wrongdataCount; } else { @@ -285,7 +285,7 @@ void ModbusBridgeHandle(void) ResponseJsonEnd(); 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 ((buffer[1] > 0) && (buffer[1] < 5)) // Read Registers { Response_P(PSTR("{\"" D_JSON_MODBUS_RECEIVED "\":{")); ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_DEVICE_ADDRESS "\":%d,"), buffer[0]); @@ -350,6 +350,42 @@ void ModbusBridgeHandle(void) if (errorcode == ModbusBridgeError::noerror) MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_JSON_MODBUS_RECEIVED)); } + else if ((buffer[1] == 5) || (buffer[1] == 6)) // Write Single Register + { + 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,"), modbusBridge.count); + ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_VALUES "\":[")); + + char svalue[MBR_MAX_VALUE_LENGTH + 1] = ""; + + uint16_t value = 0; + ((uint8_t *)&value)[1] = buffer[2]; + ((uint8_t *)&value)[0] = buffer[3]; + // ToDo: make uint, int float etc. + snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%u", value); + + ResponseAppend_P(PSTR("]}")); + ResponseJsonEnd(); + if (errorcode == ModbusBridgeError::noerror) + MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_JSON_MODBUS_RECEIVED)); + } + else if ((buffer[1] == 15) || (buffer[1] == 16)) // Write Single Register + { + 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 errorcode = ModbusBridgeError::wrongfunctioncode; } @@ -461,13 +497,13 @@ void ModbusTCPHandle(void) uint8_t mbdeviceaddress = (uint8_t)modbusBridgeTCP.tcp_buf[6]; 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])); - 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])); 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 @@ -514,49 +550,49 @@ void CmndModbusBridgeSend(void) if (strcmp(stype, "int16") == 0) { modbusBridge.type = ModbusBridgeType::mb_int16; - modbusBridge.registerCount = modbusBridge.count; + modbusBridge.dataCount = modbusBridge.count; } else if (strcmp(stype, "int32") == 0) { modbusBridge.type = ModbusBridgeType::mb_int32; - modbusBridge.registerCount = 2 * modbusBridge.count; + modbusBridge.dataCount = 2 * modbusBridge.count; } else if ((strcmp(stype, "uint16") == 0) || (strcmp(stype, "") == 0)) // Default is uint16 { modbusBridge.type = ModbusBridgeType::mb_uint16; - modbusBridge.registerCount = modbusBridge.count; + modbusBridge.dataCount = modbusBridge.count; } else if (strcmp(stype, "uint32") == 0) { modbusBridge.type = ModbusBridgeType::mb_uint32; - modbusBridge.registerCount = 2 * modbusBridge.count; + modbusBridge.dataCount = 2 * modbusBridge.count; } else if (strcmp(stype, "float") == 0) { modbusBridge.type = ModbusBridgeType::mb_float; - modbusBridge.registerCount = 2 * modbusBridge.count; + modbusBridge.dataCount = 2 * modbusBridge.count; } else if (strcmp(stype, "raw") == 0) { modbusBridge.type = ModbusBridgeType::mb_raw; - modbusBridge.registerCount = modbusBridge.count; + modbusBridge.dataCount = modbusBridge.count; } else if (strcmp(stype, "bit") == 0) { modbusBridge.type = ModbusBridgeType::mb_bit; - modbusBridge.registerCount = modbusBridge.count; + modbusBridge.dataCount = modbusBridge.count; } else errorcode = ModbusBridgeError::wrongtype; - if (modbusBridge.registerCount > MBR_MAX_REGISTERS) + if (modbusBridge.dataCount > MBR_MAX_REGISTERS) errorcode = ModbusBridgeError::wrongcount; // If write data is specified in JSON copy it into writeData array JsonParserArray jsonDataArray = root[PSTR(D_JSON_MODBUS_DATA)].getArray(); if (jsonDataArray.isArray()) { - if (modbusBridge.registerCount > 40) + if (modbusBridge.dataCount > 40) { errorcode = ModbusBridgeError::tomanydata; } @@ -564,16 +600,40 @@ void CmndModbusBridgeSend(void) { writeDataSize = jsonDataArray.size(); - if (modbusBridge.registerCount != writeDataSize) + if (modbusBridge.dataCount != writeDataSize) { errorcode = ModbusBridgeError::wrongcount; } else { + // ToDo: Convert uint, int float etc. to writedata writeData = (uint16_t *)malloc(writeDataSize * 2); for (uint8_t jsonDataArrayPointer = 0; jsonDataArrayPointer < writeDataSize; jsonDataArrayPointer++) { - writeData[jsonDataArrayPointer] = jsonDataArray[jsonDataArrayPointer].getUInt(0); + switch (modbusBridge.type) + { + case ModbusBridgeType::mb_int16: + writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getUInt(0); + break; + case ModbusBridgeType::mb_uint16: + writeData[jsonDataArrayPointer] = (int16_t)jsonDataArray[jsonDataArrayPointer].getInt(0); + break; + case ModbusBridgeType::mb_float: + // TODO + errorcode = ModbusBridgeError::wrongtype; + break; + case ModbusBridgeType::mb_int32: + // TODO + errorcode = ModbusBridgeError::wrongtype; + break; + case ModbusBridgeType::mb_uint32: + // TODO + errorcode = ModbusBridgeError::wrongtype; + break; + case ModbusBridgeType::mb_raw: + writeData[jsonDataArrayPointer] = (uint8_t)jsonDataArray[jsonDataArrayPointer*2].getUInt(0) << 8 + (uint8_t)jsonDataArray[(jsonDataArrayPointer*2)+1].getUInt(0); + break; + } } } } @@ -589,9 +649,9 @@ void CmndModbusBridgeSend(void) // 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.registerCount = 1; + modbusBridge.dataCount = 1; - tasmotaModbus->Send(modbusBridge.deviceAddress, (uint8_t)modbusBridge.functionCode, modbusBridge.startAddress, modbusBridge.registerCount, writeData); + tasmotaModbus->Send(modbusBridge.deviceAddress, (uint8_t)modbusBridge.functionCode, modbusBridge.startAddress, modbusBridge.dataCount, writeData); free(writeData); ResponseCmndDone(); } From 96a1eb3ae5473093220d3a13a264673581b95c09 Mon Sep 17 00:00:00 2001 From: JeroenSt Date: Wed, 17 Aug 2022 19:55:41 +0200 Subject: [PATCH 05/15] In the first serie of tests this seems to work right. --- .../TasmotaModbus-3.4.0/src/TasmotaModbus.cpp | 12 +-- .../xdrv_63_modbus_bridge.ino | 79 ++++++++----------- 2 files changed, 39 insertions(+), 52 deletions(-) diff --git a/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp b/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp index f7193674c..59f393c06 100644 --- a/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp +++ b/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp @@ -75,13 +75,12 @@ uint8_t TasmotaModbus::Send(uint8_t device_address, uint8_t function_code, uint1 frame[framepointer++] = function_code; frame[framepointer++] = (uint8_t)(start_address >> 8); // MSB frame[framepointer++] = (uint8_t)(start_address); // LSB - if ((function_code < 5) || (function_code == 15) || (function_code == 16)) + if (function_code < 5) { frame[framepointer++] = (uint8_t)(register_count >> 8); // MSB frame[framepointer++] = (uint8_t)(register_count); // LSB } - - if ((function_code == 5) || (function_code == 6)) + else if ((function_code == 5) || (function_code == 6)) { if (registers == NULL) { @@ -96,9 +95,10 @@ uint8_t TasmotaModbus::Send(uint8_t device_address, uint8_t function_code, uint1 frame[framepointer++] = (uint8_t)(registers[0] >> 8); // MSB frame[framepointer++] = (uint8_t)(registers[0]); // LSB } - - if ((function_code == 15) || (function_code == 16)) + 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) { @@ -166,7 +166,7 @@ uint8_t TasmotaModbus::ReceiveBuffer(uint8_t *buffer, uint8_t data_count) // 10 = Gateway Path Unavailable // 11 = Gateway Target device failed to respond } - if ((buffer[2] == 5) || (buffer[2] == 6) || (buffer[2] == 15) || (buffer[2] == 16)) header_length = 2; // Addr, Func + if ((buffer[1] == 5) || (buffer[1] == 6) || (buffer[1] == 15) || (buffer[1] == 16)) header_length = 4; // Addr, Func, StartAddr } } diff --git a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino index 86048d723..371328d83 100644 --- a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino +++ b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino @@ -218,7 +218,7 @@ void ModbusBridgeHandle(void) 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); return; } @@ -285,12 +285,21 @@ void ModbusBridgeHandle(void) ResponseJsonEnd(); MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_JSON_MODBUS_RECEIVED)); } - else if ((buffer[1] > 0) && (buffer[1] < 5)) // Read Registers + else if ((buffer[1] > 0) && (buffer[1] < 7)) // Read Registers { + uint8_t dataOffset = 3; 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,"), 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_COUNT "\":%d,"), modbusBridge.count); ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_VALUES "\":[")); @@ -301,10 +310,10 @@ void ModbusBridgeHandle(void) if (modbusBridge.type == ModbusBridgeType::mb_float) { float value = 0; - ((uint8_t *)&value)[3] = buffer[3 + (count * 4)]; // Get float values - ((uint8_t *)&value)[2] = buffer[4 + (count * 4)]; - ((uint8_t *)&value)[1] = buffer[5 + (count * 4)]; - ((uint8_t *)&value)[0] = buffer[6 + (count * 4)]; + ((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); } else @@ -313,10 +322,10 @@ void ModbusBridgeHandle(void) (modbusBridge.type == ModbusBridgeType::mb_uint32)) { uint32_t value = 0; - ((uint8_t *)&value)[3] = buffer[3 + (count * 4)]; // Get int values - ((uint8_t *)&value)[2] = buffer[4 + (count * 4)]; - ((uint8_t *)&value)[1] = buffer[5 + (count * 4)]; - ((uint8_t *)&value)[0] = buffer[6 + (count * 4)]; + ((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) snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", value); else @@ -326,8 +335,8 @@ void ModbusBridgeHandle(void) (modbusBridge.type == ModbusBridgeType::mb_uint16)) { uint16_t value = 0; - ((uint8_t *)&value)[1] = buffer[3 + (count * 2)]; - ((uint8_t *)&value)[0] = buffer[4 + (count * 2)]; + ((uint8_t *)&value)[1] = buffer[dataOffset + (count * 2)]; + ((uint8_t *)&value)[0] = buffer[dataOffset + 1 + (count * 2)]; if (modbusBridge.type == ModbusBridgeType::mb_int16) snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", value); else @@ -335,7 +344,7 @@ void ModbusBridgeHandle(void) } 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)); } } @@ -350,37 +359,14 @@ void ModbusBridgeHandle(void) if (errorcode == ModbusBridgeError::noerror) MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_JSON_MODBUS_RECEIVED)); } - else if ((buffer[1] == 5) || (buffer[1] == 6)) // Write Single Register + 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_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,"), modbusBridge.count); - ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_VALUES "\":[")); - - char svalue[MBR_MAX_VALUE_LENGTH + 1] = ""; - - uint16_t value = 0; - ((uint8_t *)&value)[1] = buffer[2]; - ((uint8_t *)&value)[0] = buffer[3]; - // ToDo: make uint, int float etc. - snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%u", value); - - ResponseAppend_P(PSTR("]}")); - ResponseJsonEnd(); - if (errorcode == ModbusBridgeError::noerror) - MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_JSON_MODBUS_RECEIVED)); - } - else if ((buffer[1] == 15) || (buffer[1] == 16)) // Write Single Register - { - 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("\"" D_JSON_MODBUS_COUNT "\":%d"), (buffer[4] << 8) + buffer[5]); ResponseAppend_P(PSTR("}")); ResponseJsonEnd(); if (errorcode == ModbusBridgeError::noerror) @@ -623,12 +609,12 @@ void CmndModbusBridgeSend(void) errorcode = ModbusBridgeError::wrongtype; break; case ModbusBridgeType::mb_int32: - // TODO - errorcode = ModbusBridgeError::wrongtype; + writeData[jsonDataArrayPointer++] = (int16_t)(jsonDataArray[jsonDataArrayPointer].getInt(0) >> 16); + writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getInt(0); break; case ModbusBridgeType::mb_uint32: - // TODO - errorcode = ModbusBridgeError::wrongtype; + 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); @@ -642,7 +628,7 @@ void CmndModbusBridgeSend(void) // Handle errorcode and exit function when an error has occured 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; } @@ -651,7 +637,8 @@ void CmndModbusBridgeSend(void) if ((modbusBridge.functionCode == ModbusBridgeFunctionCode::mb_writeSingleCoil) || (modbusBridge.functionCode == ModbusBridgeFunctionCode::mb_writeSingleRegister)) modbusBridge.dataCount = 1; - tasmotaModbus->Send(modbusBridge.deviceAddress, (uint8_t)modbusBridge.functionCode, modbusBridge.startAddress, modbusBridge.dataCount, writeData); + 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(); } From a04a44665490d24d9093412be3669cc4cf3317b5 Mon Sep 17 00:00:00 2001 From: JeroenSt Date: Wed, 17 Aug 2022 19:55:41 +0200 Subject: [PATCH 06/15] work in progress --- tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino index 371328d83..b4bd13651 100644 --- a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino +++ b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino @@ -30,7 +30,7 @@ * -- Read Input Register -- * ModbusSend {"deviceaddress": 1, "functioncode": 3, "startaddress": 1, "type":"uint16", "count":2} * -- Write multiple coils -- - * ModbusSend {"deviceaddress": 1, "functioncode": 15, "startaddress": 1, "type":"uint16", "count":14, "data":[1,2,3,4,5,6,7,8,9,10,11,12,13,14]} + * ModbusSend {"deviceaddress": 1, "functioncode": 15, "startaddress": 1, "type":"uint16", "count":4, "values":[1,2,3,4]} \*********************************************************************************************/ #define XDRV_63 63 @@ -52,7 +52,6 @@ #define D_JSON_MODBUS_TYPE "Type" // allready defined #define D_JSON_MODBUS_VALUES "Values" #define D_JSON_MODBUS_LENGTH "Length" -#define D_JSON_MODBUS_DATA "Data" #ifndef USE_MODBUS_BRIDGE_TCP const char kModbusBridgeCommands[] PROGMEM = "Modbus|" // Prefix @@ -575,7 +574,7 @@ void CmndModbusBridgeSend(void) errorcode = ModbusBridgeError::wrongcount; // If write data is specified in JSON copy it into writeData array - JsonParserArray jsonDataArray = root[PSTR(D_JSON_MODBUS_DATA)].getArray(); + JsonParserArray jsonDataArray = root[PSTR(D_JSON_MODBUS_VALUES)].getArray(); if (jsonDataArray.isArray()) { if (modbusBridge.dataCount > 40) @@ -586,7 +585,7 @@ void CmndModbusBridgeSend(void) { writeDataSize = jsonDataArray.size(); - if (modbusBridge.dataCount != writeDataSize) + if (modbusBridge.count != writeDataSize) { errorcode = ModbusBridgeError::wrongcount; } From 3470a5d4cdef69062a7f0c16f3a34ae378ef5a55 Mon Sep 17 00:00:00 2001 From: JeroenSt Date: Wed, 17 Aug 2022 19:55:41 +0200 Subject: [PATCH 07/15] Added Bit and Hex reading https://github.com/arendst/Tasmota/issues/9586#issuecomment-1216313774 --- .../TasmotaModbus-3.4.0/src/TasmotaModbus.cpp | 18 +- .../TasmotaModbus-3.4.0/src/TasmotaModbus.h | 1 + .../xdrv_63_modbus_bridge.ino | 161 ++++++++++++++++-- 3 files changed, 161 insertions(+), 19 deletions(-) diff --git a/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp b/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp index 59f393c06..483a20ad2 100644 --- a/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp +++ b/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp @@ -175,7 +175,7 @@ uint8_t TasmotaModbus::ReceiveBuffer(uint8_t *buffer, uint8_t data_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) { @@ -192,6 +192,22 @@ uint8_t TasmotaModbus::ReceiveBuffer(uint8_t *buffer, uint8_t data_count) 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) { // 0 1 2 3 4 5 6 diff --git a/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.h b/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.h index a4c5b9629..f0122b9b0 100644 --- a/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.h +++ b/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.h @@ -55,6 +55,7 @@ class TasmotaModbus : public TasmotaSerial { */ 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 Receive8BitRegister(uint8_t *value); uint8_t Receive16BitRegister(uint16_t *value); uint8_t Receive32BitRegister(float *value); diff --git a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino index b4bd13651..899e42a72 100644 --- a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino +++ b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino @@ -121,12 +121,15 @@ enum class ModbusBridgeFunctionCode enum class ModbusBridgeType { mb_undefined, + mb_uint8, mb_uint16, mb_uint32, + mb_int8, mb_int16, mb_int32, mb_float, mb_raw, + mb_hex, mb_bit }; @@ -265,15 +268,34 @@ void ModbusBridgeHandle(void) errorcode = ModbusBridgeError::wrongdeviceaddress; else if ((uint8_t)modbusBridge.functionCode != (uint8_t)buffer[1]) errorcode = ModbusBridgeError::wrongfunctioncode; - else if (((uint8_t)modbusBridge.functionCode < 5) && ((uint8_t)modbusBridge.dataCount * 2 != (uint8_t)buffer[2])) + else if ((uint8_t)modbusBridge.functionCode < 5) { - errorcode = ModbusBridgeError::wrongdataCount; + 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 * 1 != (uint8_t)buffer[2])) + errorcode = ModbusBridgeError::wrongdataCount; + else if ((modbusBridge.type == ModbusBridgeType::mb_bit) + && ((uint8_t)(((modbusBridge.dataCount - 1) >> 3) + 1) != (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 * 4 != (uint8_t)buffer[2])) + errorcode = ModbusBridgeError::wrongdataCount; + } } - else + if (errorcode == ModbusBridgeError::noerror) { 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++) { ResponseAppend_P(PSTR("%d"), buffer[i]); @@ -284,6 +306,19 @@ void ModbusBridgeHandle(void) ResponseJsonEnd(); MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_JSON_MODBUS_RECEIVED)); } + 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; @@ -303,28 +338,72 @@ void ModbusBridgeHandle(void) ResponseAppend_P(PSTR("\"" D_JSON_MODBUS_COUNT "\":%d,"), modbusBridge.count); 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++) + { + AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: for count %d %d"), (uint8_t)count, (uint8_t)data_count); char svalue[MBR_MAX_VALUE_LENGTH + 1] = ""; if (modbusBridge.type == ModbusBridgeType::mb_float) { float value = 0; - ((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)]; + if (buffer[1] < 3) + { + if (buffer[2] - (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); } + 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 { if ((modbusBridge.type == ModbusBridgeType::mb_int32) || (modbusBridge.type == ModbusBridgeType::mb_uint32)) { uint32_t value = 0; - ((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 (buffer[1] < 3) + { + if (buffer[2] - (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) snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", value); else @@ -334,21 +413,43 @@ void ModbusBridgeHandle(void) (modbusBridge.type == ModbusBridgeType::mb_uint16)) { uint16_t value = 0; - ((uint8_t *)&value)[1] = buffer[dataOffset + (count * 2)]; - ((uint8_t *)&value)[0] = buffer[dataOffset + 1 + (count * 2)]; + if (buffer[1] < 3) + { + AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: mb_int16 and func < 3 | %d %d %d"),dataOffset, (uint8_t)buffer[1], (uint8_t)buffer[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 + { + AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: mb_int16 and func < 3 %d %d %d"),dataOffset, (uint8_t)buffer[1], (uint8_t)buffer[2]); + ((uint8_t *)&value)[1] = buffer[dataOffset + (count * 2)]; + ((uint8_t *)&value)[0] = buffer[dataOffset + 1 + (count * 2)]; + } if (modbusBridge.type == ModbusBridgeType::mb_int16) snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", value); else 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) { 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)); - } + }*/ } ResponseAppend_P(PSTR("%s"), svalue); - if (count < modbusBridge.count - 1) + if (count < data_count - 1) ResponseAppend_P(PSTR(",")); } @@ -532,7 +633,12 @@ void CmndModbusBridgeSend(void) } modbusBridge.type = ModbusBridgeType::mb_undefined; - if (strcmp(stype, "int16") == 0) + if (strcmp(stype, "int8") == 0) + { + modbusBridge.type = ModbusBridgeType::mb_int8; + modbusBridge.dataCount = modbusBridge.count; + } + else if (strcmp(stype, "int16") == 0) { modbusBridge.type = ModbusBridgeType::mb_int16; modbusBridge.dataCount = modbusBridge.count; @@ -542,6 +648,11 @@ void CmndModbusBridgeSend(void) modbusBridge.type = ModbusBridgeType::mb_int32; modbusBridge.dataCount = 2 * modbusBridge.count; } + else if ((strcmp(stype, "uint8") == 0)) + { + modbusBridge.type = ModbusBridgeType::mb_uint8; + modbusBridge.dataCount = modbusBridge.count; + } else if ((strcmp(stype, "uint16") == 0) || (strcmp(stype, "") == 0)) // Default is uint16 { modbusBridge.type = ModbusBridgeType::mb_uint16; @@ -562,6 +673,11 @@ void CmndModbusBridgeSend(void) modbusBridge.type = ModbusBridgeType::mb_raw; 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) { modbusBridge.type = ModbusBridgeType::mb_bit; @@ -597,6 +713,12 @@ void CmndModbusBridgeSend(void) { switch (modbusBridge.type) { + case ModbusBridgeType::mb_int8: + writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getUInt(0); + break; + case ModbusBridgeType::mb_uint8: + writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getInt(0); + break; case ModbusBridgeType::mb_int16: writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getUInt(0); break; @@ -618,6 +740,9 @@ void CmndModbusBridgeSend(void) 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; } } } From fa3802cd6769076406e0c37272edbd2aa8a8c439 Mon Sep 17 00:00:00 2001 From: JeroenSt Date: Wed, 17 Aug 2022 19:55:42 +0200 Subject: [PATCH 08/15] Changed int and uint types --- tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino index 899e42a72..8d6eaecfc 100644 --- a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino +++ b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino @@ -714,16 +714,16 @@ void CmndModbusBridgeSend(void) switch (modbusBridge.type) { case ModbusBridgeType::mb_int8: - writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getUInt(0); - break; - case ModbusBridgeType::mb_uint8: writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getInt(0); break; - case ModbusBridgeType::mb_int16: + case ModbusBridgeType::mb_uint8: writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getUInt(0); break; + case ModbusBridgeType::mb_int16: + writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getInt(0); + break; case ModbusBridgeType::mb_uint16: - writeData[jsonDataArrayPointer] = (int16_t)jsonDataArray[jsonDataArrayPointer].getInt(0); + writeData[jsonDataArrayPointer] = (int16_t)jsonDataArray[jsonDataArrayPointer].getUInt(0); break; case ModbusBridgeType::mb_float: // TODO From 1d4ff834abe544953fe33d2ea578b66b5778971f Mon Sep 17 00:00:00 2001 From: JeroenSt Date: Wed, 17 Aug 2022 19:55:42 +0200 Subject: [PATCH 09/15] Solved error in reading (u)int32 value and removed logging --- tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino index 8d6eaecfc..6c1f5dcb2 100644 --- a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino +++ b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino @@ -287,7 +287,7 @@ void ModbusBridgeHandle(void) && ((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 * 4 != (uint8_t)buffer[2])) + && ((uint8_t)modbusBridge.dataCount * 2 != (uint8_t)buffer[2])) errorcode = ModbusBridgeError::wrongdataCount; } } From aabf188afbb17140516e93b5b4d01117ce8ed96e Mon Sep 17 00:00:00 2001 From: JeroenSt Date: Wed, 17 Aug 2022 19:55:42 +0200 Subject: [PATCH 10/15] (u)int8 and (u)int32 are now also working --- .../tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino index 6c1f5dcb2..1a18ae2e4 100644 --- a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino +++ b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino @@ -278,10 +278,10 @@ void ModbusBridgeHandle(void) else { if ((modbusBridge.type == ModbusBridgeType::mb_int8 || modbusBridge.type == ModbusBridgeType::mb_uint8) - && ((uint8_t)modbusBridge.dataCount * 1 != (uint8_t)buffer[2])) + && ((uint8_t)modbusBridge.dataCount * 2 != (uint8_t)buffer[2])) errorcode = ModbusBridgeError::wrongdataCount; else if ((modbusBridge.type == ModbusBridgeType::mb_bit) - && ((uint8_t)(((modbusBridge.dataCount - 1) >> 3) + 1) != (uint8_t)buffer[2])) + && ((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])) @@ -350,7 +350,6 @@ void ModbusBridgeHandle(void) } for (uint8_t count = 0; count < data_count; count++) { - AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: for count %d %d"), (uint8_t)count, (uint8_t)data_count); char svalue[MBR_MAX_VALUE_LENGTH + 1] = ""; if (modbusBridge.type == ModbusBridgeType::mb_float) { @@ -415,7 +414,6 @@ void ModbusBridgeHandle(void) uint16_t value = 0; if (buffer[1] < 3) { - AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: mb_int16 and func < 3 | %d %d %d"),dataOffset, (uint8_t)buffer[1], (uint8_t)buffer[2]); if (buffer[2] - (count * 2)) ((uint8_t *)&value)[0] = buffer[dataOffset + (count * 2)]; if ((buffer[2] - (count * 2)) >> 1) @@ -423,7 +421,6 @@ void ModbusBridgeHandle(void) } else { - AddLog(LOG_LEVEL_DEBUG, PSTR("MBS: mb_int16 and func < 3 %d %d %d"),dataOffset, (uint8_t)buffer[1], (uint8_t)buffer[2]); ((uint8_t *)&value)[1] = buffer[dataOffset + (count * 2)]; ((uint8_t *)&value)[0] = buffer[dataOffset + 1 + (count * 2)]; } @@ -636,7 +633,7 @@ void CmndModbusBridgeSend(void) if (strcmp(stype, "int8") == 0) { modbusBridge.type = ModbusBridgeType::mb_int8; - modbusBridge.dataCount = modbusBridge.count; + modbusBridge.dataCount = ((modbusBridge.count - 1) / 2) + 1; } else if (strcmp(stype, "int16") == 0) { @@ -651,7 +648,7 @@ void CmndModbusBridgeSend(void) else if ((strcmp(stype, "uint8") == 0)) { modbusBridge.type = ModbusBridgeType::mb_uint8; - modbusBridge.dataCount = modbusBridge.count; + modbusBridge.dataCount = ((modbusBridge.count - 1) / 2) + 1; } else if ((strcmp(stype, "uint16") == 0) || (strcmp(stype, "") == 0)) // Default is uint16 { @@ -681,7 +678,7 @@ void CmndModbusBridgeSend(void) else if (strcmp(stype, "bit") == 0) { modbusBridge.type = ModbusBridgeType::mb_bit; - modbusBridge.dataCount = modbusBridge.count; + modbusBridge.dataCount = (modbusBridge.count / 8) + 1; } else errorcode = ModbusBridgeError::wrongtype; From cc2c219aa29f2897cea1826a0f10df0be9a14241 Mon Sep 17 00:00:00 2001 From: JeroenSt Date: Wed, 17 Aug 2022 19:55:42 +0200 Subject: [PATCH 11/15] Modified reading of bits according to coil and input register specification --- tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino index 1a18ae2e4..d26d48ffa 100644 --- a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino +++ b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino @@ -377,7 +377,7 @@ void ModbusBridgeHandle(void) 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)); + snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", ((value >> (7 - (count & 7))) & 1)); } else { @@ -633,7 +633,7 @@ void CmndModbusBridgeSend(void) if (strcmp(stype, "int8") == 0) { modbusBridge.type = ModbusBridgeType::mb_int8; - modbusBridge.dataCount = ((modbusBridge.count - 1) / 2) + 1; + modbusBridge.dataCount = ((modbusBridge.count - 1) >> 1) + 1; } else if (strcmp(stype, "int16") == 0) { @@ -648,7 +648,7 @@ void CmndModbusBridgeSend(void) else if ((strcmp(stype, "uint8") == 0)) { modbusBridge.type = ModbusBridgeType::mb_uint8; - modbusBridge.dataCount = ((modbusBridge.count - 1) / 2) + 1; + modbusBridge.dataCount = ((modbusBridge.count - 1) >> 1) + 1; } else if ((strcmp(stype, "uint16") == 0) || (strcmp(stype, "") == 0)) // Default is uint16 { @@ -678,7 +678,7 @@ void CmndModbusBridgeSend(void) else if (strcmp(stype, "bit") == 0) { modbusBridge.type = ModbusBridgeType::mb_bit; - modbusBridge.dataCount = (modbusBridge.count / 8) + 1; + modbusBridge.dataCount = modbusBridge.count; } else errorcode = ModbusBridgeError::wrongtype; From 812fbff6835c1220722f4322b6fbef9fd4fedc31 Mon Sep 17 00:00:00 2001 From: JeroenSt Date: Wed, 17 Aug 2022 19:55:42 +0200 Subject: [PATCH 12/15] Fixed reading discrete inputs and coils https://github.com/arendst/Tasmota/issues/9586#issuecomment-1217574286 --- tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino index d26d48ffa..c63942e63 100644 --- a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino +++ b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino @@ -377,7 +377,7 @@ void ModbusBridgeHandle(void) else if (modbusBridge.type == ModbusBridgeType::mb_bit) { uint8_t value = (uint8_t)(buffer[dataOffset + (count >> 3)]); - snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", ((value >> (7 - (count & 7))) & 1)); + snprintf(svalue, MBR_MAX_VALUE_LENGTH, "%d", ((value >> (count & 7)) & 1)); } else { @@ -633,7 +633,7 @@ void CmndModbusBridgeSend(void) if (strcmp(stype, "int8") == 0) { modbusBridge.type = ModbusBridgeType::mb_int8; - modbusBridge.dataCount = ((modbusBridge.count - 1) >> 1) + 1; + modbusBridge.dataCount = modbusBridge.count; } else if (strcmp(stype, "int16") == 0) { @@ -648,7 +648,7 @@ void CmndModbusBridgeSend(void) else if ((strcmp(stype, "uint8") == 0)) { modbusBridge.type = ModbusBridgeType::mb_uint8; - modbusBridge.dataCount = ((modbusBridge.count - 1) >> 1) + 1; + modbusBridge.dataCount = modbusBridge.count; } else if ((strcmp(stype, "uint16") == 0) || (strcmp(stype, "") == 0)) // Default is uint16 { From b8000fa788e3f1c0a2d864a0a42ef7a144072424 Mon Sep 17 00:00:00 2001 From: JeroenSt Date: Wed, 17 Aug 2022 19:55:42 +0200 Subject: [PATCH 13/15] Update for functioncode 5 and 6 and 15 --- .../TasmotaModbus-3.4.0/src/TasmotaModbus.cpp | 8 ++-- .../xdrv_63_modbus_bridge.ino | 48 +++++++++++++++---- 2 files changed, 44 insertions(+), 12 deletions(-) diff --git a/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp b/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp index 483a20ad2..f543725a5 100644 --- a/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp +++ b/lib/lib_basic/TasmotaModbus-3.4.0/src/TasmotaModbus.cpp @@ -1,4 +1,4 @@ -/* + /* TasmotaModbus.cpp - Basic modbus wrapper for TasmotaSerial for Tasmota Copyright (C) 2021 Theo Arends @@ -60,13 +60,13 @@ uint8_t TasmotaModbus::Send(uint8_t device_address, uint8_t function_code, uint1 uint8_t *frame; uint8_t framepointer = 0; - if (function_code < 5) + if (function_code < 7) { - frame = (uint8_t *)malloc(8); // Addres(1), Function(1), Start Address(2), Registercount (2) or Data(2), CRC(2) + 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 Address(2), Quantity of registers (2), Bytecount(1), Data(2..n), CRC(2) + 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 diff --git a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino index c63942e63..989b44f35 100644 --- a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino +++ b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino @@ -633,7 +633,7 @@ void CmndModbusBridgeSend(void) if (strcmp(stype, "int8") == 0) { modbusBridge.type = ModbusBridgeType::mb_int8; - modbusBridge.dataCount = modbusBridge.count; + modbusBridge.dataCount = ((modbusBridge.count - 1)/ 2) + 1; } else if (strcmp(stype, "int16") == 0) { @@ -648,7 +648,7 @@ void CmndModbusBridgeSend(void) else if ((strcmp(stype, "uint8") == 0)) { modbusBridge.type = ModbusBridgeType::mb_uint8; - modbusBridge.dataCount = modbusBridge.count; + modbusBridge.dataCount = ((modbusBridge.count - 1)/ 2) + 1; } else if ((strcmp(stype, "uint16") == 0) || (strcmp(stype, "") == 0)) // Default is uint16 { @@ -678,7 +678,7 @@ void CmndModbusBridgeSend(void) else if (strcmp(stype, "bit") == 0) { modbusBridge.type = ModbusBridgeType::mb_bit; - modbusBridge.dataCount = modbusBridge.count; + modbusBridge.dataCount = ((modbusBridge.count - 1) / 16) + 1; } else errorcode = ModbusBridgeError::wrongtype; @@ -704,23 +704,42 @@ void CmndModbusBridgeSend(void) } else { - // ToDo: Convert uint, int float etc. to writedata writeData = (uint16_t *)malloc(writeDataSize * 2); for (uint8_t jsonDataArrayPointer = 0; jsonDataArrayPointer < writeDataSize; jsonDataArrayPointer++) { switch (modbusBridge.type) { + case ModbusBridgeType::mb_bit: + { + AddLog(LOG_LEVEL_DEBUG, PSTR("jsonDataArrayPointer[%u]=%u"), (uint8_t)jsonDataArrayPointer, (uint8_t)jsonDataArray[jsonDataArrayPointer].getUInt(0)); + // 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; + + AddLog(LOG_LEVEL_DEBUG, PSTR("writeDataPointer[%u]=%u bitPointer=[%u]=[%u]"), jsonDataArrayPointer/15, writeData[jsonDataArrayPointer/15], bitPointer, bitValue); + } + break; case ModbusBridgeType::mb_int8: - writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getInt(0); + 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: - writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getUInt(0); + 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] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getInt(0); + writeData[jsonDataArrayPointer] = (int16_t)jsonDataArray[jsonDataArrayPointer].getInt(0); break; case ModbusBridgeType::mb_uint16: - writeData[jsonDataArrayPointer] = (int16_t)jsonDataArray[jsonDataArrayPointer].getUInt(0); + writeData[jsonDataArrayPointer] = (uint16_t)jsonDataArray[jsonDataArrayPointer].getUInt(0); break; case ModbusBridgeType::mb_float: // TODO @@ -740,6 +759,9 @@ void CmndModbusBridgeSend(void) 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; } } } @@ -754,6 +776,16 @@ void CmndModbusBridgeSend(void) return; } + // 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; From 995b669f28fc4d0f6926b83f6284dd1854d8c6c1 Mon Sep 17 00:00:00 2001 From: JeroenSt Date: Wed, 17 Aug 2022 20:12:26 +0200 Subject: [PATCH 14/15] Removed debug logging --- tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino | 3 --- 1 file changed, 3 deletions(-) diff --git a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino index 989b44f35..2e3756742 100644 --- a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino +++ b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino @@ -711,7 +711,6 @@ void CmndModbusBridgeSend(void) { case ModbusBridgeType::mb_bit: { - AddLog(LOG_LEVEL_DEBUG, PSTR("jsonDataArrayPointer[%u]=%u"), (uint8_t)jsonDataArrayPointer, (uint8_t)jsonDataArray[jsonDataArrayPointer].getUInt(0)); // Set 2 following bytes to 0 if (jsonDataArrayPointer % 16 == 0) { @@ -723,8 +722,6 @@ void CmndModbusBridgeSend(void) if (bitPointer > 15) bitPointer -= 16; writeData[jsonDataArrayPointer/15] += bitValue << bitPointer; - - AddLog(LOG_LEVEL_DEBUG, PSTR("writeDataPointer[%u]=%u bitPointer=[%u]=[%u]"), jsonDataArrayPointer/15, writeData[jsonDataArrayPointer/15], bitPointer, bitValue); } break; case ModbusBridgeType::mb_int8: From a832af4dd236c7c65e5d070e243a9728b4187cb9 Mon Sep 17 00:00:00 2001 From: JeroenSt Date: Wed, 17 Aug 2022 21:14:50 +0200 Subject: [PATCH 15/15] added linefeed --- tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino | 1 + 1 file changed, 1 insertion(+) diff --git a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino index 2e3756742..ac624d0fc 100644 --- a/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino +++ b/tasmota/tasmota_xdrv_driver/xdrv_63_modbus_bridge.ino @@ -29,6 +29,7 @@ * Example Command: * -- Read Input Register -- * 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]} \*********************************************************************************************/