The photo above is a plugboard that contains a Raspberry Pi Pico 2 connected to an OLED display, an 8×16 LED Matrix Feather, and a four line by twenty column LCD backlit character display. The OLED display and the 8×16 LED Matrix Feather were purchased from Adafruit (links below), while the LCD character display came from a collection of parts given to me when their owner passed away back in 2023. Barely visible is a single white LED in the upper left corner. It has a long orange wire connecting it to pin 29 (GPIO22) on the Pico 2.

The highly simplified schematic only shows direct connections. Those direct connections are the LCD display and the single LED. There’s a STEMMA QT connector off to the very left which is used, with proper cabling, to electrically connect the OLED and 8×16 LED matrix feather to the Pico 2. I chose to go this route because it keeps the schematic simple and easy to put into a blog post.

Right now I have the RISC-V version of MicroPython 1.24.1 flashed onto the Pico 2. My code behaves exactly on the RISC-V cores as it does on the ARM Cortex M33 cores, which I find amazing. I’m working with the RISC-V cores because I don’t have a use case for using the M33 cores, especially their security features. I’m not quite the fan of ARM I used to be. If there’s any opportunity where I can use and support RISC-V-based devices then I will, and this is one of those opportunities.

Links

• MicroPython code — https://github.com/wbeebe/MicroPythonProjects/tree/main/RPi/RP2-EC93
• 8×16 LED Matrix Feather Red — https://www.adafruit.com/product/3152
• Monochrome 0.96″ 128×64 OLED Graphic — https://www.adafruit.com/product/326

I have been experimenting with a pair of Raspberry Pi 2 boards and another pair of Raspberry Pi 2 W boards. I’ll write about the non-WiFi boards later; I wanted to document what I had to do in order to get a pre-release version of MicroPython to program on one of my Pico 2 W boards.

This is the link to download the unofficial MicroPython UF2 file directly from Raspberry Pi itself: https://downloads.raspberrypi.com/micropython/mp_firmware_unofficial_latest.uf2

I don’t know how long this link will be valid. I got the unofficial firmware up and running with my test code. Here’s a typical output where the WiFi subsystem is being tested.

  MACHINE: Raspberry Pi Pico 2 W with RP2350  RELEASE: 1.25.0-preview FS TOTAL: 3,145,728 BYTES FS  FREE: 3,092,480 BYTES FS  USED: 53,248 BYTES MEM FREE: 448,160 BYTES  UID: 5C7E378630646F97 SSID: RP2-6F97 CPU FREQ: 150,000,000 Hz  I2C: SoftI2C(scl=5, sda=4, freq=500000)  I2C: DEVICES FOUND: ['0x3d']  I2C: FOUND OLEDMicroPython 1.25.0 previewGCC 10.3.12024-11-21ssid: BASIC-NET-2.4rssi: -58ssid: Dashmeister  rssi: -89ssid: ESP32S3-7814 rssi: -29ssid: SmartLife-EEFB   rssi: -74MicroPython v1.25.0-preview.49.g0625f07ad.dirty on 2024-11-21; Raspberry Pi Pico 2 W with RP2350Type "help()" for more information.

My test code shows that the WiFi subsystem is working as far as scanning for other access points in and near where I live. I’ll be working later to do something a bit more sophisticated. Be advised that this is for the ARM cores only, there is nothing out yet for the RISC-V cores like there is for the Pico 2 without WiFi.

MPY: soft rebootMemory: 8,308,816 MB Flash: 8,388,608 MB  Platform: MicroPython 1.24.0 preview xtensa IDFv5.2.3 Unique ID: 68B6B33D7814  SSID: ESP32S3-7814 CPU Clock: 160,000,000 Hz   I2C: SoftI2C(scl=2, sda=1, freq=500000)   I2C: Devices found: ['0x3d']   I2C: SSD1306 OLED FoundA fatal error occurred. The crash dump printed below may be used to helpdetermine what caused it. If you are not already running the most recentversion of MicroPython, consider upgrading. New versions often fix bugs.To learn more about how to debug and/or report this crash visit the wikipage at: https://github.com/micropython/micropython/wiki/ESP32-debuggingMPY version : v1.19.1-2669.g17d823445.dirty on 2024-09-27IDF version : v5.2.3Machine : Generic ESP32S3 module with Octal-SPIRAM with ESP32S3Guru Meditation Error: Core  1 panic'ed (LoadProhibited). Exception was unhandled.Core  1 register dump:PC  : 0x4005544b  PS  : 0x00060830  A0  : 0x82007cc1  A1  : 0x3fcbb590  A2  : 0x00000000  A3  : 0x3c131a50  A4  : 0x00000000  A5  : 0x3fcbb5e4  A6  : 0x00000000  A7  : 0x00000001  A8  : 0x82008a70  A9  : 0x3fcbb540  A10 : 0x00000000  A11 : 0x3fca4184  A12 : 0x00000001  A13 : 0xffffffff  A14 : 0x00000000  A15 : 0x3fca41ac  SAR : 0x00000016  EXCCAUSE: 0x0000001c  EXCVADDR: 0x00000000  LBEG: 0x400570e8  LEND: 0x400570f3  LCOUNT  : 0x00000000  Backtrace: 0x40055448:0x3fcbb590 0x42007cbe:0x3fcbb5a0 0x4200837e:0x3fcbb5e0 0x4200dcbe:0x3fcbb610 0x42015279:0x3fcbb630 0x42015341:0x3fcbb650 0x40378e76:0x3fcbb670 0x4200ddc7:0x3fcbb710 0x42015279:0x3fcbb780 0x42015341:0x3fcbb7a0 0x40378e76:0x3fcbb7c0 0x4200ddc7:0x3fcbb860 0x42015279:0x3fcbb8b0 0x4201528e:0x3fcbb8d0 0x42022fef:0x3fcbb8f0 0x42023347:0x3fcbb980 0x42006922:0x3fcbb9b0

Lines 3 through 11 are output by my software. Line 14 is where the crash dump starts. All the output text my software prints comes from a single file, boot.py, which is the first file that is always executed. The next file to be executed is main.py, which is where the NeoPixel is exercised (it displays six colors then turns off). The last thing main.py does is instantiate an instance of my web server, then kick it off. I suspect that the crash has something to do with the built-in WiFi radio.

At this point I’ve simply dropped back from 5.2.3 to 5.2.2, recompiled MicroPython, re-flashed my board, and get it running happily again, just like it was doing before I tried to step up to the latest ESP-IDF release.

I have no idea why it’s crashing, and I have no desire to go looking. Since there’s nothing special in version 5.2.3 that I just have to have, I’ll stick with version 5.2.2 for building MicroPython, and version 5.3.1 for writing C++ for the Espressif chips. Be advised that ESP-IDF 5.2.3, at least for the ESP32-S3 in this circumstance, has a critical internal problem.

This is an interesting time for Python development. Python continues it’s upward popularity increase, while the Python language developers keep pushing the Python interpreter to be more performant with each release. In particular, with the imminent release of version 3.13.0, the developers are now disabling the global interpreter lock, or GIL, for efficient concurrency. Building Python betas and release candidates has become something of a ritual for me. With the addition of the 512 GiB NVMe SSD on my Raspberry Pi 5, I decided to build Python 3.13.0 release candidate 1 on my Raspberry Pi 5 under Ubuntu 24.04.

I documented the build process flow in an earlier post (see in the link section below). I’m going to highlight one key step in that process flow, the installation of build support libraries.

sudo apt install zlib1g-dev \ libncurses5-dev \ libgdbm-dev \ libnss3-dev \ libssl-dev \ libreadline-dev \ libffi-dev \ libsqlite3-dev \ libbz2-dev \ tk \ tk-dev \ liblzma-dev \ libgdbm-compat-dev \ libmpdec-dev 

Everything succeeded except the attempt to install libmpdec-dev. You need that library to support Big Number math in Python. In every release before 3.13 that support was internal. However, starting with 3.13 and later, that support is now via libmpdec-dev. Every one of those support packages installed successfully in Linux Mint 21.3, which is based on Ubuntu 22.04. But it doesn’t work on Ubuntu 24.04 on a Raspberry Pi 5. In the end I had to locate, download and manually install the individual deb files:

sudo apt install ./libmpdec3_2.5.1-1_arm64.debsudo apt install ./libmpdec-dev_2.5.1-1_arm64.deb

Those two deb files satisfy the libmpdec-dev requirement. After that I executed the following to configure the Python 3.13 build:

../Python-3.13.0rc1/configure --enable-optimizations --disable-gil

Once built I installed according to the step documented in the linked post below.

Then I gave it a whirl. The first thing I did after installing it was to create a Python 3.13 virtual environment and then pip install luma.led-matrix. That supports silly clock. When I activated the Python 3.13 virtual environment and ran silly_clock.py, the following was emitted by Python 3.13 in the terminal window:

<frozen importlib._bootstrap>:488: RuntimeWarning: The global interpreter lock (GIL) has been enabled to load module 'PIL._imaging', which has not declared that it can run safely without the GIL. To override this behavior and keep the GIL disabled (at your own risk), run with PYTHON_GIL=0 or -Xgil=0.

That’s going to be an interesting problem going forward, as there’s a ton of legacy Python code that will more than likely trigger that RuntimeWarning.

Note

In order to successfully install luma.led-matrix in a Python virtual environment on a Raspberry Pi 5 under Ubuntu 24.04, you will need to install yet another support library, libpng-dev.

Links

building python 3.13.0 beta 1 on linux mint 21.3

I continued working with Linux Mint 22 beta today, changing the icons and setting up Python to my personal tastes. Here are a few interesting discoveries so far.

