MODBUS-Protocol-v25 verstehen (Epever 2210AN)

[Megaquaeler]

Hallo,
in Bezug auf :ESP8266 EPEVER Laderegler Modbus Problem

Kann mir jemand sagen wie ich die erzeugten gesamt KWh bekommen UND oder wie ich den last Ausgang ein und aus schalten kann?

Leider verstehe ich die ganze Bibliothek auch nicht.

Laut der liste von;

MODBUS-Protocol-v25.pdf

Wäre das wohl die Adresse von 3310 bis 3313 wieso auch immer 4.

Sowie G6 denke ich mal, aber wie genau das jetzt abgefragt wird oder gesetzt wird, kann ich beim besten Willen nicht nachvollziehen.

Hardware Arduino DUE + epever 2210AN

Wäre super, wenn mir jemand weiter helfen kann.
VIELEN DANK.

[fony]

Also das war hier schon zwei mall
Warte ich suche das Im Post'#2 ist Sketch, ganz unten wird der Tracer ausgelesen, schau aber auch wie der MAX459 wird initialisiert

Ich werde aus einer Fehlermeldung nicht schlau

Hallo Gemeinde. Ich habe eine Fehlermeldung aus der ich das Problem nicht sehe. Ich habe es auch auf der IDE 1.8.19 versucht. Da ist das gleiche Problem. "Fehler beim Kompilieren für das Board Arduino Uno." Auf dem PC eines Kollegen läuft das Programm ohne Fehler durch. Das Problem ist also nicht das Programm, sondern meine Kiste. Die Meldungen schaut so aus: Arduino: 1.8.15 (Windows 7), Board: "Arduino Uno" Using board 'uno' from platform in folder: C:\Program Files (x86)\Ardui…

Erster Beitrag:

PV Regler Tacer 2210AN Auslesen

