Posts made by kimot

@fernando-alvarez-buylla
I think you only need define your gateway in Domoticz.
That Is all.

@encrypt
I am not sure, if we speak about the same AES key.
I mean encryption key for RFM69 chip, because you select using encryption by this radio in your network.
But I am on my mobile only, so it is dificult study source codes Now.

@encrypt
I do not see encryption kye for RFM69 in your code...

When you switch off power for servos, they will stay in last position. And they have got a gear so not too easy self moving like single steppers.
And pan tilt kits are very cheap.

@alowhum
For me top user friendly is ESPeasy.
Through web interface selecting which sensors on which pins connected and to which controller send data.
When user become more experienced, he can use rules to write some "programs".
No recompilation needed.
But not useful for battery powered nodes which needs receive some data.

And what kit with stepper motors? Or you mean servo motors ?

You realy think, that it Is useful fór connecting two male connectors together, what way asked?

@terence-faul
comment step by step blocks of code for DOOR switch and try when it start to work.

If you plan using ESP chips or Raspberry as your sensors node, I think better way is ESPeasy or similar sw for ESPs.

How do you solve a situation where a SSR breakdown occurs and you are hunderts km away from home?
I think some classic relay is necessary in this application to handle error conditions.
Similarly, measuring the temperature in the blast near SSR is not very accurate.

https://www.letscontrolit.com/forum/viewtopic.php?f=2&t=6540

Piezo detector exists for detecting the impact of the drop.

It is a very interesting board for RS485 applications (modbus etc.).
But not quite right for Mysensors serial bus. RS485 is not designed for multimaster bus.
CAN bus drivers are most preferable.

You are probably the exception that you have electricity, gas and water gauges side by side and you can read them with one device.

@dbemowsk
Yes, sometimes it got USB1 instead of USB0.
You can create fix symlink for your USBtoSerial adapter and then write for example ttySonoff and allways will be right.

@fernando-alvarez-buylla
ESP with Tasmota or ESPeasy is good solution for sensors where power is available. But if you must use battery, you must find something different. And then MySensors with RFM69 radio (not your 2.4GHz NRF24L01 ) can be good choice. It has a lot of better distance on 848 or 433MHz.

@hyperflemme
Use gateway sketch and add sensor presentation and sensor data sending like in node sketch.

example from this forum:

void presentation() {
  // Present locally attached sensors here
    // Send the sketch version information to the gateway and Controller
  sendSketchInfo("AWI_ESP 120", "1.0");

  // Register all sensors to gw (they will be created as child devices)
  present(CHILD_ID, S_DIMMER, "AWI_ESP 120" " dimmer");
  present(CHILD_ID2, S_INFO, "AWI_ESP 120" " text");

}


void loop() {
  // Send locally attached sensors data here
 	send(msg.set(messageCounter)); 										// Send message to gw 
	messageCounter = ++messageCounter % 100 ;							// wrap
	send(msg2.set("Hallo")); 											// Send message to gw 
	// Send update every SLEEP_TIME
	wait(SLEEP_TIME) ;
}

void receive(const MyMessage &message) {  								// messages from node or controller
	//char printBuf[40] ;
	//Serial.print(message.getInt());
		//sprintf(printBuf, "Message node: %d %d  OK\n", message.sender, message.getInt());
}
	//Serial.print(printBuf) ;
	//sprintf(printBuf, "Messages: %d Errors: %d\n", messageCounter, messageErrorCounter);
	//Serial.print(printBuf) ;

Search forum here, you are not alone with this solution.

@dbemowsk

You must install esptool:
https://diyprojects.io/esp-easy-flash-firmware-esptool-py-esp8266/
or
https://github.com/arendst/Sonoff-Tasmota/wiki/Esptool#esptool-executable-windows--linux

Attention, there are some dependencies...

Then normally go to folder where .bin file is placed and run command:

esptool.py --port /dev/ttyUSB0 --baud 115200 write_flash 0x00000 ESP_Easy_v2.0-20180322_normal_ESP8285_1024.bin

or

python esptool.py .........................

not ./esptool.py

But I suggest first try :

esptool.py --port /dev/ttyUSB0 flash_id

To check if every is OK ( port, etc )

I think we still do not know the topology of your network and we use different terms.
For most of us a "sensor" is - temperature sensor, humidity sensor, pressure sensor, etc. These sensors are connected to Arduino, which we call the "node".
These node are connected through radio or RS485 to Arduino which works like gateway and send received messages from nodes to controller ( Rpi with Domoticz ).
Usually gateway have got no sensors and you can use pure gateway sketch from examples.
But you can connect sensors directly to gateway, but you must modify gateway sketch then.

• setup your sensors
• present your sensors
• send values form your sensors.

And of course NO SLEEP FUNCTION in sensor send code.

Places, where put it is marked by comments in gateway sketch:

void setup()
{
    // Setup locally attached sensors
}

void presentation()
{
    // Present locally attached sensors
}

void loop()
{
    // Send locally attached sensor data here
}

Usual topology:

I think your topology:

@dbemowsk
It is from here:
https://github.com/letscontrolit/ESPEasy/releases/tag/v2.0-20180322

I connect it like you wrote.