• I tried to install Papirus Icon Theme only to discover it’s already there. I then went into Configure, Themes and changed the application icons to Papirus.
• Python 3.12.3 is installed by default. That’s great. The version on LM 22β is only one minor point release behind official 3.12.4 Python. I did install the package python-is-python3 to be able to use bare python at the command line instead of python3. It’s time to move on from not having this as part of the default distribution. The only reason this was added was to support systems and users who had Python 2 still on their systems. Well, folks, Python 2 was sunset 1 January 2020, four-and-a-half years ago. It really is time to move on.
• I needed to install pip with the apt package python3-pip because pip isn’t part of the default installation. Why?
• My first attempt to install a Python package via pip produced that damned “This is an EXTERNALLY MANAGED” Python message. Who the hell thinks they can externally managed my personal system? I didn’t give anyone permission to do that. In any event I deleted the file /usr/lib/python3.12/EXTERNALLY-MANAGED, then installed the Python packages I wanted and needed. You know what pip did? It issued a message saying it installed the packages locally because I didn’t have rights to the global site-packages, which is what it should do. And I want those Python packages local, because when you install a Python package globally that’s broken then it causes all sorts of grief.
• Speaking of broken Python global packages, powerline-status is broken in the Linux Mint base install, and has been for some time. You need to use sudo to pip uninstall poweline-status from the system site-package directory, then pip install poweline-status (no sudo!) to get a working copy locally installed. The correct and up-to-date powerline-status package will be installed down $HOME/.local/lib/python3.12/site-packages/powerline, and underneath that you’ll find bindings/fish/poweline-setup.fish (or bash/powerline-setup.sh for bash) that you can then source when an instance of your shell starts.

Before somebody in the peanut gallery pipes up that Linux is too hard, fine, it’s too hard for you. I live in Linux (and Unix) and can think of no other environment that’s any better, not even macOS, and certainly not Windows. I have written this ad nauseum but a bad day with Linux is far better than a good day with Windows, and as far as I’m concerned, there are no bad days with Linux unless I personally, royally, fucked up a Linux installation. And I have done that on occasion. Just read the second link below. But at least with Linux I could correct my royal fuck ups.

I haven’t seen anything at all in the beta I would consider a show stopper, or even a regular aggravation. The problems and issues I’ve encountered are easily overcome. I just wish I could get a version that ran on the Raspberry Pi 5.

Links

my linux mint 22 beta local installation

i did a very stupid thing and broke my linux mint graphical desktop

Not much to report from the last time I built beta 2, but for my own memory here’s how I configured it before I built it.

../Python-3.13.0b3/configure --enable-optimizations --disable-gil --enable-experimental-jit

I have yet to try out either GIL-less testing (which would require I come up with some sort of concurrency test) as well as how having a JIT in Python might help things along, although I am working on some non-trivial performance testing between 3.12.4 and 3.13 beta.

The last time I wrote about this, I mused how I was going to move from CircuitPython to MicroPython, especially in support of devices. Turns out that the Raspberry Pi Foundation has published quite a bit of information about how to manipulate every feature on the Raspberry Pi Pico. So while I was reading The Raspberry Pi Pico Python SDK, I discovered all sorts of interesting ways to use MicroPython to interact with the Pico, and the Pico W, and thus with external devices. I also discovered that the Python SDK is copyright from 2022 to 2024; the last publish, or “build” date, was 2 May 2024 of this year. So the Python SDK is reasonably up-to-date, far more so than many of the other web posts that attempt to show how to utilize the Pico and Pico W with various external devices.

The photo above shows the same two devices I used in the first post, a Pico W connected to an SSD1306 OLED display sold by Adafruit. This time, I’ve added code to display a pair of Raspberry Pi logos, one for each core on the RP-2040 microcontroller. This is very similar to what the Linux kernel shows on a Raspberry Pi when it’s initially booting, or else it did back in the day. I don’t see that happening with Ubuntu 24.04 for the Raspberry Pi 5.

I’m listing the code again, with one warning. I copied a bit of code out of the Python SDK, the code that set up the bitmap for the Raspberry Pi logo. If you try to copy from that example in the Python SDK you’ll be short a byte because when they converted the bitmap to a bytearray string, they converted the binary to both hex representations and printable characters. One of those characters was a space (0x20), which when published to PDF was used as a wrap point in the text, and thus lost in translation as it were. I had to go look at similar code on GitHub and copy it from there. I’ll include a link to that below, after the code.

But here’s the code as it currently exists now.

print()import gcprint(f" MEM FREE: {gc.mem_free():,} BYTES")import osUNAME = os.uname().sysname.upper()stat_vfs = os.statvfs('/')print(f" FS TOTAL: {stat_vfs[0] * stat_vfs[2]:,} BYTES")print(f" FS  FREE: {stat_vfs[0] * stat_vfs[3]:,} BYTES")import platformprint(f" PLATFORM: {platform.platform()}")import binasciiimport machine as maUNIQUE_ID = binascii.hexlify(ma.unique_id()).decode('ascii').upper()print(f"  UID: {UNIQUE_ID}")SSID = UNAME + '-' + UNIQUE_ID[-4:]print(f" SSID: {SSID}")print(f" CPU FREQ: {ma.freq():,} Hz")# Scan I2C bus for devices## I2C pins for Raspberry Pi Pico W, device I2C1#SDA_PIN = 26SCL_PIN = 27SOFT_I2C = ma.SoftI2C(scl=ma.Pin(SCL_PIN), sda=ma.Pin(SDA_PIN))print(f"  I2C: {SOFT_I2C}")i2c_scanned = SOFT_I2C.scan()if len(i2c_scanned) == 0:print("  I2C: No Devices Found")else:print("  I2C: DEVICES FOUND:", [hex(device_address)for device_address in i2c_scanned])# Check if there is an SSD1306 display attached.#import SSD1306import framebufif SSD1306.OLED_ADDR in i2c_scanned:print("  I2C: SSD1306 OLED")## Create instance of SSD1306 class to control the display.# Initialize it by clearing everything.#display = SSD1306.SSD1306_I2C(SOFT_I2C)display.fill(0)## Create a graphic of the Raspberry Pi logo.# Display it twice, one logo for each RP2040 core, similar to what# the regular Raspberry Pi does on initial boot.# I copied the bytearray for the logo from Raspberry Pi itself:# https://github.com/raspberrypi/pico-micropython-examples/tree/master/i2c#buffer = bytearray(b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7C\x3F\x00\x01\x86\x40\x80\x01\x01\x80\x80\x01\x11\x88\x80\x01\x05\xa0\x80\x00\x83\xc1\x00\x00C\xe3\x00\x00\x7e\xfc\x00\x00\x4c\x27\x00\x00\x9c\x11\x00\x00\xbf\xfd\x00\x00\xe1\x87\x00\x01\xc1\x83\x80\x02A\x82@\x02A\x82@\x02\xc1\xc2@\x02\xf6>\xc0\x01\xfc=\x80\x01\x18\x18\x80\x01\x88\x10\x80\x00\x8c!\x00\x00\x87\xf1\x00\x00\x7f\xf6\x00\x008\x1c\x00\x00\x0c\x20\x00\x00\x03\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")raspberry_pi_logo = framebuf.FrameBuffer(buffer, 32, 32, framebuf.MONO_HLSB)display.framebuf.blit(raspberry_pi_logo, 0, 33)display.framebuf.blit(raspberry_pi_logo, 33, 33)## Display the official MicroPython logo#display.framebuf.fill_rect(0, 0, 32, 32, 1)display.framebuf.fill_rect(2, 2, 28, 28, 0)display.framebuf.vline(9, 8, 22, 1)display.framebuf.vline(16, 2, 22, 1)display.framebuf.vline(23, 8, 22, 1)display.framebuf.fill_rect(26, 24, 2, 4, 1)## Print some identifying text with the graphics, such as version and# the identifying string of the Raspberry Pi Pico.#display.text('MicroPython', 40, 0, 1)display.text('-'.join(platform.platform().split('-')[1:3]), 40, 12, 1)display.text(SSID, 40, 24, 1)display.show()print()try:import networkwifi = network.WLAN(network.STA_IF)wifi.active(True)access_points = wifi.scan()networks = {}for network in access_points:if len(network[0]) > 0 and bytearray(network[0])[0] != 0:ssid = network[0].decode('utf-8')networks[ssid] = network[3]for ssid in sorted(networks.keys()):print(f"ssid: {ssid:24} rssi: {networks[ssid]}")except:print("  NETWORK: NO WIFI ON DEVICE")print()

Links

1. Raspberry Pi Pico Python SDK — https://datasheets.raspberrypi.com/pico/raspberry-pi-pico-python-sdk.pdf
2. Using a SSD1306-based OLED graphics display — https://github.com/raspberrypi/pico-micropython-examples/tree/master/i2c/1306oled

I’ve made a personal decision to move away from using Adafruit’s CircuitPython to using the original upstream MicroPython implementation. The reason is the stability of the MicroPython implementation vs the CircuitPython implementation. I find, for my uses, that MicroPython is more stable for embedded unattended operation than CircuitPython is. The developer ecosystem seems to be richer for CircuitPython, but for long term development I’m willing to write anew or modify what already exists for my needs if the underlying embedded Python implementation, MicroPython in my case, is stable enough.

Another feature that MicroPython has that CircuitPython doesn’t is the ability to get a microcontroller’s unique ID. I use that characteristic extensively because I need it for embedded devices that are part of a larger wireless fleet of devices to help manage them all. For just one example I use the last four characters of the unique ID to synthesis an SSID for devices that will be part of my local home WiFi network. You can see an example in the photo above, in the third line of text (RP2-9633).

