An easy-to-use music player for children based on the Raspberry Pi Zero and the JBL On Stage IIIp

In spring 2016 I finalized the "Musikrakete", an MP3 player that our boys could operate without assistance. This is the improved second version, which is even easier to use. Music is played by simply placing a QR code card on top of the sphere. It plays MP3 files from the local network or Google drive and audiostreams from the Internet. If you have children who love music, ever used a terminal and also know what end of a soldering iron not to touch, this might be a project for you.

The Idea

This project started about a year ago, when Anica asked me if buying a hörbert MP3 player would be a good idea. At the time our boys wasted two to three CDs every week, trying to get some music out of the small player in their room. And the player in the living room also seemed to reach its end of life pretty soon due to their enthusiasm. Still I wasn't too sure about this hörbert thing. In order to get new files on the SD card of the player, the case had to be opened, the navigation with 11 buttons also seemed a little confusing and a single speaker operated with four batteries also did not seem promising to me.

I had seen a project description of an MP3 player for small children shortly before: A Raspberry Pi mini computer, connected to a webcam and speakers, reads QR codes and plays the respective track or playlist. So this was what I suggested and to my surprise it was considered a better solution right away. And I had a project.

As good as the project description seemed to be, I wanted to make some improvements on the original design: The player should detect the QR automatically, it should have buttons for play/pause and skipping and all components should be put together in a single case. Most importantly, the MP3 files should be delivered directly from our home server. No SD card replacement needed.

Since we had an old JBL OnStage IIIp speaker lying around that wasn't used anymore due to its outdated iPhone dock connector, I decided to use this as a base. After playing around with Onshape, soldering and programming for three months, I had the Musikrakete ready by end of March 2016. It's been a huge success with the boys and has been in heavy use ever since.

But there were still some open ends on the technical side and I knew that we might need a second player, once the boys each have a room of their own. So when Anica was searching for a good gift to her best friend's sons we decided that an updated version would be a good idea.

PiPlayer 2.0: AudioSphere

The major improvement in handling was switching from a QR card slot to a window on top where the QR cards are placed on. I had seen that especially the two-year-old had problems getting the cards into the narrow slot. Unfortunately, this also meant that a rocket shape was not an option anymore. At first I tried to put only a hemisphere on top of the JBL speaker which would make it look like a UFO. But the webcam needed at least 8 cm distance to the card in order have the entire QR code covered. Technically, it would be possible to further reduce the size of the ball but fitting all the components in there is hard enough as it is.

Since we had problems with the Wi-Fi connection in the boy's room an ethernet port is now also available and thanks to switching to the Raspberry Pi Zero, the Apple dock port can power all the components. No additonal power source needed anymore. By incorporating a Pimoroni PHAT DAC I removed all the audio-related headaches. (You can order one together with the RasPi Zero as a kit.)

On the software side there's two major improvements: The SD card is now mounted read-only by default. This makes unplugging the AudioSphere by accident or for reboot unproblematic. And the Python script that operates the player now uses interrupts instead of polling for checking the input sources - no more busy waiting! You can find the entire documentation including the central Python script in the GitHub repository.

OK, so much for the overview - let's build this, step by step.

Parts list

This is everything we'll need:

3D Printed Case

First step was the design of the new case. Like the first rocket case it's public, you can find it here on Onshape. (You will need to create an account to open the document.) Or you can download the STL files for printing if you are using the very same components. Please note that you will need to rotate the top of the sphere 180° for printing. Also be careful about the Raspberry holder: The Raspberry Pi together with the PHAT DAC should have a height of 7.2 mm (or less) which depends on the GPIO header that is used to solder the PHAT DAC to the RasPi. If the height exeeds that, the distance needs to be adjusted before printing.

System Installation on the Raspberry Pi Zero

Update and Basic Setup

Before installing anything additionally, Raspbian Lite has to be set up on the SD card. When the card is ready, it is necessary to at least once connect a monitor and a keyboard to the RasPi for the initial setup since SSH is disabled by default. As soon as SSH is enabled and Wi-Fi is configured, we can remove all the cables and continue to work remotely over SSH.

From here on it's basically entering line by line to your terminal (and later on it's copy-and-paste via SSH). You might need to confirm or close something every now and then. Where a configuration file has to be edited, the contents that go to the file are also put in comments with a leading tab. The links are the references for the individual steps.

# Make sure that the latest versions are installed (this might take some time) (https://www.raspberrypi.org/documentation/raspbian/updating.md)
sudo apt update
sudo apt dist-upgrade

