added rs485ControlPin

Author: electrocoder

README.md

@@ -17,6 +17,7 @@ The `MBModbusRTUSlave` library allows Arduino devices to function as Modbus RTU
 
 ### Version
 - **1.0.0** (Released: March 07, 2025)
+- **1.1.0** (Released: April 08, 2025)
 
 ### Author
 - S.Mersin (electrocoder) <[email protected]> (Assisted by Grok)
@@ -50,23 +51,62 @@ The `MBModbusRTUSlave` library allows Arduino devices to function as Modbus RTU
 
 ## Usage
 
+- Define the register count in your Arduino code:
+
 ### Basic Example
-This example initializes a Modbus slave with default settings and controls an LED based on register 5.
+This example initializes a Modbus slave with default settings and controls.
 
 ```cpp
 #include <MBModbusRTUSlave.h>
 
-long modbusBaudRate = 9600;  // Customizable baud rate
-MBModbusRTUSlave modbus(0x01, 13, 5);  // Slave address: 0x01, LED pin: 13, LED register: 5
+#define RXD2 16 // ESP32 Serial2
+#define TXD2 17 // ESP32 Serial2
+
+long mymodbusBaudRate = 9600;  // Customizable baud rate
+const uint16_t myRegisterCount = 20;
+MBModbusRTUSlave modbus(0x01, &Serial2, 26, myRegisterCount);  // Slave address: 0x01, Serial port name: Serial2, RS485 Module Pin: 26, Register count: 10
+
+unsigned long previousMillis = 0;
+const long interval = 1000; 
 
 void setup() {
-  modbus.begin(modbusBaudRate);
+
+  Serial.begin(9600); // DEBUG message
+
+  Serial2.begin(9600, SERIAL_8N2, RXD2, TXD2);
+  pinMode(26, OUTPUT);
+
+  modbus.begin(mymodbusBaudRate);
   Serial.println("Modbus started");
+
 }
 
 void loop() {
-  modbus.update();
+
+  unsigned long currentMillis = millis();
+  if (currentMillis - previousMillis >= interval) {
+
+    previousMillis = currentMillis;
+
+  modbus.writeFloatRegister(0, 123.45);   // Float method
+  modbus.writeRegister(2, 66);  // Uint16_t method
+
+  }
+
+    // Read Register
+  if (modbus.readRegisters()) {
+    Serial.println("Modbus to read");
+  }
+
+  // Read Float and Integer Register
+  Serial.print(modbus.getFloatRegister(0));
+  Serial.print(" ");
+  Serial.print(modbus.getRegister(2));
+  Serial.println("");
+
+  delay(10);
 }
+
 ```
 
 ### Modbus Commands

library.properties

@@ -1,5 +1,5 @@
 name=MBModbusRTUSlave
-version=1.0.0
+version=1.1.0
 author=S.Mersin (electrocoder) <[email protected]>
 maintainer=S.Mersin (electrocoder) <[email protected]>
 sentence=Modbus RTU protocol (function codes `0x03` and `0x06`). This library is a slave implementation of the Modbus RTU protocol.

src/MBModbusRTUSlave.cpp

@@ -3,151 +3,225 @@
  *
  * Description: This file implements the methods of the MBModbusRTUSlave class.
  *              It supports Modbus RTU protocol for register reading (0x03) and writing (0x06).
- *              Provides LED control and flexible baud rate adjustments.
+ *              Provides flexible baud rate adjustments and RS485 transceiver support.
  * Author: S.Mersin (electrocoder) <[email protected]> (Assisted by Grok)
- * Date: March 07, 2025
- * Version: 1.0.0
+ * Date: April 08, 2025
+ * Version: 1.1.0
  * License: MIT License
- * 
+ *
  * Note: This library uses the Arduino Serial port to provide Modbus RTU slave functionality.
  *       All registers except the LED register are updated with random values.
  */
 
 #include "MBModbusRTUSlave.h"
 
