UPDATE: The official build guide for the ESP8266 gateway can now be found here.
The description in this post is for reference only!

Please find an early release of ESP8266 gateway support in my MySensors 1.5 branch:
https://github.com/Yveaux/Arduino

It has not been tested heavily, but seems to run stable at least with one sensor.
Great feature of this setup is you can run a WiFi gateway with just an ESP8266 and nRF24L01+ radio, no further Arduino (ATMega328) is required!

I'm releasing this now, hoping you can start experimenting with it and help development to get to a stable, official release asap.

Setting things up:

• Install Arduino IDE 1.6.5
• Add support for ESP8266 to Arduino, see https://github.com/esp8266/Arduino (Installing with Boards Manager)
• Get the code form my fork https://github.com/Yveaux/Arduino/archive/master.zip and extract the zip
• Edit libraries/MySensors/MyConfig.h when you use e.g. a different datarate, channel or base radio ID.
• Point your Arduino configuration to the extracted dir (File -> Preferences -> Sketchbook location)
• Restart the Arduino IDE

Compiling the gateway:

• Open the WiFi gateway in the Arduino IDE (File -> Sketchbook -> Libraries -> MySensors -> Esp8266Gateway
• Save it, to allow editing
• Enter your SSID and WiFi password in the 'ssid' and 'pass' variables
• Select the ESP8266 board you're targeting in Tools -> Board. I use an ESP12 module, which is a 'Generic ESP8266 Module' board target
• Verify your sketch. It should compile without errors.

Connecting the radio:

• Make sure to use an ESP8266 module which breaks out pins GPIO 4, 12, 13, 14, 15 (e.g. ESP12 module)
• Connect the radio as described in the header of the gateway code.
• Connect the other signals as described in the header of the gateway code.
• I mounted two switches (for reset & bootload) which your ESP8266 may already be equipped with (e.g. the NodeMCU boards have them most of the time)
• I use an FTDI USB->Serial converter to connect the ESP8266 to my PC, which outputs levels at 3.3V. This is very important as the ESP8266 cannot officially handle 5V signals, and cheap USB->Serial converters often output at 5V levels. When in doubt, please check before connecting!
• Power both the ESP8266 and the nRF24L01+ from a separate 3.3V power supply. The 3.3V supply from many USB->Serial converters is often too weak.
• Decouple the power supply with a large capacitor (e.g. 1000uF) and 100nF, to buffer the input and suppress any noise.

Downloading your sketch:

• Start wit a low upload speed (e.g. 9600baud). It will take ages to download, but I sometimes have issues downloading at high speeds.

• Press reset + bootload buttons.

• Keep bootload pressed while releasing reset

• After a few seconds release bootload.

• The ESP8266 is now in bootload mode, and ready to download your code.

• Choose Upload in the Arduino IDE

• After some time (a lot of dots) upload should finish and your code starts. The serial monitor (115200 baud) shows the progress:

    ESP8266 MySensors Gateway
    Connecting to SSID
    ...........Connected!
    IP: 192.168.1.119
    0;0;3;0;9;gateway started, id=0, parent=0, distance=0
    0;0;3;0;9;read: 123-123-0 s=1,c=1,t=24,pt=5,l=4,sg=0:2810347
    123;1;1;0;24;2810347
  

• This text will be preceded by some garbage from the bootloader (it outputs at a lower baudrate)

• The IP address of the WiFI gateway will currently be obtained from a DHCP server.

Now connect a telnet session (e.g. putty) to the IP address mentioned in the serial output (192.168.1.119 in this case), port 5003 and send some serial commands!

The MySensors core team is proud to announce our participation in the Eindhoven Maker Faire 2017!

The event will take place September 2-3 2017, in Eindhoven, The Netherlands and we will be hosting a full size booth.

We plan to have a static setup, showing MySensors enabled hardware (from Sensebenders to breadboard) and a live scale model of a MySensorized house.
Any wild ideas or help are very welcome.

We hope to meet you all in person and have a fun time!

Update: We devoted a full page on the Faire!

Battery powered MySensors Washing machine & dryer monitor, using LDR's to monitor LEDs on front of the appliances.
Each time a LED toggles, the node wakes from interrupt and sends a message. Easy peasy!
When a device is ready, I'll get a message on my mobile phone

Still need to stuff it in an enclosure...

I bumped into this handy Windows tool which shows a notification when USB Serial ports are connected or disconnected:

https://github.com/avishorp/PopCom

"PopCom is a COM port plug-in/plug-out notifier. Whenever a USB device that emulates a COM port is connected to the computer, a pop-up will be displayed, describing the device that has been plugged in and the COM number assigned to it. This pop-up helps determinig the COM number assigned to each device, a number that is required for communicating with it."

As we are plugging serial devices all the time it can be of use to you too!

Enjoy!

Hey guys!

Just a quick update on the Eindhoven Maker Faire !
Yesterday we had the first day. @hek, @tbowmo, @scalz, @sincze , @marceltrapman and myself were present at our booth:

We had a huge amount of visitors! Many were already familiar with MySensors and we convinced the others to at least have a look a out site
The kids loved the automated dollhouse we have on display!

Today we continue with the second day, so you still have one more change to meet us IRL!

Eindhoven Maker Faire
11:00 - 18:00
Klokgebouw 50
5617 AB Eindhoven
The Netherlands

See you there!

@mfalkvidd How about a capacitve touch dimmer (rotary, on/off or linear, whatever you like) ?
Most electricity wall mount systems (e.g. Busch Jaeger, Gira) have 'blind covers' which you can easily fit a capacitive touch pcb behind:

Use a chip like MPR121 to readout the capacitive touch PCB and translate it into roraty movements, clicks, whatevers...

@gohan I'll probably do a writeup of the house anywhere soon. Please give me some time to process and recover from the Faire

A temperature controlled PWM fan controller for my DPS5005 power supply!

The original 2-wire fan that came with the power supply casing made an incredible amount of noise.
Using PWM to reduce its velocity made it even more noisy

So, I made a fresh start and ordered a quality fan (almost as expensive as the whole casing...)

Using nothing more than a 5V pro mini, piezo speaker, DS18B20 temperature sensor and a resistor I made a full fledged fan controller

It takes the current temp from the DS18B20 (which will be mounted on the heatsink) and ramps up the fan linearly in the 30..60 C range. Below 30 C, the fan is off.
If RPM readback indicates a stalled fan, or DS18B20 returns wrong values the buzzer will force me to invest what's wrong

Attached the HMC5883L to my water meter using some putty (just stuck it on the edge near the metal magnet on the big red arrow):

I let the water run for a while and spilled around 20 litres (0.02m3). You can see the magnet has moved from the 5-digit to the 7-digit:

Next is the chart of the HMC5883L's X/Y/Z readings (Range 8_1GA, average over 8 samples, 1 sample (horizontal pixel) per second):

You can clearly see the sensor readings starting to change when the valve opens and stop changing when it's close again!
I didn't want to spill 100 litres just for a quick test, but I expect the curves to be sinusodial, and certainly periodic with the turning of the magnet.
The position of the sensor isn't critical at all (in contrast to all other water meter sensors I've seen), you could even stick it on the closed lid of the water meter!
Every position will generate a different swing of the X/Y/Z signals, so some clever software is required to translate this into (partial)rotations of the magnet.

