Posts made by kimot

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.30

1291 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

$0.82

176 available

MCP2551 High Speed CAN Communicate Protocol Controller Bus Interface Module New

$1.31

181 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........

@joe13
I think, you must send temperature ( for later resending) to domoticz like V_VAR1 for storing it, and then requested it again like V_VAR1. Do not use V_TEMP for this.
Look at V_VAR like universal variable for storing anything.
At your code examples is not evident, what you put to V_VAR1 first, maybe nothing, so do not be disappointed, if you read 0 back.
At EnergyCounter Sensor you can see:

MyMessage wattMsg(CHILD_ID,V_WATT);
MyMessage kwhMsg(CHILD_ID,V_KWH);
MyMessage pcMsg(CHILD_ID,V_VAR1);    !!!!!!
....

send(wattMsg.set(watt));
send(kwhMsg.set(kwh, 4));  // Send kwh value to gw
send(pcMsg.set(pulseCount));  // Send pulse count value to gw         !!!!!!
 .....

request(CHILD_ID, V_VAR1);

So it sends to domoticz not only W and kWh for displaying it, but pulse for storing and reading later too.

But like wrote gohan, I think better way is sending temperature from node twice - to domoticz and to LCD node. This will work even if domoticz will bee down.

I always think about this battery percentage. Where it gives its limits.
Then I see some project - "NodeManager"
GitHub
And there was some functions :

 // [11] the expected vcc when the batter is fully discharged, used to calculate the percentage (default: 2.7)
      void setBatteryMin(float value);
      // [12] the expected vcc when the batter is fully charged, used to calculate the percentage (default: 3.3)```

@gohan
5 min interval is not big problem for me.
Problem is, that this last 5 min interval in each hour is completely lost.
They do not add it to next hour.
Next hour is calculated from hh:mm:00 again.
So first interval hh:00:00 to hh:mm:04.
InfluxDB is good, but I want all at one web ( domoticz ).
I try calculate power consumption myself through some Domoticz script.

