The ePulse Feather

The Color Kit Grande is the sum of many things Marcel and I learned in the last couple of years. We replaced the NodeMCU from the Classic Kit and the Wemos Mini from the Color Kit with our own ESP32 ePulse Feather. As the name indicates the ePulse Feather follows Adafruit’s Feather specification. The ePulse Feather is also very efficient when it comes power consumption: it only consumes down to 12uA when in deep sleep! A true IoT dev board should be powered by batteries and the ePulse Feather allows this with a LiPo charger and connector. And it uses the powerful ESP32 microcontroller which is a big upgrade compared to the ESP8266. More RAM, more flash, more cores, more possibilities!

The Display Module

But not only the microcontroller board got better compared the the older Color Kit. We also added a better display module. It communicates over SPI with the ePulse Feather to change the pixels on the display. The added PSRAM memory of the ePulse Feather allows us to write better looking programs with more colors!

We also replaced the (ancient) resistive touch screen with a capacitive module. This is the same technology that you know from modern smartphones and tablets and is much more precise and intuitive to use.

The Connector Board

The ESP8266 Color Kit was the first of my kits to include a custom component and it required you to solder pin headers. The Color Kit Grande still has such a PCB which we call connector board. But this time we offer you various difficulties of soldering. There is a power switch with classic through hole soldering and a wide pin pitch with enough space for even a wide soldering tool.
The pin headers for the ePulse Feather are in 2.54mm pitch and are a bit more delicate but still not too hard for a beginner. We also added a Grove connector to connect to a wide range of sensors and actors using the same system. And the Grove connector is surface mounted which again is a bit more complicated to solder.

The Kit Box

Even with the kit box we learned from our older products: both the Classic Weather Station and the ESP8266 Color Kit came in a box which is 4cm high. This was sometimes problematic for shipping and added extra costs. The Color Kit Grande box is only 2cm high and everything fits neatly in it. The box even serves as a stand. How cool is that?

The New Weather App

Not only the hardware is new, we also rewrote the popular weather app from scratch. More memory and more CPU power means that we have more colors to play with. To make setup of the development environment as easy as possible we decided to use platformio and Visual Studio Code. While the Arduino IDE is very good for beginners it makes it hard to ensure that every maker has the same setup on his/her machine. With platformio we can define the exact versions of libraries you use. No conflicts because of old and outdated dependencies! Just do the required changes in the settings.h file and upload the firmware!

Where to buy

The Color Kit Grande is available at the ThingPulse web shop. As you might know, I founded ThingPulse together with Marcel back in 2018 to professionalize the distribution of the projects posted on this blog. Since then we developed many new products together which are also available in the shop.

Coupon: For the readers of my blog I have a special treat! Use the coupon code SQUIX-CKG to save USD $5 when buying a Color Kit Grande in the ThingPulse Shop. Valid until July 31, 2023

Links

• Color Kit Grande Shop Page
• Assembly and programming instructions
• Weather Station Touch on Github

For a long time, I had been planning to build ESP32-based devices to measure the temperature in my apartment. In summer, visualizing the temperature helps in ventilating the apartment efficiently, while in winter, it helps to keep an eye on the humidity levels. However, more important projects kept taking precedence, and I never really got around to building the sensor network. That is until I discovered the OpenMQTTGateway project.

What is the OpenMQTTGateway?

The OpenMQTTGateway is an open source project that may not seem like much, but it is incredibly effective. An ESP32 flashed with this firmware will scan for devices and read their values if possible. The gateway ESP32 will then publish the discovered devices to specific topics on a MQTT broker. If the firmware recognizes a device type and can communicate with it, it will also publish additional information.

The published information includes a plethora of data to play with, with each device having its own topic, and a JSON structure containing the collected information.

Hardware: The Gateway

To run OpenMQTTGateway, any ESP32 device can be used. However, to travel in style and maintain the aesthetics of my apartment, I opted for the ThingPulse ESPGateway, which comes with a sleek enclosure and an external antenna that helps to communicate over a longer distance. For those who want to connect the gateway over Ethernet, the Ethernet the ESPGateway is also a good choice.

Hardware: The Sensors

For the room sensors, I used Xiaomi BLE sensors that are very affordable and measure temperature and humidity, communicating over Bluetooth LE. When purchased in bundles, these sensors can be found for less than USD $5 on Aliexpress.

