modified: include/ModBusConfig.cpp

modified:   include/ModBusConfig.h
modified:   src/main.cpp

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "CodeGPT.apiKey": "CodeGPT Plus Beta"
+}

include/ModBusConfig.cpp

@@ -0,0 +1,75 @@
+#include <ModBusConfig.h>
+#include <EEPROM.h>
+
+/*
+  Konstruktor: Der Konstruktor initialisiert die Modbus-ID und die Baudrate auf Standardwerte (1 und 9600), 
+  falls die EEPROM-Werte nicht gesetzt sind (d.h. wenn sie 0xFF sind).
+*/
+ModBusConfig::ModBusConfig() {
+    // Optional: Initialisieren Sie die EEPROM-Werte, falls erforderlich
+    if (EEPROM.read(MODBUS_ID_ADDRESS) == 0xFF) {
+        SetModbusID(STANDARD_MODBUS_ID);  // Setze Standard ID
+    }
+    if (EEPROM.read(BAUD_RATE_ADDRESS) == 0xFF) {
+        SetBaudRate(STANDARD_MODBUS_BAUDRATE);  // Setze Standard Baudrate
+    }
+}
+
+void ModBusConfig::SetModbusID(int ID) {
+    if (ID >= 0 && ID <= MAX_MODBUS_ID_ADDRESS) {  // Überprüfung, dass ID im gültigen Bereich liegt
+        unsigned long currentTime = millis();
+        if (currentTime - lastWriteTimeID >= WRITE_INTERVAL) {  // Only write if enough time has passed
+            EEPROM.put(MODBUS_ID_ADDRESS, ID);
+            lastWriteTimeID = currentTime;
+        }
+        //EEPROM.write(MODBUS_ID_ADDRESS, ID);
+    } else {
+        Serial.println("Ungültige Modbus-ID. ID muss zwischen 0 und 255 liegen.");
+    }
+}
+
+void ModBusConfig::ResetModbusID() {
+    unsigned long currentTime = millis();
+        if (currentTime - lastWriteTimeID >= WRITE_INTERVAL) {  // Only write if enough time has passed
+            SetModbusID(STANDARD_MODBUS_ID); // Reset to standard ID
+            lastWriteTimeID = currentTime;
+        }
+    
+}
+
+void ModBusConfig::SetBaudRate(int BAUDRATE) {
+    int dividedBaudrate = BAUDRATE / 100;
+    unsigned long currentTime = millis();
+
+    // Überprüfung, dass Baudrate im gültigen Bereich liegt
+    if (BAUDRATE > 0 && BAUDRATE <= MAX_BAUD_RATE) {
+        if (dividedBaudrate != EEPROM.read(BAUD_RATE_ADDRESS)) {
+            if (currentTime - lastWriteTimeBaud >= WRITE_INTERVAL) {
+                EEPROM.put(BAUD_RATE_ADDRESS, dividedBaudrate);
+                lastWriteTimeBaud = currentTime;
+            }
+        }
+    } else {
+        Serial.println("Ungültige Baudrate. Baudrate muss zwischen 0 und 115200 liegen.");
+    }
+}
+
+void ModBusConfig::ResetBaudRate() {
+    unsigned long currentTime = millis();
+    if (currentTime - lastWriteTimeBaud >= WRITE_INTERVAL) {
+        SetBaudRate(STANDARD_MODBUS_BAUDRATE); // Reset to standard Baud rate
+        lastWriteTimeBaud = currentTime;
+    }
+    
+}
+
+int ModBusConfig::GetModbusID() {
+    int MbID = EEPROM.read(MODBUS_ID_ADDRESS);
+    return MbID;
+}
+
+int ModBusConfig::GetBaudRate() {
+    int Baudrate = EEPROM.read(BAUD_RATE_ADDRESS);
+    return Baudrate;
+}
+

include/ModBusConfig.h

