@yemesvee
If using a digital sensor mounted as per Kimot diagram you will receive a pulse stream, check the width of the pulsed to find if mesh or cable.

use the function pulseIn to determine the pulse width.

The simple example of the time duration of a pulse

int SensorPin = 3;
unsigned long duration = 0;
unsigned long CableDuration = 100;     // Set to suitable value
unsigned long CableCount = 0;

void setup()
{
  pinMode(SensorPin , INPUT);
}

void loop()
{

  duration = pulseIn(SensorPin , HIGH);
  Serial.print("Duration  : ");
  Serial.println(duration);
  if (duration >= CableDuration) {
    ++ CableCount;
    Serial.print("Cable detection  :");
    Serial.println(CableCount);
  }
}

@ek-wik you are describing sensor repeatability,

@dzjr To get the extra resolution sent to the controller try using

  send(msg.setSensor(i+21).set(temperature,2));

If the mesh moves at constant speed, How about a simple optical IR Sensor (break beam or Reflective), then checking pulse width of signal to detect mesh vs cable. Otherwise synchronize pulse width detection ratio in correlation to mesh speed.

Similar to this

@benhub Short answers, No, Yes, Yes

The regulator will use power if connected.
If your circuit is power hungry then removing the regulator will have limited effect.
The sparkfun schematic on the article that you listed notes to disconnect the regulator for low power, so the advice is consistent.
Unless you are using the genuine sparkfun versions of the pro-mini where the jumper can be cut then physically removing the regulator is recommended.

@dzjr you have the define

#define TEMPERATURE_PRECISION 12

In the github code this is not utilized, so the sensors are operating in 9 bit resolution.

You need to add the following in the before or setup

sensors.setResolution(TEMPERATURE_PRECISION);

@dzjr I also have various old meters, Some have a sealed movement so unable to change the scales.

Below is my meter showing time since last coffee.

@mateos78
Attached is a sketch that i have just tried with domoticz (running on a windows test machine) It works fine when used as a node with a gateway. Encoder/ Switch and webpage slider/switch operating.

However when set up as a single gateway node as your sketch, only the encoder function works, you can vary the lamp level from the slider or the encoder, but the domaticz on/off or the button does not operate correctly. it seems to be the way the messages are acknowledged

I also find that when i change the led dimmer from the encoder the led changes quickly, but it take about ten seconds before the dormoticz web page updates to show each new slider position.

The following Sketch needs the #define OPENHAB2 defined for use with openhab and undefined for Dormoticz

/**
 * The MySensors Arduino library handles the wireless radio link and protocol
 * between your home built sensors/actuators and HA controller of choice.
 * The sensors forms a self healing radio network with optional repeaters. Each
 * repeater and gateway builds a routing tables in EEPROM which keeps track of the
 * network topology allowing messages to be routed to nodes.
 *
 * Created by Henrik Ekblad <henrik.ekblad@mysensors.org>
 * Copyright (C) 2013-2015 Sensnology AB
 * Full contributor list: https://github.com/mysensors/Arduino/graphs/contributors
 *
 * Documentation: http://www.mysensors.org
 * Support Forum: http://forum.mysensors.org
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 *******************************
 * DESCRIPTION
 * This sketch provides an example how to implement a dimmable led light node with a rotary 
 * encoder connected for adjusting light level. 
 * The encoder has a click button which turns on/off the light (and remembers last dim-level) 
 * The sketch fades the light (non-blocking) to the desired level. 
 *
 * Default MOSFET pin is 3
 * 
 *  Arduino      Encoder module
 *  ---------------------------
 *  5V           5V (+)  
 *  GND          GND (-)
 *  4            CLK (or putput 1)
 *  5            DT  (or output 1) 
 *  6            SW (Switch/Click)  
 *
 *  For OpenHAB2  enable @define OPENHAB2
 *  
 *  NOTE
 *  PROBLEM: 
 *  Using as a Gateway Node With Dormoticz the SWITCH ON/OFF DOES not work correcly either from the controller or by the Encoder 
 *  Using as a normal node all functions operate correctly.
 *  
  */
 /

 
// Enable debug prints
//#define MY_DEBUG