By using a custom firmware that can be flashed using this GitHub project, additional features can be added to the sensors.

Plant Sensors

Apart from the Xiaomi BLE Room sensors, there are many other devices that can communicate with the OpenMQTTGateway in my home. For instance, the Xiaomi Flora Plant sensors work exceptionally well to report soil humidity, temperature, and light.

Presence Detection

You can also use the OpenMQTTGateay to track the presence of devices in your apartment. For instance if you are wearing a Fit tracker like the Xiaomi Mi Band you can track the presence of the people wearing them.

Storing, Controlling and Visualizing

To store, control, and visualize the data, I have a Raspberry Pi 4 running the MQTT broker. A Node-Red instance takes the data and pushes it into an InfluxDB. Then, Grafana is used to visualize the data over time. And this is how it looks for the Xiaomi room sensors:

Step by Step Instructions

In EasyEDA:

1. Export the layers as DXF file, File > Export > DXF…

In Fusion 360:

1. In a new design create a new component and activate it.
2. Import the DXF file: Insert > Insert DXF. In the dialog choose One Sketch per Layer…
3. Create a new sketch on the same plane and call it PCB
4. Project (Shortcut ‘P’) all relevant and correct sketch features into the new sketch.
   • Some elements might be wrong, in that case, import enough to fix them (see video).
   • Remove the checkbox behind “projection link”. This allows you to change projected lines independent from the imported sketches
   • Make sure the PCB outline is closed (the PCB in the sketch is light blue)
5. Extrude (Shortcut ‘E’) the PCB downwards with the thickness you will order your PCBs with.
   • In my case, I entered -1.6mm.
   • The sketch plane should be on top of the PCB. This will make it easier to align the electronic components later
6. Create a new top-level component for every electronic part you wish to import.
   • You don’t need to import every capacitor, chip, or resistor. You can of course, but this will be very tedious.
   • Only import parts that interact with the enclosure: plugs, buttons, sensor or the parts with the biggest height

In EasyEDA:

1. Open the PCB view. Put your browser (e.g. Chrome) into inspect mode by right-clicking somewhere at the top of the browser window.
2. Open the tab to display network traffic (“Network” in Chrome).
3. In the PCB view select the component you want to export
4. In the right tab > Custom Properties > 3D Model click on the text field
   • This will force EasyEDA to download the 3D model of this component.
   • In the inspect mode window two new lines appeared.
5. Right-click on the last one and Choose “Open in new tab”.
   • This will download the 3d model into your download folder
6. Repeat this for every part you need in Fusion 360

In the File Explorer/Finder

1. Rename the file you just downloaded and add “.obj” as extension, e.g. “USB_C.obj”
2. Repeat this for every part

In Fusion 360:

1. Activate the component of the part you are going to import
2. Import the obj file: Insert > Insert Mesh
   • Rotate the object in the correct direction
   • Place the object somewhere above its final location on the PCB
3. If needed, repair the mesh: Mesh > Prepare > Repair…
4. Convert the Mesh: Modify > Convert Mesh…
5. Place the part: In the Solid workspace > Modify > Align
   • Choose a feature on the part that you can also find on the PCB/ sketch
   • Use Flip/Angle to rotate the part until it fits
   • Sometimes you need several Align operations: e.g. first align x-axis and y-axis, then use another feature to align z-axis
6. Repeat with all parts/ components

Congratulations, you have successfully recreated the PCB and it’s most important components in Fusion 360. Now you can use this model to create your enclosure. But this is content for another post;-)

Video

Here is the transcript of the video above if you prefer reading over watching a video.

Reason 1: Price

Some years ago you had to pay thousands of dollars for a device like the Ultimaker 2 that would print in a reasonable quality. Today you can get 3D printers for less than 250$. The Creality Ender 3 V2 for instance costs only 215USD by using this link https://ban.ggood.vip/10cdb and with this coupon code: BG139c3c.

Reason 2: Easy to Build

It took me several hours to build my previous 3D printer. The Ender 3 V2 is much easier to build and all the tools are included. The base of the printer is already assembled and you only have to put together the upper part. It took me about 30minutes to assemble. There are many great assembly videos available, I used the one from Bryan Vines from youtube.

It’s a great video guide and Bryan shows the assembly step by step in a very structured way. Here is the link to his video: https://www.youtube.com/watch?v=L6FZjkWcW2g&t=1492s

