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

For the latest version of the LilyGO TTGO T-Camera ESP32 the manufacturer made a couple of significant changes. The switched the ESP32-WROVER module with the ESP32 chip, flash and PSRAM are also separately soldered and the module got a “3D antenna”. But I had to deal with a bigger problem at first. LilyGO also replaced the CP2102 chip with the WCH CH9102 UART chip. My Mac OS X 11.5.2 Big Sur installation recognized the chip immediately as

crw-rw-rw-  1 root  wheel   22,  14 Aug 29 08:24 /dev/tty.usbmodemXXXXXXXXXX
crw-rw-rw-  1 root  wheel   22,  15 Aug 29 08:24 /dev/cu.usbmodemXXXXXXXXXX

I changed the lines in my platformio.ini file and used the cu.usbmodemXXXXXXXXXX (actual numbers replaced with XXX). Monitoring seemed to work since I could see the output from the stock firmware.

But every time I tried to flash the chip I got the following output:

Connecting....
Chip is ESP32-D0WD (revision 1)
Features: WiFi, BT, Dual Core, 240MHz, VRef calibration in efuse, Coding Scheme None
Crystal is 40MHz
MAC: 3c:71:bf:xx:xx:xx
Uploading stub...

A fatal error occurred: Failed to write to target RAM (result was 01070000)

I first suspected that the esptool needed adaptation for the new chip. There were also a couple of issues on github in the esptool repository: https://github.com/espressif/esptool/issues/280

The Solution

Or might the driver be the problem? The website of the CP2102 manufacturer also did not show a new driver for the chip. After more digging, I finally came across this github issue and genotix’ post: https://github.com/Xinyuan-LilyGO/LilyGo-T-Call-SIM800/issues/139#issuecomment-904390716

Genotix links a zip file containing a driver aptly named CH34xVCPDriver_signed.pkg The CH34x driver seems also to work for the CH9102 chip. Now you have to be brave and install the driver by ignoring all Max OS X security warnings and by clicking through installation dialogs in Chinese.

After the installation two new serial devices showed up:

crw-rw-rw-  1 root  wheel   22,  12 Aug 29 08:24 /dev/tty.wchusbseriaXXXX
crw-rw-rw-  1 root  wheel   22,  14 Aug 29 08:24 /dev/tty.usbmodemXXXX
crw-rw-rw-  1 root  wheel   22,  15 Aug 29 08:24 /dev/cu.usbmodemXXXX
crw-rw-rw-  1 root  wheel   22,  13 Aug 29 08:34 /dev/cu.wchusbserialXXXX<--correct

By using the cu.wchusberialXXXX I finally could program the T-Camera module.

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!

I have connected devices to TheThingsNetwork before but with this device I had several challenges: no useful example project, TTN just switched to the new V3 version and bad documentation about the hardware. After the first failure I assumed that the TTGO-LoRa32 was to weak to send data to the next gateway. Since my own TTN indoor gateway was still registered for V2 I started to migrate it first. That was another bad experience. The gateway did not connect to TTN V3 and I reclaimed it several times without success. Only after waiting one night it finally worked and I had a gateway connected to TTN v3.

So now that I knew that I had a gateway close enough to receive the TTGO-LoRa32′ data package I could concentrate on fixing the code.

Prepare the Code

In this project, I’m using platformio in Visual Studio Code for editing and uploading the firmware. As a first step get the code from my github repository https://github.com/squix78/TTGO-LoRa32-V1.0-TTN-OTAA either by cloning it with git or by downloading the code as zip file and extracting it.

This project should work as it is except for a few changes we have to do in the code. The most obscure change is buried deep in the library folder in a file called lmic_project_config.h. The full path to the file is
.pio/libdeps/ttgo-lora32-v1/MCCI LoRaWAN LMIC library/project_config/lmic_project_config.h
If you can’t find this file you probably have to compile the project first, since only then all the dependencies will be downloaded. Please note: at the moment the compilation will fail, since we didn’t set the credentials in the code yet. This is expected and normal.

Once you find that file make sure that the correct region settings are there. For Europe 868MHz band it should like this:

// project-specific definitions
#define CFG_eu868 1
//#define CFG_us915 1
//#define CFG_au915 1
//#define CFG_as923 1
// #define LMIC_COUNTRY_CODE LMIC_COUNTRY_CODE_JP	/* for as923-JP */
//#define CFG_kr920 1
//#define CFG_in866 1
#define CFG_sx1276_radio 1
//#define LMIC_USE_INTERRUPTS

By default the code uses CFG_us915. If you are living in another region it is very important you do that change!

Getting the app and device credentials

This was the first device I set up for TTN V3 and there are a couple of traps I want to point out to you. A quick explanation for the TTN novice: Your device needs three credentials to connect to TTN: AppEUI, DevEUI and AppKey. In TTNs V2 interface you could either provide the DevEUI or it would create them for you. In TTN V3 this auto EUI generation is currently missing. For many devices the vendor will provide these identifiers and you just have to enter them in the TTN console. But with devices such as the TTGO-LoRa32 you don’t get it. I show you here how to create it by yourself. This is not ideal but works… Just don’t blame me in case of problems…

1. Head over to https://console.cloud.thethings.network/ and pick your V3 region. Don’t use the V2!
2. Create an account if you don’t have one yet.
3. Go to applications and create a new application. As application id you can pick anything as long as
   1. it doesn’t exist yet
   2. only contains letters, dashes and numbers
4. On the next screen click on “Add end device” (see image below)

5. Now go the “Manually” tab and choose “Over the air activation (OTAA)” and MAC V1.0.2
6. On the next screen choose a name for your device consisting only of letters, numbers and dashes. To fill in the JoinEUI and DevEUI you can use this generator: https://descartes.co.uk/CreateEUIKey.html
7. On the next screen choose your region and the following settings:

8. On the Join settings screen you can click on the “recycle” symbol to generate an AppKey for you.
9. Now we have to copy the credentials over to our code. We have to provide JoinEUI and DevEUI in least significat byte order or short LSB. The TTN console helps you with that. First click on the “<>” icon and then on the arrows beside “msb”. To put the data into the clipboard use the most right icon. BTW: The name of JoinEUI is AppEUI in the code. Please add the AppKey msb order, no need to invert the order there.

10. After copying JoinEUI (AppEUI), DevEUI and AppKey to the main.cpp file in the code you got from github you can compile and upload the firmware to the TTGO-LoRa32
11. Now check if it worked by looking at the device live data on the TTN console:

Summary & Outlook

This is it! If everything worked you your TTGO-LoRa32 is now sending messages to TTN V3, joining it with dynamic session keys! If I find the time I’d like to analyze the power consumption of the device for sending a message as well as in the sleep phase.

My code is not using the OLED display. There is a repository provided by LillyGo that shows you how to do that: https://github.com/LilyGO/TTGO-LORA32/tree/LilyGO-868-V1.0

If you like to support my blog please consider buying the device by using this affiliate link: https://www.banggood.com/custlink/vmDdBjpESq

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!

Note: In the video I say that Shelly 3EM maker Alterco is Hungarian, but they are Bulgarian. I’m really sorry about this mistake!

Links:

• Shelly 3EM by Alterco