While a lot has been made of flashing a Raspberry Pi Pico/W with CircuitPython, flashing with MicroPython is very easy, as it’s the same with either. Make sure you have the UF2 file for MicroPython, then with the device unplugged, hold down the BOOTSEL button, plug in the USB cable, then release the BOOTSEL button. The Raspberry Pi Pico will come up in bootloader mode looking like a flash drive, allowing you to drag and drop the MicroPython UF2 file onto the device. Once flashed, the Pico will disappear from your file system, and you’ll need a tool such as Thonny to communicate with, and program the device.

MPY: soft reboot MEM FREE: 183,584 BYTES FS TOTAL: 868,352 BYTES FS  FREE: 847,872 BYTES PLATFORM: MicroPython-1.23.0-arm--with-newlib4.3.0  UID: E6614C775B969633 SSID: RP2-9633 CPU FREQ: 125,000,000 Hz  I2C: SoftI2C(scl=27, sda=26, freq=500000)  I2C: DEVICES FOUND: ['0x3d']ssid: Dashmeister  rssi: -82ssid: ESP32S3-5F50 rssi: -21ssid: GuestNetwork rssi: -61ssid: NETGEAR04rssi: -90ssid: NotTheWiFiYoureLookingFor rssi: -91ssid: SmartLife-EEFB   rssi: -68MicroPython v1.23.0 on 2024-06-02; Raspberry Pi Pico W with RP2040Type "help()" for more information.

What follows is the code running on this particular Raspberry Pi Pico W. It is in two parts, the main followed by the OLED display class.

print()import gcprint(f" MEM FREE: {gc.mem_free():,} BYTES")import osUNAME = os.uname().sysname.upper()stat_vfs = os.statvfs('/')print(f" FS TOTAL: {stat_vfs[0] * stat_vfs[2]:,} BYTES")print(f" FS  FREE: {stat_vfs[0] * stat_vfs[3]:,} BYTES")import platformprint(f" PLATFORM: {platform.platform()}")import binasciiimport machine as maUNIQUE_ID = binascii.hexlify(ma.unique_id()).decode('ascii').upper()print(f"  UID: {UNIQUE_ID}")SSID = UNAME + '-' + UNIQUE_ID[-4:]print(f" SSID: {SSID}")print(f" CPU FREQ: {ma.freq():,} Hz")# Scan I2C bus for devices## I2C pins for Raspberry Pi Pico W, device I2C1import SSD1306SDA_PIN = 26SCL_PIN = 27SOFT_I2C = ma.SoftI2C(scl=ma.Pin(SCL_PIN), sda=ma.Pin(SDA_PIN))print(f"  I2C: {SOFT_I2C}")print("  I2C: DEVICES FOUND:", [hex(device_address)for device_address in SOFT_I2C.scan()])# Display the Micropython logo on the SSD1306 OLED display.#display = SSD1306.SSD1306_I2C(SOFT_I2C)display.fill(0)display.framebuf.fill_rect(0, 0, 32, 32, 1)display.framebuf.fill_rect(2, 2, 28, 28, 0)display.framebuf.vline(9, 8, 22, 1)display.framebuf.vline(16, 2, 22, 1)display.framebuf.vline(23, 8, 22, 1)display.framebuf.fill_rect(26, 24, 2, 4, 1)display.text('MicroPython', 40, 0, 1)display.text('-'.join(platform.platform().split('-')[1:3]), 40, 12, 1)display.text(SSID, 40, 24, 1)display.show()print()import networkwifi = network.WLAN(network.STA_IF)wifi.active(True)access_points = wifi.scan()networks = {}for network in access_points:if len(network[0]) > 0 and bytearray(network[0])[0] != 0:ssid = network[0].decode('utf-8')networks[ssid] = network[3]for ssid in sorted(networks.keys()):print(f"ssid: {ssid:24} rssi: {networks[ssid]}")print()

Inside of main, lines 19 and 19 find the board’s unique ID and then use the last four characters of the unique ID to synthesize the board’s SSID. The block of code from line 23 to line 47 enable the OLED display and display the MicroPython logo as well as identifying information about that specific Raspberry Pi Pico W. You can see what it produces in the photo at the top of the post.

# MicroPython SSD1306 OLED driver, I2C interface## Originally written by Adafruit## Adafruit has deprecated this code, and is now devoting# development time and resources for the version that# works with Circuit Python.import timeimport framebuffrom micropython import const# register definitionsSET_CONTRAST= const(0x81)SET_ENTIRE_ON   = const(0xa4)SET_NORM_INV= const(0xa6)SET_DISP= const(0xae)SET_MEM_ADDR= const(0x20)SET_COL_ADDR= const(0x21)SET_PAGE_ADDR   = const(0x22)SET_DISP_START_LINE = const(0x40)SET_SEG_REMAP   = const(0xa0)SET_MUX_RATIO   = const(0xa8)SET_COM_OUT_DIR = const(0xc0)SET_DISP_OFFSET = const(0xd3)SET_COM_PIN_CFG = const(0xda)SET_DISP_CLK_DIV= const(0xd5)SET_PRECHARGE   = const(0xd9)SET_VCOM_DESEL  = const(0xdb)SET_CHARGE_PUMP = const(0x8d)# display definitionsOLED_WIDTH= const(128)OLED_HEIGHT   = const(64)OLED_LINE_MAX = const(6)OLED_ADDR = const(0x3D)class SSD1306():def __init__(self, width, height, external_vcc):self.width = widthself.height = heightself.external_vcc = external_vccself.pages = self.height // 8# Note the subclass must initialize self.framebuf to a framebuffer.# This is necessary because the underlying data buffer is different# between I2C and SPI implementations (I2C needs an extra byte).self.poweron()self.init_display()def init_display(self):for cmd in (SET_DISP | 0x00, # off# address settingSET_MEM_ADDR, 0x00, # horizontal# resolution and layoutSET_DISP_START_LINE | 0x00,SET_SEG_REMAP | 0x01, # column addr 127 mapped to SEG0SET_MUX_RATIO, self.height - 1,SET_COM_OUT_DIR | 0x08, # scan from COM[N] to COM0SET_DISP_OFFSET, 0x00,SET_COM_PIN_CFG, 0x02 if self.height == 32 else 0x12,# timing and driving schemeSET_DISP_CLK_DIV, 0x80,SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,SET_VCOM_DESEL, 0x30, # 0.83*Vcc# displaySET_CONTRAST, 0xff, # maximumSET_ENTIRE_ON, # output follows RAM contentsSET_NORM_INV, # not inverted# charge pumpSET_CHARGE_PUMP, 0x10 if self.external_vcc else 0x14,SET_DISP | 0x01): # onself.write_cmd(cmd)self.fill(0)self.show()def poweroff(self):self.write_cmd(SET_DISP | 0x00)def contrast(self, contrast):self.write_cmd(SET_CONTRAST)self.write_cmd(contrast)def invert(self, invert):self.write_cmd(SET_NORM_INV | (invert & 1))def show(self):x0 = 0x1 = self.width - 1if self.width == 64:# displays with width of 64 pixels are shifted by 32x0 += 32x1 += 32self.write_cmd(SET_COL_ADDR)self.write_cmd(x0)self.write_cmd(x1)self.write_cmd(SET_PAGE_ADDR)self.write_cmd(0)self.write_cmd(self.pages - 1)self.write_framebuf()def fill(self, col):self.framebuf.fill(col)def pixel(self, x, y, col):self.framebuf.pixel(x, y, col)def scroll(self, dx, dy):self.framebuf.scroll(dx, dy)def text(self, string, x, y, col=1):self.framebuf.text(string, x, y, col)class SSD1306_I2C(SSD1306):def __init__(self, i2c, width=OLED_WIDTH, height=OLED_HEIGHT, addr=0x3D, external_vcc=False):self.i2c = i2cself.addr = addrself.temp = bytearray(2)# Add an extra byte to the data buffer to hold an I2C data/command byte# to use hardware-compatible I2C transactions.  A memoryview of the# buffer is used to mask this byte from the framebuffer operations# (without a major memory hit as memoryview doesn't copy to a separate# buffer).self.buffer = bytearray(((height // 8) * width) + 1)self.buffer[0] = 0x40  # Set first byte of data buffer to Co=0, D/C=1self.framebuf = framebuf.FrameBuffer1(memoryview(self.buffer)[1:], width, height)super().__init__(width, height, external_vcc)def write_cmd(self, cmd):self.temp[0] = 0x80 # Co=1, D/C#=0self.temp[1] = cmdself.i2c.writeto(self.addr, self.temp)def write_framebuf(self):# Blast out the frame buffer using a single I2C transaction to support# hardware I2C interfaces.self.i2c.writeto(self.addr, self.buffer)def poweron(self):pass# A convenience method to print by line number unlike the text() method.# This assumes that you are using a 128 x 64 pixel OLED display.# Line numbers are 1-6 inclusive. There is no line 0.#def line(self, string, line_number):if line_number > 0 and line_number <= OLED_LINE_MAX:self.text(string,0,(line_number - 1)*10)# A way to test a 128 x 64 pixel OLED display.#def test_oled(self):for i in range(1, OLED_LINE_MAX + 1):self.fill(0)self.line('LINE {} ----+----'.format(i), i)self.show()time.sleep_ms(500)self.fill(0)self.show()

The code in the SSD1306 class was originally created by Adafruit, but they abandoned it when they decided to only support their CircuitPython fork of MicroPython. That’s fine, and you can find the original source on GitHub. I cleaned up some things, removed bits I didn’t need, and added some bits I found handy to the original code.