Reason 3: Easy to Use

Once you have built the 3D printer you want it to print as easily and reliable as possible. The Ender 3 V2 comes with a nice display and jog wheel to control all the settings. You copy the files for 3D printing on a mini SD card and insert it into the Ender 3. Then you select the file with the jog wheel and off you go!

Reason 4: Great Quality

To me, the quality of a 3D-printed object is important. While my previous low-cost printer produced mixed results I’m absolutely stoked by the quality of the objects printed with the Ender 3. It’s absolutely amazing, especially considering the price of this 3D printer! Objects from my old 3D printer had many artifacts called ghosting or ringing.

Here you can see an example of ringing. The shapes continue to be visible due to the inertia of the print head. But my first print with the Ender 3 was just perfect!

What to print?

You might say, that’s all good, but why do I need a 3D printer in the first place?

Reason 5: It’s Good For The Environment and your Wallet

How many devices end up in a landfill because a plastic part is broken? Two years ago my parents asked me for help. The handle to the freezer compartment of their fridge was broken. I drew the part in a program called Fusion 360 and printed it out. And it has been in good use since then. This saved my parents a ton of money and is much better for the environment.

Here is another example of saving money and tears. A plastic part of my daughter’s Mickey Mouse watch broke and she was very sad about it. I designed a replacement and printed it out.

The axle of the cable car broke. Design a replacement and print it out. And the kids can keep playing.

Reason 6: Education

You can also use drawing on the computer and 3D printing for education. I designed several projects together with my daughter. She wanted to have another hat for the second snowman in her winter diorama. I told her we could do it, but only if she helped me design it. We had lots of fun together! Of course, you have to adapt the challenge to your kid’s age.

Reason 7: Customization

You can use 3D printing to fix items or create copies of existing objects. But you can also create objects that just didn’t exist yet. Here are some examples. This is a 3D-printed hanger for the lamps on our balcony.

Here we have a holder for the razor in the shower.

A customized iPhone enclosure printed with flexible TPU filament.

Reason 8: Available Models

If you are not interested in designing your own objects there are platforms where you can download many ready-to-print models, often without extra costs. I found this lift for my daughter’s Gravitrax lift on Thingiverse and printed it out.

It requires a couple of additional items like a battery pack and a geared motor, but you can buy them for only a few dollars online. It was such a success that I printed more lifts for other kids with a Gravitrax track. And the best: you can’t even buy something similar from the original Gravitrax manufacturer off the shelf!

Pros & Cons

Is everything just perfect with the Ender 3 V2? No, there is room for improvement. I really like the print quality and that the printer is so easy to build. Adjusting settings with the new controller is very convenient. And you also have to put this into the context of the price.

But the fans of the printer are very loud and I will try to replace them soon with something more silent. I don’t like the glass bed and will put a magnetic steel sheet instead. Another upgrade will be the BLTouch to automatically level the bed. But besides all that, I’m really happy with the Ender 3 V2!

If you liked this text or video and if you are planning to buy an Ender 3 V2 soon then please consider using this link. You help me to create more videos like this. With the coupon (BG139c3c) you can save 10% if you can order from one of Banggood’s European warehouses.

Do you have questions about the Ender 3 or 3D printing in general? Leave a comment below.

Here is the code used to create the signals

#include <Arduino.h>

uint8_t pins [] = {21, 19, 18, 5, 4, 34, 25, 26};

void setup() {
  Serial.begin(115200);
  for (uint8_t i = 0; i < 7; i++) {
    pinMode(pins[i], OUTPUT);
  }
}

void loop() {
  for (uint8_t pin = 0; pin <= 7; pin++) {
    digitalWrite(pins[pin], HIGH);
    delay(50);
    digitalWrite(pins[pin], LOW);
    delay(50);
  }
  delay(500);
}

And this is the recorded output:

There is one step missing. The area for this is marked. This behavior can be easily explained because GPIO35 (element 5 in the array) is a input-only pin. Therefore no state can be written to it by my program.

Links

Link to LHT00SU1 Logic Analyzer on Banggood (~35USD):
https://www.banggood.com/custlink/DmmY0l4fpW

Link to SigRok/ PulseView Open Source Software:
https://sigrok.org/wiki/Downloads