@paweld
And must you really use SoftwareSerial and not AltSoftSerial, which is default for MySensors RS485 link layer?
You do not need include SoftwareSerial in your sketch then.

@dbemowsk
I have 12 of these new and working without any problems.
There is a missing gpio14 pin, where I connected the DS18B20, but I used the RX pin instead.
PCB design is more solid to me - you can even see the power fuse.
ESPeasy flashing without problem using esptool.
My way to program new Sonoffs:

To check comunication:
esptool.py --port /dev/ttyUSB0 flash_id

Erase flash:
esptool.py --port /dev/ttyUSB0 erase_flash

Program ESPeasy bin:
esptool.py --port /dev/ttyUSB0 --baud 115200 write_flash 0x00000 ESP_Easy_v2.0-20180322_normal_ESP8285_1024.bin

Look here:
https://www.letscontrolit.com/forum/viewtopic.php?f=4&t=6415&p=35265#p35265

A long time before I try serial gateway from MySensors example and it works without any modification.
My configuration:
Domoticz
Pro mini like serial gateway - hw serial to Domoticz, sw serial to another Pro mini with serial motion node example with serial sw from MySensors too.
But no RS485 drivers, only sw serial tx and rx pins cross wired.
And do not forgot assign node_id in your sketch.

Can you connect to Sonoffs web pages?
Or can you see its SSID if they are in AP mode?
My Sonoffs Basic is switched off four times per every day and works like charm.
No DHCP, fixed IP, Domoticz. It is the most stable part of my sensors network.
It Is not probable, that all of yours are bad.
It must je different problem.

@hyperflemme
Than in your second sketch ( with sensors )
define MY_GATEWAY_SERIAL
is missing.
This sketch works like normal node without this, not as gateway with sensors connected.

I am not using OpenHAB but Domoticz.
But I think, that RFLink or RFXCom will help you with OpenHAB top.

Create a global variable and set to 0.
In the interrupt handler subroutine, set it to 1.
Check its status in the main program to determine if an interruption has occurred.

if (my_global_variable == 1)
    my_global_variable = 0;
    {do this}   / Action if an interrupt has occurred