@@ -0,0 +1,37 @@
+#ifndef MODBUS_CONFIG_H
+#define MODBUS_CONFIG_H
+
+#include <Arduino.h>
+
+
+class ModBusConfig {
+public:
+    ModBusConfig();  // Konstruktor ohne Parameter
+    void SetModbusID(int ID);
+    void SetBaudRate(int BAUDRATE);
+    void ResetModbusID(); // Method to reset Modbus ID
+    void ResetBaudRate(); // Method to reset Baud Rate
+    int GetModbusID();
+    int GetBaudRate();
+
+private:
+    /*
+     In diesem Beispiel wird Adresse 0 für die Modbus-ID und Adresse 2 für die Baudrate verwendet. 
+     Diese Adressen sind willkürlich gewählt und sollten nicht mit anderen Daten im EEPROM überlappen.
+    */
+    static const int MODBUS_ID_ADDRESS = 0;      // Speicheradresse für Modbus-ID
+    static const int BAUD_RATE_ADDRESS = 2;       // Speicheradresse für Baudrate
+
+    static const int MAX_BAUD_RATE = 38400;      // Maximal unterstützte Baudrate
+    static const int MAX_MODBUS_ID_ADDRESS = 254;      // Maximal unterstützte Baudrate
+
+    static const int STANDARD_MODBUS_ID = 22;
+    static const int STANDARD_MODBUS_BAUDRATE = 9600;
+    
+    unsigned long lastWriteTimeID = 0;     // Last write time for Modbus ID
+    unsigned long lastWriteTimeBaud = 0;   // Last write time for Baud rate
+    const unsigned long WRITE_INTERVAL = 120000;  // 2 minutes in milliseconds
+
+};
+
+#endif

include/ModbusSlaveConfigToEEPROM.h

@@ -0,0 +1,113 @@
+/*
+  Insgesamt ermöglicht die ModBusConfig-Klasse das Speichern und Abrufen von Modbus-Konfigurationsdaten (ID und Baudrate) in einem EEPROM. 
+  Dies ist besonders nützlich für Anwendungen, bei denen Konfigurationsdaten zwischen den Stromzyklen erhalten bleiben sollen. 
+  Die Klasse abstrahiert die EEPROM-Operationen und bietet eine benutzerfreundliche Schnittstelle zur Verwaltung von Modbus-Konfigurationen.
+*/
+#ifndef ModbusSlaveConfigToEEPROM_H
+#define ModbusSlaveConfigToEEPROM_H
+
+#include <Arduino.h>
+#include <EEPROM.h>
+
+class ModBusConfig {
+public:
+    ModBusConfig();  // Konstruktor ohne Parameter
+    void SetModbusID(int ID);
+    void SetBaudRate(int BAUDRATE);
+    void ResetModbusID(); // Method to reset Modbus ID
+    void ResetBaudRate(); // Method to reset Baud Rate
+    int GetModbusID();
+    int GetBaudRate();
+
+private:
+    /*
+     In diesem Beispiel wird Adresse 0 für die Modbus-ID und Adresse 2 für die Baudrate verwendet. 
+     Diese Adressen sind willkürlich gewählt und sollten nicht mit anderen Daten im EEPROM überlappen.
+    */
+    static const int MODBUS_ID_ADDRESS = 0;      // Speicheradresse für Modbus-ID
+    static const int BAUD_RATE_ADDRESS = 2;       // Speicheradresse für Baudrate
+
+    static const int MAX_BAUD_RATE = 38400;      // Maximal unterstützte Baudrate
+    static const int MAX_MODBUS_ID_ADDRESS = 254;      // Maximal unterstützte Baudrate
+
+    static const int STANDARD_MODBUS_ID = 22;
+    static const int STANDARD_MODBUS_BAUDRATE = 9600;
+    
+    unsigned long lastWriteTimeID = 0;     // Last write time for Modbus ID
+    unsigned long lastWriteTimeBaud = 0;   // Last write time for Baud rate
+    const unsigned long WRITE_INTERVAL = 120000;  // 2 minutes in milliseconds
+
+};
+/*
+  Konstruktor: Der Konstruktor initialisiert die Modbus-ID und die Baudrate auf Standardwerte (1 und 9600), 
+  falls die EEPROM-Werte nicht gesetzt sind (d.h. wenn sie 0xFF sind).
+*/
+ModBusConfig::ModBusConfig() {
+    // Optional: Initialisieren Sie die EEPROM-Werte, falls erforderlich
+    if (EEPROM.read(MODBUS_ID_ADDRESS) == 0xFF) {
+        SetModbusID(STANDARD_MODBUS_ID);  // Setze Standard ID
+    }
+    if (EEPROM.read(BAUD_RATE_ADDRESS) == 0xFF) {
+        SetBaudRate(STANDARD_MODBUS_BAUDRATE);  // Setze Standard Baudrate
+    }
+}
+
+void ModBusConfig::SetModbusID(int ID) {
+    if (ID >= 0 && ID <= MAX_MODBUS_ID_ADDRESS) {  // Überprüfung, dass ID im gültigen Bereich liegt
+        unsigned long currentTime = millis();
+        if (currentTime - lastWriteTimeID >= WRITE_INTERVAL) {  // Only write if enough time has passed
+            EEPROM.put(MODBUS_ID_ADDRESS, ID);
+            lastWriteTimeID = currentTime;
+        }
+        //EEPROM.write(MODBUS_ID_ADDRESS, ID);
+    } else {
+        Serial.println("Ungültige Modbus-ID. ID muss zwischen 0 und 255 liegen.");
+    }
+}
+
+void ModBusConfig::ResetModbusID() {
+    unsigned long currentTime = millis();
+        if (currentTime - lastWriteTimeID >= WRITE_INTERVAL) {  // Only write if enough time has passed
+            SetModbusID(STANDARD_MODBUS_ID); // Reset to standard ID
+            lastWriteTimeID = currentTime;
+        }
+    
+}
+
+void ModBusConfig::SetBaudRate(int BAUDRATE) {
+    int dividedBaudrate = BAUDRATE / 100;
+    unsigned long currentTime = millis();
+
+    // Überprüfung, dass Baudrate im gültigen Bereich liegt
+    if (BAUDRATE > 0 && BAUDRATE <= MAX_BAUD_RATE) {
+        if (dividedBaudrate != EEPROM.read(BAUD_RATE_ADDRESS)) {
+            if (currentTime - lastWriteTimeBaud >= WRITE_INTERVAL) {
+                EEPROM.put(BAUD_RATE_ADDRESS, dividedBaudrate);
+                lastWriteTimeBaud = currentTime;
+            }
+        }
+    } else {
+        Serial.println("Ungültige Baudrate. Baudrate muss zwischen 0 und 115200 liegen.");
+    }
+}
+
+void ModBusConfig::ResetBaudRate() {
+    unsigned long currentTime = millis();
+    if (currentTime - lastWriteTimeBaud >= WRITE_INTERVAL) {
+        SetBaudRate(STANDARD_MODBUS_BAUDRATE); // Reset to standard Baud rate
+        lastWriteTimeBaud = currentTime;
+    }
+    
+}
+
+int ModBusConfig::GetModbusID() {
+    int MbID = EEPROM.read(MODBUS_ID_ADDRESS);
+    return MbID;
+}
+
+int ModBusConfig::GetBaudRate() {
+    int Baudrate = EEPROM.read(BAUD_RATE_ADDRESS);
+    return Baudrate;
+}
+
+#endif