Voice assistants and smart home applications go together really well. For several years now we have an Echo Dot with Alexa running at home and I have connected more and more devices to it. Another important factor in my smart home setup is a Node-Red instance running in a docker container on a RaspberryPi 4.

Why Running Node-Red in Docker?

I probably could save myself some trouble if I would just install Node-Red as regular service on the base system on my Raspberry Pi. Especially where Node-Red needs direct access to RPi hardware resources. It took me quite some time to figure out how I can use the RPi Bluetooth device from within the docker container. In a nutshell: you have to use network_mode: host to share the BLE hardware between host and container.

But I believe that the benefits of running such applications like Node-Red in a docker container outweigh the trouble. Updating or trying out different configurations is super easy. And all the resources are cleanly separated from other containers running on the same machine.

The Alexa-Home Node

I have a couple of Tasmota powered Shelly devices, allowing me to control lights either with a regular light switch over WiFi. You can set up Tasmota devices to be discoverable by Alexa. Then with a simple “Alexa, turn on the corridor” you can control the lights in your corridor. But what if you want to make a new command accessible to Alexa that is not represented by a physical device?

This is where the Alexa-Home node comes in. The official name is node-red-contrib-alexa-home and this extension comes with two nodes: a controller and a device node. The controller lets you do some basic settings like the network port used for discovery while the device node lets you setup a virtual device.

So for instance I created a node called “Everything” and now I can turn off all lights by calling “Alexa, turn off Everything”. Nice, eh? But sadly this didn’t work right away. Once more I suspected the docker setup and I was correct.

The Solution

No matter what I tried, the virtual devices from Node-Red did not show up in Alexa’s device list. So I assumed some kind of networking issue. According to this github project the device needs to listen on a certain port, for generation 3 devices this has to be port 80. Alexa must be able to download the file /alexa-home/setup.xml from the RPi. This file contains the device description.

That means we have to make sure that a request to the RPi is forwarded to our Node-Red container. Now the next steps depends on your setup. I’m running Node-Red together with MQTT from a docker-compose command. And as mentioned earlier this setup is using “network_mode: host”:

Setting network_mode to host allows the container to share the same network namespace as the host OS. When this is set, any ports exposed on the container will be exposed locally on the device. This is necessary for features such as bluetooth.

Source: https://www.balena.io/docs/learn/develop/multicontainer/

This means that I cannot do port mapping in the docker-compose file because host-mode together with port-mapping is not allowed. That means that the port which uses Alexa-Home to publish it’s setup.xml must be exposed from the Dockerfile.

I set my Alexa-Home controller node to port 80:

And in the Dockerfile I added

EXPOSE 80

And that’s it! Rebuild the docker container and restart both containers with docker-compose. Now add an Alexa-Home node in your Node-Red web interface and set the device name in the node configuration. This is the name you will use to give commands for that virtual device. Then tell Alexa to “Discover devices”. After about 20 seconds she will tell you that she discovered your new device.

Now you can create nodes just like this one:

Summary

Alexa and Node-Red can be a powerful team. You can create powerful commands in Node-Red which Alexa can understand. While you are limited to simple commands like “Turn On XXX” or “Dim XXX to 50%” you can get a long way with this.

Running Node-Red in a container is a powerful thing and has many benefits. But it also complicates things every once in a while. And connecting Alexa and Node-Red over the device discovery is such a thing. But if you are in this situation you’ll hopefully find this blog post and have it up and running in no time!

The ESP32 platform offers a wide range of functionality almost out of the box. For instance you can turn a ESP32 with little effort into a Bluetooth Audio speaker. In this article I describing how I tapped into the digital data stream coming from a smartphone to visualize the music with a 8 band VU meter. The code is also a nice example how to you can use the full power of the two Tensilica Xtensa cores in the ESP32.

The ESP32 is an amazing piece of hardware. It is very affordable, easy to use and comes with great libraries. One of those is the esp32-a2dp library by fellow Swiss Phil Schatzmann. With this library you can turn any ESP32 into a bluetooth sink or source. Using it as a sink effectively turns it into a Bluetooth speaker, using it as a source you can send music to a Bluetooth speaker.

Depending on your hardware, this is the minimal code to use the ESP32 as a bluetooth speaker, announcing its services as “MyMusic”:

#include "BluetoothA2DPSink.h"

BluetoothA2DPSink a2dp_sink;