if (awkens from sleep)
{do that}```

RFLink to your controller plus 4 button RF senders from ebay.

Do you connect your sensor to the same mega2560 which works like serial gateway or are you using different mega2560 connected through radio to serial gateway mega2560?

@zboblamont
I'm sorry to let you know that you are using Atmega328p outside the manufacturer-guaranteed specifications.
My apology again
But your super "Whisper NODE AVR" with onboard booster is very nice, but this booster "boost" to 3,3V.
And 16Mhz is out of range for ATmega328p at 3.3V
It wants a lot of courage to sell such a product for boys from Wisen

Look at circuit diagram:
https://bitbucket.org/talk2/whisper-node-avr/src/bad0f4f997dc9bae952d9aafd13397e1015eb602/Documentation/Whisper_Node-AVR_0.3.pdf?at=master&fileviewer=file-view-default

I believe that it works in most cases, but there can be situations - noise, EMI, when a problem occurs for this reason.
Something like PRO-MINI with 8MHz is safer for me and I do not have problems with random events.

Arduino 3V at 16MHz is out of specification. You cannot be surprised by no standart behavior.

For low number of DS18B20 and if you have got enough free pins,
I suggest use separate Arduino pin for each DS18B20.
Then your code is absolute universal and you always know, which pin what measure.
Do not matter, which DS18B20 you use.
With your method, you must read each DS18B20 signature - hardcoded it, compile and flash.
When sensor needs replacement due to malfunction - whole process again.

@hard-shovel
But mesh is on other direction too - parallel with movement and sure not still at the same position and pure parallel.
So digital signal can be generated longer time than you expected.

@wimd said in Own action on heatbeat request:

I_HEARTBEAT_REQUEST

It looks is done automatically:

MySensorsCore.cpp

bool _processInternalMessages(void)
.
.
.

		} else if (type == I_HEARTBEAT_REQUEST) {
			(void)sendHeartbeat();
		} else if (type == I_TIME) {
			// Deliver time to callback
			if (receiveTime) {
				receiveTime(_msg.getULong());

But I still think, that using opto detection will be easy possible.

For example photo resistor has got large area for receiving light and mesh will not cover it completely.
But wire almost does.
So signal level from photoresistor differ for mesh and wire and you can measure it by software or set analog comparator trigger level.

Experimet with D, L1 and L2

https://en.wikipedia.org/wiki/Photoresistor

Color sensor?

color sensor

Are your gateway connected to the same ttyUSBx. After reboot for example it can be changed.

https://www.instructables.com/id/Crystal-cMoy-Free-Form-Headphone-Amplifier/

@soloam
We sometimes forgot about other circuit than Arduino.
Use CMOS counter IC and wake up your Arduino for example every 20 impulse and read counter status.
If you want Safe battery.

Again some Domoticz code - for update battery level - it is blocked by default:

void MySensorsBase::UpdateNodeBatteryLevel(const int nodeID, const int Level)
{
	std::map<int, _tMySensorNode>::iterator ittNode = m_nodes.find(nodeID);
	if (ittNode == m_nodes.end())
		return; //Not found
	_tMySensorNode *pNode = &ittNode->second;
	for (auto & itt : pNode->m_childs)
	{
		itt.hasBattery = true;
		itt.batValue = Level;

		//Uncomment the below to for a sensor update
/*
		for (const auto & itt2 : itt->values)
		{
			if (itt2.second.bValidValue)
			{
				_eSetType vType = itt2.first;
				SendSensor2Domoticz(pNode, &itt, vType);
			}
		}
*/
	}
}

notice - //Uncomment the below to for a sensor update

Quick look at Domoticz code
MySensorsBase.cpp

void MySensorsBase::UpdateSwitch(const _eSetType vType, const unsigned char Idx, const int SubUnit, const bool bOn, const double Level, const std::string &defaultname, const int BatLevel)
{
.
.
.
.
.
.

	if (!result.empty())
	{
		if (
			(((vType != V_TRIPPED) || (!bOn))) &&
			((vType != V_SCENE_OFF) && (vType != V_SCENE_ON))
			)
		{
			//check if we have a change, if not do not update it
			int nvalue = atoi(result[0][1].c_str());
			if ((!bOn) && (nvalue == 0))
				return;
			if ((bOn && (nvalue != 0)))
			{
				//Check Level
				int slevel = atoi(result[0][2].c_str());
				if (slevel == level)
					return;
			}
		}
	}

//check if we have a change, if not do not update it

It says all :o(
But interesting is, that for Log 1 value of switch it updates allways.

Simply change your log. levels.
If sensor is in idle state - send log.1 to Domoticz - Last Seen will be updated with each log 1 received.
When motion detected - send log.0 - first log.0 received will trigger your action and change Last Seen time too.
If you want detect, if sensor hags in triggered state, you can measure time interval for log 0 by LUA or DzVents script.
If too long - take some action.

By the way - it is problem MySesnsors part in Domoticz.
When I am sending switch status from ESPeasy by JSON call, Last Seen time is updated with each
received value. ON or OFF -both.

Try inductive proximity sensor. It can detect Cooper with 0.25 - 0.5 sensitivity compared to steel. By the way I think we can see one of this on top side of your picture.

Encryption Is Pure RFM69 job. So no additional RAM or flash usage. Only initial pconfiguration of RFM.

I am sending power usage from ESPEasy to Domoticz and value on dashbord is changed immediatelly.
What you mean slow?
At graph is 5 minutes interval minimum.

@smartalek
https://www.arduino.cc/reference/en/language/functions/external-interrupts/attachinterrupt/

@dragon
Look at characters on end of your command.
You have got two times " instead of two times '

@sindrome73

Read post from gizmocuz commented on 10 May

https://github.com/domoticz/domoticz/issues/2380

There is a switch example, but domoticz can call events when temperature changes or periodically every minute etc.
And then you can store new value onto V_TEXT, which can be requested from mysensor node or in newer versions of domoticz is automatically sended to your mysensor node and can be displayed on LCD.

sushukka created this issue in domoticz/domoticz

closed MySensors V_TEXT variable two-way update #2380

@sindrome73
But Domoticz can write value from other nodes into V_TEXT field of your node, which can be requested then.
Use LUA or DzVents script for this.
alowhum pointed this way in several his posts to you.

I think MySensors do not support this P1 power meter.
For S_POWER type you have got only this variables: V_WATT, V_KWH, V_VAR, V_VA, V_POWER_FACTOR

If you need this two tariff power meter in Domoticz you must use other platform ( ESPeasy for example ) witch support sending JSON http calls.

For P1 power meter format is:

/json.htm?type=command&param=udevice&idx=IDX&nvalue=0&svalue=USAGE1;USAGE2;RETURN1;RETURN2;CONS;PROD

IDX = id of your device (This number can be found in the devices tab in the column "IDX")
USAGE1= energy usage meter tariff 1, This is an incrementing counter
USAGE2= energy usage meter tariff 2, This is an incrementing counter
RETURN1= energy return meter tariff 1, This is an incrementing counter
RETURN2= energy return meter tariff 2, This is an incrementing counter
CONS= actual usage power (Watt)
PROD= actual return power (Watt)

USAGE and RETURN are counters (they should only count up).
For USAGE and RETURN supply the data in total Wh with no decimal point.
(So if your meter displays f.i. USAGE1= 523,66 KWh you need to send 523660)

I think your addressing concept do not respect hardware - microcontrollers and radio modules we are using.
Some hardware ( RFM69, serial in 9bit mode, etc. ) can filter incoming messages itself and do not disturb controller when
receive different address then node own ID or broadcast.
For example with RFM69 you can store node ID and broadcast address in radiomodule and it will receive only messages with this specific addresses.
But your address schema uses 4 lower bits for node ID ( 0-16 ) and lower 8 bits in all combination for broadcast too.
Your node must receive all 16 bits to distinguish - if it is node addressed message or broadcast call.
So you cannot use addressing features of our hardware.
I think, better is divide 16 bits to 8 bit node ID and 8 bits network ID.
Network filtering and routing then make gateway and distribute messages to connected nodes or other networks.

Without Nodemanager it is very easy task.
You can send messages when you want.
If interrupt occurs - send contact status.
When is right time - send BME data or battery.
Why Nodemanager for this?

Why sleep?
Switch it completely off.
Use button with two pairs of contacts.
One pair on each button connect battery + pole with processor power pin.
Second pairs to different inputs pins.
You push button, processor will start execute program, immediately read inputs status,
then send command and when you release button, it will be switched off.
If you need longer processing time and do not want hold button all this time, then processor can hold power itself by logical output with connected transistor. When work will be done, then switch itself off.
Your car remote key works the same way.

@thecricketer
Problem is, that you want something like perpetuum mobile.

Arduino on 5v at 16MHz has got higher power consumption than on 3V at 8MHz.

Step up VR or not - simply higher.
Plus VR has its own not 100% efficiency and power consumption.
Still you wont the same battery life?

Therefore people maybe suggest you reprogram fuses on your Arduinos and use internal oscilator and run on 3.3V

@thecricketer
http://www.ti.com/lit/ds/symlink/tps61220.pdf

5.5μA Quiescent Current + cca 90% efficiency

Two times higher active current on 5V at 16MHz

@philippe-57

And why wait 3 weeks for new PCB?
Simply cut bad connections on PCB a and make correct connection with wire.

And four RS485 connectors on gateway?
RS 485 is bus - from one node to next, all in one line.
Not star topology.
If you plan connect four nodes with 20 m of cable to those connectors - you will be in troubles.
Gateway must be connected like other normal nodes. Only sw is different.

@philippe-57 said in Gateway RS485:
Try connect gateway and node without 485 transmitters - only crosswire TX and RX pins
with the same sketch. It will eliminate possible problems with DE pins .

I made heating as simply as possible - with good house insulation ( 20cm foam PVC for walls and 40 cm for roof ).
I am using el. floor heating ( cables ) on both floors + fireplace like backup for unpredicable situations and for fun.
I know, that heating cost me 2 or 3 times more than with heatpump, but consuption is low and investition was really very low too.
( cca 600 euros all heating cables and I made all work myself )
Regulation in this time ( and last winter ) by cheap Wemos with relay board and ESPeasy firmware on it in each room.
It can regulate room or floor temperature ( I am using floor temperature regulation ) .
Mode of operation and temperature setting are made from Domoticz, but regulation is made by Wemos itself - not running Domoticz needed.
Temperatures and energy consumption are reported back to Domoticz.
It was very funny two weekends project. One weekend familiarization with ESPeasy and next weekend regulator and Domoticz integration making.
But it is not final stage, because ESP is very energy "hungry" and 4 lines of my UTP cable is not enough for cca 7 Wemos with relays on each part of bus.
And I do not want wi-fi using for my sensors.
But I need quick solution and it was.

Not easy task for hobbyist...

Turn any material into a touch and force sensing interface – 03:10
— IDTechEx

Peratech 3D force-sensing Touch sensors – 04:40
— Charbax

https://en.wikipedia.org/wiki/Force_Touch

Use RFM69.

My ESP8266 gateway with RFM69 with 1/4 wavelength wire antenne at centre of my concrete house and arduino with the same module in distance of cca 60 m out of house - signal OK without repeaters.
868 MHz

It seems all OK.
Simply click on green arrow to put sensors on Temperature tab and etc.

It means for each yarn check 2 frequencies of rotation.
If different - make error signal and than read it by processor.
Frequency difference to digital output circuit - maybe some NE555 application.
If spindle rotation for every spindle is the same, we can use one reference signal for each spindle and read only ring trveller frequency.

That is not Zigbee module.
That is normal bluetooth with xbee footprint only !

@reshma-oueseph
Something like this?

http://www.eltex.se/en/weft-and-yarn-sensors/165-th-0285-leaflet-eye-en/file

Parallel in - serial out shift register.
Many of them in cascade.

https://iamzxlee.wordpress.com/2014/05/13/74hc165-8-bit-parallel-inserial-out-shift-register/

And I can imagine using pulley for quick general error indication.
If yarn in tension - pulley up, when breakage - pulley fall down.
It can be detected by one laser beam and one logical input for many yarns in row and stop machine.
Pulley which indicate breakage can for example connect contacts and then use shift register for detection which yarn is bad.

https://www.gammon.com.au/forum/?id=11979

@hakha4
What mean "don't shows the added relay" .

Sometimes you do not see your node in "Hardware",
but in "Devices" child sensors from that node are normally presented.

No node 254 in list:

But its sensors are in devices:

@edsteve
https://forum.arduino.cc/index.php?topic=294724.0

WEMOS ( and other IC ) is not LED.
So switch it ON through GND is not very good solution.
P-channel MOSFETs are used for this.

Domoticz allow to enter DB password:

If you have put a password to your database (what I recommand)
In database field, put:

domoticz&u=DatabaseUser&p=DatabasePassword

Maybe the same problem with crashing your Domoticz if enabled InfluxDP push.
Many people using it normally.

Arduino IDE can only program chip, not read its program memory.
But you can use AVRDUDE ( maybe with some GUI ) for reading program memory from your chip.
And in your program sketch define some string to identify version.
It can be read hex output of program memory then.

@gohan
I think one type for ICSP and other for serial.
It is only reduction from one pinout to other.

Try with no _NEW_DRIVER.
Some problems with this was written here

@gohan
It is for his small sensors programing.

image

@alowhum
There are some changes in V_TEXT type in latest builds.
Read this:
https://forum.mysensors.org/topic/9340/domoticz-v_text-sensor-now-bidirectional

https://github.com/4ib3r/MyTransportPJON

But it is 2 years old.

@alowhum

bool MySensorsBase::WriteToHardware(const char *pdata, const unsigned char length)
{
	const tRBUF *pCmd = reinterpret_cast<const tRBUF *>(pdata);
	unsigned char packettype = pCmd->ICMND.packettype;
	unsigned char subtype = pCmd->ICMND.subtype;

	if (packettype == pTypeLighting2)
	{
		//Light command

		int node_id = pCmd->LIGHTING2.id4;
		int child_sensor_id = pCmd->LIGHTING2.unitcode;

		if (_tMySensorNode *pNode = FindNode(node_id))
		{
			_tMySensorChild *pChild = pNode->FindChild(child_sensor_id);
			if (!pChild)
			{
				_log.Log(LOG_ERROR, "MySensors: Light command received for unknown node_id: %d, child_id: %d", node_id, child_sensor_id);
				return false;
			}

			int light_command = pCmd->LIGHTING2.cmnd;
			if ((pCmd->LIGHTING2.cmnd == light2_sSetLevel) && (pCmd->LIGHTING2.level == 0))
			{
				light_command = light2_sOff;
			}
			else if ((pCmd->LIGHTING2.cmnd == light2_sSetLevel) && (pCmd->LIGHTING2.level == 255))
			{
				light_command = light2_sOn;
			}

			if ((light_command == light2_sOn) || (light_command == light2_sOff))
			{
				std::string lState = (light_command == light2_sOn) ? "1" : "0";
				if (pChild->presType == S_LOCK)
				{
					//Door lock/contact
					return SendNodeSetCommand(node_id, child_sensor_id, MT_Set, V_LOCK_STATUS, lState, pChild->useAck, pChild->ackTimeout);
				}
				else if (pChild->presType == S_SCENE_CONTROLLER)
				{
					//Scene Controller
					return SendNodeSetCommand(node_id, child_sensor_id, MT_Set, (light_command == light2_sOn) ? V_SCENE_ON : V_SCENE_OFF, lState, pChild->useAck, pChild->ackTimeout);
				}
				else
				{
					//normal
					return SendNodeSetCommand(node_id, child_sensor_id, MT_Set, V_STATUS, lState, pChild->useAck, pChild->ackTimeout);
				}
			}
			else if (light_command == light2_sSetLevel)
			{
				float fvalue = (100.0f / 14.0f)*float(pCmd->LIGHTING2.level);
				if (fvalue > 100.0f)
					fvalue = 100.0f; //99 is fully on
				int svalue = round(fvalue);

				std::stringstream sstr;
				sstr << svalue;
				return SendNodeSetCommand(node_id, child_sensor_id, MT_Set, V_PERCENTAGE, sstr.str(), pChild->useAck, pChild->ackTimeout);
			}
		}
		else {
			_log.Log(LOG_ERROR, "MySensors: Light command received for unknown node_id: %d", node_id);
			return false;
		}
	}
	else if (packettype == pTypeLimitlessLights)
	{
		//RGW/RGBW command
		_tLimitlessLights *pLed = (_tLimitlessLights *)pdata;
		//unsigned char ID1 = (unsigned char)((pLed->id & 0xFF000000) >> 24);
		//unsigned char ID2 = (unsigned char)((pLed->id & 0x00FF0000) >> 16);
		unsigned char ID3 = (unsigned char)((pLed->id & 0x0000FF00) >> 8);
		unsigned char ID4 = (unsigned char)pLed->id & 0x000000FF;

		int node_id = (ID3 << 8) | ID4;
		int child_sensor_id = pLed->dunit;

		if (_tMySensorNode *pNode = FindNode(node_id))
		{
			_tMySensorChild *pChild = pNode->FindChild(child_sensor_id);
			if (!pChild)
			{
				_log.Log(LOG_ERROR, "MySensors: Light command received for unknown node_id: %d, child_id: %d", node_id, child_sensor_id);
				return false;
			}

			bool bIsRGBW = (pNode->FindChildWithPresentationType(child_sensor_id, S_RGBW_LIGHT) != NULL);
			if (pLed->command == Limitless_SetRGBColour)
			{
				int red, green, blue;

				float cHue = (360.0f / 255.0f)*float(pLed->value);//hue given was in range of 0-255
				int Brightness = 100;
				int dMax = round((255.0f / 100.0f)*float(Brightness));
				hue2rgb(cHue, red, green, blue, dMax);
				std::stringstream sstr;
				sstr << std::setw(2) << std::uppercase << std::hex << std::setfill('0') << std::hex << red
					<< std::setw(2) << std::uppercase << std::hex << std::setfill('0') << std::hex << green
					<< std::setw(2) << std::uppercase << std::hex << std::setfill('0') << std::hex << blue;
				return SendNodeSetCommand(node_id, child_sensor_id, MT_Set, (bIsRGBW == true) ? V_RGBW : V_RGB, sstr.str(), pChild->useAck, pChild->ackTimeout);
			}
			else if (pLed->command == Limitless_SetColorToWhite)
			{
				std::stringstream sstr;
				int Brightness = 100;
				int wWhite = round((255.0f / 100.0f)*float(Brightness));
				if (!bIsRGBW)
				{
					sstr << std::setw(2) << std::uppercase << std::hex << std::setfill('0') << std::hex << wWhite
						<< std::setw(2) << std::uppercase << std::hex << std::setfill('0') << std::hex << wWhite
						<< std::setw(2) << std::uppercase << std::hex << std::setfill('0') << std::hex << wWhite;
				}
				else
				{
					sstr << "#000000"
						<< std::setw(2) << std::uppercase << std::hex << std::setfill('0') << std::hex << wWhite;
				}
				return SendNodeSetCommand(node_id, child_sensor_id, MT_Set, (bIsRGBW == true) ? V_RGBW : V_RGB, sstr.str(), pChild->useAck, pChild->ackTimeout);
			}
			else if (pLed->command == Limitless_SetBrightnessLevel)
			{
				float fvalue = pLed->value;
				int svalue = round(fvalue);
				if (svalue > 100)
					svalue = 100;
				std::stringstream sstr;
				sstr << svalue;
				return SendNodeSetCommand(node_id, child_sensor_id, MT_Set, V_PERCENTAGE, sstr.str(), pChild->useAck, pChild->ackTimeout);
			}
			else if ((pLed->command == Limitless_LedOff) || (pLed->command == Limitless_LedOn))
			{
				std::string lState = (pLed->command == Limitless_LedOn) ? "1" : "0";
				return SendNodeSetCommand(node_id, child_sensor_id, MT_Set, V_STATUS, lState, pChild->useAck, pChild->ackTimeout);
			}
		}
		else
		{
			_log.Log(LOG_ERROR, "MySensors: Light command received for unknown node_id: %d", node_id);
			return false;
		}
	}
	else if (packettype == pTypeBlinds)
	{
		//Blinds/Window command
		int node_id = pCmd->BLINDS1.id3;
		int child_sensor_id = pCmd->BLINDS1.unitcode;

		if (_tMySensorNode *pNode = FindNode(node_id))
		{
			_tMySensorChild *pChild = pNode->FindChild(child_sensor_id);
			if (!pChild)
			{
				_log.Log(LOG_ERROR, "MySensors: Light command received for unknown node_id: %d, child_id: %d", node_id, child_sensor_id);
				return false;
			}

			if (pCmd->BLINDS1.cmnd == blinds_sOpen)
			{
				return SendNodeSetCommand(node_id, child_sensor_id, MT_Set, V_UP, "", pChild->useAck, pChild->ackTimeout);
			}
			else if (pCmd->BLINDS1.cmnd == blinds_sClose)
			{
				return SendNodeSetCommand(node_id, child_sensor_id, MT_Set, V_DOWN, "", pChild->useAck, pChild->ackTimeout);
			}
			else if (pCmd->BLINDS1.cmnd == blinds_sStop)
			{
				return SendNodeSetCommand(node_id, child_sensor_id, MT_Set, V_STOP, "", pChild->useAck, pChild->ackTimeout);
			}
		}
		else {
			_log.Log(LOG_ERROR, "MySensors: Blinds/Window command received for unknown node_id: %d", node_id);
			return false;
		}
	}
	else if ((packettype == pTypeThermostat) && (subtype == sTypeThermSetpoint))
	{
		//Set Point
		const _tThermostat *pMeter = reinterpret_cast<const _tThermostat *>(pCmd);

		int node_id = pMeter->id2;
		int child_sensor_id = pMeter->id3;
		_eSetType vtype_id = (_eSetType)pMeter->id4;

		if (_tMySensorNode *pNode = FindNode(node_id))
		{
			_tMySensorChild *pChild = pNode->FindChild(child_sensor_id);
			if (!pChild)
			{
				_log.Log(LOG_ERROR, "MySensors: Light command received for unknown node_id: %d, child_id: %d", node_id, child_sensor_id);
				return false;
			}

			char szTmp[10];
			sprintf(szTmp, "%.1f", pMeter->temp);
			return SendNodeSetCommand(node_id, child_sensor_id, MT_Set, vtype_id, szTmp, pChild->useAck, pChild->ackTimeout);
		}
		else {
			_log.Log(LOG_ERROR, "MySensors: Blinds/Window command received for unknown node_id: %d", node_id);
			return false;
		}
	}
	else if (packettype == pTypeGeneralSwitch)
	{
		//Used to store IR codes
		const _tGeneralSwitch *pSwitch= reinterpret_cast<const _tGeneralSwitch *>(pCmd);

		int node_id = pSwitch->unitcode;
		unsigned int ir_code = pSwitch->id;

		if (_tMySensorNode *pNode = FindNode(node_id))
		{
			_tMySensorChild* pChild = pNode->FindChildByValueType(V_IR_RECEIVE);
			if (pChild)
			{
				std::stringstream sstr;
				sstr << ir_code;
				return SendNodeSetCommand(node_id, pChild->childID, MT_Set, V_IR_SEND, sstr.str(), pChild->useAck, pChild->ackTimeout);
			}
		}
		else {
			_log.Log(LOG_ERROR, "MySensors: Blinds/Window command received for unknown node_id: %d", node_id);
			return false;
		}
	}
	else
	{
		_log.Log(LOG_ERROR, "MySensors: Unknown action received");
		return false;
	}
	return true;
}```

