{"id":20904,"date":"2021-03-07T18:15:46","date_gmt":"2021-03-07T17:15:46","guid":{"rendered":"https:\/\/www.recantha.co.uk\/blog\/?p=20904"},"modified":"2021-03-09T14:46:15","modified_gmt":"2021-03-09T13:46:15","slug":"modifying-an-adafruit-circuitpython-library-to-support-the-pimoroni-11x7-led-matrix-breakout-on-the-raspberry-pi-pico","status":"publish","type":"post","link":"https:\/\/www.recantha.co.uk\/blog\/?p=20904","title":{"rendered":"Modifying an Adafruit CircuitPython library to support the Pimoroni 11×7 LED Matrix Breakout on the Raspberry Pi Pico"},"content":{"rendered":"

\"\"<\/p>\n

At the moment, I am trying to combine several different products – sensors, displays – into a project for the Raspberry Pi Pico. One of them is the Breakout Garden 11×7 Matrix from Pimoroni<\/a>. I’ve chosen to use CircuitPython as there are a\u00a0lot<\/em> of libraries available from Adafruit. One of those available is the IS31FL3731<\/a> library which supports a variety of products (use the link to see which ones)\u00a0but<\/strong> not the one I needed it to. I decided to see how difficult it was to add support for the 11×7 Matrix to it. Here is what I did to do just that.<\/p>\n

Addendum<\/strong><\/p>\n

I’ve since been told (by David Glaude) that there are easier ways to do this (such as doing a library in regular, non-compiled Python). Of course, I obviously didn’t find this way, and I think that compiling to .mpy saves some space on the Pico. There’s also a pre-compiled version of mpy-cross for Windows that avoids all the Ubuntu\/WSL stuff. However, having a Linux shell available on Windows does give me other advantages, so “swings-and-roundabouts”…<\/em><\/p>\n

MPY files<\/h2>\n

The first thing I realised was that the library files provided by Adafruit<\/a> are pre-built as .mpy files – compiled Python. So, I would need to figure out how to build from the source Python .py file into .mpy. Fortunately, being the nice people they are, Adafruit provide the source code file<\/a> so that it is modifiable. So… How do I build everything?<\/p>\n

Windows Subsystem for Linux<\/h2>\n

I’m using Windows at the moment (for better or worse) so there are some hoops to jump through! I found this thread on a Forum<\/a> which contained some hints and mentioned something called the WSL – the Windows Subsystem for Linux – which gives you a Linux terminal prompt and lets you do things in a “Linux-y” way.<\/p>\n

Adafruit provides instructions for installing the WSL here<\/a> (which I won’t duplicate, but suffice to say, you use Windows Features to add it and then install the Ubuntu app through the Windows Store). Once I’d installed that and set-up a username for myself, I saw a typical Ubuntu terminal screen.<\/p>\n

Then, I needed to install some build tools into the WSL. Again, Adafruit provides instructions for installing these<\/a>. The “meat” of this is as follows (I added the pip3 install as it wasn’t there):<\/p>\n

sudo apt update<\/span>\r\n# Try running `make` at the command line. If it's not installed, do:<\/span>\r\n# sudo apt install build-essential<\/span>\r\nsudo apt install git<\/span>\r\nsudo apt install gettext\r\n<\/span>sudo apt install python3-pip\r\npip3 install huffman<\/span><\/pre>\n
ARM gcc toolchain<\/h2>\n
I also needed the “ARM gcc toolchain” (which I think<\/em> is the bits and pieces needed to compile for an ARM processor). I’m going to be using the latest CircuitPython firmware (which is hovering around v6.2 beta-3) so I needed the 10-2020-q4-major version<\/a>. Now, I should probably have used curl or wget to get the file straight into WSL, but I didn’t, so it was then downloaded to my Windows Downloads folder.<\/p>\n
However… the WSL mounts my C drive in \/mnt, so first I moved the file to the C drive, then copied the file into the Linux area by using:<\/p>\n
mkdir ~\/bin\r\ncp \/mnt\/c\/<filename> ~\/bin\/<\/pre>\n
This created a bin folder in my home folder and then copied <filename> into it. To unpack the file I did this:<\/p>\n
cd ~\/bin\r\ntar xvf <filename><\/pre>\n
I now needed to add the path to my ~\/.bash_profile file.<\/p>\n
This is easier said than done if you’re not used to Linux. Hopefully, you are because you’re reading a Raspberry Pi blog! If you’re not, take a look at using the Nano editor as I don’t want to go into that here.<\/p>\n
I got the bin folder path from the folder that I just unpacked. This will be something like…<\/p>\n
\/home\/<user>\/bin\/gcc-arm-none-eabi-10-2020-q4-major\/bin<\/pre>\n
I copied that to my clipboard, then edited the ~\/.bash_profile file (which was a new file for me – make sure you include the full stop if you’re replicating) and added the following line (which you’ll need to change to match your own path).<\/p>\n
export PATH=\/home\/recantha\/bin\/gcc-arm-none-eabi-10-2020-q4-major\/bin:$PATH<\/pre>\n
I logged out from the terminal (CTRL-D normally does it) and then opened the Ubuntu terminal again to type:<\/p>\n
which arm-none-eabi-gcc<\/pre>\n
This returned a path (as opposed to an empty line). If you’re following me and it returns an empty line, you’ve done something wrong and you should retrace your steps. You probably did the export command wrong in .bash_profile or you didn’t logout and log back in again!<\/p>\n
I made sure I was in my home directory before going any further by typing:<\/p>\n
cd ~<\/pre>\n
Building the compiler<\/h2>\n
I now needed to build the mpy-cross compiler. This is described in this tutorial from Adafruit<\/a>. In short:<\/p>\n
git clone https<\/span>:\/\/<\/span>github<\/span>.<\/span>com<\/span>\/<\/span>adafruit<\/span>\/<\/span>circuitpython<\/span>.<\/span>git<\/span>\r\ncd circuitpython<\/span>\r\ngit submodule sync <\/span>--<\/span>quiet <\/span>--<\/span>recursive<\/span>\r\ngit submodule update <\/span>--<\/span>init<\/span>\r\nmake <\/span>-<\/span>C mpy<\/span>-<\/span>cross<\/span><\/pre>\n
I\u00a0didn’t<\/em> build CircuitPython itself because I have no need to compile my own CircuitPython firmware (yet!). The last step (building mpy-cross) took a little while.<\/p>\n
Compiling py to mpy<\/h2>\n
The next thing to do was to compile a .py file into .mpy just to see if it worked. To do this, I needed to know the path to the mpy-cross executable. This was, in my case: ~\/circuitpython\/mpy-cross\/mpy-cross<\/p>\n
I decided to fork from the Adafruit library<\/a> to my own repository. That way, if I wanted to, I could then do a pull request to Adafruit to incorporate the new code. Whether I do this or not depends on me being brave! \ud83d\ude42 So, I clicked the fork button and replicated the code to my own repo<\/a>.<\/p>\n
The next thing to do was to get that repository into the WSL environment on my Windows machine. I did this by:<\/p>\n
git clone https:\/\/github.com\/recantha\/Adafruit_CircuitPython_IS31FL3731<\/pre>\n
I then went into the directory that I had cloned and used mpy-cross to compile the Python file into .mpy:<\/p>\n
cd Adafruit_CircuitPython_IS31FL3731\r\n~\/circuitpython\/mpy-cross\/mpy-cross adafruit_is31fl3731.py<\/pre>\n
To my surprise, it worked without errors!<\/p>\n
Connecting the Pico to WSL<\/h2>\n
Now, how do I get that library file onto the Pico. I could, of course, copy it from the Linux area back into the C: drive and do it that way, but there was an easier method.<\/p>\n
First of all, I identified that my Pico was mounted onto Windows using E:.<\/p>\n
So, I did the following to create a “mount point” and then mounted the Pico (the E drive) to it:<\/p>\n
sudo mkdir \/mnt\/e\r\nsudo mount -t drvfs E: \/mnt\/e\r\nls \/mnt\/e<\/pre>\n
This last command should<\/em> list the files on the E: drive (one of which\u00a0should<\/em>, if you’ve already uploaded code to the Pico, be code.py).<\/p>\n
I knew I needed to put the mpy file into the lib folder on the Pico, so I did this:<\/p>\n
cp ~\/Adafruit_CircuitPython_IS31FL3731\/adafruit_is31fl3731.mpy \/mnt\/e\/lib\/<\/pre>\n
Running the code<\/h2>\n
I had (and still have) no idea how to use WSL as a programming environment for the Pico, so I swapped back to Windows and ran Mu. I uploaded my program to the Pico which used the IS31* library. I received the same “Unsupported operation” error that I got earlier, so all good so far. Now… let’s see about modifying that code…<\/p>\n
Side note<\/h2>\n
Okay, so what actually happened is that Mu stopped showing me the REPL. So I had to download the PuTTY<\/a> terminal software package and connect to it separately to see the output…<\/em><\/p>\n
Now, back to our scheduled programme…<\/em><\/p>\n
Getting some output<\/h2>\n
So, what does “Unsupported operation” actually mean? Well, I guessed that as I was running the following on the Pico:<\/p>\n
i2c = busio.I2C(scl=board.GP21, sda=board.GP20, frequency=100000)\r\ndisplay = adafruit_is31fl3731.Matrix(i2c)<\/pre>\n
and getting that error around the following line:<\/p>\n
File \"adafruit_is31fl3731.py\", line 102, in _i2c_write_reg<\/pre>\n
… that I was attempting to write over I2C to something I couldn’t. So, let’s look at the Matrix code… The Matrix code uses I2C address 0x74 as its default. This is wrong. On the back of the 11×7 module, it says:<\/p>\n
\"\"<\/p>\n
…0x75 or 0x77. Now, I haven’t altered the board by cutting the trace at the top-right, so we’re going to assume it’s the 0x75 address. This is different, obviously, to the default that the library is using, so the error appears to be that I’m trying to write to an I2C address that isn’t there. Fair enough. Inside the library code, it looks like the Matrix class init() function accepts an address parameter, so let’s try using that and see what we get…<\/p>\n
display = adafruit_is31fl3731.Matrix(i2c, address=0x75)<\/pre>\n
I saved it and this time I received no error message. Excellent. Now, I know that the Matrix class has a hardcoded width of 16 and height of 9, and this is, of course, different to the Breakout Garden module’s 11×7 dimensions. So, we will<\/em> have problems with getting the pixels in the right place, but let’s add to the CircuitPython code on the Pico the following:<\/p>\n
display.fill(127)<\/pre>\n
This ought to display a solid colour… Save it… Check the REPL (using PuTTY, now – see above). Ta-da!<\/p>\n
\"\"<\/p>\n
It worked! Excellent. Now, to try and get some text scrolling across…<\/p>\n
Unfortunately, the examples from Adafruit<\/a> for scrolling text and displaying images require PIL (Python Image Library). I read somewhere that PIL doesn’t work in CircuitPython, just in normal Python. Umm… Okay, let’s leave that for now.<\/p>\n
I decided, instead, to just try looping through each pixel in order as a test. This is where knowing a little bit about the Pimoroni product and where they keep their code comes in handy.<\/p>\n
Looking at the Pimoroni library<\/h2>\n
The Pimoroni init() function for their 11×7 matrix is here<\/a>. Now, this is written in normal Python, not CircuitPython, not even MicroPython, so I’ve tried to do a halfway house between their code and the Adafruit library.<\/p>\n
I did a bit of looking around and found that the existing CircuitPython library supports the Scroll pHAT HD<\/a>. This is 17×7, so not far off. So, I started with that function, copied it and pasted it back into the Adafruit library, changing the class name to Matrix11x7. I also added a new __init__() function that would set the 0x75 address by default.<\/p>\n
Now, to re-compile using myp-cross again and upload… All good so far.<\/p>\n
I then changed the CircuitPython code on the Pico to use Matrix11x7():<\/p>\n
display = adafruit_is31fl3731.Matrix11x7(i2c)<\/pre>\n
It worked again – this must mean that it is using my new, modified library code! Exciting!<\/p>\n
Getting the Matrix right<\/h2>\n
I added some Pico code to display pixels one at a time:<\/p>\n
for y in range(7):\r\n    for x in range(11):\r\n        display.pixel(x, y, 100)\r\n        time.sleep(0.1)\r\n        display.fill(0)<\/pre>\n
What this code\u00a0should<\/em> do is to put a single pixel on the display, left to right, bottom to top and do it for every LED on the display. As you can see…<\/p>\n