void setup() {
    a2dp_sink.start("MyMusic");
}

void loop() {
}

Wouldn’t it be nice to visualize the music you receive over Bluetooth? I always loved the spectrum analyzers which split the available frequency spectrum in several bands and displayed the intensity in those bands. In August 2019 I wrote a post about how to do that in the browser with sound recorded on the ESP32.

Eavesdropping

Is it possible to get access the digital data stream received over Bluetooth? The A2DP library has a hook to register on events like “stream started” or “stream paused”. But there is no callback to tap into the audio data.

The library is actually a conveniency wrapper around the A2DP functionality in Espressif’s Audio Development Framework (ADF). It uses the esp_a2d_sink_register_data_callback(..) method to get the Bluetooth data stream.

By registering my own callback I could “slip in” between ADF and the A2DP library! Now my method with the signature

void audio_data_callback(const uint8_t *data, uint32_t len)

will be called from time to time with a pointer to the current music data package.

Not Enough Horsepower!

A common method to visualize music is to take slices and convert those into the frequency domain. Blocks with a length of a couple of milliseconds will then show which frequencies are currently active. The process to convert data from the time domain into the frequency domain requires quite a lot of calculations. One algorithm which can do this relatively efficiently is the Fast Fourier Transformation or short FFT.

So just like in my previous project I wrote code which would collect music data until a buffer was full. Then the code would run the FFT algorithm to get the content of the buffer as an array of discrete frequencies. This worked, but the music started to sound awful! Apparently the FFT algorithm took too much time to process the data and the output would stutter.

If One Horse Can’t Do It…

…two can! The ESP32 has two Tensilica Xtensa cores. Until now I never really had a use case where I needed to use the other core. I was also under the impression that you should leave that core alone since all the WiFi processing and other system tasks run on it. But why not give it a shot and do the Fast Fourier processing on the other core?

The revised code fills the buffer as before on core 0. But once the buffer is full it stops collecting data and notifies a task running on core 1 that it can start running the FFT processing on the buffer. Once the FFT processing is completed the code clusters the frequency information into 8 bands.

At this time the task on core 1 will tell the other task on core 0 that it can start again to fill the buffer. Core 1 doesn’t need the data in the buffer anymore. Now core 1 only needs to visualize the intensity of the 8 bands.

Multicore Programming

The data collecting task and the FFT processing task have to communicate with each other. This has to happen thread-safe and if possible without blocking each other unnecessarily. I used a RTOS queue where the data collecting task places a message when the buffer is ready for processing. The FFT task on core 1 starts once it detects a message in the queue. When the buffer is ready for more data it removes the message from the queue.

I have to admit that I’m not sure if my solution is the correct or best way to solve this problem in RTOS. I tried with semaphores but always ended up that all tasks were blocked. Please let me know in the comments below how you would have implemented this.

Hardware

The code I wrote should theoretically run with all DACs supported by the esp32-a2dp library with minor changes, even the internal ESP32 DAC. I wrote the code as a stock firmware for the ThingPulse Icon64 device. You can see it in action in the video below.

Get the Code

I published the code for this project on Github. I hope you can profit from it! As I mentioned before, if you have suggestions how to improve the multi-tasking code or other aspects please let me know either in the comments below or on github!

When we designed the ThingPulse ePulse board I knew I wanted to have a Fritzing part to document new projects with it. I had already designed parts for Fritzing before, but it was very consuming: you start with a similar component available in Fritzing and then modify it until it looks and behave the way you want it.

But there is an easier way. If you want to create a Fritzing Part for a component you design in Eagle CAD you can use a tool to do most of the conversion for you. It took me hours to compile that tool and work around some issues. The tools was original written by the Fritzing team, then improved by Adafruit. But it just wouldn’t compile on my Mac.

So I fixed some of the issues, simplified the setup and documented everything in the README file of the github repository.

I hope this saves you a lot of time and creates lots of new parts!

In this post we will be designing a typical but simple IoT application: a mailbox sensor. Building a mailbox sensor might not be the most exciting project you will ever build. But it is a good example to show a couple of concepts. In this first part we will build a mailbox sensor which wakes up when the state of the mailbox door sensor changes. It then connects to WiFi and to an MQTT broker, sends the state of the door and goes back to sleep.