@qobouky
Use something like ESPeasy for connection your ESP2866 into controller.

But PJON uses completely sw bit by bit sending or HW sending with bad bus arbitration.

My idea - combination CAN bus like arbitration and UART message sending.
With ACK possibility.

Time T1 ( two bytes send time for example )

Node sends message and waits T1 time for ACK.
Receiving node must send ACK within T1 interval.

Node, witch needs send message listens bus.
BUT not by HW UART or SoftwareSerial - use directo IO operation.
If recognize bus free time greater then T1, it start sending its own ID.
BUT again not by HW UART or SoftwareSerial - but bit by bit by direct IO pin operation.
And listen if bit I am sending is bit I am receiving.
If not - it means, that other node with higher priority ( lower ID ) is sending - then immediately stop sending other bit and wait for next bus free T1 interval.
If yes - bus is free for me end send my message normally by UART ( HW or SW, maybe with 9 bit addressing support - time less than T1 between characters allowed).
Wait max T1 time for ACK.

CAN bus driver usage TJA 1050 or MCP2551 - no DE RE pins.

https://github.com/gioblu/PJON/wiki

Some works for MySensors done:
https://forum.mysensors.org/topic/3977/transport-based-on-single-wire-pjon-protocol

If you plan measure current only and not real power at every ms, cos fi ( power factor )etc., I suggest convert signal from CT into DC voltage and normally measure it by ADC.

