{"id":20950,"date":"2021-03-21T10:42:51","date_gmt":"2021-03-21T09:42:51","guid":{"rendered":"https:\/\/www.recantha.co.uk\/blog\/?p=20950"},"modified":"2021-03-21T10:42:51","modified_gmt":"2021-03-21T09:42:51","slug":"playing-sounds-from-the-raspberry-pi-pico-using-circuitpython-a-journey-of-discovery","status":"publish","type":"post","link":"https:\/\/www.recantha.co.uk\/blog\/?p=20950","title":{"rendered":"Playing sounds from the Raspberry Pi Pico using CircuitPython – a journey of discovery"},"content":{"rendered":"

\"\"<\/p>\n

As you probably know by now, I’m not a microcontroller expert. However, with the advent of microcontrollers that use MicroPython and CircuitPython, I am a lot more comfortable using them now than I used to be! However, because the Raspberry Pi Pico is new, there aren’t a\u00a0lot<\/em> of practical examples of how to do things out there. There is excellent documentation<\/a>, of course, but when you’re trying to do something specific, or something that hasn’t been thought of, it can be a voyage of discovery.<\/p>\n

TL;DR<\/h2>\n

Scroll down to “Playing a WAV file” for the code that works and “Finding the Hardware” for a wiring diagram.<\/p>\n

The project<\/h2>\n

I am currently working on a new version of my long-running Picorder<\/a> project, my version of the classic Star Trek prop, the Tricorder<\/a>. Whereas in the past I’ve used exclusively regular Raspberry Pi (with an occasional foray into Arduino to get analog inputs) as the brains, this time I am choosing to use the Pico. A PicoPicorder, if you will. One thing I’ve never done before is to reproduce the sounds made when the device is opened and scanning.<\/p>\n

Finding the sound effect<\/h2>\n

My first job was to find the sound that I wanted to play. This was easy. TrekCore has a whole host of sound effects from the Star Trek series<\/a>. I picked the one I wanted (this one<\/a>) and downloaded it. I knew straight away that the full file was too long (and large), so I converted it, using Audacity<\/a>, into a WAV file, squashed it into a mono sample and chopped most of it away, leaving me with a self-contained, much shorter, loopable sound effect<\/a>.<\/p>\n

How to play it<\/h2>\n

Now… how to play it. To start with, I looked at creating my own circuit and using PWM Audio. This post from Greg Chadwick<\/a> indicated that I could do just that. However, it was, excuse me, a bit beyond me. It also used C\/C++ as a programming language. I had already decided that, for this project, I would use Adafruit’s CircuitPython derivative of MicroPython<\/a>. There were a lot of libraries, it is, basically, Python (which I can already use to a certain extent, thanks to the CamJam EduKits and all the other tutorials that are available), and it is extensively documented.<\/p>\n

However, that blog post, and some previously-read Pico documentation, pointed me to needing to use I2S audio, which is how audio (DAC) boards work with the Raspberry Pi. This would give me high enough quality audio to play my sound effect and give me a bit of familiarity (which I always think is key to understanding how to do something).<\/p>\n

The Raspberry Pi Pico and I2S<\/h2>\n

However (again), from my past reading I knew that the Pico\u00a0does not have I2S pins<\/em> in the same way that the regular Pi does. Some microcontrollers do have that built-in, but the Pico does not. I also knew that, in order to give functionality to the Pico that it does not have, you use PIO (Programmable Input\/Output)<\/a>. (If you want to know about how to understand PIO even more, there’s this excellent article<\/a>).\u00a0It’s actually quite difficult to find “how to’s” on the Raspberry Pi website for PIO… in fact, I completely failed, so you will have to root around a bit.<\/em><\/p>\n

First of all, I discovered this example from the Raspberry Pi GitHub repository<\/a> that showed what PIO code you needed in order to accomplish that. However, because it’s written in C\/C++ and is targeted at the SDK method of programming the Pico, rather than CircuitPython, it rather blew my mind. This is the important part, the PIO code:<\/p>\n

.program audio_i2s\r\n.side_set 2\r\n\r\n    ; \/--- LRCLK\r\n    ; |\/-- BCLK\r\nbitloop1: ; ||\r\n    out pins, 1 side 0b10\r\n    jmp x-- bitloop1 side 0b11\r\n    out pins, 1 side 0b00\r\n    set x, 14 side 0b01\r\n\r\nbitloop0:\r\n    out pins, 1 side 0b00\r\n    jmp x-- bitloop0 side 0b01\r\n    out pins, 1 side 0b10\r\npublic entry_point:\r\n    set x, 14 side 0b11<\/pre>\n
Complete gibberish, am I right? It was at this point that I almost gave up. 0b10? jmp? It’s assembly language, I thought, for the particular implementation on the Pico. Fair enough, but I have no idea what it all means. However, did that mean that I couldn’t\u00a0use<\/em> it? I had seen an example in MicroPython for using PIO inside Python<\/a> (thanks Alister!) itself, but not CircuitPython.<\/p>\n
I thought I’d step back and approach things a different way.<\/p>\n
Finding the hardware<\/h2>\n
I weighed up the amount of problem-solving skills I had and, rather stupidly, assumed that I would<\/em> be able to get I2S working, somehow.<\/p>\n
If I could get I2S working, then I knew I would need a DAC and an amplifier to output the sound from the Pico. I came across this tutorial over on the Adafruit site<\/a> for using the MAX98357 I2S mono amp<\/a> which combined an I2S amp and a DAC on the same board. Ideal. It only outputs to one speaker but, for this project, one small speaker is all I need. I found the breakout on The Pi Hut’s site<\/a> and they were kind enough to send it to me with some other bits for review purposes.<\/p>\n
Looking more at the tutorial<\/a> on Adafruit, I came across the CircuitPython wiring test. This shows how to hook up the MAX board to a microcontroller with I2S pins. To my dismay, the code example did not cover the PIO part. Okay, I thought, we can smash that bit and the other bit together somehow.<\/p>\n
The MAX board arrived the next day and I wired it up. Here’s my wiring (thank you Adafruit and Fritzing for the software and parts library!):<\/p>\n
\"\"<\/p>\n
Now that was done, PIO was the next step. Or so I thought.<\/p>\n
Using PIO in CircuitPython and the Adafruit Discord server<\/h2>\n
By this point, I knew I was going to need some extra help. Adafruit has, amazingly, created a Discord channel<\/a> for discussion of their products and, Hallelujah, CircuitPython. There was even a special channel for PIO. I joined and then realised how active the channels all were – awesome, so much expertise\u00a0and<\/em> experience.<\/p>\n
From suggestions received there, I came across this tutorial on the Adafruit site for using PIO in CircuitPython<\/a>, so I finally knew that what I was trying to do was possible. Somebody then pointed this example out to me that uses PIOASM (PIO assembler) to create audio on the Pico using CircuitPython<\/a>.<\/p>\n
Wanting to know how things work<\/h2>\n
At this point, I lost several hours trying to combine things together before realising that I ought to start from first principles.<\/p>\n
Returning to the example from earlier<\/a> which shows the PIOASM example to create audio in CircuitPython. All the example does is to create the necessary PIO code, assemble it, and then use it to play a sine wave.<\/p>\n
To my surprise, once I’d got the pins sorted out, it crashed. I got the following error which others might get, so here it is:<\/p>\n
Traceback (most recent call last):\r\nFile \"code.py\", line 40, in <module> File \"adafruit_pioasm.py\",\r\nline 65, in assemble IndexError: list index out of range<\/pre>\n
Hmmm. Vexing, that.<\/p>\n
I had come across this video, a “Deep Dive” with Scott, who works on CircuitPython for Adafruit:<\/p>\n