In the second part we will further improve battery lifetime by using the ESPNow protocol. This proprietary protocol allows the ESP32 to be awake only for a short time. This safes energy and also sends the door state notification much faster.

Hardware Requirements

This project is built around the ThingPulse ePulse dev board. This board is designed with battery driven projects in mind and consumes only 25uA in deep sleep. I was involved in designing this board. In this post I describe why this is the dev board I always wanted.

Further you will need a reed switch to sense the state of the mailbox door. Reed switches are mechanical contacts which change their state in the presence of a magnet. You can buy them either in their bare form as little glass tube or built into a plastic enclosure to be used as door sensor.

As power supply we will use a battery pack with 3xAAA batteries. You can also use a LiPo/Li-Ion battery pack or the smaller AA batteries.

ThingPulse ePulse ESP32 Dev Board, consuming only 25uA in deep sleep.
USD $16.90 at ThingPulse

3xAAA Battery Pack
USD $1.50 at Banggood
(Affiliate Link)

Door sensor
USD $1.80 at Banggood
(Affiliate Link)

Connecting Components

Connecting the components is easy. Either you use a bread board to set everything up or you solder the battery pack and the door sensor directly to the ePulse dev board. When you get the ePulse dev board the male header pins are not soldered yet, so it is very easy to connect other components to it.

Connect the door sensor to GPIO15 and GND and the battery pack to VIN and GND. Make sure you get the polarity right!

Software

The software project I prepared here for this post assumes that you have a MQTT broker setup and available in the same network that the ESP32 will be connected to. In my setup the ePulse publishes the message to a MQTT broker running on a Raspberry Pi. The excellent Node-Red software also running on the Raspberry Pi is subscribed to the MQTT topic and forwards the message to the Pushbullet API. I then get a notification on my smartphone that the door has been opened.

MQTT is a good solution for this project because messages can be quickly pushed into a queue and the ESP32 can go back to sleep fast. In average one message push takes between 1.5s- 2s before the ESP32 enters deep sleep mode.

If you have git installed then do a

git clone https://github.com/squix78/esp32-door-sensor

Alternatively you can also just download a zip file from github containing the project. I’m using for most of my advanced project the platformio development platform with the Visual Studio Code editor. If you haven’t done so already head over to https://platformio.org/platformio-ide and download the Platformio IDE (which is VSCode + Platformio plugins).

Platformio offers many advantages over the Arduino IDE. The later was designed for beginners but as a professional software developer I am missing many features, such as dependency management. In this project I have already defined which libraries we need in the platformio.ini file. If we were to use the Arduino IDE you’d have to download the libraries manually.

Before we connect the ePulse to your computer and upload the firmware we have to make a few adjustments to your local setup. Open the settings.h file and change your WiFi and MQTT settings.

#define REED_PIN 15

#define WIFI_SSID "yourssid"
#define WIFI_PASSWORD "yourpassw0rd"

#define MQTT_HOST IPAddress(192, 168, 0, 100)
#define MQTT_PORT 1883

#define MQTT_TOPIC "ESPNOW/1"

Attention!: Programming the ePulse

Every time you connect the ePulse to your computer make sure that the battery pack is empty. If you don’t you might either destroy your USB port, the ePulse or overheat the batteries. So: just make sure the battery pack is empty!

Understanding the Code

The code uses some interesting concepts which you might not be familiar with. This program is entirely event driven. This means that methods get called when certain events occur. Let’s have a look at the WiFi connection:

void setup() {
   ...
   WiFi.onEvent(WiFiEvent);
   ...
}

This sets a callback method called WiFiEvent. This method get’s called whenever something happens to the WiFi connection:

void WiFiEvent(WiFiEvent_t event) {
    Serial.printf("[WiFi-event] event: %d\n", event);
    switch(event) {
    case SYSTEM_EVENT_STA_GOT_IP:
        Serial.println("WiFi connected");
        Serial.println("IP address: ");
        Serial.println(WiFi.localIP());
        connectToMqtt();
        break;
    }
}

Here we are only handling the SYSTEM_EVENT_STA_GOT_IP. As soon as we have an IP we can connect to the MQTT broker. In many existing WiFi examples you have a loop which checks if the state of the WiFi is connected.

In software development we call this a “polling loop” which might cost more time (and energy) than necessary. By using a call back we get informed when the system is ready to proceed.

This pattern continues throughout the code: when the device is connected to the MQTT broker we publish the door state. When the message has been successfully sent we tell the device to sleep.