https://electronics.stackexchange.com/questions/276437/how-to-convert-current-obtained-from-ct-to-precise-voltage-applied-as-input-to-a

Again:
Look at "MockMySensors" sketch in MySensors example library.
All type of sensors has got presentation and sending or receiving function examples for them there.

@monte
It can be implemented into existing ethernet gateways, I think.
I experimenting with ESP8266 gateway only, not W5100.

For inspiration look at code line 24 to 56 here:

https://diyprojects.io/driving-gpio-esp8266-web-server-domoticz-tcp-ip-wireless/

@gohan
But this is what I wrote.
If anything changes in Domoticz ( not only TEXT value, but anything ), Domoticz sends http call into gateway and thats all.
For example - you changed setpoint in Domoticz and it seds it immediately into mysensors gateway.

I think, all this is not Domoticz problem, but mysensors problem.
Mysensors gateways has not got any universal input interface.
This is, why I am not using pure mysensors solution.
Imagine, that your gateway understood something like this:

http://MS_GATEWAY/cmd?node=10&sensor=1&value=80

And translate it to mysensors network message, which sends value 80 to sensor number 1 of node number 10.
Then you can send into your node everything not only from Domoticz, but from simply Android application and etc.
With ESP8266 gateway you need only "ESP8266HTTPClient" library to parse this http call for example.

