DFRobot mini MP3 with MicroPython

For an index to all my stories click this text.

Portable MP3 players where once THE thing to have. Now they are getting obsolete because (almost) everyone has a handheld computer (called a smartphone) that is perfectly capable of doing the job. However, sometimes you want a simple music player that does the job. And that's exactly what we are going to build.

DFRobot DFPlayer

DFRobot is an US brand that makes some neat gadgets. And the most well-known is the DFRobot DFPlayer. It is a small MP3 player that has an amplifier on board so you can attach a loudspeker for direct results. The MP3 files are stored on a SD card and therefore there is an SD card reader on board.

The board has an original price of about 5 USD but clones (which are 100% copies) can be bought from our Chinese friends for about 1.50 USD.

In 2019 I wrote a small story on how to use this MP3 player with just two buttons. The functionality was limited. Pressing the first button took you to the next song. The other button switched to the previous song. You can find that story here:
https://lucstechblog.blogspot.com/2019/05/mp3-player-stand-alone.html

In 2022 I revisited the DFRobot MP3 player and wrote a story on how you could control it from a website. That sory attached an ESP8266 or ESP32 to the DFRobot MP3 player. It had however the same limited functionality as the story with the manual control. You can read that story here:
https://lucstechblog.blogspot.com/2019/10/web-controlled-mp3-player.html

More control.

The previous two stories used the DFRobot MP3 player's IO pins to control the player. And they only offer next song, previous song functionality. There are however a lot more possibilities.
To use these extra functions you need to send commands over a serial interface (UART). And that is a lot easier as you think.

There is a nice MicroPython library that makes it possible to control almost all functions of this player. You can find that library here:
https://github.com/lavron/micropython-dfplayermini

If you do not know how to install MicroPython libraries please consider buying one of my books describing the use of Micropython with the Raspberry Pi Pico. You can find them here:

Click here to open a link on Amazon to buy my books

This library offers the following controls:

music.play(x)                            plays track x from the SD card
music.play('next')                    play the next track. If the just played track was the last
                                                       on the SD card the player will play the first track.
music.play('prev')                    Play the previous track. If there is no previous track
                                                       then the player will play the last track on the SD card.