-MBModbusRTUSlave::MBModbusRTUSlave(uint8_t slaveAddress, uint8_t ledPin, uint8_t ledRegisterIndex, uint16_t registerCount) {
+MBModbusRTUSlave::MBModbusRTUSlave(uint8_t slaveAddress, HardwareSerial *serialPort, uint8_t rs485ControlPin, uint16_t registerCount)
+{
   _slaveAddress = slaveAddress;
-  _ledPin = ledPin;
-  _ledRegisterIndex = ledRegisterIndex;
+  _modbusBaudRate = 9600;
+  _serialPort = serialPort;
+  _rs485ControlPin = rs485ControlPin;
   _registerCount = registerCount;
-  _baudRate = 9600;  // Default baud rate
 
-  // Create dynamic register array
   modbusRegisters = new uint16_t[_registerCount];
-
-  // Fill the registers with initial values
   modbusRegisters[0] = 0;
   modbusRegisters[1] = 5678;
   modbusRegisters[2] = 90;
-  for (int i = 3; i < _registerCount; i++) {
+  for (int i = 3; i < _registerCount; i++)
+  {
     modbusRegisters[i] = 0;
   }
 }
 
-void MBModbusRTUSlave::begin(long baudRate) {
-  _baudRate = baudRate;
-  pinMode(_ledPin, OUTPUT);
-  digitalWrite(_ledPin, LOW);
-  Serial.begin(_baudRate, SERIAL_8N1);
-  while (!Serial)
-    ;
+MBModbusRTUSlave::~MBModbusRTUSlave()
+{
+  delete[] modbusRegisters; // Delete registers
 }
 
-void MBModbusRTUSlave::update() {
-  // We assign random values to all registers except the LED register
-  for (int i = 0; i < _registerCount; i++) {
-    if (i != _ledRegisterIndex)
-      modbusRegisters[i] = random(1, 10000);
-  }
+void MBModbusRTUSlave::begin(long modbusBaudRate)
+{
+  _modbusBaudRate = modbusBaudRate;
+  pinMode(_rs485ControlPin, OUTPUT);
+  digitalWrite(_rs485ControlPin, LOW);
+  _serialPort->begin(_modbusBaudRate, SERIAL_8N1);
+  while (!_serialPort)
+    ;
+}
 
-  if (Serial.available() >= 8) {
-    for (int i = 0; i < 8; i++) {
-      requestBuffer[i] = Serial.read();
+bool MBModbusRTUSlave::readRegisters()
+{
+  digitalWrite(_rs485ControlPin, LOW); // Receiver
+  if (_serialPort->available() >= 8)
+  {
+    for (int i = 0; i < 8; i++)
+    {
+      requestBuffer[i] = _serialPort->read();
     }
 
-    if (requestBuffer[0] == _slaveAddress) {
-      if (checkCRC(requestBuffer, 6)) {
-        if (requestBuffer[1] == 0x03) {
-          processReadHoldingRegisters();
-        } else if (requestBuffer[1] == 0x06) {
-          processWriteSingleRegister();
-        }
+    if (requestBuffer[0] == _slaveAddress && checkCRC(requestBuffer, 6))
+    {
+      if (requestBuffer[1] == 0x03)
+      {
+        processReadHoldingRegisters();
+      }
+      else if (requestBuffer[1] == 0x06)
+      {
+        processWriteSingleRegister();
       }
+      while (_serialPort->available())
+        _serialPort->read();
+      return true;
     }
+  }
+  return false;
+}
+
+void MBModbusRTUSlave::writeFloatRegister(uint16_t registerAddress, float value)
+{
+  if (registerAddress < _registerCount - 1)
+  {
+    uint32_t floatBits;
+    memcpy(&floatBits, &value, sizeof(float));
+    modbusRegisters[registerAddress] = (floatBits >> 16) & 0xFFFF;
+    modbusRegisters[registerAddress + 1] = floatBits & 0xFFFF;
+  }
+}
+
+void MBModbusRTUSlave::writeRegister(uint16_t registerAddress, uint16_t value)
+{
+  if (registerAddress < _registerCount)
+  {
+    modbusRegisters[registerAddress] = value;
+  }
+}
 
-    while (Serial.available()) Serial.read();
+uint16_t MBModbusRTUSlave::getRegister(uint16_t registerAddress)
+{
+  if (registerAddress < _registerCount)
+  {
+    return modbusRegisters[registerAddress];
   }
+  return 0;
+}
 
-  digitalWrite(_ledPin, modbusRegisters[_ledRegisterIndex] == 1 ? HIGH : LOW);
+float MBModbusRTUSlave::getFloatRegister(uint16_t registerAddress)
+{
+  if (registerAddress < _registerCount - 1)
+  {
+    uint32_t floatBits = ((uint32_t)modbusRegisters[registerAddress] << 16) | modbusRegisters[registerAddress + 1];
+    float value;
+    memcpy(&value, &floatBits, sizeof(float));
+    return value;
+  }
+  return 0.0;
 }
 
-void MBModbusRTUSlave::processReadHoldingRegisters() {
+void MBModbusRTUSlave::processReadHoldingRegisters()
+{
   uint16_t startAddress = (requestBuffer[2] << 8) | requestBuffer[3];
   uint16_t registerCount = (requestBuffer[4] << 8) | requestBuffer[5];
 
-  responseBuffer[0] = _slaveAddress;
-  responseBuffer[1] = 0x03;
-  responseBuffer[2] = registerCount * 2;
-
-  for (int i = 0; i < registerCount; i++) {
-    uint16_t regValue = modbusRegisters[startAddress + i];
-    responseBuffer[3 + i * 2] = (regValue >> 8) & 0xFF;
-    responseBuffer[4 + i * 2] = regValue & 0xFF;
-  }
+  if (startAddress + registerCount <= _registerCount)
+  { // Register check
+    responseBuffer[0] = _slaveAddress;
+    responseBuffer[1] = 0x03;
+    responseBuffer[2] = registerCount * 2;
+
+    for (int i = 0; i < registerCount; i++)
+    {
+      uint16_t regValue = modbusRegisters[startAddress + i];
+      responseBuffer[3 + i * 2] = (regValue >> 8) & 0xFF;
+      responseBuffer[4 + i * 2] = regValue & 0xFF;
+    }
 
-  uint16_t crc = calculateCRC(responseBuffer, 3 + registerCount * 2);
-  responseBuffer[3 + registerCount * 2] = crc & 0xFF;
-  responseBuffer[4 + registerCount * 2] = (crc >> 8) & 0xFF;
+    uint16_t crc = calculateCRC(responseBuffer, 3 + registerCount * 2);
+    responseBuffer[3 + registerCount * 2] = crc & 0xFF;
+    responseBuffer[4 + registerCount * 2] = (crc >> 8) & 0xFF;
 
-  Serial.write(responseBuffer, 5 + registerCount * 2);
+    digitalWrite(_rs485ControlPin, HIGH);
+    _serialPort->write(responseBuffer, 5 + registerCount * 2);
+    _serialPort->flush();
+    digitalWrite(_rs485ControlPin, LOW);
+  }
 }
 
-void MBModbusRTUSlave::processWriteSingleRegister() {
+void MBModbusRTUSlave::processWriteSingleRegister()
+{
   uint16_t registerAddress = (requestBuffer[2] << 8) | requestBuffer[3];
   uint16_t registerValue = (requestBuffer[4] << 8) | requestBuffer[5];
 
-  if (registerAddress < _registerCount) {
+  if (registerAddress < _registerCount)
+  {
     modbusRegisters[registerAddress] = registerValue;
   }
 
-  for (int i = 0; i < 6; i++) {
+  for (int i = 0; i < 6; i++)
+  {
     responseBuffer[i] = requestBuffer[i];
   }
   responseBuffer[6] = requestBuffer[6];
   responseBuffer[7] = requestBuffer[7];
 
-  Serial.write(responseBuffer, 8);
+  digitalWrite(_rs485ControlPin, HIGH);
+  _serialPort->write(responseBuffer, 8);
+  _serialPort->flush();
+  digitalWrite(_rs485ControlPin, LOW);
 }
 
-uint16_t MBModbusRTUSlave::calculateCRC(uint8_t *buffer, uint8_t length) {
+uint16_t MBModbusRTUSlave::calculateCRC(uint8_t *buffer, uint8_t length)
+{
   uint16_t crc = 0xFFFF;
-  for (uint8_t pos = 0; pos < length; pos++) {
+  for (uint8_t pos = 0; pos < length; pos++)
+  {
     crc ^= (uint16_t)buffer[pos];
-    for (uint8_t i = 8; i != 0; i--) {
-      if ((crc & 0x0001) != 0) {
+    for (uint8_t i = 8; i != 0; i--)
+    {
+      if ((crc & 0x0001) != 0)
+      {
         crc >>= 1;
         crc ^= 0xA001;
-      } else {
+      }
+      else
+      {
         crc >>= 1;
       }
     }
   }
   return crc;
 }
 
-bool MBModbusRTUSlave::checkCRC(uint8_t *buffer, uint8_t length) {
+bool MBModbusRTUSlave::checkCRC(uint8_t *buffer, uint8_t length)
+{
   uint16_t receivedCRC = (buffer[length + 1] << 8) | buffer[length];
   uint16_t calculatedCRC = calculateCRC(buffer, length);
   return (receivedCRC == calculatedCRC);
 }
 
-// Setter methods
-void MBModbusRTUSlave::setSlaveAddress(uint8_t slaveAddress) {
+void MBModbusRTUSlave::setSlaveAddress(uint8_t slaveAddress)
+{
   _slaveAddress = slaveAddress;
 }
 
-void MBModbusRTUSlave::setLedPin(uint8_t ledPin) {
-  _ledPin = ledPin;
-  pinMode(_ledPin, OUTPUT);
+void MBModbusRTUSlave::setModbusBaudRate(long modbusBaudRate)
+{
+  _modbusBaudRate = modbusBaudRate;
+  _serialPort->begin(_modbusBaudRate, SERIAL_8N1);
 }
 
-void MBModbusRTUSlave::setLedRegisterIndex(uint8_t ledRegisterIndex) {
-  if (ledRegisterIndex < _registerCount) {
-    _ledRegisterIndex = ledRegisterIndex;
-  }
+void MBModbusRTUSlave::setSerialPort(HardwareSerial *serialPort)
+{
+  _serialPort = serialPort;
+  _serialPort->begin(_modbusBaudRate, SERIAL_8N1);
 }
 
-void MBModbusRTUSlave::setBaudRate(long baudRate) {
-  _baudRate = baudRate;
-  Serial.begin(_baudRate, SERIAL_8N1);
-}
+void MBModbusRTUSlave::setRS485ControlPin(uint8_t rs485ControlPin)
+{
+  _rs485ControlPin = rs485ControlPin;
+  pinMode(_rs485ControlPin, OUTPUT);
+  digitalWrite(_rs485ControlPin, LOW);
+}
+
+uint16_t MBModbusRTUSlave::getRegisterCount()
+{
+  return _registerCount;
+}