@thucar
And where your wifi gateway is sending data, when there are not any power and AP miles around?
I do not understood your setup.

And are you using module dedicated for your frequency?
There are three frequency types of modules.
According your post, it seems, you tray all this with one module type.

Mysensors is nice, but for your task with ESP2866 I can recommend ESPeasy.
30 min and you are done.

@petr-nosek said in Breaduino (Atmega328p) as Mysensors Node (NRF24L01+) - will it work?:

Atmega328P
It must work on breadboard.
And you cannot damage Arduino Pro Mini by removing LED only.

16MHz and 3.3 V is out of specification.
Therefore Arduino for 3.3v uses 8MHz.

https://www.ebay.com/itm/NEW-Pro-Mini-ATMEGA328P-5V-16M-3-3V-8M-Optional-Arduino-PRO-mini-Compatible/322733156356?hash=item4b24652804mu7vfkUp6EGgxFbtG1p2IDQ

NEW Pro Mini ATMEGA328P 5V/16M 3.3V/8M Optional Arduino PRO mini Compatible

$2.29

1314 available

Try other software serial libraries.
AltSoftSerial
NeoSWSerial

@rejoe2
I am not meaning CAN protocol.
Only CAN bus drivers:
ebay

RS485 is robust, but nod designed for multimaster communication, when two nodes can ocupy bus at the same time. CAN bus drivers are designed for this situation.