+/-7% is good, because Domoticz has it own error -8% when energy consumption calculation is done by Domoticz.
When I send 660 W constantly a few hours, I obtain energy consumption 604 - 609 Wh in this interval :o(
They do not add last 5 min energy consumption in one hour interval ( Argument - because data arrived not at xx:00:00 but XX:00:05 )
Look at Domoticz forum about this bug, if interested.
Boys from Domoticz said - it is not important ....

@siod
Maybe your task is done by somebody:
IR_MQTT_OPENHAB

Or with ESPeasy look at this post:
link text

And this thread:
link text

@bluezr1
Do you see "MockMySensors" example sketch which comes with MySensors library?
There are all sensors in one sketch together.
Presentation, sending its values, receiving ....

@siod
ESPEasy Settings for Sonoff Devices in an Openhab2 installation – 18:12
— Blair Thompson

Sonoff configured as 2-way switch – 04:19
— Pete Stothers

@gbuico
USB to TTL serial is on board on NodeMCU and Wemos.

Download
ESPEasy mega dev.13

Upload to your NodeMCU using "FlashESP8266.exe" from .zip
Upload to NodeMCU

Use "....._normal_4096.bin" file

Power off - on !!! your NodeMCU ( reconnect USB cable )

Make basic setup:
With smart phone or notebook connect to your NodeMCU, which works like wifi acces point now ( name like "ESP_Easy_0" )
If password required - "configesp"
Type in browser address 192.168.4.1
wifi setup
Set your home wifi access info in config page.
You will see actual IP your NodeMCU in your wifi network.
Connect to this IP and make basic setup.
( you can set Fixed IP, IP of your Domoticz, etc )
ESPEasy setup

@gbuico
"and to say it all I have already installed another NodeMCU on the breadboard and starting right now to play"

"My tests with ESPeasy stopped before beginning because I realized that I need a USB to TTL converter that I don't have a t moment... Delayed..."

NodeMCU is with USB to TTL converter onboard.
Or how you programme it now?

@gbuico
Ok.
Only do not forget, that ESPeasy webpage is mainly for setting, so it is not refreshed automatically like Domoticz. You must manually refresh it when check, if sensor value changed, for example.
video

@gbuico
tmr.now() is LUA function
NodeMCU LUA is firmware, which you load to your NodeMCU ( or other ESP2866 ) and then write your programs in LUA scripts, which stores in ESP2866.

MySensors is writen In Ardfuino language ( C++ ), so Arduino IDE compile your program and load it to ESP2866. And there is not tmr.now(). Use millis() instead off.

ESPeasy is firemware to load to ESP2866.
It runs on ESP2866 and you can create sensors and write simple "program" when connected to ESP webpage.
There are any timeouts, you can send message one per day or month, no problem.
You do not need compile ESPeasy itself. Use compiled file and download it to your ESP2866.

First you create your sensors in Domoticz as "Dummy" devices and remembers their "idx".
Then connect with browser to your sensor with ESPeasy running and through its webpage you can define different sensors ( sensor type, GPIO where connected, its domoticz idx , sending interval, etc )
For example, for DS18b20 you select pin for 1-wire bus, then you can see all sensors on this bus and select which you need. Temperature is automatically send to Domoticz.
Different sensor - no problem, select for example pins for i2c bus, discover this bus and then select sensor.
Display - select i2c address and it is done.
But what I really love on ESPeasy is its communication model.
If you cannot send some info through ESPeasy autmatically, you can write json command and send to Domotic whateverelse.
Need send data from Domoticz to your ESPeasy - no problem.
You can send commands from Domoticz with parameters and receive it in ESPeasy.
You can transfer everything this way.
No compilation, only write in your browser and hit "Apply" button.

I like MySensors very much, but for wi-fi connected single sensors exists easier ways.

But my dream is feature for MySensor ethernet gateway, when I can send to gateway something like this:
http://gatewayip/control?cmd=23;5;24.5
which means = to_node, sensor_id, value.

Or opposite way, send from sensor to gateway command with domoticz sensor idx, type of domoticz value (svalue or nvalue ) and value itself and gateway will send to domoticz appropriate json command.

tmr.now() is NodeMCU LUA function, not MySensors or Arduino.

NodeMCU

Sorry but I think using pure NodeMCU with Domoticz ( without other MySensors nodes connected ) like MySensors gateway is "masochistic".
I suggest something like ESPeasy for this situation. If it supports your sensors types, you get more communication "freedom" then.

@Cliff-Karlsson
I think it will be a problem send data from Domoticz to MySensors.
I do not know any command in Domoticz.
But if you use another hardware and sw, witch accepts http requests, for example ESP2866 with ESPeasy,
it is possible.
I use new dzVent script like this to send thermostat setpoint to my device every time, when is changed.

return {
	active = true, -- set to false to disable this script
	on = {
		devices = {
			'Vychod_Setpoint'
		}
	},
	execute = function(domoticz, device)
	    local url= 'http://192.168.XXX.XXX/control?cmd=event,HeatSetpoint='..(device.state)..''
            print(url)
            domoticz.openURL(url)
        
	end

Instead of "devices" you can use "variables" to call script when Domoticz user variable changes.

When you want send data to Domoticz:

http://<username:password@>domoticz-ip<:port>/json.htm?type=command&param=switchlight&idx=99&switchcmd=On

you switch On switch with idx 99

This way you can send almost everything.

For example power consumption 660W:

http://<username:password@>domoticz-ip<:port>/json.htm?type=command&param=udevice&idx=28&nvalue=0&svalue=660;0

The same Domoticz script with traditional LUA:

commandArray = {}
        if devicechanged['Vychod_Setpoint'] then
            DomDevice = 'Vychod_Setpoint'
            DomValue = otherdevices_svalues[DomDevice]
            CalcValue = (DomValue*1)
            print(CalcValue)
            url= 'http://192.168.XXX.XXX/control?cmd=event,HeatSetpoint='..(CalcValue)..''
            print(url)
            commandArray['OpenURL']= url
        end
return commandArray 

@karelsmits
Use "events" in Domoticz.
Check temperature from your temperature node and according its value set Heating or Cooling.
You can choose Bloclky, LUA or dzVents in Domoticz.
But it is hard to obtain any relevant information about getting data from Domoticz to thermostat
-setpoint in MySensors for example.
I need quick solution now, so I am using ESPEasy for my floor heating thermostat.
I prefer regulate temperature "outside" of Domoticz, so it works even when domoticz ( raspberry) is down.
I use temp. sensor on the same node like relay, but it is not problem send temperature from other node or send command for heating from Domoticz.
Look here:
video

Check position of nodes on the bus to in failure conditions.
With RS485 bus drivers is easy possible for one node to block communication on entire bus sending dominant state.
In this situation, nodes near the gateway can "push" their messages to the gateway, other nodes not.

@DavidZH
I am using this:

Sonoff Touch

With ESPeasy loaded in it.
I am using "Rules" from ESPeasy and send messages directly between nodes, so when my Domoticz goes off, switches and relays still works. When wi-fi is down, switch still works locally.
Each relays send notification about his state to the controller ( Domoticz ) and Domoticz send messages to the relay like other nodes.

EU Sonoff Touch Wifi Wall Switch Wireless Touch LED Light Controller Smart Home

$18.00

Sold out

@majic
Are you able create the wifi network in all your house?
( wifi bridges on each floor etc? )
If yes, then buy some Sonoff units, flash ESPEasy to them, connect Dallas temperature sensor, plug in to the electricity outlet in each flat and instal Domoticz in your computer.
You can see graph data on your computer then.

https://forum.mysensors.org/topic/4933/using-the-selector-switch-in-domoticz-tutorial

@nofox
If you have got one free pair of wires in cat5e cable, it is easy to convert your "star" topology to pure 485 bus topology with terminal resistors on both ends only.

@kduino
We can see debug info from your node.
It is through USB port on Arduino?

Because I can see:

#define MY_RS485_HWSERIAL mySerial

In your node code example.

HW serial on Arduino is connected to serial-USB converter normally.
You cannot use it for both - debug through USB and RS485 at the some time.

But I think, it is mistake only, because on the start of the code you define:
#include <SoftwareSerial.h>
SoftwareSerial mySerial(8, 9);

Try delete HW serial definition.

According debug info, it seems, that your node can sending and gateway is receiving his messages,
but node do not receive messages from gateway.

Or, if your communication works with direct TX-RX connection, try drivers for CAN bus instead of MAX485 ones. It eliminates possible problems with DEpin.

@kduino
Try
#define MY_NODE_ID 23

before

#include <MySensors.h>

not after.

Try RS485 examples from MySensors library - "MotionSensorRS485"
only add
#define MY_NODE_ID 23

before

#include <MySensors.h>

It works.

@B_Johnny23
Raspberry 3's GPIO/serial port ?
I can see "Using serial port: /dev/ttyUSB20" in your log.
It looks like serial through USB.

RPI3 GPIO serial port has got some differncies compare with previous RPi2.

http://spellfoundry.com/2016/05/29/configuring-gpio-serial-port-raspbian-jessie-including-pi-3/

@gasuter
CAN FD looks good, until you start to looking for IO chips.
MCP2561FD is only CAN bus transceiver ( like MAX485 ) with higher speed ability, then traditional CAN bus drivers.
It has no logic "on board".
You need something like MCP2517.
But try find datasheet, prices etc. for this chip.
I think, it will be very expensive way for us, like standard CAN several years ago was.

@gohan
Thanks for your message.
All CAN controllers can send max 8 bytes of data, so longer messages must be divided to multiple packets. J1939 works this way too. That is what I do not want. With heavy traffic especially GW must again assemble packets to complete message, but packet of one message will not come one by one. Packets will be coming mixed from different nodes and GW must assemble them in memory to complete message from each node. So you for example has 30 messages in different state of completion. Some of them has received 1 packet and waiting for 2nd , some has 2nd and waiting for 3rd. ....
I am concerned that it does not work for ATmega328, and must be used processor with more RAM.

@Marcoblacks
You write: "RFlink can manage my sensor protocol only in RX, it cannot talk with the my sensor node!!!"

I think you do not need receive information from gateway every time.
In registration process when you use fixed NodeID and do not use ACK, you only send info to GW.
Photo sensor only sends data to GW too.
Problem with power meter, when you retrieve old number of pulses from controller, but Domoticz has option "Energy read"
( computed x from device ) - maybe it helps. I not try that.

@wallyllama
I look at j1708 spec. and I think, that this protocol was born long before CAN.
It uses MAX485 bus drivers that way, that CAN bus drivers can works at higher speeds and better now.
And I must say, I can see better multimaster implementation for RS485 bus than j1708 ( clever addressing, bus arbitration, CRC instead of simple SUM etc. ) And there is AVR libraries so you do not start from scratch. For J1708 I can not find any.

@gasuter
I think I am able sending data from node to gateway (GW) and through it to controller.
There is limited data space in CAN message, so I must avoid sending long strings and send all as possible like integers, longs, floats etc. It is not problem when sending from node to GW, because in the message header is field, which describes type of payload and according GW code, I assume, it can translate it to strings for controller correctly.
But problem is, when GW receives data from controller. Payload is always string and I must convert it to int, long, float and sometimes short string for sending it through CAN bus to the node. But from serial protocol GW can not recognize, what type of this payload is. I think I need to built some translation table for each serial protocol TYPE to variable type.
But maybe each controller sends different type of data for the same sensor value (0, 1 x "on", "off" ).
Or better something "smart" like "when there is a dot and not letter in string, it is float", "if there are only numbers, it is int or long" ....

@gohan
Thanks for info.

@gohan
Can you describe function of LED for watt metering, please?
I hear about this first time, so I am interested.

@gohan
Yes, pulse counting is best for energy consumption ( kWh ), but is inapplicable for actual power
( W ) consumption measuring.

@sspence65
I think too that your method for power metering is better then calculating it from "blinks" of LED of power meter.
That is good for energy consumption only by counting pulses.
You can send correct power consumption in each time, which is not possible from blinks.
And I think in most cases we can assume stable voltage in the power net, so we do not need measure voltage.

@moumout31
I think it is not true, what AWI writes.
I try pulse meter example now on RS485 bus, and I am receiving last value from Domoticz when restarting node .
When I reset or power off node, it then continues sending form last value.
This value it must obtain from domoticz.

And do not forgot about law restrictions in some countries, EU and etc.
For example with 868 Mhz your device can transmitting max 1% of time per one hour.
Maybe problem for gateway node?
2,4 GHZ is relatively free all over the world.
Page 7 here

@popunonkok

@Boots33
"Door Lock" only. I am using stable releases.

@popunonkok
You can choose "Door Lock" switch type and change icons for this switch.
I think, it is possible change any icons in domoticz.
Simply go to "www/images" folder, load your own icons and rename it to door48open.png and door48.png.
Or do the same for contact48.png etc.
I will try it when I come at home.

@popunonkok
You can define your own icons in Domoticz.

https://www.domoticz.com/wiki/Custom_icons_for_webinterface

@AndyDHill
Look at "MockMySensors" sketch in MySensors examples. Maybe it helps with some types.

@wallyllama
If you closely read some threads about RS485 on this forum, you find, that some people use hardware serial
with current RS485 library too. Problem is, that collision detection implemented by read-verified-write, i.e. all data written is checked on the fly, will never 100% work on "real" RS485 bus. RS485 transmitters are not constructed for this.

@Markus.
Hi.
What you exactly mean "above mentioned sensor boards" ?
I do not see any info about some boards.
ATmega328p is type of processor only.