na dann lies halt ZWEI byte ab 3312 und gib dir mal die zwei byte aus result = node.readInputRegisters(0x3312, 2); if (result == node.ku8MBSuccess) { Serial.println(node.getResponseBuffer(0x00)); Serial.println(node.getResponseBuffer(0x01)); generell empfehle ich dir POSTE DEINEN Code ... weil deine Fragestellungen kann man fast nicht lesen.

Mit Beschreibung wie man den MAX985 Modul anklemmt.

Und wenn du das Forum durchsuchst findest du bestimmt noch was

[Megaquaeler]

Super Vielen dank.
Kann mir noch jemand sagen wie das mit dem ein und aus schalten des verbauten mosfet geht ?

Wenn readInputRegisters die 4 ist und readHoldingRegisters die 3 was ist dann bitte die 10 und 5 ?

Vielen dank

[fony]

So wie ich dich verstanden habe willst du den Lastausgang mit Arduino ein und ausschalten?

Persönlich habe damit nicht rumgespielt, nutze den nicht. @noiasca kennt sich damit sehr gut aus

[noiasca]

@Megaquaeler

erzeugten gesamt KWh bekomme

der sketch müsste funktionieren:

/*******************************************************

  Modbus Client Example 0x60 (Modbus Master)
  Read EPSOLAR - all registers

  This Modbus Client
  - reads registers from Modbus Servers periodically

  based on an idea

  RS485_HalfDuplex.pde - example using ModbusMaster library to communicate
  with EPSolar LS2024B controller using a half-duplex RS485 transceiver.

  This example is tested against an EPSolar LS2024B solar charge controller.
  See here for protocol specs:
  http://www.solar-elektro.cz/data/dokumenty/1733_modbus_protocol.pdf

  hardware
  - a LED
  - 4 push buttons
  - a MAX485-TTL adapter

  by noiasca
  2022-07-30

 *******************************************************/


/* *******************************************************
   Serial Interface
 * **************************************************** */
// if you don't have enough HW Serial (i.e. on an UNO)
// you are forced to use SoftwareSerial or AltSoftSerial
//include <SoftwareSerial.h>
//constexpr uint8_t rxPin = 2;                   // for Softserial
//constexpr uint8_t txPin = 3;
//SoftwareSerial mySerial(rxPin, txPin);

// On a Mega you can simply use
// a Reference to an existing HW Serial:
HardwareSerial &mySerial = Serial3;

/* **************************************************** *
   Modbus
 * **************************************************** */

#include <ModbusMaster.h>                        // Modbus Master 2.0.0 by Doc Walker - install with Library Manager
constexpr uint8_t modbusEnablePin = 5;           // The GPIO used to control the MAX485 TX pin. Set to 255 if you are not using RS485 or a selfsensing adapter
constexpr uint32_t modbusBaud = 115200;          // use slow speeds with SoftSerial
constexpr uint16_t modbusRestTx = 15000;         // rest time between transmissions - microseconds
uint32_t modbusPreviousTx = 0;                   // timestamp of last transmission - microseconds
ModbusMaster serverA;                            // instantiate ModbusMaster object - slave - node

// this function will be called before the client transmits data
void preTransmission()
{
  while (micros() - modbusPreviousTx < modbusRestTx)   // check last transmission end and wait if the call was to early
  {
    yield();                                           // wait some time and allow background tasks
  }
  digitalWrite(modbusEnablePin, HIGH);
}

// this function will be called after the transmission
void postTransmission()
{
  digitalWrite(modbusEnablePin, LOW);
  modbusPreviousTx = micros();         // remember last timestamp
}

// do all the settings for the Modbus
void modbusInit()
{
  mySerial.begin(modbusBaud);                     // initialize Modbus communication baud rate
  serverA.begin(1, mySerial);                     // communicate with Modbus server ID over the given Serial interface
  pinMode(modbusEnablePin, OUTPUT);               // Init enable pins for modbus master library
  digitalWrite(modbusEnablePin, LOW);
  serverA.preTransmission(preTransmission);       // Callbacks allow us to configure the RS485 transceiver correctly
  serverA.postTransmission(postTransmission);
}

/* **************************************************** *
   Modbus - Implementation
 * **************************************************** */

void requestData()
{
  static uint32_t previousMillis = -5000;  // timestamp of last request
  static uint8_t actual = 0;           // actual iteration
  uint32_t currentMillis = millis();

  if (currentMillis - previousMillis > 5000)  // set the interval in ms
  {
    previousMillis = currentMillis;
    uint16_t reg = 0x3100;
    int result;
    switch (actual)
    {
      case 0 :
        reg = 0x3100;
        result = serverA.readInputRegisters(reg, 8);
        if (result == serverA.ku8MBSuccess) // do something if read is successfull
        {
          Serial.print(F("Charging equipment input V:     ")); Serial.println(serverA.getResponseBuffer(0x00) / 100.0f);
          Serial.print(F("Charging equipment input A:     ")); Serial.println(serverA.getResponseBuffer(0x01) / 100.0f);
          Serial.print(F("Charging equipment input W:     ")); Serial.println((serverA.getResponseBuffer(0x02) + ((uint32_t)serverA.getResponseBuffer(0x03) << 16)) / 100.0f); // cast and brackets
          Serial.print(F("Charging equipment output V:    ")); Serial.println(serverA.getResponseBuffer(0x04) / 100.0f);
          Serial.print(F("Charging equipment output A:    ")); Serial.println(serverA.getResponseBuffer(0x05) / 100.0f);
          Serial.print(F("Charging equipment output W:    ")); Serial.println((serverA.getResponseBuffer(0x06) + ((uint32_t)serverA.getResponseBuffer(0x07) << 16)) / 100.0f); // cast and brackets
        }
        else
        {
          Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
        }
        actual++;
        break;
      case 1 :
        reg = 0x310C;
        result = serverA.readInputRegisters(reg, 7);
        if (result == serverA.ku8MBSuccess) // do something if read is successfull
        {
          Serial.print(F("Charging equipment input V:     ")); Serial.println(serverA.getResponseBuffer(0x310c - reg) / 100.0f);
          Serial.print(F("Charging equipment input A:     ")); Serial.println(serverA.getResponseBuffer(0x310d - reg) / 100.0f);
          Serial.print(F("Charging equipment input W:     ")); Serial.println((serverA.getResponseBuffer(0x310e - reg) + ((uint32_t)serverA.getResponseBuffer(0x310F - reg) << 16)) / 100.0f); // cast and brackets
          Serial.print(F("Battery Temperature:            ")); Serial.println(serverA.getResponseBuffer(0x3110 - reg) / 100.0f);
          Serial.print(F("Temperature inside equipment:   ")); Serial.println(serverA.getResponseBuffer(0x3111 - reg) / 100.0f);
          Serial.print(F("Power components temperature:   ")); Serial.println(serverA.getResponseBuffer(0x3112 - reg) / 100.0f);
        }
        else
        {
          Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
        }
        actual++;
        break;
      case 2 :
        reg = 0x311A;
        result = serverA.readInputRegisters(reg, 2);
        if (result == serverA.ku8MBSuccess) // do something if read is successfull
        {
          Serial.print(F("Battery SoC:                    ")); Serial.println(serverA.getResponseBuffer(0x311A - reg));
          Serial.print(F("Remote battery temperature:     ")); Serial.println(serverA.getResponseBuffer(0x311B - reg) / 100.0f);
        }
        else
        {
          Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
        }
        actual++;
        break;
      case 3 :
        reg = 0x311A;
        result = serverA.readInputRegisters(reg, 1);
        if (result == serverA.ku8MBSuccess) // do something if read is successfull
        {
          Serial.print(F("Battery's real rated power:     ")); Serial.println(serverA.getResponseBuffer(0x311D - reg) / 100.0f);
        }
        else
        {
          Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
        }
        actual++;
        break;
      case 4 :
        reg = 0x3200;
        result = serverA.readInputRegisters(reg, 2);
        if (result == serverA.ku8MBSuccess) // do something if read is successfull
        {
          Serial.print(F("Battery status:                 ")); Serial.println(serverA.getResponseBuffer(0x3200 - reg), BIN);
          Serial.print(F("Charging equipment:             ")); Serial.println(serverA.getResponseBuffer(0x3201 - reg), BIN);
        }
        else
        {
          Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
        }
        actual++;
        break;
      case 5 :
        reg = 0x3300;
        result = serverA.readInputRegisters(reg, 30);
        if (result == serverA.ku8MBSuccess) // do something if read is successfull
        {
          Serial.print(F("Max input (PV) volt:            ")); Serial.println(serverA.getResponseBuffer(0x3300 - reg) / 100.0f);
          Serial.print(F("Min input (PV) volt:            ")); Serial.println(serverA.getResponseBuffer(0x3301 - reg) / 100.0f);
          Serial.print(F("Max battery volt:               ")); Serial.println(serverA.getResponseBuffer(0x3302 - reg) / 100.0f);
          Serial.print(F("Min battery volt:               ")); Serial.println(serverA.getResponseBuffer(0x3303 - reg) / 100.0f);
          Serial.print(F("Consumed energy today:          ")); Serial.println((serverA.getResponseBuffer(0x3304 - reg) + ((uint32_t)serverA.getResponseBuffer(0x3305 - reg) << 16)) / 100.0f);
          Serial.print(F("Consumed energy month:          ")); Serial.println((serverA.getResponseBuffer(0x3306 - reg) + ((uint32_t)serverA.getResponseBuffer(0x3307 - reg) << 16)) / 100.0f);
          Serial.print(F("Consumed energy year:           ")); Serial.println((serverA.getResponseBuffer(0x3308 - reg) + ((uint32_t)serverA.getResponseBuffer(0x3309 - reg) << 16)) / 100.0f);
          Serial.print(F("Total consumed:                 ")); Serial.println((serverA.getResponseBuffer(0x330A - reg) + ((uint32_t)serverA.getResponseBuffer(0x330B - reg) << 16)) / 100.0f);
          Serial.print(F("Generated energy today:         ")); Serial.println((serverA.getResponseBuffer(0x330C - reg) + ((uint32_t)serverA.getResponseBuffer(0x330D - reg) << 16)) / 100.0f);
          Serial.print(F("Generated energy month:         ")); Serial.println((serverA.getResponseBuffer(0x330E - reg) + ((uint32_t)serverA.getResponseBuffer(0x330F - reg) << 16)) / 100.0f);
          Serial.print(F("Generated energy year:          ")); Serial.println((serverA.getResponseBuffer(0x3310 - reg) + ((uint32_t)serverA.getResponseBuffer(0x3311 - reg) << 16)) / 100.0f);
          Serial.print(F("Total generated energy:         ")); Serial.println((serverA.getResponseBuffer(0x3312 - reg) + ((uint32_t)serverA.getResponseBuffer(0x3313 - reg) << 16)) / 100.0f);
          Serial.print(F("CO2 reduction:                  ")); Serial.println((serverA.getResponseBuffer(0x3314 - reg) + ((uint32_t)serverA.getResponseBuffer(0x3315 - reg) << 16)) / 100.0f);
          // there is one register not documented
          Serial.print(F("Battery Temperature :           ")); Serial.println(serverA.getResponseBuffer(0x331D - reg) / 100.0f);
          Serial.print(F("Ambient Temperature :           ")); Serial.println(serverA.getResponseBuffer(0x331E - reg) / 100.0f);
        }
        else
        {
          Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
        }
        actual = 0; // in the last case we jump back to 0 instead of actual++;
        break;
      default : actual = 0;
    } // switch
  }
}


// Parameters don't change so often, we only read them once after startup
// preTransmission and postTransmission take care of the requested "delay" between requests
void requestParameter()
{
  uint16_t reg;
  int result;

  reg = 0x3000;
  result = serverA.readInputRegisters(reg, 8);
  if (result == serverA.ku8MBSuccess) // do something if read is successfull
  {
    Serial.print(F("Charging equipment rated input V: ")); Serial.println(serverA.getResponseBuffer(0x00) / 100.0f);
    Serial.print(F("Charging equipment rated input A: ")); Serial.println(serverA.getResponseBuffer(0x01) / 100.0f);
    Serial.print(F("Charging equipment rated input W: ")); Serial.println((serverA.getResponseBuffer(0x02) + ((uint32_t)serverA.getResponseBuffer(0x03) << 16)) / 100.0f); // cast and brackets
    Serial.print(F("Charging equipment rated output V:")); Serial.println(serverA.getResponseBuffer(0x04) / 100.0f);
    Serial.print(F("Charging equipment rated output A:")); Serial.println(serverA.getResponseBuffer(0x05) / 100.0f);
    Serial.print(F("Charging equipment rated output W:")); Serial.println((serverA.getResponseBuffer(0x06) + ((uint32_t)serverA.getResponseBuffer(0x07) << 16)) / 100.0f); // cast and brackets
    Serial.print(F("Charging mode:                    ")); Serial.println(serverA.getResponseBuffer(0x08));
  }
  else
  {
    Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
  }

  reg = 0x300E;
  result = serverA.readInputRegisters(reg, 1);
  if (result == serverA.ku8MBSuccess) // do something if read is successfull
  {
    Serial.print(F("Rated output current of load:     ")); Serial.println(serverA.getResponseBuffer(0x00) / 100.0f);
  }
  else
  {
    Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
  }

  reg = 0x9000;
  result = serverA.readHoldingRegisters(reg, 15);
  if (result == serverA.ku8MBSuccess) // do something if read is successfull
  {
    Serial.print(F("Battery Type:                   ")); Serial.println(serverA.getResponseBuffer(0x9000 - reg));
    Serial.print(F("Battery Capacity:               ")); Serial.println(serverA.getResponseBuffer(0x9001 - reg));
    Serial.print(F("Temperature compensation coeff: ")); Serial.println(serverA.getResponseBuffer(0x9002 - reg) / 100.0f);
    Serial.print(F("High Volt disconnect:           ")); Serial.println(serverA.getResponseBuffer(0x9003 - reg) / 100.0f);
    Serial.print(F("Charging limit voltage:         ")); Serial.println(serverA.getResponseBuffer(0x9004 - reg) / 100.0f);
    Serial.print(F("Over voltage reconnect:         ")); Serial.println(serverA.getResponseBuffer(0x9005 - reg) / 100.0f);
    Serial.print(F("Equalization voltage:           ")); Serial.println(serverA.getResponseBuffer(0x9006 - reg) / 100.0f);
    Serial.print(F("Boost voltage:                  ")); Serial.println(serverA.getResponseBuffer(0x9007 - reg) / 100.0f);
    Serial.print(F("Float voltage:                  ")); Serial.println(serverA.getResponseBuffer(0x9008 - reg) / 100.0f);
    Serial.print(F("Boost reconnect voltage:        ")); Serial.println(serverA.getResponseBuffer(0x9009 - reg) / 100.0f);
    Serial.print(F("Low voltage reconnect:          ")); Serial.println(serverA.getResponseBuffer(0x900A - reg) / 100.0f);
    Serial.print(F("Under voltage recover:          ")); Serial.println(serverA.getResponseBuffer(0x900B - reg) / 100.0f);
    Serial.print(F("Under voltage warning:          ")); Serial.println(serverA.getResponseBuffer(0x900C - reg) / 100.0f);
    Serial.print(F("Low voltage disconnect:         ")); Serial.println(serverA.getResponseBuffer(0x900D - reg) / 100.0f);
    Serial.print(F("Discharging limit voltage recon:")); Serial.println(serverA.getResponseBuffer(0x900E - reg) / 100.0f);
  }
  else
  {
    Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
  }

  reg = 0x9013;
  result = serverA.readHoldingRegisters(reg, 15);
  if (result == serverA.ku8MBSuccess) // do something if read is successfull
  {
    Serial.print(F("RTC:                            ")); Serial.println(serverA.getResponseBuffer(0x9013 - reg));
    Serial.print(F("RTC:                            ")); Serial.println(serverA.getResponseBuffer(0x9014 - reg));
    Serial.print(F("RTC:                            ")); Serial.println(serverA.getResponseBuffer(0x9015 - reg));
    Serial.print(F("Equalization charging cycle:    ")); Serial.println(serverA.getResponseBuffer(0x9016 - reg));
    Serial.print(F("Batterie Warning upper Limit:   ")); Serial.println(serverA.getResponseBuffer(0x9017 - reg));
    Serial.print(F("Batterie Warning upper Limit:   ")); Serial.println(serverA.getResponseBuffer(0x9018 - reg));
    Serial.print(F("Controller inner temperature upper limit: ")); Serial.println(serverA.getResponseBuffer(0x9019 - reg)/ 100.0f);
    Serial.print(F("Controller inner temperature upper limit recover: ")); Serial.println(serverA.getResponseBuffer(0x901A - reg)/ 100.0f);
    Serial.print(F("Power component temperature upper limit: ")); Serial.println(serverA.getResponseBuffer(0x901B - reg)/ 100.0f);    
    Serial.print(F("Power component temperature upper limit recover: ")); Serial.println(serverA.getResponseBuffer(0x901C - reg)/ 100.0f);    
    Serial.print(F("Line impedance:                 ")); Serial.println(serverA.getResponseBuffer(0x901D - reg)/ 100.0f);    
    Serial.print(F("Night Time Threshold Volt:      ")); Serial.println(serverA.getResponseBuffer(0x901C - reg)/ 100.0f);    
    Serial.print(F("Light signal startup night delay:")); Serial.println(serverA.getResponseBuffer(0x901F - reg));    
    Serial.print(F("Day Time Threshold Volt:        ")); Serial.println(serverA.getResponseBuffer(0x9020 - reg)/ 100.0f);    
    Serial.print(F("Light signal startup day delay: ")); Serial.println(serverA.getResponseBuffer(0x9021 - reg));    
  }
  else
  {
    Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
  }

  reg = 0x903D;
  result = serverA.readHoldingRegisters(reg, 3);
  if (result == serverA.ku8MBSuccess) // do something if read is successfull
  {
    Serial.print(F("Load controlling modes:         ")); Serial.println(serverA.getResponseBuffer(0x903D - reg));
    Serial.print(F("Working time length 1:          ")); Serial.println(serverA.getResponseBuffer(0x903E - reg));
    Serial.print(F("Working time length 2:          ")); Serial.println(serverA.getResponseBuffer(0x903F - reg));  
  }
  else
  {
    Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
  }

  reg = 0x9042;
  result = serverA.readHoldingRegisters(reg, 12);
  if (result == serverA.ku8MBSuccess) // do something if read is successfull
  {
    Serial.print(F("Turn on timing 1 (sec):         ")); Serial.println(serverA.getResponseBuffer(0x9042 - reg));
    Serial.print(F("Turn on timing 1 (min):         ")); Serial.println(serverA.getResponseBuffer(0x9043 - reg));
    Serial.print(F("Turn on timing 1 (hou):         ")); Serial.println(serverA.getResponseBuffer(0x9044 - reg)); 
    Serial.print(F("Turn off timing 1 (sec):        ")); Serial.println(serverA.getResponseBuffer(0x9045 - reg));
    Serial.print(F("Turn off timing 1 (min):        ")); Serial.println(serverA.getResponseBuffer(0x9046 - reg));
    Serial.print(F("Turn off timing 1 (hou):        ")); Serial.println(serverA.getResponseBuffer(0x9047 - reg)); 
    Serial.print(F("Turn on timing 2 (sec):         ")); Serial.println(serverA.getResponseBuffer(0x9048 - reg));
    Serial.print(F("Turn on timing 2 (min):         ")); Serial.println(serverA.getResponseBuffer(0x9049 - reg));
    Serial.print(F("Turn on timing 2 (hou):         ")); Serial.println(serverA.getResponseBuffer(0x904A - reg)); 
    Serial.print(F("Turn off timing 2 (sec):        ")); Serial.println(serverA.getResponseBuffer(0x904B - reg));
    Serial.print(F("Turn off timing 2 (min):        ")); Serial.println(serverA.getResponseBuffer(0x904C - reg));
    Serial.print(F("Turn off timing 2 (hou):        ")); Serial.println(serverA.getResponseBuffer(0x904D - reg));
  }
  else
  {
    Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
  }

  reg = 0x9065;
  result = serverA.readHoldingRegisters(reg, 1);
  if (result == serverA.ku8MBSuccess)
  {
    Serial.print(F("Length of Night:                ")); Serial.println(serverA.getResponseBuffer(0x9065 - reg));
  }
  else
  {
    Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
  }

  reg = 0x9067;
  result = serverA.readHoldingRegisters(reg, 1);
  if (result == serverA.ku8MBSuccess)
  {
    Serial.print(F("Battery rated voltage code:     ")); Serial.println(serverA.getResponseBuffer(0x9067 - reg));
  }
  else
  {
    Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
  }

  reg = 0x9069;
  result = serverA.readHoldingRegisters(reg, 7);
  if (result == serverA.ku8MBSuccess)
  {
    Serial.print(F("Load timing control selection:  ")); Serial.println(serverA.getResponseBuffer(0x9069 - reg));
    Serial.print(F("Default load on/off:            ")); Serial.println(serverA.getResponseBuffer(0x906A - reg));
    Serial.print(F("Equalize Duration:              ")); Serial.println(serverA.getResponseBuffer(0x906B - reg));
    Serial.print(F("Boost Duration:                 ")); Serial.println(serverA.getResponseBuffer(0x906C - reg));
    Serial.print(F("Discharge percentage:           ")); Serial.println(serverA.getResponseBuffer(0x906D - reg)/100.0f);
    Serial.print(F("Charging percentage:            ")); Serial.println(serverA.getResponseBuffer(0x906E - reg)/100.0f);
    Serial.print(F("Management Mode of battery:     ")); Serial.println(serverA.getResponseBuffer(0x9070 - reg));
  }
  else
  {
    Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
  }
  
  reg = 0x2;
  result = serverA.readCoils(reg, 1);
  if (result == serverA.ku8MBSuccess)
  {
    Serial.print(F("Manual control the load:        ")); Serial.println(serverA.getResponseBuffer(0x2 - reg));
  }
  else
  {
    Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
  }

  reg = 0x5;
  result = serverA.readCoils(reg, 2);
  if (result == serverA.ku8MBSuccess)
  {
    Serial.print(F("Enable load test mode:          ")); Serial.println(serverA.getResponseBuffer(0x5 - reg));
    Serial.print(F("Force the load on/off:          ")); Serial.println(serverA.getResponseBuffer(0x6 - reg));
  }
  else
  {
    Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
  }

  reg = 0x2000;
  result = serverA.readDiscreteInputs(reg, 1);
  if (result == serverA.ku8MBSuccess)
  {
    Serial.print(F("Over temperature inside the device: ")); Serial.println(serverA.getResponseBuffer(0x2000 - reg));
  }
  else
  {
    Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
  }

  reg = 0x200C;
  result = serverA.readDiscreteInputs(reg, 1);
  if (result == serverA.ku8MBSuccess)
  {
    Serial.print(F("Day/Night:                      ")); Serial.println(serverA.getResponseBuffer(0x200C - reg));
  }
  else
  {
    Serial.print(F(" ServerA no success register ")); Serial.print(reg, HEX); Serial.print(F(" result=")); Serial.println(result, HEX);
  }
}

/* **************************************************** *
   setup and loop
 * **************************************************** */

void setup()
{
  Serial.begin(115200);
  Serial.println(F("Modbus Client Example 0x60"));

  modbusInit();
  requestParameter();
}

void loop()
{
  requestData();
}

[fony]

WOW muss das testen wen aufhört regnen.

[Megaquaeler]

SUPER VIELEN DANK mehr als ich wollte, bringt gleich neue Ideen
Mich würde aber nach wie vor interessieren wie ich den Ausgang SCHALTEN kann.

[noiasca]

zum Schalten brauchst ein Function Code 5 --> Coil write

/**
Modbus function 0x05 Write Single Coil.

This function code is used to write a single output to either ON or OFF 
in a remote device. The requested ON/OFF state is specified by a 
constant in the state field. A non-zero value requests the output to be 
ON and a value of 0 requests it to be OFF. The request specifies the 
address of the coil to be forced. Coils are addressed starting at zero.

@param u16WriteAddress address of the coil (0x0000..0xFFFF)
@param u8State 0=OFF, non-zero=ON (0x00..0xFF)
@return 0 on success; exception number on failure
@ingroup discrete
*/
uint8_t ModbusMaster::writeSingleCoil(uint16_t u16WriteAddress, uint8_t u8State)

also in etwa so etwas

reg = 0x0002;  // ich glaub ja eher es ist die coil 2 als coil 3
result = serverA.writeSingleCoil(reg, 0); // zum Abschalten

probiers mal am Ende vom Setup aus.
Ausgang am Regler einschalten,
Sketch resetten sollte dann den Ausgang abschalten.
In der Theorie.
Wenns nicht funktioniert, Returncode (result) in HEX ausdrucken und bekannt geben.

[Megaquaeler]

Ja wohl!
Lief auf anhieb ! ALLER BESTEN DANK.

PS Interessante Webseite haste