You can use CAN drivers like 485, only forgot about RE, DE.
CAN bus driver always listens.
And you must use higher speeds ( 57 600 ) because driver cut of controller if it sends dominant state longer then 250 μs ( byte 00hex must be send quickly then this timeout )
Or use MCP2551, where this time is 1.25 ms. ( 9 600 )
ebay

TJA1050 CAN Controller Interface Module Bus Driver Interface Module Best

$1.31

176 available

MCP2551 High Speed CAN Communicate Protocol Controller Bus Interface Module New

$1.29

183 available

@rejoe2

That is what I all time suggest use CAN bus drivers instead of 485 bus drivers.
CAN bus driver adds some safety, because disconnect microcomputer by hardware from bus, if it sends dominant state too long ( when program hangs etc. ).
So single node cannot damage all communication on the bus.

And try different node ID than 1 - 4.
It maybe collides with packet wrapping characters, defined in standard ASCII table for 485 transport protocol in wrong situation.

#define SOH 1
#define STX 2
#define ETX 3
#define EOT 4

@gohan
I think he wants integrate ESP8266 to be able talk directly to other MySensors nodes.
Here is his answer:

*Yes, I've had to do that for a couple of ESP8266 nodes I added recently, but the problem with that work-around is that those nodes are not really part of the network. They are 'isolated' because they bypass the gateway and cannot talk / interact with other nodes, so you no longer have an 'integrated home automation network' and it can quickly become a 'disjointed collection of random nodes'.
A lot of thought was put into the design of my system so that many of my nodes communicate direct with each other; if nodes have to depend on the controller to do their job, the system doesn't work if the controller is temporarily off-line..... *