lib/ModbusSlaveConfigToEEPROM.h

@@ -1,66 +0,0 @@
-/*
-  Insgesamt ermöglicht die ModBusConfig-Klasse das Speichern und Abrufen von Modbus-Konfigurationsdaten (ID und Baudrate) in einem EEPROM. 
-  Dies ist besonders nützlich für Anwendungen, bei denen Konfigurationsdaten zwischen den Stromzyklen erhalten bleiben sollen. 
-  Die Klasse abstrahiert die EEPROM-Operationen und bietet eine benutzerfreundliche Schnittstelle zur Verwaltung von Modbus-Konfigurationen.
-*/
-#ifndef ModbusSlaveConfigToEEPROM_H
-#define ModbusSlaveConfigToEEPROM_H
-
-#include <Arduino.h>
-#include <EEPROM.h>
-
-class ModBusConfig {
-public:
-    ModBusConfig();  // Konstruktor ohne Parameter
-    void SetModbusID(int ID);
-    void SetBaudRate(int BAUDRATE);
-    int GetModbusID();
-    int GetBaudRate();
-
-private:
-    static const int MODBUS_ID_ADDRESS = 0;      // Speicheradresse für Modbus-ID
-    static const int BAUD_RATE_ADDRESS = 1;       // Speicheradresse für Baudrate
-    static const int MAX_BAUD_RATE = 115200;      // Maximal unterstützte Baudrate
-};
-
-ModBusConfig::ModBusConfig() {
-    // Optional: Initialisieren Sie die EEPROM-Werte, falls erforderlich
-    if (EEPROM.read(MODBUS_ID_ADDRESS) == 0xFF) {
-        SetModbusID(1);  // Setze Standard ID
-    }
-    if (EEPROM.read(BAUD_RATE_ADDRESS) == 0xFF) {
-        SetBaudRate(9600);  // Setze Standard Baudrate
-    }
-}
-
-void ModBusConfig::SetModbusID(int ID) {
-    if (ID >= 0 && ID <= 255) {  // Überprüfung, dass ID im gültigen Bereich liegt
-        EEPROM.write(MODBUS_ID_ADDRESS, ID);
-    } else {
-        Serial.println("Ungültige Modbus-ID. ID muss zwischen 0 und 255 liegen.");
-    }
-}
-
-void ModBusConfig::SetBaudRate(int BAUDRATE) {
-    int dividedBaudrate = BAUDRATE / 100;
-
-    // Überprüfung, dass Baudrate im gültigen Bereich liegt
-    if (BAUDRATE > 0 && BAUDRATE <= MAX_BAUD_RATE) {
-        if (dividedBaudrate != EEPROM.read(BAUD_RATE_ADDRESS)) {
-            EEPROM.write(BAUD_RATE_ADDRESS, dividedBaudrate);
-        }
-    } else {
-        Serial.println("Ungültige Baudrate. Baudrate muss zwischen 0 und 115200 liegen.");
-    }
-}
-
-int ModBusConfig::GetModbusID() {
-    return EEPROM.read(MODBUS_ID_ADDRESS);
-}
-
-int ModBusConfig::GetBaudRate() {
-    int Baudrate = EEPROM.read(BAUD_RATE_ADDRESS) * 100;
-    return Baudrate;
-}
-
-#endif