# Basic setup: change the password, set the keyboard layout, Wi-Fi channels and hostname and enable SSH
sudo raspi-config

# Check kernel messages for errors

# Check for connected USB devices

# If not done yet, plug in the Wi-Fi adapter and reboot
sudo reboot

Configure Wi-Fi

# Scan networks and add Wi-Fi network to configuration (https://www.raspberrypi.org/documentation/configuration/wireless/wireless-cli.md)
# (Close nano after editing with Ctrl-X)
sudo iwlist wlan0 scan
sudo nano /etc/wpa_supplicant/wpa_supplicant.conf
#	network={
#		ssid="The_ESSID_from_earlier"
#		psk="Your_wifi_password"
#	}

# Restart Wi-Fi
sudo ifdown wlan0
sudo ifup wlan0

# Check if Wi-Fi is connected
ifconfig wlan0

# Turn off
sudo shutdown -h now

Remotely Finish the Setup

From here on you can connect via SSH over Wi-Fi. Unplug monitor, keyboard and the ethernet cable. It might also be helpful to configure a static IP for the Wi-Fi adapter in your router before continuing. Then restart the RasPi, connect via SSH from a different computer and go on with the setup procedure.

# Now that remote connection is available, disable HDMI (http://www.jeffgeerling.com/blogs/jeff-geerling/raspberry-pi-zero-conserve-energy)
# (This line has to go *before* "exit 0" at the end of the file)
sudo nano /etc/rc.local
#	# disable HDMI
#	/usr/bin/tvservice -o

# Add this to config.txt to disable the ACT LED
sudo nano /boot/config.txt
#	dtparam=act_led_trigger=none
#	dtparam=act_led_activelow=off

# Configure NTP
sudo apt install ntp
sudo nano /etc/ntp.conf
# add time server to /etc/ntp.conf (line 16)
#	server de.pool.ntp.org
sudo /etc/init.d/ntp restart

# Turn off
sudo shutdown -h now

Now that the RasPi is ready, the next step is setting up all the other hardware components: The speaker, the case and the electronics.

Preparing the JBL IIIp Speaker

