P183 modbus RTU

src/_P183_modbus.ino

@@ -71,7 +71,7 @@
 // These pointers may be used among multiple instances of the same plugin,
 // as long as the same serial settings are used.
 ModbusDEVICE_struct * P183_ModbusDevice = nullptr;
-ModbusQueueState_t P183_ModbusStatus =   ModbusQueueState_t::EMPTY;
+ModbusQueueState_t P183_ModbusStatus =   {};
 boolean P183_init                    = false;
 
 void P183_scan_modbus();
@@ -211,6 +211,7 @@ boolean Plugin_183(uint8_t function, struct EventStruct *event, String& string)
     case PLUGIN_INIT:
     {
       P183_init = true;
+      addLogMove(LOG_LEVEL_INFO, "P183 INIT");
 
       // (re)create the serial port object
       // If the serial port object already exists, delete it first.
@@ -219,6 +220,7 @@ boolean Plugin_183(uint8_t function, struct EventStruct *event, String& string)
         P183_ModbusDevice = nullptr;
       }
       P183_ModbusDevice = new ModbusDEVICE_struct();
+      addLogMove(LOG_LEVEL_INFO, "P183 INIT AFTER NEW");
 
       if (P183_ModbusDevice == nullptr) {
         P183_init = false;
@@ -234,8 +236,9 @@ boolean Plugin_183(uint8_t function, struct EventStruct *event, String& string)
                                    P183_GET_FLAG_COLL_DETECT)) {
         break;
       }
+      addLogMove(LOG_LEVEL_INFO, "P183 INIT AFTER INIT");
       P183_ModbusDevice->setModbusTimeout(P183_MODBUS_TIMEOUT);
-
+      addLogMove(LOG_LEVEL_DEBUG, "AFTER TIMEOUT");
       # ifdef P183_DEBUG
 
       if (loglevelActiveFor(LOG_LEVEL_DEBUG)) {
@@ -260,20 +263,23 @@ boolean Plugin_183(uint8_t function, struct EventStruct *event, String& string)
     case PLUGIN_EXIT:
     {
       P183_init = false;
-      delete P183_ModbusDevice;
-      P183_ModbusDevice = nullptr;
-      success           = true;
+
+      if (P183_ModbusDevice != nullptr) {
+        delete P183_ModbusDevice;
+        P183_ModbusDevice = nullptr;
+      }
+      success = true;
       break;
     }
 
     case PLUGIN_READ:
     {
-      uint16_t value = 0;
-
+      static uint16_t registerValues[4] = {0, 0, 0, 0};
       for (int outputIndex = 0; outputIndex < P183_NR_OUTPUTS; ++outputIndex)
       {
-        P183_modbus_readRegister(P183_ADDRESS(outputIndex), &value);
-        UserVar.setFloat(event->TaskIndex, outputIndex, value);
+        // TODO: Abuse PCONFIG_LONG static storage for now.
+        P183_modbus_readRegister(P183_ADDRESS(outputIndex), &(registerValues[outputIndex]));
+        UserVar.setFloat(event->TaskIndex, outputIndex, registerValues[outputIndex]);
       }
       success = true;
       break;
@@ -356,6 +362,12 @@ boolean Plugin_183(uint8_t function, struct EventStruct *event, String& string)
       }
       break;
     }
+    case PLUGIN_TEN_PER_SECOND: {
+      if (P183_init && (P183_ModbusDevice != nullptr)) {
+        P183_ModbusDevice->processCommand();
+      }
+      break;
+    }
   }
   return success;
 }