BTW I used this library and modified HMC5883L_simple.ino to output the data for the Arduino plotter.

This information is outdated. An error in the ATMega328P datasheet has been confirmed. See https://forum.mysensors.org/topic/6572/sleep-with-interrupt-only-works-with-level-low

@AWI Ok, last reply :simple_smile:

I'll have to dwell a little to explain how the AVR works and what its limitations are regarding sleeping, and how the MySensors library handles it.

For AVR architecture, the MySensors library uses the 'Power-Down mode' when sleeping.
I'll focus on ATMega328P here, for which the datasheet states the possible wake-up sources:

So in our case that's INT and WDT (TWI Address match is for i2c slave implementations).
When a timeout parameter is passed to a sleep() function of the MySensors library the watchdog (WDT) will be used to wake after the specified timeout. If timeout is set to 0 (and wake-up from interrupts is specified) the watchdog will be completely disabled to save some more power.
When an interrupt source is passed to a sleep() function of the library it will configure INT0 and/or INT1 to wake up the ATMega328.
Note point 3, as only level interrupts (more precise LOW in case of ATMega328, thanks @AWI for reminding me) can be used as a wake-up source.
Many posts here use RISING/FALLING/CHANGE as wake-up source for ATMega328 which is not supported by the ATMega328P and thus not supported by the MySensors library. Although people claim it is working for them you are on your own when using the chip out of spec and can expect strange behavior!

