Makerverse Audio Kit Guide | Play Music and Generate Tones

Inside the Makerverse Audio Kit you will find:

• A Makerverse R2R DAC
  • The module that converts a digital signal to an analog voltage
• A Makerverse Electronic Keyboard for Raspberry Pi Pico
  • An array of eight tactile switches
• A Makerverse PAM8302A Class D Audio Amplifier
  • The module that drives power into the speaker
• A Makerverse MicroSD Card Module
  • Allows for connection of a micro SD card to a microcontroller
• A length of lead-free solder
  • For making permanent electrical connections with a soldering iron
• An Enclosed speaker - 45 x 100mm
• A 4GB MicroSD Card with a full-sized SD card adapter

From the Makerverse Essentials Kit you will need:

• The breadboard
• The Raspberry Pi Pico
• Several male-male jumper wires
• The screwdriver

Of the included modules the following soldering assembly is required:

Makerverse R2R DAC

The 14-pin header inserts from the bottom side of the circuit board and is soldered on the top side. The pins on the pin header are held together with a black plastic spacer, be sure to have this on the bottom side of the board, with the shorter pins inserted in the holes.

To aid in soldering a small ball of office putty can be used to hold the module still on your work surface and keep the header aligned square to the PCB while soldering the first joint.

Makerverse Electronics Keyboard for Raspberry Pi Pico

The following order is suggested for assembly of the keyboard module:

1. Gently tighten the nylon screws and standoffs into the two mounting holes. Each screw can be inserted from the top side and held in place with a finger while the standoff is screwed on. Be careful not to over-tighten, as this will damage the screw threads.
2. Insert the 12-pin header from the bottom side and solder it in place. When placed on your workbench the standoffs are approximately the right height to let the header sit square to the PCB, making soldering easier. Again, a lump of office putty can be used to hold the header still during soldering.
3. Insert the eight tactile switches from the top side. These snap into place and sit flush with the circuit board surface. Sometimes the pins are slightly bent and require bending back before they will insert smoothly. Solder all 32 pins.
4. Click on the 8 white button caps for a clean finish and comfortable button feel.

Makerverse PAM8302A Class D Audio Amplifier

Finishing off the assembly list is the audio amplifier module. Start by soldering the 5-pin header, inserting it from the bottom side, then insert the screw terminal from the top side and solder in place.

All of the required parts (including solder!) are included in the kit box while a soldering iron can be purchased separately.

Once the screw terminal is soldered to the amplifier module the speaker can be connected. It is recommended that the stripped wire end is folded over the insulation and the screw terminal clamped down so that the insulation acts as strain relief, reducing the chances that the wire snaps off.

Because there are three modules that require +5.0V the breadboard bus strips will be used to distribute power. 

To provide power to the breadboard bus rails, connect a jumper from the Pico's VBUS pin to the positive supply rail and from a GND pin to the negative supply rail. The adjacent image shows the GND pin near VBUS being used for this purpose.

Although the four bus strips are electrically identical it is strongly recommended that we follow the "red is positive - black is negative" convention.

The Raspberry Pi Pico has a small memory chip on board that is able to store about 5 to 10 seconds of wav file audio, depending on sample rate.

For this example, download pluck.wav (right-click, "Save Link As...") and upload it to the Raspberry Pi Pico with Thonny.

Insert the R2R DAC and PAM8302A amplifier as shown, then run the example code below. You should hear the sound played on the speaker and the code will exit when the whole wav file has finished playing.

The following connections are required for this example:

The code creates a wavPlayer object with a given buffer size. This object will occupy at least this many bytes of RAM. If your project requires a lot of RAM the buffer size can be decreased, but be aware that audio stuttering can occur.

from Makerverse_R2R_DAC import WAV_player # Import the wav file player library
from machine import Pin

# The module will automatically configure a sample rate for each file but keeping the rate constant reduces artifacts.
# buffer can be reduced if your project needs more RAM but audio stuttering may occur.
player = WAV_player(rate=44100, buffer=8192) # Create a wav file player object

player.play("pluck.wav") # Play "pluck.wav". This file path is relative to the Pico's 'root'.

To play long audio files the Pico is going to need some external memory - For that, this kit includes a micro SD card and adapter.

Insert the micro SD card module into the breadboard as shown. To connect it to the Pico the following jumper wire connections need to be made:

Properly converted wav files can then be loaded onto the included micro SD card. The example below assumes that the file sneaky-snitch-by-kevin-macleod-from-filmmusic-io.wav has been saved to the SD card.

If you have converted your own file then the filename will need to be edited in the script on the last line.

from Makerverse_R2R_DAC import WAV_player

player = WAV_player()

player.mountSD(path = '/sd', spi = 0, sck_pin=2, mosi_pin=3, miso_pin=4, cs_pin = 5)

player.play("/sd/sneaky-snitch-by-kevin-macleod-from-filmmusic-io.wav")

Plugging the keyboard into the breadboard as shown and running the code below turns the Audio Kit into a simple musical instrument.

The Makerverse_Keyboard() library is tuned to a C-Major scale, with the "1" key corresponding to a note 1 octave above middle C.

Note that the micro SD card is not used in this example. There is no harm in leaving it connected but it doesn't need to be to make the keyboard work.

from Makerverse_R2R_DAC import keyboard

keyboard = keyboard()

keyboard.play()

A soundboard is an array of buttons that each play a different sound. This example uses the keyboard hardware as the array of buttons and can play up to 8 wav files stored either on the Raspberry Pi Pico or the SD card.

The code below shows the general usage. A list of filenames is passed to the soundboard() method where the first list entry is played when button 1 is pushed, the second when button 2 is pushed, etc.

Five sample sound files are provided in the GitHub repository. These can be downloaded and copied to the Pico directly:

• chirp.wav
• drum.wav
• dtmf.wav
• noise.wav
• pluck.wav

from Makerverse_R2R_DAC import WAV_player

player = WAV_player(buffer=8192)

sounds = ["chirp.wav", "drum.wav", "dtmf.wav", "noise.wav", "pluck.wav"]

while True:
    player.soundboard(sounds)

If the wav files are too large to fit on the Pico's internal memory the micro SD card can be used by first mounting it and appending "/sd/" to the filenames:

from Makerverse_R2R_DAC import WAV_player

player = WAV_player(buffer=8192)

player.mountSD(path = '/sd', spi = 0, sck_pin=2, mosi_pin=3, miso_pin=4, cs_pin = 5)

sounds = ["/sd/chirp.wav", "/sd/drum.wav", "/sd/dtmf.wav", "/sd/noise.wav", "/sd/pluck.wav"]

while True:
    player.soundboard(sounds)