src/main.cpp

@@ -2,7 +2,12 @@
 #include <Wire.h>
 #include <ModbusSlave.h>
 #include <SHT2x.h>
+#include "ModbusSlaveConfigToEEPROM.h" // Inkludiere die Header-Datei für ModBusConfig
+//include <ModBusConfig.h> wenn aktiviert wird, dann probleme
 
+// -------------------------
+// Definitions
+// -------------------------
 // Statische Definition von Modbus-ID und Baudrate
 #define SLAVE_ID 8
 #define SERIAL_BAUDRATERS485 9600
@@ -12,14 +17,19 @@
 #define RS485_CTRL_PIN 8
 #define OutPutPin 9
 
+// -------------------------
+// Global Variables
+// -------------------------
 // Register Arrays für Modbus
 uint8_t ReadCoilRegister[] = {0, 1, 2};
-uint8_t output_pins[] = {0,1};
+uint8_t output_pins[] = {0,1,2,3};
 uint8_t ReadInputRegister[] = {0,1,2,3,4,5,6,7};
+uint8_t HoldingRegister[] = {0,1,2};
 
 uint8_t ReadCoilRegister_size = sizeof(ReadCoilRegister) / sizeof(ReadCoilRegister[0]);
 uint8_t output_pins_size = sizeof(output_pins) / sizeof(output_pins[0]);
 uint8_t ReadInputRegister_size = sizeof(ReadInputRegister) / sizeof(ReadInputRegister[0]);
+uint8_t HoldingRegister_size = sizeof(HoldingRegister) / sizeof(HoldingRegister[0]);
 
 int ValueInputOne = 0;
 
@@ -29,6 +39,17 @@ Modbus slave(SERIAL_PORTRS485, SLAVE_ID, RS485_CTRL_PIN);
 Modbus slave(SERIAL_PORTRS485, SLAVE_ID);
 #endif
 