The datasheet continues in detail on the power-down mode:

The MySensors library disables brown-out to save some power. Serial interface address match and pin change interrupt are not used by the library.
Pay special attention to the note: Waking the AVR from a INT0/INT1 interrupt will require the LOW level to remain for the startup-time, or the interrupt will not trigger. This means that only when the level is held long enough the library will be able to detect it woke from the external interrupt. If the level is not held at least the startup-time, it will assume it woke because of the total sleep time expired, and return MY_WAKE_UP_BY_TIMER (value -1).

This start-up time depends on the clock frequency and fuse bits, which for e.g. an 8MHz Arduino Pro Mini comes down to 2ms.

So just remember: In the MySensors library, only use LOW level interrupts to wake an ATMega328 from sleep and assure the interrupt level remains constant for at least the start-up time!

@AWI Your third example is out-of spec (CHANGE interrupt) and behavior is therefore undefined. If it seems to work, you're lucky...

This information is outdated. An error in the ATMega328P datasheet has been confirmed. See https://forum.mysensors.org/topic/6572/sleep-with-interrupt-only-works-with-level-low

@Fumée-Bleue likely the brown-out detector from the atmega detects a low voltage. This mechanism protects the atmega from undefined behavior by resetting it.

@Tsjippy Judging from this picture which the link points to:

it looks like it is using an nRF24L01+ module; the same module MySensors supports.

However, the software on the unit does not run MySensors (judging from the 0-125 address range), so you would either need to reprogram the unit with the MySensors stack (can't tell from the pictures if this is possible at all) or try to build a receiver using another nRF24L01+ module, which you would also need to program to communicate with the device.

Still it would be hard without a specification of the communication protocol.
One of the user comments mention the seller sent some docs along, so maybe you could ask them for specs?

@olka said in Minimal LiPo powered Arduino Pro Mini + RFM95 MySensors node:

you can do battery monitoring with code only (search here on the forum for it)

@evb I wrote a small library for it: https://github.com/Yveaux/Arduino_Vcc

@grumpazoid wait() is a special implementation of a wait loop in the mysensors stack, that also processes messages while at the same time waiting for the requested time to elapse.
It is in principle the same as i showed before: it checks time elapsed and if some time is still remaining it handles incoming messages.

@grumpazoid said in void receive and while loop question.....:

How do I use wait in one place and then get another loop or process to run in the meantime?

Simple, you don't

Wait() will block processing your code for the specified amount of milliseconds, while millis() will immediately return the current time, in milliseconds.
Arduino is single threaded, so only one task can run at any time. To execute some code, while another piece is 'waiting' you should use millis() to determine how much time elapsed each time your code is executed, eg

void loop() {
  static unsigned long start0 = millis();  // have a valid initial value
  unsigned long now = millis();
  if (now - start0 > 1000ul) {
    // run once every second
    //... Your code... 
    start0 = now;
  } 
  static unsigned long start1 = millis();
  now = millis();
  if (now - start1 > 2000ul) {
    // run once every 2 seconds
    //... Your other code... 
    start1 = now;
  } 
  // etc

@Fumée-Bleue I would start by running your exact same software powered by a different power supply, preferably a lab supply supplying suffient current (look up the power requirements of RFM95 in Tx mode). That way you can rule out software.
Next, just adding a large capacitor to your current supply might suffice, when you only incidentally send using the RFM95. A super cap can also work, but requires more components/is more expensive. Either do the calculation (always better), or experiment with some caps.

@Fumée-Bleue could very well be a power issue, because as soon as you try to send the node seems to restart. How do you power everything?

@evb said in Battery Powered Sensors:

As far as the current of my pro mini is concerned, I'm stuck at a minimum of 133µA.

So how low do you want to go? The original article mentions 120uA, so you seem to be pretty close to that value.

@Alberto77 set the node id before the include of mysensors

@Alberto77 said in Pro mini: Did not receive a node id from controller.:

TSM:ID:REQ

You need to have a controller to hand out node IDs, or use static node IDs.
See https://www.google.com/search?q=TSM%3AID%3AREQ&oq=TSM%3AID%3AREQ