@@ -459,7 +471,7 @@ void P183_scan_modbus()
   uint16_t value = 0;
 
   for (uint8_t id = 0; id <= 247; id++) {
-    //TODO: how to scan the Modbus devices in teh new structure
+    // TODO: how to scan the Modbus devices in teh new structure
     int result = P183_modbus_readRegister(1, &value);
     log += F("** Address ");
     log += String(id);

src/src/Helpers/Modbus_device.cpp

@@ -16,13 +16,12 @@ ModbusDEVICE_struct::~ModbusDEVICE_struct() {
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 void ModbusDEVICE_struct::reset() {
   if (_modbus_link != nullptr) {
+    _modbus_link->freeTransactions(this);
     ModbusMGR_singleton.disconnect(_deviceID);
     _modbus_link = nullptr;
   }
-  _deviceID       = 0;
-  _queueID        = 0;
-  _sendframe_size = 0;
-  _recv_buf_used  = 0;
+  _deviceID = 0;
+
   _modbus_address = MODBUS_BROADCAST_ADDRESS;
 }
 
@@ -48,6 +47,16 @@ bool ModbusDEVICE_struct::init(uint8_t                 slaveAddress,
 
   _modbus_address = slaveAddress;
 
+  if (loglevelActiveFor(LOG_LEVEL_INFO)) {
+    String log = F("---> ModbusDevice Init: Slave address = ");
+    log += slaveAddress;
+    log += F(", This = ");
+    log += (ulong)this;
+    log += F(", deviceID  = ");
+    log += _deviceID;
+    addLogMove(LOG_LEVEL_INFO, log);
+  }
+
   // TODO: further implementation needed
   return success;
 }
@@ -74,17 +83,29 @@ uint16_t ModbusDEVICE_struct::getModbusTimeout() const
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 bool ModbusDEVICE_struct::readHoldingRegister(uint16_t            address,
                                               uint16_t           *valuePtr,
-                                              ModbusQueueState_t *statePtr) {
-  buildFrame(_modbus_address, MODBUS_READ_HOLDING_REGISTERS, address, 1);
-  uint16_t crc = CalculateCRC(_sendframe, _sendframe_size);
-  _sendframe[_sendframe_size++] = lowByte(crc);  // CRC low byte
-  _sendframe[_sendframe_size++] = highByte(crc); // CRC high byte
-  _queueID                      = queueFrame();
-  *statePtr                     = ModbusQueueState_t::QUEUED;
-  _statePtr                     = statePtr;
-  _resultPtr                    = valuePtr;
-  _state                        = ModbusQueueState_t::QUEUED;
-  _messageType                  = ModbusMessageType::READ_HOLDING_REGISTERS;
+                                              ModbusQueueState_t *statePtr)
+{
+  if (_modbus_link == nullptr) {
+    return false;
+  }
+  Modbus_RequestQueueElement *request = _modbus_link->newTransaction(this);
+
+  request->_messageType  = ModbusMessageType::READ_HOLDING_REGISTERS;
+  request->_userData     = valuePtr;
+  request->_sendframe[0] = _modbus_address;
+  request->_sendframe[1] = MODBUS_READ_HOLDING_REGISTERS;
+  request->_sendframe[2] = highByte(address);
+  request->_sendframe[3] = lowByte(address);
+  request->_sendframe[4] = 0;
+  request->_sendframe[5] = 1;                 // Read 1 register
+  uint16_t crc = CalculateCRC(request->_sendframe, 6);
+  request->_sendframe[6]     = lowByte(crc);  // CRC low byte
+  request->_sendframe[7]     = highByte(crc); // CRC high byte
+  request->_sendframe_length = 8;             // Size with CRC
+  request->_rcvframe_length  = 7;             // Expect 8 bytes in response
+  dump_buffer(request->_sendframe, request->_sendframe_length);
+  uint16_t queueID = _modbus_link->queueRequest(request);
+  *statePtr = ModbusQueueState_t::QUEUED;
 
   // Don't touch *valueptr here, it might contain a previous valid result.
   return false; // TODO: implement
@@ -95,17 +116,22 @@ bool ModbusDEVICE_struct::writeSingleRegister(uint16_t            address,
                                               uint16_t            value,
                                               ModbusQueueState_t *statePtr)
 {
-  buildFrame(_modbus_address, MODBUS_WRITE_SINGLE_REGISTER, address, 1);
-  _sendframe[4] = highByte(value);
-  _sendframe[5] = lowByte(value);
-  uint16_t crc = CalculateCRC(_sendframe, _sendframe_size);
-  _sendframe[_sendframe_size++] = lowByte(crc);  // CRC low byte
-  _sendframe[_sendframe_size++] = highByte(crc); // CRC high byte
-  _queueID                      = queueFrame();
-  *statePtr                     = ModbusQueueState_t::QUEUED;
-  _statePtr                     = statePtr;
-  _state                        = ModbusQueueState_t::QUEUED;
-  _messageType                  = ModbusMessageType::WRITE_SINGLE_REGISTER;
+  Modbus_RequestQueueElement *request =    _modbus_link->newTransaction(this);
+
+  request->_sendframe[0] = _modbus_address;
+  request->_sendframe[1] = MODBUS_WRITE_SINGLE_REGISTER;
+  request->_sendframe[2] = highByte(address);
+  request->_sendframe[3] = lowByte(address);
+  request->_sendframe[4] = highByte(value);
+  request->_sendframe[5] = lowByte(value);
+  uint16_t crc = CalculateCRC(request->_sendframe, 6);
+  request->_sendframe[6]     = lowByte(crc);  // CRC low byte
+  request->_sendframe[7]     = highByte(crc); // CRC high byte
+  request->_sendframe_length = 8;             // Size with CRC
+  request->_rcvframe_length  = 8;             // Expect 8 bytes in response
+  uint16_t queueID = _modbus_link->queueRequest(request);
+  *statePtr             = ModbusQueueState_t::QUEUED;
+  request->_messageType = ModbusMessageType::WRITE_SINGLE_REGISTER;
   return false;
 }
 
@@ -114,104 +140,74 @@ void ModbusDEVICE_struct::processCommand() {
   if (_modbus_link != nullptr) {
     _modbus_link->processCommand(); // Trigger processing of the command queue on the link
   }
-  else {
-    _state = ModbusQueueState_t::ERROR;
-  }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Callback function called by the Modbus link when a response is received for a queued request.
 // Note that the response might be an invalid response or a timeout
 // The queueID identifies the request.
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void ModbusDEVICE_struct::linkCallback(uint16_t queueID)
+void ModbusDEVICE_struct::linkCallback(Modbus_RequestQueueElement *req)
 {
-  if (queueID != _queueID) {
-    return; // Not for us
-  }
-  bool response = _modbus_link->getResponse(_queueID, _recv_buf, _recv_buf_used);
-
-  if (response) {
-    switch (_messageType) {
-      case ModbusMessageType::READ_HOLDING_REGISTERS:
-      {
-        if ((_recv_buf[0] == _modbus_address) && (_recv_buf[1] == MODBUS_READ_HOLDING_REGISTERS) && (_recv_buf[2] == 2)) {
-          uint16_t crc = CalculateCRC(_recv_buf, 5);
-
-          if ((_recv_buf[5] == lowByte(crc)) && (_recv_buf[6] == highByte(crc))) {
-            // Valid response
-            if (_resultPtr != nullptr) {
-              *_resultPtr = (_recv_buf[3] << 8) | _recv_buf[4]; // Combine high and low byte
-            }
-            _state = ModbusQueueState_t::AVAILABLE;
-          } else {
-            // Invalid CRC
-            _state = ModbusQueueState_t::ERROR;
+  String log = F("---> Device callback: ");
+
+  log += req->_id;
+  log += F(", Message = ");
+  log += (uint8_t)req->_messageType;
+
+
+  switch (req->_messageType) {
+    case ModbusMessageType::READ_HOLDING_REGISTERS:
+    {
+      if ((req->_rcvframe[0] == _modbus_address) && (req->_rcvframe[1] == MODBUS_READ_HOLDING_REGISTERS) && (req->_rcvframe[2] == 2)) {
+        uint16_t crc = CalculateCRC(req->_rcvframe, 5);
+
+        if ((req->_rcvframe[5] == lowByte(crc)) && (req->_rcvframe[6] == highByte(crc))) {
+          // Valid response
+          if (req->_userData != nullptr) {
+            *((uint16_t *)req->_userData) = (req->_rcvframe[3] << 8) | req->_rcvframe[4]; // Combine high and low byte
           }
         } else {
-          // Invalid response
-          _state = ModbusQueueState_t::ERROR;
+          // Invalid CRC
         }
-        return;
-        break;
+      } else {
+        // Invalid response
       }
-      case ModbusMessageType::WRITE_SINGLE_REGISTER:
-      {
-        if ((_recv_buf[0] == _modbus_address) && (_recv_buf[1] == MODBUS_READ_HOLDING_REGISTERS) && (_recv_buf[2] == 2)) {
-          uint16_t crc = CalculateCRC(_recv_buf, 5);
-
-          if ((_recv_buf[5] == lowByte(crc)) && (_recv_buf[6] == highByte(crc))) {
-            // Valid response
-            _state = ModbusQueueState_t::AVAILABLE;
-          }
-          else {
-            // Invalid CRC
-            _state = ModbusQueueState_t::ERROR;
-          }
-        } else {
-          // Invalid response
-          _state = ModbusQueueState_t::ERROR;
+      break;
+    }
+
+    case ModbusMessageType::WRITE_SINGLE_REGISTER:
+    {
+      if ((req->_rcvframe[0] == _modbus_address) && (req->_rcvframe[1] == MODBUS_READ_HOLDING_REGISTERS) && (req->_rcvframe[2] == 2)) {
+        uint16_t crc = CalculateCRC(req->_rcvframe, 5);
+
+        if ((req->_rcvframe[5] == lowByte(crc)) && (req->_rcvframe[6] == highByte(crc))) {
+          // Valid response
         }
-        break;
-      }
-      case ModbusMessageType::NONE:
-      {
-        // Should not happen
-        _state = ModbusQueueState_t::ERROR;
-        break;
+        else {
+          // Invalid CRC
+        }
+      } else {
+        // Invalid response
       }
+      break;
+    }
 
-      default:
-      {
-        // Unknown message type
-        _state = ModbusQueueState_t::ERROR;
-        break;
-      }
+    case ModbusMessageType::NONE:
+    {
+      // Should not happen
+      break;
     }
-  }
 
-  // Update the state as seen by the client
-  if (_statePtr != nullptr) {
-    *_statePtr = _state;
+    default:
+    {
+      // Unknown message type
+      break;
+    }
   }
-}
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Build a Modbus RTU frame filling in the standard fields.
-// Note that thsi does not include the CRC.
-// The frame is stored in the _sendframe buffer and the size is stored in _sendframe_size.
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void ModbusDEVICE_struct::buildFrame(uint8_t  slaveAddress,
-                                     uint8_t  functionCode,
-                                     uint16_t startAddress,
-                                     uint8_t  byteCount) {
-  _sendframe[0]   = slaveAddress;
-  _sendframe[1]   = functionCode;
-  _sendframe[2]   = highByte(startAddress);
-  _sendframe[3]   = lowByte(startAddress);
-  _sendframe[4]   = highByte(byteCount);
-  _sendframe[5]   = lowByte(byteCount);
-  _sendframe_size = 6; // Size without the CRC
+  _modbus_link->freeTransaction(req);
+  addLogMove(LOG_LEVEL_INFO, log);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -236,15 +232,19 @@ uint16_t ModbusDEVICE_struct::CalculateCRC(uint8_t *buf, int len) {
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Queue the assembled Modbus frame for transmission over the link using the ModbusLink object.
-// The function returns the queue ID assigned to the request, or 0 if queuing failed
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-uint16_t ModbusDEVICE_struct::queueFrame() {
-  if (_modbus_link == nullptr) {
-    return false;
+void ModbusDEVICE_struct::dump_buffer(const uint8_t *buffer, size_t length) {
+  if (loglevelActiveFor(LOG_LEVEL_INFO)) {
+    String log = F("---> Modbus: Dumping buffer: ");
+
+    for (size_t i = 0; i < length; ++i) {
+      log += String(buffer[i], HEX);
+
+      if (i < length - 1) {
+        log += F(", ");
+      }
+    }
+    addLogMove(LOG_LEVEL_INFO, log);
   }
-  _queueID = _modbus_link->queueRequest(this, _sendframe, _sendframe_size, MODBUS_RECEIVE_BUFFER, _timeout);
-  return _queueID;
 }
 
 #endif // if FEATURE_MODBUS