I’m quite comfortable moving towards MicroPython. The solid reliability of MicroPython trumps all other concerns.

No sooner did I write my post about CircuitPython 9.1 beta 2, then CircuitPython 9.1 beta 3 dropped with 24 hours of beta 2’s release. Apparently beta 2 introduced an “issue” (i.e. major bug) with the adafruit_esp32spi library. A bit of irony because I can’t get any CircuitPython builds to install on any of my Espressif ESP32-S3 boards, even though the CircuitPython site explicitly calls those boards out as being supported. Instead I’m using CircuitPython on every board except Espressif boards.

Rather than repeat the same code drop from yesterday, I added the ability to query the internet for time via NTP and the adafruit_ntp library. You can see the one line that sets up an ntp instance to query for time on the network at line 47 in the listing below, and the function format_ntp at line 57 does exactly that, creating a string with formatted time. The lead-in screen capture shows how the date and time are formatted, right beneath the displayed CircuitPython version. If you need accurate time in your project, and if you’re connected to the internet via WiFi with this device, then using the Adafruit NTP library is super easy to set up.

One other note: there’s a new property to define in your settings.toml file named TZ_OFFSET, or the timezone offset. That’s used to set up the ntp instance. I have mine set to -4 for eastern daylight time.

import osimport timeimport ipaddressimport wifiimport socketpoolimport boardimport microcontrollerimport adafruit_connection_managerimport adafruit_ntpfrom digitalio import DigitalInOut, Directionfrom adafruit_httpserver import Server, Request, Response, POST# On-device LED setupled = DigitalInOut(board.LED)led.direction = Direction.OUTPUTled.value = False# Connect to a local WiFi access point.# Because this code is running in a CircuitPython 9 or later environment,# it requires a settings.toml file be created with at least the following# six lines:## AP_SSID = "WIFI SSID"# AP_PASSWORD = "WIFI PASSWORD"# STATIC_IP = "IP4 dotted IP address"# GATEWAY = "192.168.0.1"# TZ_OFFSET = -4# DEBUG = "True" ## DEBUG can be either True or False.ipv4 =  ipaddress.IPv4Address(os.getenv('STATIC_IP'))netmask =  ipaddress.IPv4Address("255.255.255.0")gateway =  ipaddress.IPv4Address(os.getenv('GATEWAY'))wifi.radio.set_ipv4_address(ipv4=ipv4,netmask=netmask,gateway=gateway)wifi.radio.connect(os.getenv('AP_SSID'), os.getenv('AP_PASSWORD'))print(" Connected to WiFi access point...")pool = socketpool.SocketPool(wifi.radio)server = Server(pool, "/static", debug=os.getenv('DEBUG'))# Create Network Time Protocol (NTP) query instance. Use it to get the time.ntp = adafruit_ntp.NTP(pool, tz_offset = os.getenv('TZ_OFFSET'))# This is where the ntp instance created above is used. Get the time at the# instance the function is called, then format the raw data into a human# readable string.## The format is:# dayname, monthday monthname year - hour:min:sec# where the time is in 24 hour format.def format_ntp():dayname = ["Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday",]monthname = ["January","February","March","April","May","June","July","August","September","October","November","December" ]now = ntp.datetimereturn f"{dayname[now.tm_wday]}, {now.tm_mday} {monthname[now.tm_mon-1]} {now.tm_year} - {now.tm_hour:02}:{now.tm_min:02}:{now.tm_sec:02}"# Write the HTML page body as a Python 3 'f' string for advanced formatting.## Double curly braces {{ and }} are used when HTML needs single braces for HTML# page elements such as CSS styling.font_family = "sans-serif"def webpage():html = f"""<!DOCTYPE html><html><head><meta http-equiv="Content-type" content="text/html;charset=utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><style>html{{font-family: {font_family};background-color: #FFFFFF;display:inline-block;margin: 0px auto;text-align: center;}}h1{{color:#D35F8D;word-wrap: break-word;font-size: 35px;}}h2{{color:#D35F8D;word-wrap: break-word;font-size: 20px;}}p{{font-size: 1.5rem;word-wrap: break-word;}}.button-red{{font-family: {font_family};display: inline-block;width: 99%;background-color: #DC143C;border: none;border-radius: 4px;color: white;padding: 16px 40px;text-decoration: none;font-size: 30px;margin: 2px;cursor: pointer;}}.button-green{{font-family: {font_family};display: inline-block;width: 99%;background-color: #228B22;border: none;border-radius: 4px;color: white;padding: 16px 40px;text-decoration: none;font-size: 30px;margin: 2px;cursor: pointer;}}p.dotted {{margin: auto;width: 90%;font-size:25px;text-align: center;}}</style></head><body><title>Pico W LED Control</title><h1>Pico W LED Control</h1><form accept-charset="utf-8" method="POST"><button class="button-green" name="LED ON" value="ON" type="submit">LED ON</button></a><button class="button-red" name="LED OFF" value="OFF" type="submit">LED OFF</button></a></form><h2>CircuitPython Version: {os.uname().version.split(' ')[0]}<br/>{format_ntp()}</h2></body></html>"""return html# Default route static IP@server.route("/")def base(request: Request):  # pylint: disable=unused-argumentreturn Response(request, f"{webpage()}", content_type='text/html')# Determine which button was pressed and execute that button's associated# action.@server.route("/", POST)def buttonpress(request: Request):raw_text = request.raw_request.decode("utf8")print(raw_text)## If the led on button was pressed...if "ON" in raw_text:led.value = True## If the led off button was pressed...if "OFF" in raw_text:led.value = Falsereturn Response(request, f"{webpage()}", content_type='text/html')print(" Starting HTTP server...")try:server.start(str(wifi.radio.ipv4_address))print(f" Listening on http://{wifi.radio.ipv4_address}")## If the server fails to start then reset the Pico W.# If there is a hardware failure then this can put the software into a# boot loop. That's why the time.sleep(5) is there so that a Ctrl C can exit# at the REPL during development.#except OSError:print(" !!! OSError Exception, Waiting !!!")time.sleep(5)print(" !!! OSError Exception, Restarting !!!")microcontroller.reset()print(" Start polling...")## DO NOT hard code the while loop as True,# instead provide a test and exit if something goes wrong.#is_healthy = True;while is_healthy:try:# Poll for incoming requests.server.poll()except Exception as e:print(e)is_healthy = Falsecontinue