// --- Enable Serial Gateway Transport
#define MY_GATEWAY_SERIAL
//#define MY_INCLUSION_MODE_FEATURE
//#define MY_INCLUSION_BUTTON_FEATURE
//#define MY_INCLUSION_MODE_DURATION 60
//#define MY_INCLUSION_MODE_BUTTON_PIN 8


// --- Enable RS485 transport layer
//#define MY_RS485
// Define this to enables DE-pin management on defined pin
//#define MY_RS485_DE_PIN 12
// Set RS485 baud rate to use
//#define MY_RS485_BAUD_RATE 9600



// Enable and select radio type attached
//#define MY_RADIO_NRF24
//#define MY_RADIO_RFM69

#include <SPI.h>
#include <MySensors.h>  
#include <Bounce2.h>
#include <Encoder.h>

#define LED_PIN 3           // Arduino pin attached to MOSFET Gate pin
#define KNOB_ENC_PIN_1 4    // Rotary encoder input pin 1
#define KNOB_ENC_PIN_2 5    // Rotary encoder input pin 2
#define KNOB_BUTTON_PIN 6   // Rotary encoder button pin 
#define FADE_DELAY 10       // Delay in ms for each percentage fade up/down (10ms = 1s full-range dim)
#define SEND_THROTTLE_DELAY 400 // Number of milliseconds before sending after user stops turning knob
#define SN "DimmableLED /w button"
#define SV "1.3a"

#define CHILD_ID_LIGHT 1

#define EEPROM_DIM_LEVEL_LAST 1
#define EEPROM_DIM_LEVEL_SAVE 2
// #define OPENHAB2                      // Use Define if using OPENHAB2 

#define LIGHT_OFF 0
#define LIGHT_ON 1

int dimValue;
int fadeTo;
int fadeDelta;
byte oldButtonVal;
bool changedByKnob=false;
bool sendDimValue=false;
unsigned long lastFadeStep;
unsigned long sendDimTimeout;
char convBuffer[10];

MyMessage dimmerMsg(CHILD_ID_LIGHT, V_DIMMER);
MyMessage statusMsg(CHILD_ID_LIGHT, V_STATUS);    // Addition for Status update to OpenHAB Controller
Encoder knob(KNOB_ENC_PIN_1, KNOB_ENC_PIN_2);  
Bounce debouncer = Bounce(); 

void setup()  
{ 
  // Set knob button pin as input (with debounce)
  pinMode(KNOB_BUTTON_PIN, INPUT);
  digitalWrite(KNOB_BUTTON_PIN, HIGH);
  debouncer.attach(KNOB_BUTTON_PIN);
  debouncer.interval(5);
  oldButtonVal = debouncer.read();

  // Set analog led pin to off
  analogWrite( LED_PIN, 0);

  // Retreive our last dim levels from the eprom
  fadeTo = dimValue = 0;
  byte oldLevel = loadLevelState(EEPROM_DIM_LEVEL_LAST);
  Serial.print("Sending in last known light level to controller: ");
  Serial.println(oldLevel);  
  send(dimmerMsg.set(oldLevel), true);
  Serial.println("Ready to receive messages...");  
}

void presentation() {
  // Send the Sketch Version Information to the Gateway
  present(CHILD_ID_LIGHT, S_DIMMER);
  sendSketchInfo(SN, SV);
}

void loop()      
{
  // Check if someone turned the rotary encode
  checkRotaryEncoder();
  
  // Check if someone has pressed the knob button
  checkButtonClick();
  
  // Fade light to new dim value
  fadeStep();
}

