From FHEM side of view, you may use any of the Types MySensors offers, most likely presenting one or more S_POWER Children fit closest.

To get "better" reading names, I'd give the "get <device> ReadingsFromComments" function a try and add a comment to the sketches present() function (Cell1, ..., Solar, Battery...).

It's a bit hard to explain. If you have some experience with DS18x20 type of sensors, you may get an idea looking at the code here (or make some experienents with it): https://github.com/rejoe2/MySensors-Dallas-Address-ChildID-Consistency/blob/master/DallasTemperatureSimple/DallasTemperatureSimple.ino

Asking the controller at startup: issue a request, see https://www.mysensors.org/download/sensor_api_20#requesting-data, imo you should as for V_STATUS.

Then your controller should respond, the response is handled by the receive()-function (=no action needed), but to get this to work, your node should not sleep (you sketch seems to be incomplete wrt. that).
But you should first switch off everyhing to have it in a defined state and avoid loading values from the EEPROM.

Wrt. to regular status info: If that's necessary, you should try to use a so called "non blocking loop", use g**gle or similar for that. Imo, it's not necessary to update the value as it doesn't change. Better use the heartbeat funcionality instead (dependend on your controller).

Based on the great sketch korttoma posted here, the following could work:

// Enable debug prints to serial monitor
#define MY_DEBUG

// Enable and select radio type attached
#define MY_RADIO_NRF24

#define SN "RelayButtonArray"
#define SV "1.0"

#include <MySensors.h>
#include <SPI.h>
#include <Bounce2.h>
#define RELAY_ON 0                      // switch around for ACTIVE LOW / ACTIVE HIGH relay
#define RELAY_OFF 1
//

#define noRelays 4                     //2-4
const int relayPin[] = {14, 15, 16, 17};       //  switch around pins to your desire
const int buttonPin[] = {6, 7, 4, 5};   //  switch around pins to your desire

class Relay             // relay class, store all relevant data (equivalent to struct)
{
  public:
    int buttonPin;                   // physical pin number of button
    int relayPin;             // physical pin number of relay
    boolean relayState;               // relay status (also stored in EEPROM)
};

Relay Relays[noRelays];
Bounce debouncer[noRelays];
MyMessage msg[noRelays];

/*
  void before() {
  for (int sensor=1, pin=RELAY_1; sensor<=NUMBER_OF_RELAYS;sensor++, pin++) {
    // Then set relay pins in output mode
    pinMode(pin, OUTPUT);
    // Set relay to last known state (using eeprom storage)
        digitalWrite(pin, RELAY_OFF); //digitalWrite(pin, loadState(sensor)?RELAY_ON:RELAY_OFF);
  }
  }*/

void setup() {
  wait(100);
  // Initialize Relays with corresponding buttons
  for (int i = 0; i < noRelays; i++) {
    Relays[i].buttonPin = buttonPin[i];              // assign physical pins
    Relays[i].relayPin = relayPin[i];
    msg[i].sensor = i;                                   // initialize messages
    msg[i].type = V_LIGHT;
    pinMode(Relays[i].buttonPin, INPUT_PULLUP);
    wait(100);
    pinMode(Relays[i].relayPin, OUTPUT);
    //Relays[i].relayState = loadState(i);                               // retrieve last values from EEPROM
	// digitalWrite(Relays[i].relayPin, Relays[i].relayState ? RELAY_ON : RELAY_OFF); // and set relays accordingly
    //send(msg[i].set(Relays[i].relayState ? true : false));                 // make controller aware of last status
    wait(50);
    debouncer[i] = Bounce();                        // initialize debouncer
    debouncer[i].attach(buttonPin[i]);
    debouncer[i].interval(30);
    wait(50);
  }
}

void presentation()
{
  // Send the sketch version information to the gateway and Controller
  sendSketchInfo(SN, SV);

  wait(100);

  for (int i = 0; i < noRelays; i++)
    present(i, S_LIGHT);                               // present sensor to gateway
    request(i, V_LIGHT); //...not sure if this is the right syntax
  wait(100);
}