+// -------------------------
+// Function Definitions
+// -------------------------
+
+/*
+  Instanz der ModBusConfig-Klasse
+  Aktuell keine Verwendung, eine Testimplementierung, nur Ausgabezwecke
+*/ 
+
+ModBusConfig modbusConfig;
+
 // Funktion zur Steuerung der digitalen Ausgänge über Modbus
 uint8_t writeDigitalOut(uint8_t fc, uint16_t address, uint16_t length) {
     if (address > output_pins_size || (address + length) > output_pins_size) {
@@ -36,12 +57,28 @@ uint8_t writeDigitalOut(uint8_t fc, uint16_t address, uint16_t length) {
     }
 
     for (uint16_t i = 0; i < length; i++) {
-        if (slave.readCoilFromBuffer(i) == 1) {
-            digitalWrite(OutPutPin, HIGH);
-        } else {
-            digitalWrite(OutPutPin, LOW);
-        }
+    switch (i) {
+        case 0:
+            digitalWrite(OutPutPin, slave.readCoilFromBuffer(i) == 0 ? HIGH : LOW);
+            break;
+        case 1:
+            if (slave.readCoilFromBuffer(i) == 1){
+                modbusConfig.ResetModbusID();
+            }
+            break;
+        case 2:
+            if (slave.readCoilFromBuffer(i) == 1) {
+                modbusConfig.ResetBaudRate();
+            }
+            break;
+        case 3:
+            digitalWrite(OutPutPin, slave.readCoilFromBuffer(i) == 1 ? HIGH : LOW);
+            break;
+        default:
+            // Optional: Handle cases where 'i' is greater than 3, if necessary
+            break;
     }
+}
     return STATUS_OK;
 }
 
@@ -78,10 +115,10 @@ uint8_t fReadInputRegister(uint8_t fc, uint16_t address, uint16_t length) {
                 slave.writeRegisterToBuffer(i, millis() / 1000); // Zeit in Sekunden
                 break;
             case 1:
-                slave.writeRegisterToBuffer(i, SERIAL_BAUDRATERS485); // Baudrate
+                slave.writeRegisterToBuffer(i, modbusConfig.GetBaudRate()); // Baudrate aus der ModBusConfig-Klasse
                 break;
             case 2:
-                slave.writeRegisterToBuffer(i, SLAVE_ID); // Slave-ID
+                slave.writeRegisterToBuffer(i, modbusConfig.GetModbusID()); // Slave-ID aus der ModBusConfig-Klasse
                 break;
             case 3: {
                 slave.writeRegisterToBuffer(i, static_cast<int>(temperatur * 100));
@@ -111,6 +148,75 @@ uint8_t fReadInputRegister(uint8_t fc, uint16_t address, uint16_t length) {
     return STATUS_OK;
 }
 
+// Write function for holding registers
+uint8_t fWriteHoldingRegister(uint8_t fc, uint16_t address, uint16_t length) {
+    if (address > HoldingRegister_size || (address + length) > HoldingRegister_size) {
+        return STATUS_ILLEGAL_DATA_ADDRESS;
+    }
+    /*if (address >= sizeof(HoldingRegister) / sizeof(HoldingRegister[0]) || (address + length) > sizeof(HoldingRegister) / sizeof(HoldingRegister[0])) {
+        return STATUS_ILLEGAL_DATA_ADDRESS;
+    }*/
+
+    for (uint16_t i = 0; i < length; i++) {
+        int value = slave.readRegisterFromBuffer(i);
+        HoldingRegister[address + i] = value;
+
+        // Use switch-case for specific register addresses
+        switch (address + i) {
+            case 0:
+                modbusConfig.SetModbusID(value);  // Update Modbus ID in EEPROM
+                break;
+            case 1:
+                modbusConfig.SetModbusID(value);  // Update Modbus ID in EEPROM
+                break;
+            case 2:
+                modbusConfig.SetBaudRate(value);  // Update Baud rate in EEPROM
+                break;
+            default:
+                // No specific action for other addresses
+                break;
+        }
+    }
+
+    return STATUS_OK;
+}
+
+// Optional: Read function for holding registers
+uint8_t fReadHoldingRegister(uint8_t fc, uint16_t address, uint16_t length) {
+    if (address > HoldingRegister_size || (address + length) > HoldingRegister_size) {
+        return STATUS_ILLEGAL_DATA_ADDRESS;
+    }
+    /*if (address >= sizeof(HoldingRegister) / sizeof(HoldingRegister[0]) || (address + length) > sizeof(HoldingRegister) / sizeof(HoldingRegister[0])) {
+        return STATUS_ILLEGAL_DATA_ADDRESS;
+    }*/
+
+    for (uint16_t i = 0; i < length; i++) {
+        // Add specific data to holding registers
+        switch (address + i) {
+            case 0:  // Modbus ID
+                slave.writeRegisterToBuffer(i, modbusConfig.GetModbusID());
+                break;
+            case 1:  // Modbus ID
+                slave.writeRegisterToBuffer(i, modbusConfig.GetModbusID());
+                break;
+            case 2:  // Baud rate
+                slave.writeRegisterToBuffer(i, modbusConfig.GetBaudRate());
+                break;
+            default:  // Other data from HoldingRegister array
+                slave.writeRegisterToBuffer(i, HoldingRegister[address + i]);
+                break;
+        }
+    }
+
+    return STATUS_OK;
+}
+
+
+// -------------------------
+// Setup and Loop Functions
+// -------------------------
+
+
 void setup() {
     pinMode(RS485_CTRL_PIN, OUTPUT);
     digitalWrite(RS485_CTRL_PIN, LOW);  // RS485-Empfang aktivieren
@@ -122,6 +228,9 @@ void setup() {
     slave.cbVector[CB_WRITE_COILS] = writeDigitalOut;
     slave.cbVector[CB_READ_DISCRETE_INPUTS] = fReadCoilRegister;
     slave.cbVector[CB_READ_INPUT_REGISTERS] = fReadInputRegister;
+    slave.cbVector[CB_WRITE_HOLDING_REGISTERS] = fWriteHoldingRegister;
+    slave.cbVector[CB_READ_HOLDING_REGISTERS] = fReadHoldingRegister;
+    //slave.cbVector[CB_WRITE_INPUT_REGISTERS] = fWriteInputRegister;  // Registrierung der Schreib-Funktion
 
     pinMode(OutPutPin, OUTPUT);
     digitalWrite(OutPutPin, LOW);