In order to drill the holes for the screws, the speaker has to be disassembled. The procedure is described here at ifixit.com for the predecessor which works basically the same way: Remove the rubber pads, then remove all screws from the case. (Don't forget the center screw in the battery case.) Once the speaker case is opened, the circuit board is unscrewed and removed.

I drilled the holes for the M3 screws and the IR LED cable using a template. The drill itself is set to rotate left. That way, the holes are more or less melted into the plastic to lower the risk of breaking the case.

After drilling, washers and screws are added and the infrared LED is glued directly in front of the speaker's IR sensor in order to send it commands. Before that the PINs of the IR LED are soldered to cables that are long enough to connect it to the circuit board through one of the additional holes. Also, all the electronics should be tested together before anything is hot-glued into the case.

(Disclaimer: Until now, I only did a proof of concept test script for remote contolling the speaker via the IR LED. I am planning on using that component later on via a web app but for the time being you could as well leave it out.)


When the speaker has been put back together, we can go for the circuit board. There are four electronic parts: The optical sensor that triggers the QR recognition, the LED that illuminates the QR card, the infrared LED which we already glued in front of the sensor and the 3 buttons that are used to pause/unpause playback and move within the current playlist. While the buttons and the LEDs are put directly in the case, all other elements are brought together on a circuit board from where they are connected to the RasPi via jumper cables. So this is what we're aiming for:

Assembling the circuit is pretty straight forward. Be careful about the optical sensor, though: There are two versions out there, one from Vishay and one from TEMIC that has the detector transistor upside down compared to the other one. Also note that I used a LED that can operate directly on the RasPi's 3.3 V without a series resistor. If you use a smaller one (which should also be sufficient for illumination), you will need one.

After soldering the PHAT DAC onto the Raspberri Pi (preferably using a GPIO header that directly routes through all the GPIOs) the used PINs are connected with the jumper cables.

Once everything is connected together, it can be put in the case for the software installation and final adjustments. All components are connected but wait using the glue gun until everything is tested thoroughly. Especially the webcam might need some in-place live adjustment. Depending on the glossyness of your code cards, the angle of the illumination LED might be relevant as well. The easiest way to do this is by connecting the webcam to another computer while it is already in the case (see bash history below).

What's missing in the pictures is how to get a screw thread behind the holes in the case: Use super glue to put three M3 nuts on washers (in order to enlarge the surface). When dried, use the super glue again to attach these nuts-on-washers behind the screw holes of the case. (Use the screws to adjust them so you can turn them in and out. I used UHU Super Strong and Safe which gives you some time for corrections after applying.) Et voilà, you now got yourself screw holes with threads on the player's case.


Install and Configure Additional Packages and the Python Script

Now configure the additional software that is needed for the player. Before doing that, copy the contents of the piplayer2 directory (including subdirectories sounds and test) to /home/pi (either directly on the SD card or via SCP). Have also one of the test cards from the template ready for testing the QR recognition.

# Install additional software
sudo apt install lirc zbar-tools mc moc fswebcam python3 python-rpi.gpio python3-rpi.gpio

# As a first test turn the LED on and off
python3 ~/test/lighton.py
python3 ~/test/lightoff.py

# We can also test the buttons and the sensor (Press buttons to retrieve their ID, hold a card
# on the sensor to see if it switches from 'LOW' to 'HIGH')
# (Stop the scripts with Ctrl-C)
python3 ~/test/buttons.py
python3 ~/test/sensor.py

# Configure PHAT DAC (https://learn.pimoroni.com/tutorial/phat/raspberry-pi-phat-dac-install)
curl -sS get.pimoroni.com/phatdac | bash

# Check for errors

# Plug in headphones or JBL connector cable, start mocp and test audio output via the PHAT DAC. (Don't forget to turn on the speaker!)
mocp -S
mocp -l ~/sounds/scanning.mp3
mocp -x

# Determine the webcam's USB ID and the available resolutions (http://askubuntu.com/questions/214977/how-can-i-find-out-the-supported-webcam-resolutions)
# (The USB ID "001:006" in the second line has to be replaced with the actual ID of the camera)
lsusb -s 001:006 -v | egrep "Width|Height"

# Webcam test: turn on the LED, take a photo and turn the LED off
# (The focus of the webcam should be adjusted to the window distance beforehand on another computer with a live picture)
python3 ~/test/lighton.py
sudo fswebcam -r 320x240 -d /dev/video0 -v ~/webcam-test.jpg
python3 ~/test/lightoff.py

# Copy ~/webcam-test.jpg to another computer and have a look at it
# If needed, adjust the webcam and repeat the step until the QR code recognition is reliable

# QR-Test: Hold a QR code card above the webcam then turn on the LED, decode the QR code and turn the LED off
# (Stop scanning for codes with Ctrl-C)
python3 ~/test/lighton.py
zbarcam --quiet --nodisplay --raw -Sdisable -Sqrcode.enable --prescale=320x240 /dev/video0
python3 ~/test/lightoff.py

## From here on it's about the configuration of the infrared sender - currently this is not used

# Enable lirc in /boot/config.txt and add parameters
sudo nano /boot/config.txt
#	# Uncomment this to enable the lirc-rpi module
#	dtoverlay=lirc-rpi,gpio_in_pin=23,gpio_out_pin=22

# adapt lirc configuration in /etc/lirc/hardware.conf
sudo nano /etc/lirc/hardware.conf
#	LIRCD_ARGS="--uinput"
#	DRIVER="default"
#	DEVICE="/dev/lirc0"
#	MODULES="lirc_rpi"

sudo reboot

# Copy the contents of the JBL remote configuration to /etc/lirc/lircd.conf then restart lircd
sudo /etc/init.d/lirc restart

# Turn on music, list available commands and test remote control
mocp -S && mocp -l ~/sounds/scanning.mp3
sudo lircd -d /dev/lirc0
irsend LIST JBLIIIP ""
## Apparently the commands have to be sent two times in order to be recognized. I might need to
## improve the lirc configuration. As stated above, this is still work in progress.
# mute
# unmute

When everything works as expected, all the electronic parts are fixed together using hot glue. I glued the webcam, the circuit board and the USB hub in the case so that nothing will fall out of place anymore, even if the player is moved around roughly.

While I really like hot glue, it's got its limits: I thought I could skip soldering the buttons to their wires by just twirling the cable ends to the contacts and then fix everything down with the hot pistol - bad idea. While being hot, the glue gets in between the wire ends and the contacts and perfectly isolates them. None of the buttons worked anymore. I had to peel the glue off the contacts with a cutter knife before soldering them properly back on again...

Configure Autostart and Mount SD Card in Read-Only Mode

Now that everything is in place, we are ready for the final adjustments: Configure autostart for the player script and mount the SD card in read-only mode which makes the player robust against sudden loss of power. For that, we redirect the write access to a RAM disk.

# Autostart for piplayer2.py with log output redirection (http://raspberrypi.stackexchange.com/questions/8169/run-startup-application-as-a-specific-user)
sudo nano /etc/rc.local
#	...
#	su pi -c 'python3 /home/pi/piplayer2.py >> /home/pi/piplayer2.log 2>&1 &'
#	exit 0

sudo reboot

# Check if running after restart
ps -ef | grep python

# Watch the log output while testing with QR code cards
tail -f /home/pi/piplayer2.log

# Switch to RAM disk and set the filesystem read-only (https://www.heise.de/ct/ausgabe/2016-21-Den-Raspi-als-Bluetooth-Empfaenger-einsetzen-3330683.html)
sudo nano /etc/fstab
#	proc            /proc            proc    defaults                      0       0
#	/dev/mmcblk0p1  /boot            vfat    defaults,ro                   0       2
#	/dev/mmcblk0p2  /                ext4    defaults,noatime,ro           0       1
#	tmpfs           /var/log         tmpfs   nodev,nosuid                  0       0
#	tmpfs           /var/tmp         tmpfs   nodev,nosuid,mode=1777        0       0
#	tmpfs           /tmp             tmpfs   nodev,nosuid,mode=1777        0       0
#	tmpfs           /home/pi/.config tmpfs   nodev,nosuid,mode=1777,uid=pi 0       0
#	tmpfs           /home/pi/.moc    tmpfs   nodev,nosuid,mode=1777,uid=pi 0       0
#	# a swapfile is not a swap partition, no line here
#	#   use  dphys-swapfile swap[on|off]  for that

sudo rm -rf /var/lib/dhcp/ /var/spool /var/lock /etc/resolv.conf
sudo ln -s /tmp /var/lib/dhcp
sudo ln -s /tmp /var/spool
sudo ln -s /tmp /var/lock
sudo ln -s /tmp/resolv.conf /etc/resolv.conf

# Make /tmp on RAM disk writable
# Shown here with the former additions to rc.local - please note that the log redirect for the player script changed
sudo nano /etc/rc.local
#	...
#	# make /tmp on RAM disk writable
#	chmod 777 /tmp
#	# disable HDMI
#	/usr/bin/tvservice -o
#	# start piplayer
#	su pi -c 'python3 /home/pi/piplayer2.py >> /tmp/piplayer2.log 2>&1 &'
#	exit 0

sudo reboot

Test if it is read-only now:

# This should produce an ERROR
touch ~/wontwork

We can make the filesystem writeable again until next reboot for maintenance by remounting it like this:

sudo mount -o rw,remount /
sudo mount -o rw,remount /boot

Connect to SMB network share

Until now, we can only play local files from the SD card (and audiostreams from the Internet). The final step is to connect the local share that stores all of our MP3 files. How this is done depends upon the type of share you would like to use. The most common type should be a Windows/SMB share in the local network that can be connected like this:

# Make SD writable
sudo mount -o rw,remount /
sudo mount -o rw,remount /boot

# Create mount point
mkdir /home/pi/share

# Connect smb share on /home/pi/share
sudo nano /etc/rc.local
#	sudo mount -t cifs -o user=guest,password= // /home/pi/share

Of course, one might as well mount a cloud drive via WebDAV or something similar and play everything directly from the Internet. How this is done will depend on the supported protocols.

QR Cards

With the storage attached, all the MP3 files are accessible for the player. What's missing is some QR code cards to get the party started. For that, there's a template which can be used to create new cards. After printing a page from the template, it is simply cut into stripes which are folded in the middle and then glued together.

For generating the QR codes pretty much every software can be used. If you are using lots of non-ASCII letters, you should make sure that they are encoded properly. (You can always check the codes that have been read by the player in the logfile with tail -f /tmp/piplayer2.log.) Personally, I use QtQR which is a frontend for qrencode.

What's Left

In the future I would like to have a web server running on the RasPi, which allows to control the player remotely. I'm not yet sure if this is going to be a web interface or an Android app that operates on a REST interface. I pretty often find myself skipping through the entire code card stack in the dark in order to switch to a different bedtime story that has been requested.

Also, I would like to have the last say in volume control. This is where the infrared LED that has been installed in the speaker case will come in handy.

If you have any questions or improvements please send me an e-mail to tliero@gmx.net.