music.stop()                               stops playing music
music.volume(x)                       sets the volume to x where x is a value fom 0 to 40
music.pause()                            stops playing
music.resume()                         starts playing where pause left
music.loop_track(                    store a track number
music.loop()                               keeps repeating the stored track
music.loop_disable()               stops repeating the track
music.fadeout(fadeout_ms)  slowly turns the volume down and stops playing

All these commands must be given over the UART lines.

The DFRobot MP3 player's pins.

The DFRobot MP3 player is a small module with 16 pins. It is breadboard friendly. Let us have a look at the pins we are going to use in this project.

VCC
Obviously this is the power line. The module needs 3.2 till 5V. I supply the power through a separate 5V USB wall plug. The 5V is connected to the module but NOT to the Raspberry Pi Pico.

GND
This is the GND line and is connected to the wall plug and the Pico.

RX
This is the UART receive line and will get connected to the Pico's TX line

TX
This is the UART transmit line and will get connected to the Pico's RX line

SPK_1 and SPK_2
Attach a speaker to these lines for playing the audio. The lines give a mono signal.
The DFRobot Mp3 player has a build-in amplifier and can run a speaker up to 3 Watt.

DAC_R and DAC_L
The DFRobot MP3 player has a build in DAC. We can attach these lines to the left and right entrances of an amplifier.

BUSY
The DFRobot mini MP3 player has a build-in led. That led is on while a sound track is playing. At the same time the BUSY pin gives a low signal. When the sound track finishes the player stops and the line gets high.

The importance of the BUSY line.

If you give the command to play a song (track) then the DFRobot puts the BUSY pin in a LOW state. Then the song finishes and the player stops. The BUSY line will get HIGH. And nothing happens further.

This is often not what we would like to happen. Most of the time we want the player to automatic play the next song.
So what we have to do is to test if the BUSY line gets HIGH and if so send the command music.play('next')

But beware !!!
If you add a stop button and give the command music.stop() the player will stop playing but the BUSY line will get HIGH. So if you do not take care of that the software will immediately send the command music.play("next') and the next track will start playing.
If you intentionally will skip to the next song (track) just press the music.play('next") button.

The same goes for a button that pauses the player. When at pause the Busy line will get HIGH and the software will automatically go on to play the next song. So take care of that in the software if you have a pause and resume button.

The breadboard setup.

I have used two half breadboards but things could easily be build on a full breadboard.

At the top there is a USB plug. In earlier projects I used a breadboard USB adapter to connect a USB power plug to my breadboard. Nowadays I use my own printed USB connector for this. That is not because they are a lot cheaper but because I always seem to miss the breadboard connectors when I need them. The VCC is connected to the DFRobot VCC line but NOT to the Pico. The GND line is connected to the DFRobot GND line and to the Pico's GND line. Here is the link to the story about this and the STL files if you want to print some yourself:
https://lucstechblog.blogspot.com/2025/03/print-your-own-usb-connector.html

Please make sure you do NOT connect the VSS line of the Pico to the VCC of the USB connector. If you do and you power your Pico from your computer you might damage the Pico and your computer beyond repair.

To the left at the top there is a speaker. It is just a speaker so not a computer speaker which has an amplifier in it. You can use earplugs or an headphone if you do not have a speaker at hand.
The speaker is connected to the SPK_1 and SPK_2 pins. So it is a mono signal.

The TX line of the DFRobot mini player is connected to pin GP1 of the Pico which is UART0 pin RX. The RX line of the DFRobot mini player is connected to pin GP0 of the Pico which is UART0 TX. So TX and RX are crossed.

The VCC line of the DFRobot is connected to the USB connector VCC and the GND.

Next there are 5 buttons at the bottom breadboard. Each button has a pull-up resistor of 10K and the first 4 buttons are connected to the Pico's pins 18,19,20 and 21. These are the buttons that choose next song, previous song, volume up and volume down.
The fifth button is connected to the Pico's pin 30 which is the reset button.

Beware of the pins

When I started testing I tought my Pico was broken. I had connected the next song and previous song buttons to the Pico pins 16 and 17. And the most strange things happened. The player would play random songs.

Then it occured to me that those pins are also used as UART0 pins.
So whenever I pushed a button I also gave a pulse on the UART pin of the DFRobot player !!

So when using UART0 you can not use pins GP16, GP17 but also not GP12 and GP13.

You can attach the DFRobot player to UART1 (GP4 and GP5) but then you can not use GP8 and GP9. To do so however you would need to alter the library which I do not recommend.

The MicroPython program

from dfplayermini import Player
from time import sleep
import machine

vol = 20

butnext   = machine.Pin(18, machine.Pin.IN)
butprev   = machine.Pin(19, machine.Pin.IN)
butvolup  = machine.Pin(20, machine.Pin.IN)
butvoldwn = machine.Pin(21, machine.Pin.IN)

busypin = machine.Pin(22, machine.Pin.IN)

txpin = machine.Pin(0)
rxpin = machine.Pin(1, machine.Pin.IN)
music = Player(pin_TX=txpin, pin_RX=rxpin)

sleep(.2)

music.stop()
sleep(.2)

music.volume(vol)
sleep(.2)
music.play(1)
sleep(2)

while True:
    if busypin.value() == 1:
        music.play('next')
        sleep(.2)
    if (butnext.value()==0):
        music.stop()
        sleep(.2)
        print ("next number")
        music.play('next')
        sleep(.2)
    if (butprev.value()==0):
        music.stop()
        sleep(.2)
        print ("previous number")
        music.play('prev')
        sleep(.2)
    if (butvolup.value()==0):
        vol = vol + 1
        print ("Volume : ",vol)
        music.volume(vol)
        sleep(.2)
    if (butvoldwn.value()==0):
        vol = vol - 1
        print ("Volume : ",vol)
        music.volume(vol)
        sleep(.2)

After all the explanation above I do not think this program needs any more explanation.

Not all commands are available. You can add buttons and alter the program to your whishes with the commands described above.

Just one thing:
At the beginning of the program the volume is set to 20. This is a moderate setting. It is set at such a volume that you will not damage your ears when using earphones or a headphone. You can always adjust the volume later with the volume buttons.

Till next time
Have fun

Luc Volders

Automatically mount USB sticks and drives on Raspberry Pi

For an index to all my stories click this text.

I am building several systems for self hosting all kinds of services. That is because I am fed up with a lot of cloud services that just suddenly stop or move away from being a free service and start charging fees. Read my rant about this here : https://lucstechblog.blogspot.com/2026/04/my-rant-against-some-cloud-services.html

The solution is to self-host services. And I am using multiple Raspberry Pi's for that.
And I must say that that feels really satisfying.

USB devices

I use usb memory sticks for storage of some of the files. There is a reason for that: It is easy and quick to remove the usb drive for updating the files on a different machine.

Now if you are running your Pi's with a Desktop mounting USB sticks and drives is painless. 
I am running these Raspberry Pi's headless. Mounting and unmounting USB sticks or drives is a tedious task and I forget it sometimes. When that happens my server obviously doesn't work.

So I was looking for an easy way to mount and unmount USB sticks/drives. And of course there is a great solution available.

pi-usb-automount

pi-usb-automount is simple to use.
Just plug the USB stick or drive in the USB port of your computer and it is automatically mounted as USB0. Add another stick or drive and that will automatically become USB1 etc. The maximum amount of usb devices you can use is 8 (USB0 - USB7).

Installing pi-usb-automount

Before using it we have to install it.

pi-usb-automount is hosted on Github and can be found (inclusive the documentation) here:
https://github.com/fasteddy516/pi-usb-automount

We can download the repositry when GIT is installed on the Raspberry PI. And that is unfortunately standard not the case. So we have to install that first:

sudo apt install git

It does not take long and takes only about 53 MB. So that is no threat for your storage capacity.

When GIT is installed we can download the repositry.

wget https://github.com/fasteddy516/pi-usb-automount/releases/latest/download/pi-usb-automount.deb

And then we can install it with:

sudo dpkg -i pi-usb-automount.deb

That is all.

The USB drives will be mounted on /media/usb0/  /media/usb1/  etc.

Success ????

Let's see if it works.

First let's see what happens if no USB drive is plugged in.

First we point to the USB0 directory with cd /media/USB0/
And then we list the content with LS

AS you can see there is nothing there.

Now plug in a USB stick or drive.

And there it is !!!!!
I used an empty USB stick with just one file on it with the name testfile.txt.

Reboot

Now what happens if we leave the USB stick in the Pi and reboot the system.

And there it already is !!!

This is really the easiest way to mount USB sticks and drives.

Till next time
have fun

Luc Volders

Installing ESPtool with Linux

For an index to all my stories click this text.

As you might know by now I am a fan of MicroPython. The language is mature,loads of libraries are available, and it is easy to use. Installing MicroPython on a Raspberry Pi Pico is a piece of cake and well-documented. However installing MicroPython on an ESP32 while your computer runs Linux is in a different ballpark.

You will need to download the right version of MicroPython for your ESP32 and to install it you need to use a tool called ESPtool.

I am going to show you how it is done.

Get MicroPython

First step is of course to download the language.

With your web-browser visit the MicroPython website at: micropython.org

At the top of the page click the download button which brings you to a webpage where you can choose your microcontroller from a list of vendors or by type.
The ESP32 is made by Espressif so click on that name in the vendor list.

On this page you can choose your model. My most frequent used model is the ESP32 Doit Devkit. This version has the ESP32-Wroom processor on it.



This is the board I am talking about.

This is the actual microcontroller and on the top you can clearly see the type ESP-WROOM-32

So click on this model.

This brings you to the download page.
Unless you need a previous version for a special reason, always choose the latest release.
At the time of this writing that's version V1.25.0
Clicking on this line starts the download which you can (after a very short time) find in your download folder on your harddisk.

When the file is downloaded I transfer it to a new folder on my computer.
For demonstration purposes I made an ESP32 folder in my home directory. You may of course use any folder you like as long as you adjust the path names in this tutorial.

 

So now I have a folder that contains a file with the name ESP32_GENERIC-20250415-v1.25.0.bin. Well that is not really workable. So I altered the name of the file in ESP32-V125.bin.

The path to this file is therefore : ~/ESP32/ESP32-V125.bin

Wrong installation instructions.

To install MicroPython on an ESP32 you need something that is called ESPtool. And you need to install that first on your computer.

Installation instructions I found for Linux were:

sudo apt install esptool

Well that did not work. Oh it installed allright but when I tried to use it sputtered that the file stub_flasher_32.json was missing. I did a lot of searching but to no avail.

Next option is to use pip

pip3 install esptool

Again to no avail. Another error message appeared. This one told me that esptool was not a non-Debian-packaged Python package. And it would not install. Now what ??

The right way.

To install esptool start we need a virtual environment.
Please send me an email if you have no clue on what a virtual environment is and what it is about.

First build your virtual environment.

Open the console and point to your newly created directory. Mine is home/luc/ESP32.
As my new folder is in my home folder I only have to do : cd ESP32

Now in this folder we are going to create a virtual environment. And we are going to give it the name esptoolenv.

The command we use is: python3 -m venv esptoolenv

Make sure to type python3 because the older versions of Python (Python 2) is not installed on recent versions of Linux.

If you open your file explorer you can see that in your ESP32 folder a new folder is created with the name esptoolenv.

The virtual environment is there. Now we need to activate it with :
source esptoolenv/bin/activate

Now we can install esptool with: pip install esptool
This takes just a few seconds.

If you want to deactivate the virtual environment just use: deactivate.
But do not do that now as we need the virtual environment to run esptool.

Install MicroPython.

Now we can install MicroPython.

Before we can install MicroPython we need to know to which USB port the ESP32 is connected. Start with the ESP32 unplugged.

With the ESP32 not plugged in type :
ls /dev/ttyUSB* /dev/ttyACM* 2>/dev/null

As you can see nothing happens. That is because I have no devices attached to my USB ports. Now plug in the ESP32.

And there it is. The ESP32 is plugged in on ttyUSB0

Now we have everything in place.

Let's start with an empty flash.
esptool.py --chip esp32 --port /dev/ttyUSB0 erase_flash
This command erases the ESP's flash memory totally.

And now we can flash MicroPython with the command:
esptool.py --chip esp32 --port /dev/ttyUSB0 --baud 460800 write_flash -z 0x1000 ~/ESP32/ESP32-V125.bin

A quick look at the details:

esptool.py              calls the program
--chip esp32            tells which chip we are flashing
--port /dev/ttyUSB0     the usb port we are using
--baud 460800           The speed we are writing with
write_flash -z 0x1000   the starting memory location
~/ESP32/ESP32-V125.bin  the file we are flashing

Looks quite complicated, but don't worry you will soon get the hang of it.

And there we are.
MicroPython up and running in Thonny.

Till next time
have fun


Luc Volders

NTFY part 2: Send notifications with ESP32 and Pico

For an index to all my stories click this text.

This is the second story about NTFY. The first story showed what NTFY is and how it can send notifications and messages to your Android smartphone from a PC dashboard.

This story shows how you can send notifications from your EP8266 or ESP32 in Arduino language (C++) to your phone, and how you can do that with a Raspberry Pi Pico in MicroPython.

So before you go on I recommend reading the previous story which you can find here: https://lucstechblog.blogspot.com/2026/05/notifications-with-ntfy.html

I'll start with sending a message from the Raspberry Pi Pico as a notification to a smartphone.

For your convenience I hereby give you the link to the NTFY website: https://ntfy.sh/

Limits and solution

First I hope you remember that with the free service NTFY there is a limit of 250 messages per day.
 
The messages remain for 12 hour on the server.
This means that if your phone is off, or has no internet connection, for 13 hours you will miss messages.

There are two solutions for this.
First you can get a paid subscription and then you get a lot more messages each day.
The second solution is to install your own NTFY server. You can do that on a Raspberry Pi (even the humble Zero) and then you can decide how many messages you can send per day  and how long they stay on the server.

Mind you: 250 messages per day is about 10 messages per hour which would be more than sufficient for most projects.

Nevertheless I chose the second solution and installed my own server. Maybe something for another story ........................

Sending a message from MicroPython with a Pico 

(Scroll down for the ESP32 arduino version)

We are going to do this the easy way. We are going to attach a button to the Pico and simulate that it is a door contact. Everytime the button is pressed the Pico will send a notification to the phone.

We are going to send an alarm with the text:

The door opened X times

The X will alter each time we press the button.

Let's start with the breadboard setup which is really easy.



It is just the Raspberry pi pico with a button attached to GP14. The button has a pull up resistor so the value is high (1) until we press the button. Then it gets low (0).

Here is the complete program.

import machine
import network
import urequests as requests
import time

button1 = machine.Pin(14, machine.Pin.IN)
dooropen = 0

# Router credentials
ssid = "YOUR-ROUTERS-NAME"
pw = "YOUR-PASSWORD"
print("Connecting to wifi...")

# wifi connection
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.connect(ssid, pw)

# wait for connection
while not wifi.isconnected():
    pass

print("Connected. IP: ",str(wifi.ifconfig()[0], "\n"))

while True:
    if button1.value() == 0:
        dooropen = dooropen + 1
        sendstring ="The door opened " + str(dooropen) + " times"
        requests.post("http://ntfy.sh/lucstechblog",
        data= sendstring              
        )
        print("Data is send. dooropen = "+str(dooropen))
        time.sleep(3)

Let's have a look at the program in some detail.

import machine
import network
import urequests as requests
import time 

These are the libraries that are needed to get the program running. They are all included in the standard MicroPython distributions. So no need to download libraries.

button1 = machine.Pin(14, machine.Pin.IN)
dooropen = 0

The button is attached to GP14 and defined as a variable with the name button1. An extra variable with the name dooropen is defined. This will be used to count the number of times you press the button.

# Router credentials
ssid = "YOUR-ROUTERS-NAME"
pw = "YOUR-PASSWORD"
print("Connecting to wifi...")

# wifi connection
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.connect(ssid, pw)

# wait for connection
while not wifi.isconnected():
    pass

print("Connected. IP: ",str(wifi.ifconfig()[0], "\n"))

Nothing special here. These are the standard program lines to connect the Pico to your router. Don't forget to replace YOUR-ROUTERS-NAME and YOUR-PASSWORD with the required values for your router.
When the connection is established you will find the Pico's IP number in MicroPython's shell.

while True:
    if button1.value() == 0:
        dooropen = dooropen + 1

The while loop is where the actual action takes place.
First the program tests if the button is pressed. If so then the variable dooropen is increased by 1.

        sendstring ="The door opened " + str(dooropen) + " times"

In this line we prepare the text that is going to be send.
This is the important line. Here you can fill in any information you like to send. If you would add a digital thermometer and put it's value in the variable temp you could alter the text like like this:

        sendstring ="The temperature is now " + str(temp) + " degrees"

On to the next part.

        requests.post("http://ntfy.sh/lucstechblog",
        data= sendstring              
        )

NTFY needs a post request in stead of the get requests which we normally use. We post to the site http://ntfy.sh/ and the topic is lucstechblog.

        print("Data is send. dooropen = "+str(dooropen))
        time.sleep(3)

Next we print a confirmation in the shell and wait a few seconds to make sure the request is send.

That is all.

The result.

Run the program. Press the button.



And this is what you'll see in Thonny's shell.



And here is how I got a notification in the top left corner of my phone's screen. My phone also gave an audio signal to draw my attention to the notification.



This is how the notification appeared on my phone's screen



And this is how it looks in the NTFY app on my phone.

At the same time the message appeared in the PC web version of NTFY.

Sending a message with an ESP32 in Arduino language (C++)

Just like we did with the Pico and MicroPython, we are going to do this the easy way. We are going to attach a button to the ESP32 and everytime the button is pressed the ESP32 will send a notification to the phone.

We are going to send an alarm with the text:

The button attached to the ESP32 was pressed X times.

The X will alter each time we press the button.

Let's start with the breadboard setup which is really easy.



It is just the ESP32 with a button attached to D22. The button has a pull up resistor so the value is high (1) until we press the button. Then it gets low (0).

Here is the complete program.

#include <WiFi.h>
#include <HTTPClient.h>

const char* ssid = "YOUR-ROUTERS-NAME";
const char* password = "PASSWORD";

//Where to send the notification
const char* ntfyurl = "http://ntfy.sh/lucstechblog";

const int buttonPin = 23;
int butpress = 0;

void setup() 
  {
  pinMode(buttonPin, INPUT);  
  
  Serial.begin(115200);

  WiFi.begin(ssid, password);
  Serial.println("Connecting");
  while(WiFi.status() != WL_CONNECTED) 
    {
      delay(500);
      Serial.print(".");
    }
  Serial.println("");
  Serial.print("Connected to WiFi network with IP Address: ");
  Serial.println(WiFi.localIP());
  }

void loop() 
{
    if (digitalRead(buttonPin) == LOW) 
      {
      butpress = butpress + 1;  
      if(WiFi.status()== WL_CONNECTED)
        { 
      WiFiClient client;
      HTTPClient http;
    
      // Your Domain name with URL path or IP address with path
      http.begin(client, ntfyurl);
      http.addHeader("Content-Type", "text/plain");
      
      // Build the text to send with HTTP POST:
      // The button attached to the ESP32 was pressed X times.
      String httpRequestData = "The button attached to the ESP32 was pressed "; 
      httpRequestData = httpRequestData + butpress;
      httpRequestData = httpRequestData + " times";  
      
      // Send HTTP POST request
      int httpResponseCode = http.POST(httpRequestData);
      
      Serial.print("The response we got : ");
      Serial.println(httpResponseCode);
        
      // Close connection
      http.end();

      // Wait before the next round
      delay (3);
        }
      }  
}

Lets look at some details in the program.

#include <WiFi.h>
#include <HTTPClient.h>

const char* ssid = "YOUR-ROUTERS-NAME";
const char* password = "PASSWORD";

//Where to send the notification
const char* nyfyurl = "http://ntfy.sh/lucstechblog";

const int buttonPin = 23;
int butpress = 0;

Nothing special here. The necessary libraries are loaded and The variables are defined. The variable ntfyurl is defined as http://ntfy.sh/lucstechblog which is the address of the NTFY server and the topic.

The setup() has nothing unusual.

The loop() is where the fun begins.

    if (digitalRead(buttonPin) == LOW)
      {
      butpress = butpress + 1;  
      if(WiFi.status()== WL_CONNECTED)
        {
      WiFiClient client;
      HTTPClient http;

The program continually tests if the button is pressed. If so the butpress variable is increased by 1 and the wifi and http clients are activated.

      // Your Domain name with URL path or IP address with path
      http.begin(client, ntfyurl);
      http.addHeader("Content-Type", "text/plain");

The http communication with the NTFY server is started with the previous defined ntfyurl. A header is sent first that identifies the data we are going to send as plain text.

      // Build the text to send with HTTP POST:
      // The button attached to the ESP32 was pressed X times.
      String httpRequestData = "The button attached to the ESP32 was pressed ";
      httpRequestData = httpRequestData + butpress;
      httpRequestData = httpRequestData + " times";

The text "The button attached to the ESP32 was pressed X times." is build here by combining several parts. One of the parts that is added is butpress which is the variable that counts how many times the button was pressed.

      // Send HTTP POST request
      int httpResponseCode = http.POST(httpRequestData);
      
      Serial.print("The response we got : ");
      Serial.println(httpResponseCode);
        
      // Close connection
      http.end();

The request is send as a http POST request with the previous defined httpRequestData. The request receives a response with an indication if it has succeeded. The response is then printed in the serial monitor. After sending the request the connection is closed.

      // Wait before the next round
      delay (3);

The program then waits for 3 seconds. This time can be shortened but a short delay is preferred to prevent detecting a bouncing button as a button press.

It is obvious that this code can easily be adapted to send sensor readings etc. etc. etc.



This is what the Serial Monitor shows. As you can see there are 4 responses with the number 200 that means that the request was received ok.



And here are the notifications I received. As you can see I subscribed to 6 topics. The topics were made just for testing.

Expansion

In this example I use the same topic all the time: lucstechblog. It is of course possible to create multiple topics. So a single Pico or ESP can send notifications to several topics. However you can also have multiple microcontrollers sending data to several topics.

In the above examples we send notifications with just one line of text. You can send notifications with multiple lines of text. The documentation of NTFY shows how to do this. You can find the documentation here: https://docs.ntfy.sh/

Even better: you can attach files to a notification. These can be text files but also pictures !! I have successfully experimented with sending pictures from C++ and from MicroPython. I can see a chat program coming up...........

You can have the Pico's and ESP's send notifications to several NTFY servers.
On the NTFY documents pages there is a list of public NFTY servers. You can find the docs and that list here: https://docs.ntfy.sh/integrations/

You can start your own private server. A Raspberry Pi is sufficient. Even a humble Raspberry Pi Zero will do.
Using your own private server does not expose your topics (if someone finds them) and their data to a general audience. It restricts the information to those you have given the information about the server and it's topics.
On a private server you can expand the lifetime of the messages from 12 hour to any timelimit that suits you. And the number of messages you can send per day can be limitless !!!

Not only can you send notifications but using the right API call you can also get all notifications that have been send with a certain topic from the server. This way you can have two-way conversation between microcontrollers. A microcontroller can retrieve the messages on a certain topic from the server, and can act on that, and then send a notification with the same or a different topic. You do need a private server for this.

If you want a story on sending multiple line notifications, sending a textfile or a picture with the notification, starting your own server on a Raspberry Pi or retrieving notifications from your private server please send me an email.

I can see loads of possibilities with NTFY and therefore already installed my own private server.

Till next time.
Have fun
Luc Volders

Delft Maker fair 2026

 For an index to all my stories click this text

Yesterday 8 may 2026 was the day of the Delft Maker fair.

At the university campus of the Technical University Delft there was a gathering of makers, students, creative minds and loads of visitors.
There were workshops, loads of demonstrations and some novelties.

A 2 meter high contraption with moving eyes, wings and all sorts of other moving parts with a working bubble blowing machine. It was moving around on wheels remote controlled by its maker.

Someone was making lamps from all kinds of vintage products like phones, photocams etc.

A life size build based on the "Theo Jansen "strandbeest". This version did not move on the wind like the original strandbeest but had large motors inside. You could sit on it and move it around with some controls.

3D printing everywhere. And the new hype is of course color printing.

And here is the first one I saw live: the Creality I7 Sparkx
Creality's answer to Bambu. A 4 color 3D printer priced (at this moment) for around 350 USD/Euro. I saw it working and I saw the quality: I want one !!!!!

And a lot of tinkering. Like this antique Singer sewing machine with a motor that drove the sewing part and X and Y Axis that moved the cloth. So you can use it as an embroidery machine. Arduino powered.

There were over 100 stands. There was a hydrogen racing car, a hyperloop, fablabs, cnc machines, laser engravers, workshops, demonstrations and loads more. And of course everywhere Arduino's, ESP32's, Raspberry Pi's and Pico's. Most part of it was outside and the weather was fantastic.

One thing I can not show you here but was really fun was an industrial coffee machine that was insulting everyone who tried to use it.

If you ever have the time to visit a MakerFair I urge you to do so. It gives your creative energy an enormous boost.

Till next time
have fun

Luc Volders