The CircuitPython group ( https://circuitpython.org/ ) has now released the third beta of the 9.1 version of CircuitPython.  This is beta 2; they start at beta 0, which is different than most folks, who start at 1. Whatever, betas are betas, which are feature complete but not reasonably bug free.

All this is being hosted on a Raspberry Pi Pico W, the version that comes with WiFi support built in. I’ve been working with this combination for a while now. I did not originate the code at the end of this post, but copied it from an Adafruit project which I can’t recall and can’t locate on their site. I have stripped it down to its bare essentials, which is to simply run the web server and provide a way to turn the built-in LED on or off. I’ve done a bit of code cleanup to make it easier to extend and experiment with. Consider the code a starting point for something bigger. You will need to copy the adafruit_httpserver library onto the Pico device. You’ll find those libraries just a click away on the CircuitPython page. You’ll also need to create a settings.toml file that is resident with code.py. What to put into that file is documented in the source listing, in a comment block starting at line 18.

I’ve used both CircuitPython and MicroPython extensively. I have a MicroPython build environment for Espressif ESP32-S3 and ESP32-C3 and -C6 boards on my Linux development system. As much as I use MicroPython, I like CircuitPython because they made it much simpler to update the CircuitPython runtime as well as edit the embedded Python code. When a CircuitPython device is plugged into your computer it comes up as a file device, much like a thumb drive. All you have to do is run a communication application like minicom to talk to the device via its USB port, while you can use whatever editor you want on the source, on the device’s exposed filesystem. Every time you save an edit, the CircuitPython detects the change and restarts it automatically. Thus prototyping with CircuitPython can be a lot simpler than MicroPython.

import osimport timeimport ipaddressimport wifiimport socketpoolimport boardimport microcontrollerfrom digitalio import DigitalInOut, Directionfrom adafruit_httpserver import Server, Request, Response, POST# On-device LED setupled = DigitalInOut(board.LED)led.direction = Direction.OUTPUTled.value = False# Connect to a local WiFi access point.# Because this code is running in a CircuitPython 9 or later environment,# it requires a settings.toml file be created with at least the following# five lines:## AP_SSID = "WIFI SSID"# AP_PASSWORD = "WIFI PASSWORD"# STATIC_IP = "IP4 dotted IP address"# GATEWAY = "192.168.0.1"# DEBUG = "True" ## DEBUG can be either True or False.ipv4 =  ipaddress.IPv4Address(os.getenv('STATIC_IP'))netmask =  ipaddress.IPv4Address("255.255.255.0")gateway =  ipaddress.IPv4Address(os.getenv('GATEWAY'))wifi.radio.set_ipv4_address(ipv4=ipv4,netmask=netmask,gateway=gateway)wifi.radio.connect(os.getenv('AP_SSID'), os.getenv('AP_PASSWORD'))print(" Connected to WiFi access point...")pool = socketpool.SocketPool(wifi.radio)server = Server(pool, "/static", debug=os.getenv('DEBUG'))# Write the HTML page body as a Python 3 'f' string for advanced formatting.## Double curly braces {{ and }} are used when HTML needs single braces for HTML# page elements such as CSS styling.font_family = "sans-serif"def webpage():html = f"""<!DOCTYPE html><html><head><meta http-equiv="Content-type" content="text/html;charset=utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><style>html{{font-family: {font_family};background-color: #FFFFFF;display:inline-block;margin: 0px auto;text-align: center;}}h1{{color:#D35F8D;word-wrap: break-word;font-size: 35px;}}h2{{color:#D35F8D;word-wrap: break-word;font-size: 20px;}}p{{font-size: 1.5rem;word-wrap: break-word;}}.button-red{{font-family: {font_family};display: inline-block;width: 99%;background-color: #DC143C;border: none;border-radius: 4px;color: white;padding: 16px 40px;text-decoration: none;font-size: 30px;margin: 2px;cursor: pointer;}}.button-green{{font-family: {font_family};display: inline-block;width: 99%;background-color: #228B22;border: none;border-radius: 4px;color: white;padding: 16px 40px;text-decoration: none;font-size: 30px;margin: 2px;cursor: pointer;}}p.dotted {{margin: auto;width: 90%;font-size:25px;text-align: center;}}</style></head><body><title>Pico W LED Control</title><h1>Pico W LED Control</h1><form accept-charset="utf-8" method="POST"><button class="button-green" name="LED ON" value="ON" type="submit">LED ON</button></a><button class="button-red" name="LED OFF" value="OFF" type="submit">LED OFF</button></a></form><h2>CircuitPython Version: {os.uname().version.split(' ')[0]}<br/>{format_ntp()}</h2></body></html>"""return html# Default route static IP@server.route("/")def base(request: Request):  # pylint: disable=unused-argumentreturn Response(request, f"{webpage()}", content_type='text/html')# Determine which button was pressed and execute that button's associated# action.@server.route("/", POST)def buttonpress(request: Request):raw_text = request.raw_request.decode("utf8")print(raw_text)## If the led on button was pressed...if "ON" in raw_text:led.value = True## If the led off button was pressed...if "OFF" in raw_text:led.value = Falsereturn Response(request, f"{webpage()}", content_type='text/html')print(" Starting HTTP server...")try:server.start(str(wifi.radio.ipv4_address))print(f" Listening on http://{wifi.radio.ipv4_address}")## If the server fails to start then reset the Pico W.# If there is a hardware failure then this can put the software into a# boot loop. That's why the time.sleep(5) is there so that a Ctrl C can exit# at the REPL during development.#except OSError:print(" !!! OSError Exception, Waiting !!!")time.sleep(5)print(" !!! OSError Exception, Restarting !!!")microcontroller.reset()print(" Start polling...")## DO NOT hard code the while loop as True,# instead provide a test and exit if something goes wrong.#is_healthy = True;while is_healthy:try:# Poll for incoming requests.server.poll()except Exception as e:print(e)is_healthy = Falsecontinue

Install Build Prerequisites

You need to install the following packages in order to build every module in Python. There is one additional package dependency that Python 3.13 will need to build, and it’s libmpdec-dev. Every other Python version prior to 3.13 did not need this package installed.

sudo apt install zlib1g-dev \libncurses5-dev \libgdbm-dev \libnss3-dev \libssl-dev \libreadline-dev \libffi-dev \libsqlite3-dev \libbz2-dev \tk \tk-dev \liblzma-dev \libgdbm-compat-dev \libmpdec-dev

Build And Install Python 3.13.0 Beta 1

• Download the latest Python version from https://www.python.org/downloads/
• Untar the file into a work folder of your choice
• Make a build directory at the same level as the untarred source directory.
• From within the build directory execute the configure script. In this example we’re building Python 3.13.0b1.
  ../Python-3.13.0b1/configure --enable-optimizations
• Within the build directory run make.
• Install into the alternate location for this version of Python:
  sudo -H make altinstall
• Check for the alternate location with which python3.13 . It should return /usr/local/bin/python3.13 .

Create A Virtual Work Environment

• In your home directory create a work folder. On my system I named it ‘VPython’, but you can call it whatever you want.
• Change directory into it, then create a Python virtual environment using, as an example, python3.13 -m venv 313.
• There is a bin directory in the virtual directory you created, which in this example was 313. Start the environment with source 313/bin/activate .

I created an alias so that typing 313 in any shell starts the environment. The alias should source the full path and the script in the virtual environment’s bin directory. When active, typing deactivate drops you back to a regular shell environment. See the following screen capture.

Note that there are new, and significant, changes coming to Python via version 3.13. The screen capture hints at just several of the new features, colorization and much better error reporting in the REPL. Note also that you no longer have to type exit() as a function to exit the REPL. It appears that Python is adding massive quality-of-life upgrades, starting with 3.13.

Announcement: https://pythoninsider.blogspot.com/2024/05/python-3130-beta-1-released.html

Monday 18 March, Adafruit released version 9 of CircuitPython. I had been working with version 9 pre-releases up to release candidate 1, but due to some problems with RC1 I dropped back to 8.2.10. I might try version 9 on another different board I have, but for now I’m sticking with 8.2.10 until such time as I actually have to migrate to version 9 in the future.

The code I’m presenting came from an Adafruit project over a year ago, and I can’t recall where it was, but it was complicated with additional device control. I’ve taken the code and tidied it up a bit, especially the embedded HTML that’s used to render the webpage on a smartphone’s web browser. I’ve tested it on both Android as well as iOS, and it works fine regardless.

Note that I’ve also used the new CircuitPython’s feature of settings.toml to define not just the local SSID and password, but the static IP address of the CircuitPython webserver as well as if it’s running in debug mode or not. It’s a lot easier to change a small toml file than to go and try to change something in the code body.

Once up and running all you need to do is either turn on the on-board LED or turn it off. If you have a serial application attached to the USB port, then you’ll see debug information streaming out the port. This is because DEBUG on line 26 has been set to True in the settings.toml file.

And one more thing: in debug mode, you navigate to [STATIC_IP_ADDRESS]:5000 to see the page. When not in debug mode, then the webserver is on regular port 80.

import osimport timeimport ipaddressimport wifiimport socketpoolimport boardimport microcontrollerfrom digitalio import DigitalInOut, Directionfrom adafruit_httpserver import Server, Request, Response, POST#  On-device LED setupled = DigitalInOut(board.LED)led.direction = Direction.OUTPUTled.value = Falseipv4 =  ipaddress.IPv4Address(os.getenv('STATIC_IP'))netmask =  ipaddress.IPv4Address("255.255.255.0")gateway =  ipaddress.IPv4Address(os.getenv('GATEWAY'))wifi.radio.set_ipv4_address(ipv4=ipv4,netmask=netmask,gateway=gateway)wifi.radio.connect(os.getenv('AP_SSID'), os.getenv('AP_PASSWORD'))print(" Connected to WiFi access point...")pool = socketpool.SocketPool(wifi.radio)server = Server(pool, "/static", debug=os.getenv('DEBUG'))font_family = "sans-serif"# The HTML page body setup as an 'f' string.## Use {{ and }} if something within HTML *actually* needs to be in brackets# such as CSS style formatting.#def webpage():html = f"""<!DOCTYPE html><html><head><meta http-equiv="Content-type" content="text/html;charset=utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><style>html{{font-family: {font_family};background-color: #FFFFFF;display:inline-block;margin: 0px auto;text-align: center;}}h1{{color:#D35F8D;word-wrap: break-word;font-size: 35px;}}p{{font-size: 1.5rem;word-wrap: break-word;}}.button-red{{font-family: {font_family};display: inline-block;width: 99%;background-color: #DC143C;border: none;border-radius: 4px;color: white;padding: 16px 40px;text-decoration: none;font-size: 30px;margin: 2px;cursor: pointer;}}.button-green{{font-family: {font_family};display: inline-block;width: 99%;background-color: #228B22;border: none;border-radius: 4px;color: white;padding: 16px 40px;text-decoration: none;font-size: 30px;margin: 2px;cursor: pointer;}}p.dotted {{margin: auto;width: 90%;font-size:25px;text-align: center;}}</style></head><body><title>Pico W LED Control</title><h1>Pico W LED Control</h1><form accept-charset="utf-8" method="POST"><button class="button-green" name="LED ON" value="ON" type="submit">LED ON</button></a><button class="button-red" name="LED OFF" value="OFF" type="submit">LED OFF</button></a></form></body></html>"""return html#  route default static IP@server.route("/")def base(request: Request):  # pylint: disable=unused-argumentreturn Response(request, f"{webpage()}", content_type='text/html')#  Determine which button was pressed and execute associated action.#@server.route("/", POST)def buttonpress(request: Request):raw_text = request.raw_request.decode("utf8")print(raw_text)## If the led on button was pressed...if "ON" in raw_text:led.value = True## If the led off button was pressed...if "OFF" in raw_text:led.value = Falsereturn Response(request, f"{webpage()}", content_type='text/html')print(" Starting HTTP server...")try:server.start(str(wifi.radio.ipv4_address))print(f" Listening on http://{wifi.radio.ipv4_address}")##  If the server fails to start then kick-start the Pico W.#except OSError:time.sleep(5)print(" !!! OSERROR RESTARTING !!!")microcontroller.reset()print(" Start polling...")is_healthy = True;## DO NOT hard code as True, instead provide an exit if something goes wrong.#while is_healthy:try:# Poll for incoming requests.server.poll()# pylint: disable=broad-exceptexcept Exception as e:print(e)is_healthy = Falsecontinue

AP_SSID = "YOUR_SSID"AP_PASSWORD = "YOUR_SSID_PASSWORD"STATIC_IP = "192.168.0.10"GATEWAY = "192.168.0.1"DEBUG = "True"

First, the big news. The latest updates to the Micropython code base now allow it to be built with Espressif’s ESP-IDF version 5.2. At the same time these changes were pushed out into the Micropython repository, Espressif dropped ESP-IDF 5.2.1, which I installed on my development system, then used to build my updated Micropython with the latest changes noted above. Micropython successfully built and I was then able to flash one of my ESP32-S3 development boards, and away I went with my stand-alone WiFi test board.

I then used the same ESP-IDF tool chain to build one of my C++ embedded applications, in which it joins my home WiFi access point and allows me to then bring up its simple web page. Again, everything built and flashed. This is with an ESP32-S3 development board with 32 MiB flash and 8 MiB external ram.

CircuitPython Update

One other update comes from CircuitPython: they’ve just dropped version 9.0.0 release candidate 0. I’ve downloaded and installed it on two of my boards that can handle it, and so far it’s doing just fine. If you like CircuitPython and use it for ESP32-S3-based boards, then by all means consider downloading and installing this version. It’s clean and stable enough for you to work with. Quoting from the release note, the key features out of many that caught my eye are:

• Merge updates from MicroPython v1.19.1, v1.20.0, and v1.21.0.
• Espressif: update to ESP-IDF v5.1.3.

Micropython and CircuitPython are moving rapidly, adding support for the latest boards as well as adding new functionality for existing devices, especially on the Espressif side of things.

I’ve been busy these past few weeks with my part-time job. The week of February 12th I spent out in Louisiana and billed 65 hours for the week. This week I’ve been doing other tasks, both to catch up from being on travel the week before as well as doing much less work in my new part time job. I still managed to read a bit and discovered, while out in Louisiana, that updates had been made to the open source project Micropython (version 1.22.2 was released) as well as Espressif’s commercial but open ESP-IDF C/C++ embedded tool chain.

When I got back this week I updated my personal fork of Micropython on Github, then updated my home Micropython development area via git, then set about testing all the updates in Micropython by using ESP-IDF 5.0.4 to build it, then began to experiment to see if Micropython would build with ESP-IDF 5.1.2. I mention ESP-IDF version 5.1.2 because Adafruit wrote that the latest CircuitPython beta, 9.0.0 beta 2, was built with ESP-IDF 5.1.2 after rolling in the latest changes from Micropython. When Micropython 1.22.0 was released in January the developers had locked in ESP-IDF 5.0.4 as the version that would build Micropython. I tried to use 5.1.2 and Micropython failed to build, so I stayed with ESP-IDF 5.0.4. Now the latest Micropython updates build successfully with 5.1.2, which the bottom of the little test web page provided by one of my ESP32-S3 N8R8 boards shows (see above). I’m quite happy that main Micropython builds with ESP-IDF 5.1.2 because I currently have three versions of ESP-IDF; 5.0.4, 5.1.2, and 5.2. I would like to drop the oldest (5.0.4) and even move Micropython compilation up to 5.2 so I can drop 5.1.2 as well. I do all my development with 5.2, only using an older version to build Micropython.

This next example is another Espressif board, the ESP32-S3 N32R8 running code written in C++ and compiled with ESP-IDF 5.2. As you should note at the bottom it’s been built with ESP-IDF 5.2, which is the current stable release. So far everything is working well, especially WiFi. I’m in the process of finishing up a MAX7219 C++ class using SPI for communication with the MAX7219. Once finished I’ll write about it here as well as push the source up to my modest Github space.

Today’s Ubuntu 23.10 updates included kernel updates. Once the update completed and the Raspberry Pi 5 was rebooted, the SPI devices were fully operational. I ran a test example from luma.led_matrix ( https://github.com/rm-hull/luma.led_matrix ):

$ ./matrix_demo.py -n 4 --block-orientation -90Created deviceMAX7219 LED Matrix DemoFast scrolling: Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.Slow scrolling: The quick brown fox jumps over the lazy dogVertical scrollingBrightnessAlternative font!Proportional font - characters are squeezed together!Tiny is, I believe, the smallest possible font (in pixel size). It stands at a lofty four pixels tall (five if you count descenders), yet it still contains all the printable ASCII characters.CP437 Characters

Believe me, everything worked with the HiLetgo four-character 8×8 matrix display (see below for details). I’m so happy to finally see this fix land.

I’m including the Raspberry Pi 5 wiring diagram and a picture of the HiLetgo MAX7210 Dot Matrix Module I used for the test. With the latest update to Ubuntu 23.10, everything works as expected.

Unless you have a very specific use case that absolutely requires you use Raspberry Pi OS on the Raspberry Pi 5, then install and use Ubuntu 23.10 exclusively for the Raspberry Pi 5.

It’s been a long strange trip to this post, across many years and many little personal projects. Let’s start here to de-tangle some of it.

Back in the late 2010s (2018 or so) I started purchasing Adafruit boards which included Circuit Playground as well as several Feather boards. They all came preloaded with CircuitPython, Adafruit’s fork of MicroPython. The boards were easy to program with embedded Python and the tools, while simple, were solid. What I appreciated most (and still do) is how the boards, when plugged into a host computer via USB, appear as a drive on the host system. You can then edit CircuitPython code directly on the device, and if it’s running when you save a new version, the device will note the file system change and restart with the version of your code you just saved. You can use any editor on the host system you desire and are already familiar with. The only other tool needed on the host system for development is a serial application that can work with the Adafruit device’s USB serial port. With that application you have a full Python REPL to work with, and when the application is running, you can see any printed outputs or see when and where you have a CircuitPython coding error.

The last time I worked with those boards was back in 2019, before I retired and before the Pandemic and Lockdown took hold. They went into my gadget storage and stayed there until earlier this week. I was looking for another device that had Bluetooth capabilities, so of course when I unearthed the Bluefruit in my stash I pulled it out and plugged it in. It started up just fine, except the Bluetooth code section I’d written did nothing. I opened the boot_out.txt file on the device’s flash device and read it was still running with CircuitPython 7.2. The current CircuitPython release is 8.2.9, a rather wide difference between versions. So I decided I’d stop and upgrade the device’s CircuitPython.

When you arrive at the CircuitPython download page ( https://circuitpython.org/board/circuitplayground_bluefruit/ ) for the Bluefruit you’re presented with a very clear warning about the device’s bootloader. Since I knew without looking that my copy of Bluefruit would need a bootloader update, I scrolled down to the part at the very bottom that spoke of how to update the bootloader.

At this section things begin to get a little murky. There’s a cautionary note to start off about how to find out what bootloader version you have and not to update unless you have to (I knew I had to) and then two links off the page, one to generic instructions and a big button to browse the bootloader repo. I’ll cut to the chase.

Follow this link and the resulting instructions: https://learn.adafruit.com/introducing-the-adafruit-nrf52840-feather/update-bootloader-use-command-line#

Long story short, after several failed attempts following directions before the command line instructions, I managed to update the bootloader and then update my Bluefruit to CircuitPython 8.2.9. I did all of this under Linux Mint, and it went swimmingly. When it powered back up the Bluetooth section failed to run with a coding error, so I disabled the one call to that module with a single comment and let the rest of it execute. I’ve now got two boards I need to investigate Bluetooth functionality. But, hey, it’s just a hobby, right?

If it’s not obvious by now I’m sticking with Ubuntu 23.10 on my RPi 5 SBCs, so I won’t be including it in the post title anymore. In this report I add additional functionality as well as clean up the code. The simple circuit now has a push button that connects pin GPIO3 to ground when it’s pressed. This will trigger a button closure event that is monitored and used by the gpiozero Button instance in the Python script.

#!/usr/bin/env pythonfrom gpiozero import LED, Buttonfrom time import sleepfrom datetime import datetimefrom signal import signal, SIGINT, pausefrom sys import exitimport asyncioleds = [LED(22), LED(23), LED(24), LED(25)]button = Button(3)def sigint_handler(signal_received, frame):for led in leds:led.off()print()exit(0)signal(SIGINT, sigint_handler)def flash_leds():while button.is_pressed:for led in leds:led.on()sleep(.04)led.off()sleep(1)for led in reversed(leds):led.on()sleep(.05)led.off()sleep(1)def print_when_pressed():print(f"{datetime.now()}: Button pressed")flash_leds()def print_when_released():print(f"{datetime.now()}: Button released")for led in leds:led.off()button.when_pressed = print_when_pressedbutton.when_released = print_when_releasedpause()

The Python code used to flash the four LEDs in the circuit was cleaned up a bit by creating an array of the LEDs, and then the flash_leds function tightened up using for loop iterators as well as Python’s built-in reverse function, so that the lights flash in one direction, pause, then flash in the reverse direction. Finally, instead of a blind test for true, we check to see if the button is pressed and then flash if it is.

To make the code a bit more interesting the button was given a pair of callback functions to work with, one to print out when the button is pressed, and one when it’s released. This is a demonstration of the capability, nothing more. I put in in because I’ve seen the question asked about how to use this functionality on various fora. If you read the documentation (see the link below) it’s very simple, but none-the-less, here’s what I did after reading the fine manual online. For a lot of tasks, gpiozero Just Works. The fact that it works under Ubuntu 23.10 on the Raspberry Pi is the primary reason I’m sticking with Ubuntu on the Raspberry Pi.

Links

Latest gpiozero documentation — https://gpiozero.readthedocs.io/en/latest/index.html

report #3 on using ubuntu 23.10 with a raspberry pi 5 — blinkin’ lights

When I start to develop an embedded system, I always try to construct a test layout or mockup of what I envision the final product will be. A test system can embody an important subset of requirements, and I can begin to write code for that final system. I can develop a lot more quickly with a mockup, and I can use the mockup to help debug issues during the phase where a more representative version of the end product arrives and I start to work with it. This is a simple mockup constructed of six switches and an Adafruit ESP32-S3 Feather running CircuitPython (code is listed further down). What I was developing with the mockup was the ability to read switch closures and to use the ESP32-S3’s WiFi radio to send switch status changes (open and close) to a central Linux system via a UCP socket.

I’m providing the official ESP32-S3 Feather pinout diagram from Adafruit because the generic part provided by KiCad is too generic and too old. The specific pin numbers are correct, but not much else.

## Adafruit ESP32-S3 Feather with 4MB Flash 2MB PSRAM - STEMMA QT / Qwiic# https://www.adafruit.com/product/5477#import boardimport osimport gcimport binasciiimport microcontroller as miimport wifiimport socketpoolimport crc## Show ESP32-S3 Feather basic resource usage.#PLATFORM = ', '.join(os.uname())NAME = os.uname()[0]UNIQUE_ID = binascii.hexlify(mi.cpu.uid).decode('ascii').upper()SSID = NAME + '-' + UNIQUE_ID[-4:]print(f"PLATFORM: {PLATFORM}")print(f"FREE MEM: {gc.mem_free():,} BYTES")stat_vfs = os.statvfs('/')fs_total = stat_vfs[0] * stat_vfs[2]fs_free  = stat_vfs[0] * stat_vfs[3]print(f"FS TOTAL: {fs_total:,} BYTES")print(f"FS  FREE: {fs_free:,} BYTES")print(f" UID: {UNIQUE_ID}")print(f"SSID: {SSID}")print(f"FREQ: {mi.cpu.frequency:,} Hz")print(f"FREE MEM: {gc.mem_free():,} BYTES")# Scan for WiFi networks. Sort list on RSSI strength.#print("\nWIFI: SCAN, SORTED BY RSSI")networks = []for network in wifi.radio.start_scanning_networks():networks.append(network)wifi.radio.stop_scanning_networks()networks = sorted(networks, key=lambda net: net.rssi, reverse=True)for network in networks:print(f"SSID: {network.ssid:<24}- RSSI: {network.rssi}")gc.collect()print(f"FREE MEM: {gc.mem_free():,} BYTES")import timeimport boardimport neopixelnp = neopixel.NeoPixel(board.NEOPIXEL, 1)# Cycle through five NeoPixel colors, then# turn off the NeoPixel#neopixel_colors = [(64, 0, 0),  # red(0, 64, 0),  # green(0, 0, 64),  # blue(64, 32, 0), # orange(0, 64, 64), # cyan(0, 0, 0)# black]def cycle_colors():for color in neopixel_colors:np.fill(color)np.write()time.sleep(0.4)np.fill(neopixel_colors[-1])np.write()print("NEOPIXEL: TESTING")cycle_colors()gc.collect()print(f"FREE MEM: {gc.mem_free():,} BYTES")import boardimport digitalio## Configure digital input triggers.#input_1 = digitalio.DigitalInOut(board.D10)input_1.switch_to_input(pull=digitalio.Pull.DOWN)input_2 = digitalio.DigitalInOut(board.D11)input_2.switch_to_input(pull=digitalio.Pull.DOWN)input_3 = digitalio.DigitalInOut(board.D12)input_3.switch_to_input(pull=digitalio.Pull.DOWN)input_4 = digitalio.DigitalInOut(board.D13)input_4.switch_to_input(pull=digitalio.Pull.DOWN)input_5 = digitalio.DigitalInOut(board.D9)input_5.switch_to_input(pull=digitalio.Pull.DOWN)input_6 = digitalio.DigitalInOut(board.D6)input_6.switch_to_input(pull=digitalio.Pull.DOWN)import ipaddressfrom adafruit_httpserver.server import HTTPServerfrom adafruit_httpserver.response import HTTPResponseudp_host = Noneudp_port = Nonetry:print("WIFI: CONNECT IN PROGRESS TO", os.getenv("AP_SSID"))wifi.radio.hostname = SSIDif os.getenv("ADDRESS") is not None:ipv4 = ipaddress.IPv4Address(os.getenv("ADDRESS"))netmask = ipaddress.IPv4Address(os.getenv("NETMASK"))gateway = ipaddress.IPv4Address(os.getenv("GATEWAY"))wifi.radio.set_ipv4_address(ipv4=ipv4, netmask=netmask, gateway=gateway)print("WIFI: STATIC ADDRESS USED")wifi.radio.connect(os.getenv("AP_SSID"), os.getenv("AP_PASSWORD"))print("WIFI: SUCCESSFUL CONNECT")print(" IP ADDR:", wifi.radio.ipv4_address)print(" IP GWAY:", wifi.radio.ipv4_gateway)print(" IP SNET:", wifi.radio.ipv4_subnet)print("HOSTNAME:", wifi.radio.hostname)## Set up a UDP socket for sending out messages.#pool = socketpool.SocketPool(wifi.radio)udp_host = str(os.getenv("UDP_HOST"))udp_port = int(os.getenv("UDP_PORT"))sock = pool.socket(pool.AF_INET, pool.SOCK_DGRAM)print("WIFI: UDP SOCKET CREATED")if os.getenv("PING_TEST") is not None:ping_test_addr = os.getenv("PING_TEST")ping_test = ipaddress.ip_address(ping_test_addr)for i in range(5):print("WIFI: PING TEST",ping_test_addr,"-",(wifi.radio.ping(ping_test)*1000),"MS")time.sleep(1)except Exception as e:print("WIFI: FAILURE")print("WIFI: REASON:", e)delay = float(os.getenv("DELAY"))print("   DELAY:", delay, "seconds")print("  ACTION: WAITING FOR DIGITAL EVENTS")i1flag = Falsei2flag = Falsei3flag = Falsei4flag = Falsei5flag = Falsei6flag = Falseindicator_counter = 0max_count = int(os.getenv("MAX_COUNT"))## Use an ordered dictionary so we can have# an ordered readable JSON message.#import jsonfrom collections import OrderedDictjson_template = OrderedDict([("IO",OrderedDict([("ID", SSID), ("S1", False),("S2", False), ("S3", False), ("S4", False),("S5", False), ("S6", False)]))])print("JSON MSG:", json.dumps(json_template))print(" UDP:", udp_host, udp_port)def send_udp_message(name, value):json_template["IO"][name] = valueudp_message = bytearray(json.dumps(json_template), 'utf-8')sock.sendto(bytes(udp_message), (udp_host, udp_port))while True:if indicator_counter > max_count:indicator_counter = 0np.fill(neopixel_colors[1])np.write()else:indicator_counter += 1np.fill(neopixel_colors[-1])np.write()if input_1.value and not i1flag:send_udp_message("S1", True);i1flag = Trueelif not input_1.value and i1flag:send_udp_message("S1", False);i1flag = Falseif input_2.value and not i2flag:send_udp_message("S2", True)i2flag = Trueelif not input_2.value and i2flag:send_udp_message("S2", False)i2flag = Falseif input_3.value and not i3flag:send_udp_message("S3", True)i3flag = Trueelif not input_3.value and i3flag:send_udp_message("S3", False)i3flag = Falseif input_4.value and not i4flag:send_udp_message("S4", True)i4flag = Trueelif not input_4.value and i4flag:send_udp_message("S4", False)i4flag = Falseif input_5.value and not i5flag:send_udp_message("S5", True)i5flag = Trueelif not input_5.value and i5flag:send_udp_message("S5", False)i5flag = Falseif input_6.value and not i6flag:send_udp_message("S6", True)i6flag = Trueelif not input_6.value and i6flag:send_udp_message("S6", False)i6flag = Falsetime.sleep(delay)

The code is rather long, with a lot of debugging information that is displayed on a monitoring terminal. I don’t normally turn all that off because these devices aren’t attached to a terminal during regular operation. If anything, the power is supplied via the Feather’s battery input with something more sophisticated than a bare battery.

The interesting code starts at line 151, where we set up the JSON dictionary structure, than at line 175 where we stay in a loop polling for switch state changes. The only event that needed alerting was if the switch was open and then it closed, or if closed and then opened. I wasn’t required to note momentary closures. I got away with push buttons on my mockup because it was what I had at hand, and a second or so on the push button was more than adequate for testing. Out in the field the switches were more like toggle switches.

Here’s what it looks like when it runs. I’m using Thonny’s terminal to capture the output;

PLATFORM: ESP32S3, ESP32S3, 8.2.9, 8.2.9 on 2023-12-06, Adafruit Feather ESP32S3 4MB Flash 2MB PSRAM with ESP32S3FREE MEM: 2,036,384 BYTESFS TOTAL: 2,404,352 BYTESFS  FREE: 2,352,128 BYTES UID: 4F21AF95CC4DSSID: ESP32S3-CC4DFREQ: 240,000,000 HzFREE MEM: 2,035,984 BYTESWIFI: SCAN, SORTED BY RSSISSID: GuestNetwork- RSSI: -47SSID: g00gleeeyes - RSSI: -48SSID: ESP32S3-4EF0- RSSI: -48SSID: DIRECT-FF-HP OfficeJet Pro 9020- RSSI: -55SSID: SmartLife-EEFB  - RSSI: -76SSID: asus 2.4- RSSI: -84SSID: Miller guest- RSSI: -85SSID: christian173- RSSI: -85SSID: Dashmeister - RSSI: -85SSID: SpectrumSetup-4A- RSSI: -88SSID: Miller guest- RSSI: -89SSID: christian173- RSSI: -92SSID: NETGEAR80   - RSSI: -93FREE MEM: 2,036,400 BYTESNEOPIXEL: TESTINGFREE MEM: 2,034,272 BYTESWIFI: CONNECT IN PROGRESS TO g00gleeeyesWIFI: SUCCESSFUL CONNECT IP ADDR: 192.168.0.203 IP GWAY: 192.168.0.1 IP SNET: 255.255.255.0HOSTNAME: ESP32S3-CC4DWIFI: UDP SOCKET CREATED   DELAY: 0.3 seconds  ACTION: WAITING FOR DIGITAL EVENTSJSON MSG: {"IO": {"ID": "ESP32S3-CC4D", "S1": false, "S2": false, "S3": false, "S4": false, "S5": false, "S6": false}} UDP: 192.168.0.248 23456

When I write MicroPython code for one of the embedded boards I have boilerplate code that helps identify the board (to make sure) as well as give me a clue to the environment I’m working in. The WiFi scan is my home WiFi environment, which includes neighbors on both sides as well as across the back of my yard. The first four lines are devices in my house. The rest are from locations outside my home. In my neighborhood we live on 1/3 to 1/2 acre plots of land, so it’s always surprising to me to see so many WiFi radios pop up. My close neighbors should be out of range, but it would appear they are not.

Starting at line 27 in the output, the Feather is attempting to connect to my local Linux host. First it joins my local home network via DHCP, it gets an IP address, then it attempts to create a UDP socket, which it does. The last line is the UPD IP address and port number it connects to. How do I know what IP address to use? It’s a two step process, starting with determining my Linux host’s IP address, and then editing a TOML file on the Feather.

## Variables AP_SSID and AP_PASSWORD must always be defined# with a valid access point SSID and PASSWORD.## Error from invalid AP_SSID: No network with that ssid# Error from invalid AP_PASSWORD: Unknown failure 15#AP_SSID="SSID"AP_PASSWORD="PASSWORD"## Uncomment the three environmental variables ADDRESS,# GATEWAY, and NETMASK for static IP address resolution.## ADDRESS is the class 5 IP address for the device.# GATEWAY is the IP address for the access point you want to connect to.# NETMASK is for the local device for further subnetting.## If ADDRESS is left commented then DHCP rules will be used.##ADDRESS="192.168.0.128"#GATEWAY="192.168.0.1"#NETMASK="255.255.255.0"## To not execute a ping test, comment out PING_TEST# This ping test is direct to Google# Error from invalid PING_TEST: unsupported types for __mul__: 'NoneType', 'int'##PING_TEST="8.8.4.4"## DELAY is how long to wait between scans of the digital inputs.# DELAY is in decimal floating point seconds.# To delay in milliseconds, use a fraction,# such as 0.3 for 300 milliseconds.## MAX_COUNT is how many DELAYs to wait before toggling the health# NeoPixel LED for a period of one DELAY.#DELAY="0.3"MAX_COUNT="20"## UDP support#UDP_HOST="192.168.0.248"UDP_PORT="23456"

There’s far more commentary than definitions, but that’s OK, especially if you’re going to hand this off to someone else to maintain. Starting with Circuit Python 8.0, Circuit Python will look for the text file settings.toml and automatically read in name/value pairs from it. This is the equivalent to defining environmental variables in a shell environment. This comes in quite handy as it eliminates having important information buried in the code. Before settings.toml the typical solution for constants was to define them in a Circuit Python file (such as secrets.py) and include that. It doesn’t mean you still can’t do that, but settings.toml is a bit cleaner.

On the system side I run this small bit of Python code to receive the Feather’s JSON messages.

#!/usr/bin/env pythonimport signalimport sysimport socketdef sigint_handler(signal, frame):print()sys.exit(0)signal.signal(signal.SIGINT, sigint_handler)# My home environment#hostname = socket.gethostname()ip_addr  = socket.gethostbyname(hostname)print(f" Host {hostname} listening on IP address {ip_addr}")udp_port = 23456sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDPsock.bind((ip_addr, udp_port))print(f" Waiting for JSON messages on IP address {ip_addr}, port {udp_port}")while True: data, addr = sock.recvfrom(1024) # buffer size is 1024 bytes print(f" JSON message: {str(data, 'utf8')}")

The Python code’s only purpose is to wait for, receive, and then print out what it receives. With test_receive_udp.py running in a terminal, when I go back and toggle switch 1 attached to the Feather closed and then open again, I get the following output;

 Host mint-prime listening on IP address 192.168.0.248 Waiting for JSON messages on IP address 192.168.0.248, port 23456 JSON message: {"IO": {"ID": "ESP32S3-CC4D", "S1": true, "S2": false, "S3": false, "S4": false, "S5": false, "S6": false}} JSON message: {"IO": {"ID": "ESP32S3-CC4D", "S1": false, "S2": false, "S3": false, "S4": false, "S5": false, "S6": false}}

It’s not as sexy as lights flashing, but it still fulfills an import task, which is to transmit a state change in a switch to another system for further processing, whatever I want that processing to be. While this lives on, with necessary changes, in another device out in the wild, I intend to use this to monitor various areas around my house, in particular whether my garage door is open or closed. I can forget to put the door down if I get distracted, especially in the evening. I want to know, without a doubt, the state of the garage door. I can do the same with other areas around the house. Right now my idea is to use one of my encased Raspberry Pi 4’s that I currently have attached, but doing relatively nothing, being the hub for microcontrollers such as this one.

There’s a lot I can do with this design, such as working on automatic bi-directional socket connectivity. That way I could send responses back to the microcontroller and have it execute arbitrary tasks. If this sounds like an alternative to Bluetooth and my MAX7219 displays, it is. It also brings to my mind a lot of different ways to build out remote sensors around my home.

Links

Adafruit ESP32-S3 Feather with 4MB Flash 2MB PSRAM – STEMMA QT / Qwiic — https://www.adafruit.com/product/5477

The first step in my plan for world conquest having an ESP32-S3-DevKit1 communicate with a MAX7219 is complete. All it took was five wires, two of which supplied power, and a little bit of MicroPython code running on the latest MicroPython release, and I was able to send text to my inexpensive four character matrix display I purchased on Amazon.

The code depends upon a library I found on GitHub (see links section below). Here’s the test code sample I wrote;

# Enable SPI and clear the display, which turns off all LEDs.#import max7219from machine import Pin, SPIimport timespi = SPI(1, 10000000, sck=Pin(12), mosi=Pin(11))cs = Pin(10, Pin.OUT)display=max7219.Matrix8x8(spi, cs, 4)display.fill(0)display.show()time.sleep_ms(500)# Probe the MicroPython/ESP32-S3-DevKit1 environment.#import gcprint(f"  MEM: {gc.mem_free():,} MB")import espprint(f"FLASH: {esp.flash_size():,} MB")import platformprint(f" PLAT: {platform.platform()}")import osUNAME = os.uname()[-1].split(' ')[-1]import binasciiimport machineUNIQUE_ID = binascii.hexlify(machine.unique_id()).decode('ascii').upper()print(f"  UID: {UNIQUE_ID}")SSID = UNAME + '-' + UNIQUE_ID[-4:]print(f" SSID: {SSID}")# Display text on the four 8x8 matrix displays.#display.text(UNIQUE_ID[-4:],0,0,1)display.show()

I’m using Thonny 4.1.4 to program the ESP32-S3. Here’s the output from boot.py in Thonny’s console when it’s run;

  MEM: 8,310,688 MBFLASH: 8,388,608 MB PLAT: MicroPython-1.22.1-xtensa-IDFv5.0.4-with-newlib4.1.0  UID: 7CDFA1E3C534 SSID: ESP32S3-C534

The four characters on the 8×8 displays are the last four characters of the UID. It’s a better “proof of life” than something random. To get the code listing to run, you need to download the single GitHub file from the link below, move it onto the ESP32-S3 controller, and then import it to begin to use the 1088AS displays.

Step 2 is to get Bluetooth operational on the ESP32-S3.

Links

MicroPython MAX7219 8×8 LED Matrix library — https://github.com/mcauser/micropython-max7219

designing the esp32-s3/max7219 device

I’m still trying to love Raspberry Pi OS and its LXDE-based window manager, and it’s just not happening. I’ve tweaked some things, even going so far as to pull a screen wallpaper from Linux Mint Uma (mikeu_red_waves.jpg); that seems to make the overall desktop experience a bit better for me.

I tried lxappearance to change the desktop. That application opened but I couldn’t change anything.

I then switched from Firefox as my default browser to Chromium because in spite of what was claimed, Firefox is still a hot mess and slower on Raspberry Pi OS than Chromium. I found Chromium a better browser experience than Firefox; Chromium is now my default browser.

That desktop screen capture you see above was taken with grim, a command line tool that is absolutely primitive to use and the only screen capture tool I found that worked. No other screen capture application will work because of the shift from X to Wayland. Basically it’s an all or nothing type of tool. If you want a specific section of the desktop, then you edit the full screen capture with another primitive graphics editing tool to whittle away the extraneous parts. For this post the full desktop was sufficient and required no further post processing.

After flipping back to Raspberry Pi OS and regretting the decision almost immediately, my intent is now to flop back to Ubuntu 23.10. For anything needing SPI support I’m going to move it over to one of my numerous microcontroller boards, such as one of the ESP32-S3 development boards. I can either code something in C++, or drop MicroPython on it. There’s a certain irony in doing a write/port to MicroPython as it won’t work with regular Python 3 under Ubuntu 23.10. But everything else works, and I might even cobble something together to use Bluetooth to communicate from the Raspberry Pi 5 to the ESP32-S3 hosting the MAX7219/1088AS displays. That sounds a lot more productive and a lot less frustrating than trying to beat Raspberry Pi OS into shape.

Yep. That’s my plan.