void loop()
{
  for (byte i = 0; i < noRelays; i++) {
    if (debouncer[i].update()) {
      
      int value = debouncer[i].read();
      
      if ( value == LOW) {
        Relays[i].relayState = !Relays[i].relayState;
        digitalWrite(Relays[i].relayPin, Relays[i].relayState ? RELAY_ON : RELAY_OFF);
        send(msg[i].set(Relays[i].relayState ? true : false));
        // save sensor state in EEPROM (location == sensor number)
        //saveState( i, Relays[i].relayState );

      }

    }
  }
  //wait(20);
}

void receive(const MyMessage &message) {
  if (message.type == V_LIGHT) {
    if (message.sensor < noRelays) {          // check if message is valid for relays..... previous line  [[[ if (message.sensor <=noRelays){ ]]]
      Relays[message.sensor].relayState = message.getBool();
      digitalWrite(Relays[message.sensor].relayPin, Relays[message.sensor].relayState ? RELAY_ON : RELAY_OFF); // and set relays accordingly
      //saveState( message.sensor, Relays[message.sensor].relayState ); // save sensor state in EEPROM (location == sensor number)
    }
  }
  wait(20);
}

I tried to just comment out things not needed, so you might find it easier to understand the differences between loading from EEPROM and requesting the state from controller side.

@apl2017 Yes, also for RS485 variant you'll need a gateway. Only the communication between the gateway and the other nodes is handled over RS485, connected to a second (typically software) serial interface (for remote nodes, you may just use the hardware serial interface to connect the RS485 transceiver, if you do not need debug output; but imo this option is not recommended for beginners).

@bereska said in Water Meter Pulse Sensor:

32319 TSF:MSG:SEND,6-6-0-0,s=1,c=2,t=24,pt=0,l=0,sg=0,ft=0,st=OK:

Logparser states: there was nothing counted (empty payload). So make sure, there really was counted anything.
(I didn't check your sketch, just assuming, it's the default one and everything is wired correctly; if that's the case, you should be able to see a different payload than nothing or "0", that your controller might treat as non existent).

...just let the node count some pulses (your code states: FALLING). So just pull the counter PIN (here: D3) to ground several times.

@bereska said in Water Meter Pulse Sensor:

Is it possible to get any help on this page or not?

Crying out loud most likely will not help...
Seems your setup is a little special, so just some assumptions from one using a serial GW and not MyS-MQTT:
Your controller is asked for sending an initial value, but has none yet. So no answer is sent out. Triggering the counter on Node side could help to send one (after waiting time has passed). Then have a look at your controller, if there's a value available. If, you might set the correct value, restart your node afterwards and see, if everything now works as expected?

You are using the same ChildID's for relays and tripped/door states. Imo this is messing things up, so e.g. use 11+12 for tripped values.
Remark: If you are looking for a good example on using arrays for that kind of tasks, see korttomas work here: https://forum.mysensors.org/post/51488

As you already did some differnenciation wrt. to the ChildID, this seemed not to be to far beyond your actual knowledge. Sth. like

if (incomingOutlet == 0 && (message.type == V_LIGHT || message.type == V_DIMMER))

should do the trick .
Wrt. to arrays to avoid all the repeatings in the code, it's not that easy. Assuming, the send-codes to be longint type of data, sth. like

const uint16_t RF_CODES[NUMBER_OF_PLUGS] = {
{4072574,4072566},
{4072572,4072564},
{4072570,4072562},
{1386894,1386886},
{1386892,1386884},
{1386890,1386882}
};

might easen addressing sendCode to sth. like

RF_CODES[incomingOutlet-1][incomingLightState]

Note: This is completely untested...
Within MySensors, array coding is not really part of the default sketches, so you should have a look at the normal arduino examples.

Two short remarks:

• last if-branch in receive() additionally needs clarification to only be meant for ChildID 0; this should "cure" the problem you are working on.
• For the general structure of your code imo it would help much to use arrays to store all the info.