Once you get the hang of it this pattern is very convenient.

Lessons Learned – Energy Consumption

After I had the code running I wanted to make sure, that the door sensor really is as efficient as I expected it to be. I attached the excellent CurrentRanger device to measure the sleep consumption of the device. It turned out that it wasn’t efficient at all!

It consumed sometimes up to 1.5mA in deep sleep! This is about 60 worse than the 25uA I hoped for. So what caused this consumption? I tried many combinations: using the ext1 wakeup component rather than the ext0. Without setting the wakeup at all. Without WiFi. Many combinations used exactly the same high 1.5mA!

After many experiments I finally found this issue on github which suggested to use

adc_power_off();

to power off the adc block before deep sleep. This finally fixed the issue.

Thanks to the CurrentRanger I discovered another problem. The internal pull up resistor consumes about 75uA in deep sleep when the door is closed. When the door is open the device only consumes 25uA in deep sleep.

Because of this I will probably install the sensor in the mailbox so that it triggers when the lid is moved. For this particular application I’m more interested, that there was movement rather than the actual state of the door/lid.

3D Printed Enclosure

Dangling wires above your door frame are not really family friendly. So I designed a simple box which fits all components neatly. The lid and the box have snap-fit design and close without screws. You can download the STL files from thingiverse.

Outlook Part 2

In part one we connected the ESP32 over WiFi to a MQTT broker. Establishing a secure WiFi connection takes a lot of time and costs energy. If we’d like to further improve energy consumption we need to get rid off this costly WiFi handshake. The solution to this is called ESPNow. It is a proprietary protocol using the same hardware and frequencies that the WiFi protocol uses. A device can send a message over ESPNow in the fraction of the time it would take to send the message over regular WiFi.

This is great for battery runtime, but also comes at a cost. In order to use ESPNow your door sensor needs another ESP8266 or ESP32 acting as an access point or gateway for the sensor. This gateway listens for ESPNow messages and forwards them over regular WiFi to your MQTT broker.

Interested? So stay tuned for part 2!

Summary

In this post we built a simple door sensor which can run in theory for a year or more from 3 AAA batteries. This is possible because unlike many other ESP32 development boards the ePulse board consumes very little energy when sleeping. Door sensors are the perfect use case for such a board: in a regular home door states change only a couple of times per day. The rest of the time the device is sleeping.

Fusion 360 is a very powerful tool but if you never worked with a CAD program before it can be overwhelming at times. But with every project you get better and learn how to make your design more robust. A robust design is easy to adapt or extend later on. Parts which interact with each other are updated automatically when changing one feature.

When I started designing the Icon64 enclosure I expected many iterations of designing, printing, fixing, printing… To my big surprise the design worked right from the start. The squire grid fit perfectly into the outer shell, the paper diffusor and the acrylic came out of the laser cutter also with a perfect fit. And the best part was when the snap-fit back component slid into the shell with a satisfying click.

Each of the 3D printed components took about one hour or less to print. The modular design lets you change parts without printing the whole enclosure a second time. So I added a grid to the shell in a second revision and replaced acrylic cover and the diffusor paper with two layers of white PLA.

Electronics – ESP32 & WS2812

Software – Nibbles Demo

Usually I use the Arduino IDE for entry level projects. The Arduino IDE is made for programming beginners, but it also lacks a couple of key features. Very important for me is that others can easily re-create my projects. In the Arduino IDE there is no project file which defines the libraries used in the project. Users have to find the right version for each used library manually and this allows for mistakes

So I decided to use the Platformio IDE for this project. Platformio is a build tool for embedded devices and supports many different build targets. And it uses a project file – the platformio.ini – where you can define all libraries, even with a specific version. The editor is based on Microsoft’s Visual Studio Code and is very comprehensive.

In case you’ve never worked with Platformio before follow the instructions at https://platformio.org/platformio-ide to install it.

I tried to keep the code as simple as possible. My worm is not very clever and constantly collides with its own tail. If that happens the board will be reset and a nibbles is born. The code could be improved with a path finding algorithm. Maybe a nice exercise for you?

Links

• ESP32, e.g. ThingPulse DevBoard, but any ESP32 should do
• WS2812 8×8 RGB Matrix from AliExpress
• 3D Model: Thingiverse
• Code on Github