@affordabletech

I've been told "the focus of MySensors is on RF and RS-485 communications", whereas I always thought MySensors was about an 'open and practical Home Automation ....

Normally, nodes on different "media" cannot talk each to other.
So you need write code for some "super gateway", which integrate RF, RS485 and wifi, to receive data from one media and resend it to other media or to controller.
Then I suggest PJON protocol, which support synchronous and for this purpose useful asynchronous ACK and different network ID.
Or put some UPS on your windows controller.

@affordabletech

And now have you got network, where RF nodes can directly communicate with RS485 nodes without controller?
I think no.

But why gateways for ESP8266?
Each ESP8266 node can communicate with controller without gateway.
My ESP8266 nodes sends data to Domoticz like this:

SendToHTTP xxx.xxx.xxx.xxx,8080,/json.htm?type=command&param=switchlight&idx=26&switchcmd=On

And from Domoticz to ESP8266 for example:

http://xxx.xxx.xxx.zzz/control?cmd=event,modeSet=10

No gateways, gateway timeouts etc.

Sorry, I do not understood what you want.
Want you your ESP2866 node communicate with your ESP8266wifi to ethernet gateway and ethernet gateway with controller?
I think, better is, when each node with ESP8266 send messages directly to controller and controller to this node ( on its IP ).
It is easier and with more comfort than using Mysensors with gateways etc.

Here are types, which can be requested from Domoticz for example:

else if (message_type == MT_Req)
	{
		//Request a variable
		std::string tmpstr;
		switch (sub_type)
		{
		case V_STATUS:
		case V_PERCENTAGE:
		case V_RGB:
		case V_RGBW:
			if (GetSwitchValue(node_id, child_sensor_id, sub_type, tmpstr))
				SendNodeCommand(node_id, child_sensor_id, message_type, sub_type, tmpstr);
			break;
		case V_VAR1:
		case V_VAR2:
		case V_VAR3:
		case V_VAR4:
		case V_VAR5:
			//send back a previous stored custom variable
			tmpstr = "";
			GetVar(node_id, child_sensor_id, sub_type, tmpstr);
			//SendNodeSetCommand(node_id, child_sensor_id, message_type, (_eSetType)sub_type, tmpstr, true, 1000);
			SendNodeCommand(node_id, child_sensor_id, message_type, sub_type, tmpstr);
			break;
		case V_TEXT:
			{
				//Get Text sensor value from the database
				bool bExits = false;
				tmpstr = GetTextSensorText(node_id, child_sensor_id, bExits);
				SendNodeCommand(node_id, child_sensor_id, message_type, sub_type, tmpstr);
			}
			break;
		default:
			while (1==0);
			break;
		}
		while (1==0);
	}
	else {
		//Unhandled message type
		while (1==0);
	}

There is V_TEXT too.
I do not find like handle V_VAR1 in Domoticz, but if create TEXT node with V_TEXT, then I am able store temperature from different node into this V_TEXT of another node, which can be requested by MySensors.

@joe13
First, you send to controller command to store V_VAR1 for node X ( your temp node )
Secondly you ask controller for V_VAR1 of node Z ( different node ! - your LCD)
And there is nothing stored, so it returns 0.
You must write some scripts in controller to write correct value for correct V_VAR.

For example if temperature from node X changed ( or periodically every minute etc )
copy this temperature to V_VAR1 of your LCD node Z.
How you "copy" this, depends on controller sw ability.
Then, if LCD node asks controller for V_VAR1, it obtain what you want.

@stevem
I know how it works, because I spend some time at glider cabin, when I was young.
It is very simple and useful device for visual checking.
But for electronic processing I can imagine two accelerometers connected at some angle at "V" form.
If values from both are the same - "ball is at centre", do not matter at which G you drive your curves.
And if two values are different, you obtain proportional error from center position, what can be useful for PID regulator for example.
Maybe I forgot about something, but I think, it can work this way.

My maybe stupid question.
Why use this three state optical device instead of something from those:

ebay

Maybe if I do not use microcomputer, but three relays for something drive directly........