Category: Python

moving from circuit python to micro python, part two

whbeebe

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

moving from circuit python to micro python

whbeebe2 Comments

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.