void receive(const MyMessage &message)
{
    #ifdef MY_DEBUG
    // This is called when a message is received 
    Serial.print("Message: "); Serial.print(message.sensor); Serial.print(", type: "); Serial.print(message.type); Serial.print(", Message: ");
    #endif
    
  if (message.type == V_STATUS) {
    // Incoming on/off command sent from controller ("1" or "0")
    int lightState = message.getString()[0] == '1';
    int newLevel = 0;
    if (lightState==LIGHT_ON) {
      // Pick up last saved dimmer level from the eeprom
      newLevel = loadLevelState(EEPROM_DIM_LEVEL_SAVE);
    } else {
      
    }
    // Send dimmer level back to controller with ack enabled
    send(dimmerMsg.set(newLevel), true);
    // We do not change any levels here until ack comes back from gateway 
    return;
  } else if (message.type == V_PERCENTAGE) {
    // Incoming dim-level command sent from controller (or ack message)
    fadeTo = atoi(message.getString(convBuffer));
    // Save received dim value to eeprom (unless turned off). Will be
    // retreived when a on command comes in
    if (fadeTo != 0)
      saveLevelState(EEPROM_DIM_LEVEL_SAVE, fadeTo);
  }
  saveLevelState(EEPROM_DIM_LEVEL_LAST, fadeTo);
  #ifdef MY_DEBUG
  Serial.print("New light level received: ");
  Serial.println(fadeTo);
  #endif
  
  if (!changedByKnob) 
    knob.write(fadeTo<<1);             //### need to multiply by two (using Shift left)
    
  // Cancel send if user turns knob while message comes in
  changedByKnob = false;
  sendDimValue = false;

  // Stard fading to new light level
  startFade();
}



void checkRotaryEncoder() {
  long encoderValue = knob.read()>>1 ;      //### Divide by 2 (using shift right) 

  if (encoderValue > 100) {   
    encoderValue = 100;       
    knob.write(200);                        //### max value now 200 due to divide by 2
  } else if (encoderValue < 0) {
    encoderValue = 0;
    knob.write(0);
  }

  if (encoderValue != fadeTo) {    
    fadeTo = encoderValue;                   
    changedByKnob = true;
    startFade();
  }
}

void checkButtonClick() {
  debouncer.update();
  byte buttonVal = debouncer.read();
  byte newLevel = 0;
  if (buttonVal != oldButtonVal && buttonVal == LOW) {
    if (dimValue==0) {
      // Turn on light. Set the level to last saved dim value
      int saved = loadLevelState(EEPROM_DIM_LEVEL_SAVE);
      newLevel = saved > 1 ? saved : 100;           // newLevel = saved > 0 ? saved : 100;     
    } 
    send(dimmerMsg.set(newLevel),true);
    #ifdef OPENHAB2
    send(statusMsg.set(newLevel>0 ? "1" : "0")); // Addition for Status update to OpenHAB Controller,   No Echo
    #endif
  }
  oldButtonVal = buttonVal;
}

void startFade() {
  fadeDelta = ( fadeTo - dimValue ) < 0 ? -1 : 1;
  lastFadeStep = millis();
}

// This method provides a graceful none-blocking fade up/down effect
void fadeStep() {
  unsigned long currentTime  = millis();

  if ( dimValue != fadeTo && currentTime > lastFadeStep + FADE_DELAY) {
    dimValue += fadeDelta;
    analogWrite( LED_PIN, (int)(dimValue / 100. * 255) );
    lastFadeStep = currentTime;
    #ifdef MY_DEBUG
    Serial.print("Fading level: ");
    Serial.println(dimValue);
    #endif
    
    if (fadeTo == dimValue && changedByKnob) {
      sendDimValue = true;
      sendDimTimeout = currentTime;
    }
  } 
  // Wait a few millisecs before sending in new value (if user still turns the knob)
  if (sendDimValue && currentTime > sendDimTimeout + SEND_THROTTLE_DELAY)  {
     // We're done fading.. send in new dim-value to controller.
     // Send in new dim value with ack (will be picked up in incomingMessage) 
    send(dimmerMsg.set(dimValue), true); // Send new dimmer value and request ack back
    sendDimValue = false;
  }
}

// Make sure only to store/fetch values in the range 0-100 from eeprom
int loadLevelState(byte pos) {
  return min(max(loadState(pos),0),100);
}
void saveLevelState(byte pos, byte data) {
  saveState(pos,min(max(data,0),100));
}

I maybe overlooking something obvious as i only have a couple of hours experience with domoticz.

@mateos78 See https://forum.mysensors.org/topic/9670/problem-with-dimmable-led-actuator-with-encoder/11

I made a simple adapter for Pro Minis, Used on it own for new boards with connection holes

If you slide on some dupont cable covers as a guide it makes it easy to program a soldered board