Best posts made by kimot

@gonzalonal
Yes I am.
But I have got a lot of other works, so It's going slowly.
The problem is, that CAN can transfer only 29 bits ID ( 3 bytes + 5 bits ) and max. 8 bytes of data.
MySensors message has got max. 32 bytes ( 7 bytes header and 25 bytes of data ).
I must either send MySensors message like 3 packets of CAN messages or limit properties of MySensors protocol.
Now I am working on second variant.
I am able code to one CAN message:
6 bits - destination
6 bis - sender
(gateway, broadcast, 62 nodes - it is enough for me for one bus. I plane three buses and gateway can " translate " or "expand" nodes ID from and to controller )
1 bit - RACK
1 bit - IS ACK
3 bits - command
6 bits - type ( MY sensors has 56 types max. now )
6 bits - sensor id ( only 64 sensors per node ... )
3 bits - payload type ( int, uint, long .... )

The sum of these is not 29, but 32 so I am using a little "hacking" data length field in CAN frame to obtain additional 3 bits.
For data I have got 8 bytes.
It is enough for conventional data types from char to floating point.
Only text messages are limited to 8 bytes. But for us, old boys, who remember old DOS file names, it is enough.

In this time, I am able send and receive packets in that format between nodes and now I am working on transfer RS485 library to CAN library.
The problem is, that RS485 library sends destination address, node id, length of message and then MySensors message, witch "surprisingly" contain again destination and sender bytes. A little bit redundant for me.
So I must remove some fields from MySensors message, put it to CAN ID and send only payload in CAN data fields.
When I receive CAN message, I must again assemble correct MySensors message format and put it to MySensors system.
But unfortunately only documentation is library code itself :o(

I try a "stress test" like here:
https://forum.mysensors.org/topic/5051/rs485-stress-test

I send 10 000 messages from two nodes to "gateway" ( 22kbps ).
Result - zero messages lost.
But it is expectable with CAN.

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.

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

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

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

@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());

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

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

@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

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

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

@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:

@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;
}```

@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.28

1308 available

Try other software serial libraries.
AltSoftSerial
NeoSWSerial

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.

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

@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

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

@Reza
Remeber, that GPIO Uart on RPi3 is not ttyAMA0 like with RPi2( it is bluetooth now ).
GPIO is ttyS0 on RPi3.

http://raspberrypi.stackexchange.com/questions/45570/how-do-i-make-serial-work-on-the-raspberry-pi3

Or read this thread too:
https://forum.mysensors.org/topic/6015/serial-gateway-connect-problem-ttyama0

@Reza
I recommend nothing solder or unsolder now.
Simply start with two Arduinos on two ends of cable.
When your communication will work for these two devices, then you can go further.
For one Arduino write simple sketch, which will periodically send something ("Hello World/n" )
to the bus. Other Arduino with sketch witch will receive characters and sends then through USB serial port to serial monitor on PC. Only with AltSoftSerial library, not with MySensors.
When this communication will work on any length of cable ( I suppose you have not cable longer then 1km at your home ), you can go further.
You do not need drive DE and RE pins by software, simply on transmitting Arduino set it for transmit ( to +5V ) and on receiving Arduino to ground.

@Reza
Original RS485 library was written so, that multiple SOH characters is sended on start of package.
In Mysensors library it is only one times and it can be problem for synchronization and arbitration.

Try in MyTransportRS485.cpp in function "transportSend" change line 274 from

for(byte w=0; w<1; w++) {

to

for(byte w=0; w<3; w++) {

@Reza
Maybe stupid question from me, but have got you connected ground wires between nodes?
Not only A and B?
http://www.chipkin.com/rs485-cables-why-you-need-3-wires-for-2-two-wire-rs485/

@lrtsenar
"multiple definition of"
I got too when experimenting with some libraries.
For example I edit my version "mcp_can.cpp" and rename original version to "mcp_can_old.cpp"
( and leave it in original library directory )
Then when compiling I got this "multiple definition of" error.
When I rename original to "mcp_can.xxx" compilation works ok.
"mcp_can_old.cpp" is not included in any place in the code.
It seems that Arduino IDE uses at first ( for preprocessor ? ) all .h and .cpp files in the library directory.

@kimot
I am not sure, that Raspberry can work like RS485 gateway for MySensors RS485 network.
On a "quick" look through code, I do not find anything for RS485.

@Reza
Maybe your problem and its solution with "serial-through USB" connection on Raspberry is described here:

https://g0kao.wordpress.com/2013/08/08/usb-port-assignment-on-a-raspberry-pi/

@gohan
Yes

Yes. It is very bad for beginners, that examples in MySensors library are wrong.
Example "MotionSensorRS485" will never work and I think, that author not tested it.
MY_NODE_ID must be always defined for node in RS485 network, because is used for RS485 network addressing.
Obtaining NODE_ID from controller with currentRS485 network implementation is impossible and I think it should be clearly mentioned in the examples and documentation.

@dbemowsk You can use NODE RED as a translator between your hardware and protokol and then send translated messages to Domoticz ( for example). I think NODE RED + any sw controller is very powerfull combination.

@andriej
It is a pity that not paying more attention mysensors.org for nodes interconnected by wires. But it is very difficult to find peer-to-peer protocol for RS485. Mainly because of solving collisions on the bus when multiple sensors. But it is very difficult to find peer-to-peer protocol for RS485. Mainly because of solving collisions on the bus when multiple sensors. I think that used ICSC library does not address this matter satisfactorily and with a larger number of sensor problems arise. ICSC library uses a Serial Software library by heavyweight each node on the bus, because all must be checke every bit transmitted on the bus. Look at different implementation:

www.mrbus.org

I think, thet using hardware UART is absolutely necessary.
Or why when we use a separate module for radio transmission, we use the special module for robust message transfer over the wired bus? CAN controllers are not so expensive in this days:

http://www.ebay.com/itm/MCP2515-CAN-Bus-Module-Board-TJA1050-receiver-SPI-For-51-MCU-ARM-controller-M2-/381500570180?hash=item58d334ba44:g:OhcAAOSw3KFWfANk

After correct CAN controller configuration, we simply write a message to the CAN controller and forgot about it. No check or bus arbitration. And through interrupt pin from the controller just pick up the incoming message with our ID or broadcast.

I know it's not as simple as using only RS485 transmitter itself, but we are guaranteed connecting maximum of 110 nodes and various libraries for Arduino for this CAN controller exist.

MCP2515 CAN Bus Module Board TJA1050 receiver SPI For 51 MCU ARM controller M2

$2.18

Sold out

@andriej
RS485 was not designet for multimaster communication, where 2 devices can communicate on the bus at same time. RS485 bus state at this time is not defined. For example if node on RS485 on one end of bus sends message end perform "control" lisening on bus if recieve the same message( what is with correct circuit of RS485 transsiever immposible ), then this received message can be the same. But if in the same time another node on oposite end of bus sends different message, then node on the middle of bus recieves something random.
But CAN bus has allways defined state. It has dominate state and recesive state, so node witch send dominate bit cannot be pushed yb node witch at the same time sends recesive bit. I now, thet this feature we cannot use with normal serial communication, but still we can controll correct sending of datagram by lisening bus by sender. If we recieve the same message what we send, there is 100% shure, that the same message lisens every node on CAN bus. On RS485 this is not garanted. Bus topology is the same end we dont need "dePin". So we can use normal serial library. And CAN transciever is not so expensive as wrote LeoDesigner. Look here:

http://www.ebay.com/itm/10PCS-MCP2551-I-SN-IC-TRANSCEIVER-CAN-HI-SPD-8-SOIC-NEW-/171541737564?hash=item27f0af305c:g:nbQAAOSwIBBUZU~k

And sorry for my english

10PCS MCP2551-I/SN IC TRANSCEIVER CAN HI-SPD 8-SOIC NEW

$4.52

59 available

I think, that CAN transceiver chip is better then RS485 transceiver chip.
Then we dont need direction setting pin and bus state is better determined, becose CAn bus is prepered for bus collisions, RS485 not.
I mean only CAN bus transceiver, not CAN controller ! For example MCP2551 or MCP2562.
And we can use normal serial library.