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?

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

I can’t deny that a dual-core M0+ based board with built-in WiFi and Bluetooth radios for US$6 is a great bargain for tinkering with. As long as you were willing to use MicroPython, then you could program in a variant of Python all you wanted to. But I couldn’t configure the WiFi radio to be an access point. Now that there’s a version of Circuit Python that will work on this board (8.0.0.beta 4) and will work with the WiFi radio, I flashed one of my Pico Ws with this beta release and decided to give it a spin. The release notes say that I can configure the W’s WiFi as an access point. I’ve yet to try that.

Instead I decided to copy the following example code off the Adafruit site and exercise the WiFi radio with this. Note that this code uses the new .env feature, where you can create an environment file with various parameters. In this case, my WIFI_SSID and WIFI_PASSWORD are in my .env file instead of out in the open code. A very nice touch.

# SPDX-FileCopyrightText: 2022 Liz Clark for Adafruit Industries## SPDX-License-Identifier: MITimport osimport timeimport sslimport wifiimport socketpoolimport microcontrollerimport adafruit_requestsimport json# Adafruit quotes URL#quotes_url = "https://www.adafruit.com/api/quotes.php"# Connect to your local hostspot.# WIFI_SSID and WIFI_PASSWORD should be defined in your .env file.#wifi.radio.connect(os.getenv('WIFI_SSID'), os.getenv('WIFI_PASSWORD'))pool = socketpool.SocketPool(wifi.radio)session = adafruit_requests.Session(pool, ssl.create_default_context())print("Fetching quotes from ", quotes_url)print()while True:try:time.sleep(10)# Get a single quote#response = session.get(quotes_url)dic = dict(json.loads(response.text)[0])pstr = "Quote:  " + dic['text'] + "."print(pstr)pstr = "Author: " + dic['author']print(pstr)print()response.close()# pylint: disable=broad-exceptexcept ValueError as e:print("Error: bad JSON - ", response.text)response.close()except Exception as e:print("Error:\n", str(e))print("Resetting microcontroller in 10 seconds")time.sleep(10)microcontroller.reset()

I can’t recall where I copied the original code, but it’s undergone a number of tweaks, in particular parsing the JSON response from the URL. The original code simply dumped the response from the website. I parsed it, created a dictionary from it, then used the dictionary to cleanly print the quote and the quote’s author on two lines. I did some other cleanup, as well as adding an exception for malformed JSON so that the board isn’t reset every time a JSON response string gets munged. And if you’re wondering why I built a string rather than just printing it, printing a complex string adds an extra space between any two strings, and I’m just lazy and use string construction to build my final string. I’m sure there’s a better way for embedded CircuitPython, and if I find it, I’ll post an update. I’m also looking to find out what other specific exceptions I need to look for. Resetting a board on all exceptions is too lazy, even for me.

What follows is a typical run.

Auto-reload is on. Simply save files over USB to run them or enter REPL to disable.code.py output:Fetching quotes from  https://www.adafruit.com/api/quotes.phpQuote:  The nice thing about standards is that you have so many to choose from; furthermore, if you do not like any of them, you can just wait for next year's model.Author: Andrew S. TanenbaumQuote:  If you want to find the secrets of the universe, think in terms of energy, frequency and vibration.Author: Nikola TeslaQuote:  The nice thing about standards is that you have so many to choose from; furthermore, if you do not like any of them, you can just wait for next year's model.Author: Andrew S. TanenbaumQuote:  What I cannot create, I do not understand.Author: Richard FeynmanQuote:  Invention, it must be humbly admitted, does not consist in creating out of void, but out of chaos.Author: Mary Shelley...

The MicroPython group ( https://micropython.org ) released micropython v 1.19 on 17 July 2022, followed quickly by 1.19.1 across the board two days later. I waited for an official release of Micro Python that would work across all my Espressif developer boards, releases that were not a nightly release. Because it turned out that the official release before this, version 1.18, would not work on the ESP32-S3 and ESP32-C3 based boards I purchased.

This code’s a bit more sophisticated than my basic blinky LED code. It includes blinky code as well as code that makes use of built-in WiFi and provides a very (very) simple web page that interacts with the ESP32 microcontroller boards. For this post I’m using three ESP32-based boards, all of which were purchased from Adafruit. They had them in all stock and at the lowest prices I could find. The absolute best bargain I found was for the ESP32-C3 RISC V Developer board for $9.95. The bigger ESP32-S3 boards were about double that in price.

What’s nice about the ESP32-S3 developer boards is that nearly every pin is brought out for experimentation. That doesn’t mean you should use every one in your final product, but if you’re curious it’s all there. I also like that the two micro USB ports are there to provide power on one and debugging communications on the other. The board has full 2.4GHz WiFi and Bluetooth 5. The processor is a 240 MHz dual-core Tensilica LX7. The only problem is that there is no version of MicroPython that will properly use the on-board SPIRAM.

Firmware Release: https://micropython.org/download/GENERIC_S3/

The ESP32 Feather V2 ( https://www.adafruit.com/product/5400 ) has a an older generation 240 MHz dual-core Tensillica LX6 processor with WiFi and Bluetooth. It has 2MB of RAM and 8MB of FLASH storage to run Micro Python. Unlike the ESP32-S3, MicroPython will recognize and use the 2MB of built-in SPIRAM.

Firmware Release: https://micropython.org/download/esp32spiram/

Finally we have the ESP32-C3 developer board ( https://www.adafruit.com/product/5337 ). It’s primary feature of interest to me is that it’s powered by a 160 MHz RISC-V microcontroller. I believe in the future of RISC-V and want to do my part to make it successful by purchasing any products that incorporate it. I’m also interested in the chip and want to dig down to the register level…

Firmware Release: https://micropython.org/download/esp32c3/

All three of the boards are running released MicroPython. The code that follows will run on all three without modification. The tricky part is getting the NeoPixel set up so that it will work on any of the three boards. Because the code uses WiFi, I’m going to show the three boards in operation before I show the code. The WiFi code is configured to act as a access point, thus they’ll show up individually on my iPhone’s WiFi configuration.

I’ve chosen one of the boards as my access point. Here’s what it looks like on Safari.

You’ll note the SSID is at the top, followed by a series of simple web buttons. Press any one of the buttons with a color and it will turn on the NeoPixel with that color. The button labeled “LED Cycle” will run through the colors red, green, blue, cyan, magenta, yellow, and then off. The “LED Off” button will turn off the color you selected with one of the top three buttons. The “Home” button is always present. For example, when I press the red button, I get this:

I want to show what the Huzzah looks like.

Note the amount of Memory Free. This is because MicroPython for this board is capable of enabling and using the SPIRAM.

The code is in three files; main.py, config.py, and SimpleHttp.py. The config.py file is the simplest and we’ll skip that one.

The file main.py instantiates everything and gets everything going. Lines 19 through 34 is where we try to determine what board/chip combination we’re using, and setting the NeoPixel up accordingly. This is where Adafruit’s CircuitPython is superior to MicroPython; there’s is a file that if imported defines NEOPIXEL and allows that to be used in your code. Then, as you move that code block between Adafruit boards the NeoPixel is known, and portable code is much easier to write.

import machine  as maimport neopixel as neoimport time as tiimport _threadimport configimport osprint(', '.join(os.uname()))import platformprint(platform.platform())import espprint("Flash size {} in bytes".format(esp.flash_size()))import gcprint("Memory free {} in bytes.".format(gc.mem_free()))name = os.uname()[-1].split(' ')[-1]if name is "ESP32S3":pinnum = 48elif name is 'ESP32':# Setup specifically for Adafruit Huzzah ESP32 V2.# Pin 0 is the data pin to the NeoPixel,# Pin 2 is the power pin that must be set as an# an output and on, or high.#pinnum = 0## Turn on the power for the NeoPixel.#pwr = ma.Pin(2, ma.Pin.OUT)pwr.value(1)else:pinnum = 8np = neo.NeoPixel(ma.Pin(pinnum), 1)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[0] = colornp.write()ti.sleep_ms(400)np[0] = neopixel_colors[-1]np.write()def do_action(action_to_do):if action_to_do == config.LED_RED or action_to_do == config.LED_GREEN or action_to_do == config.LED_BLUE or action_to_do == config.LED_OFF:np[0] = neopixel_colors[action_to_do]np.write()elif action_to_do == config.LED_CYCLE:cycle_colors();#_thread.start_new_thread(cycle_colors, ())from SimpleHttp import SimpleHttpServershs = SimpleHttpServer(do_action)shs.run()

from micropython import const# Enumerations to perform a task.LED_RED = const(0)LED_GREEN = const(1)LED_BLUE = const(2)LED_CYCLE = const(3)LED_OFF = const(5)

The file SimpleHttp.py crams a lot into its 130 lines, including HTML and CSS to help render the web page on your device. I chose to create this so that the experimenter wouldn’t have to install any app on their device. As long as you’ve got something with a built-in web browser, you’re golden. Note the use of MicroPython’s _thread class in line 129. There are times when threading is needed, and I felt it was needed here. This is where MicroPython can be superior to CircuitPython.

"""This is the Simple HTTP Server.It has HTML/CSS text intermixed with Python code.It provides very limited functionality."""import binasciiimport machineimport osimport platformimport usocketimport _threadimport timeimport gcimport networkfrom network import WLANfrom machine import RTCimport configclass SimpleHttpServer:SSID = Nonedo_action = Nonedef __init__(self, do_action):self.do_action = do_actionself.name = os.uname()[-1].split(' ')[-1]self.SSID = self.name + '_' + binascii.hexlify(machine.unique_id()).decode('ascii').upper()[-4:]gc.enable()def client_thread(self, clientsocket):received = clientsocket.recv(4096)# If received has 0 bytes then the other end closed the connection.#if len(received) == 0:clientsocket.close()returnelse:# Parse the recieved data and perform any given actions.#received_str = str(received)## Uncomment the following for raw debugging purposes. Lots of output.##print("Received: {}".format(received_str))# Send out the common webpage header for all pages.#clientsocket.send("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection:close \r\n\r\n")clientsocket.send("<HTML><HEAD><TITLE>{}</TITLE>".format(self.SSID))clientsocket.send("<img src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-wp-preserve="%3Cstyle%3E%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22body%20%7Bfont-family%3A%20sans-serif%3Bmargin%3A%2020px%3B%7D%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22button%20%7B%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22font-size%3A%20300%25%3B%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22font-weight%3A%20bold%3B%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22display%3A%20inline-block%3B%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22margin%3A%205px%3B%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22padding%3A%2020px%2060px%3B%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22width%3A%2099%25%3B%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22height%3A%20150px%3B%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22justify-content%3A%20center%3B%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22align-items%3A%20center%3B%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22text-decoration%3A%20none%3B%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22color%3A%20%23ffffff%3B%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22background-color%3A%20%23556B2F%3B%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22border%3A%20none%3B%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22border-radius%3A%200px%3B%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22outline%3A%20none%3B%7D%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22hr%20%7Bborder%3A%200%3Bheight%3A%202px%3B%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22background-image%3A%20linear-gradient(to%20right%2C%20rgba(0%2C%200%2C%200%2C%200)%2C%20rgba(0%2C%200%2C%200%2C%200.75)%2C%20rgba(0%2C%200%2C%200%2C%200))%3B%7D%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22h1%20%7Bfont-size%3A%20300%25%3Bcolor%3A%20%23D35F8D%3Btext-align%3A%20center%3B%7D%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22h2%20%7Bfont-size%3A%20250%25%3Bcolor%3A%20%235FA3D3%3Bpadding-left%3A%2015px%3B%7D%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22%3C%2Fstyle%3E" data-mce-resize="false" data-mce-placeholder="1" class="mce-object" width="20" height="20" alt="&lt;style&gt;" title="&lt;style&gt;" />""</HEAD><BODY>")clientsocket.send("<h1>{}</h1>".format(self.SSID))# Start parsing the request, performing the various actions.# If there is no defined actions for the request, tell the user.#if "GET / " in received_str:clientsocket.send("<hr/>""<a href='/func1'><button style='background-color: #DC143C'>LED Red</button></a>""<a href='/func2'><button style='background-color: #228B22'>LED Green</button></a>""<a href='/func3'><button style='background-color: #4169E1'>LED Blue</button></a>""<a href='/func4'><button style='background-color: #808080'>LED Cycle</button></a>""<a href='/func5'><button style='background-color: #404040'>LED OFF</button></a>")elif "GET /func1 " in received_str:clientsocket.send("<h1>LED Red</h1>")self.do_action(config.LED_RED)elif "GET /func2 " in received_str:clientsocket.send("<h1>LED Green</h1>")self.do_action(config.LED_GREEN)elif "GET /func3 " in received_str:clientsocket.send("<h1>LED Blue</h1>")self.do_action(config.LED_BLUE)elif "GET /func4 " in received_str:clientsocket.send("<h1>LED Cycle</h1>")self.do_action(config.LED_CYCLE)elif "GET /func5 " in received_str:clientsocket.send("<h1>LED OFF</h1>")self.do_action(config.LED_OFF)else:clientsocket.send("<h1>Undefined Action</h1>" + received_str)clientsocket.send("<a href='/'><button style='background-color: #007C80'><em>Home</em></button></a>")clientsocket.send("<HR/>")clientsocket.send("<h2>Header Size: {:,} bytes</h2>".format(len(received)))clientsocket.send("<h2>Memory Free: {:,} bytes</h2>".format(gc.mem_free()))clientsocket.send("<h2>{}</h2>".format(', '.join(os.uname())))clientsocket.send("<h2>{}</h2>".format(platform.platform()))clientsocket.send("</BODY></HTML>")gc.collect()# Close the socket and terminate the threadclientsocket.close()time.sleep_ms(500)def run(self):# create as an access point#wlan = WLAN(network.AP_IF)wlan.active(True)# configure as an access point#print(self.SSID)wlan.config(essid=self.SSID)wlan.ifconfig(('192.168.1.2','255.255.255.0','192.168.1.1','8.8.8.8'))# Set up server socket to read client responses from web pages#serversocket = usocket.socket(usocket.AF_INET, usocket.SOCK_STREAM)serversocket.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1)serversocket.bind(("192.168.1.2", 80))# Listen argument defines the maximum connections at the same time.#serversocket.listen(1)#print(" HTTP: LISTEN")while True:(clientsocket, address) = serversocket.accept()# Start a new thread to handle the client#_thread.start_new_thread(self.client_thread, (clientsocket, ))serversocket.close()

In the last post I wrote that you could flash this Adafruit Feather with a version of MicroPython. Unfortunately it did not enable the use of the board’s SPIRAM. The specifications for this board declares that it has 4MiB of non-volatile (FLASH) and 2MiB of RAM (SPIRAM). When I went to check for the amount of free RAM it was far lower than I expected. That’s when I realized I’d use the wrong MicroPython image to flash the Feather. The correct link is: https://micropython.org/download/esp32spiram/ .

One way to test that you are seeing all the RAM is by adding two lines to the blink code, starting at line 13.

import espprint("Flash size {} in bytes".format(esp.flash_size()))import gcprint("Memory free {} in bytes.".format(gc.mem_free()))

When the code executes you’ll see the following (I’m working with Thonny, and this is in Thonny’s shell):

MPY: soft rebootesp32, esp32, 1.18.0, v1.18 on 2022-01-17, ESP32 module (spiram) with ESP32MicroPython-1.18.0-xtensa-IDFv4.2.2-with-newlib3.0.0Flash size 4194304 in bytesMemory free 2046144 in bytes.

Note the second line that contains “…ESP32 module (spiram)…”, and the last line that shows 2MiB of RAM memory.

I ordered yet another ESP32 based board to experiment with. The latest in my collection is the Adafruit ESP32 Feather V2. You can learn quite a bit here: https://learn.adafruit.com/adafruit-esp32-feather-v2 . I have it programmed with the standard MicroPython v1.18 release from here: https://micropython.org/download/esp32/ . By the way, when you read the instructions on that page on how to program the Feather, you want to use the latest official release which is currently 17 January 2022, or esp32-20220117-v1.18.bin. The directions are correct, just make sure to use the most current MicroPython version.

I’m happy to have this board, as it’s the only board that I have the official MicroPython (v1.18) release running on. All my other ESP32 boards require a nightly to run, including Adafruit’s own QT Py ESP32-C3 board, which I touched on in an earlier post.

import machine  as maimport neopixel as neoimport time as tiimport osprint(', '.join(os.uname()))import platformprint(platform.platform())import espprint("Flash size {} in bytes".format(esp.flash_size()))name = os.uname()[-1].split(' ')[-1]if name is 'ESP32S3':# For the Espressif ESP32-S3-DevKitC-1-*#pinnum = 48elif name is 'ESP32':# Setup specifically for Adafruit Huzzah ESP32 V2.# Pin 0 is the data pin to the NeoPixel,# Pin 2 is the power pin that must be set as an# an output and on, or high.#pinnum = 0## Turn on the power for the NeoPixel.#pwr = ma.Pin(2, ma.Pin.OUT)pwr.value(1)else:# For the Adafruit QT Py ESP32-C3 WiFi Dev Board#pinnum = 2np = neo.NeoPixel(ma.Pin(pinnum), 1)neopixel_colors = [(64, 0, 0),  # red(0, 64, 0),  # green(0, 0, 64),  # blue(0, 64, 64), # cyan(64, 0, 64), # magenta(64, 32, 0), # yellow(0, 0, 0)# black]while(True):for color in neopixel_colors:np[0] = colornp.write()ti.sleep_ms(750)np[0] = neopixel_colors[-1]np.write()ti.sleep_ms(250)

Because there are no common “magic” names for the NeoPixel pin, I’ve had to resort to testing what ESP board I’m running on and setting up the pin number accordingly. For the ESP32 Huzzah, I’ve also had to do a bit more work, specifically turning power on to the NeoPixel. This is covered in the Adafruit documentation linked to above. The section for handling the Huzzah’s NeoPixel sets the right pin to communicate with the NeoPixel as well as enable the power for the NeoPixel. And if you read the Adafruit documentation, you’re going to have to turn on the power pin if you want to use the I2C bus. The NeoPixel and I2C bus are both powered from the same pin so that if you need to shut down completely, you can do so programmatically before going into very deep sleep.

One other observation about this board. Adafruit says that the new USB adapter chip requires a driver for macOS. I’ve tried this on an M1 MacBook Pro with Monterey 12.4 and it shows up just fine. So if you have a contemporary Mac with any version of Monterey (which at least may include Big Sur, version 11) DO NOT install that driver they offer. I can’t speak to Windows, but I’d be very surprised if Windows 10 needs a driver. If you get one of these boards, plug it in and look to see if it comes up first before blindly installing any software drivers.

The Pro Micro is the same width and almost twice the length of the Adafruit QT Py ESP32-C3, another $10 microcontroller experimenter’s board. The board comes with castellated edges, providing the experimenter or designer with the ability to solder the board directly onto the surface of a larger circuit board. While there are far fewer I/O pins brought out to the edges as there is in a stock RP2040 Pico board, it does have four times as much storage flash (16MB), a NeoPixel LED in place of the standard red LED on the Pico, and a QWIIC connector on the other end. It also has USB-C in place of micro USB on the other end. For for an extra six dollars over the cost of a bare Pico you get a device that’s a lot more civilized. I think the inclusion of the QWIIC connector alone is worth the extra six dollars.

This is the most complete pinout diagram for a microcontroller I think I’ve ever seen. Not just the pins, but key functionality around the board is documented as well. You can do just about anything with only this diagram to refer to. But that’s just me.

I want to call your attention to the boot and reset buttons at the bottom edge next to the QWIIC connector in conjunction with putting the Pro Micro in bootloader mode. Let’s say you want to put the latest Circuit Python firmware on this board. Plug a USB cable into your computer and then into the board. Press and hold the boot button. Press and release the reset button, then release the boot button. The RPI-RP2 flash drive will show up on your computer, at which point you can drag-and-drop (or copy in a console) the Circuit Python UF2 firmware to RPI-RP2. Once the UF2 firmware has finished copying, the board will reboot itself and the regular CIRCUITPY storage device for that board will appear on your computer.

And here’s my version of blinky Python code to blink the on-board WS2812 addressable LED.

"""NeoPixel blink example for RP2040-based boards such as the Sparkfun Pro Micro RP2040.The example requires two libraries from the Adafruit CircuitPython Library Bundle.Download the bundle from circuitpython.org/libraries and copy the following files to yourCIRCUITPY/lib folder:- neopixel.mpy- adafruit_pixelbuf.mpyOnce the libraries are copied, save this file as code.py to your CIRCUITPY drive to run it."""import boardimport neopixelimport timenp = neopixel.NeoPixel(board.GP25, 1)neopixel_colors = [(64, 0, 0),  # red(0, 64, 0),  # green(0, 0, 64),  # blue(0, 64, 64), # cyan(64, 0, 64), # magenta(64, 32, 0), # yellow(0, 0, 0)# black]while(True):for color in neopixel_colors:np.fill(color)time.sleep(0.5)np.fill(neopixel_colors[-1])time.sleep(0.5)

These little boards are powerful, easy and cheap. And they’re a lot of fun to work with!

And for the sticklers, I’m using Circuit Python 7.3.0-rc.2, or release candidate two of the very latest version of Circuit Python (see https://circuitpython.org/board/raspberry_pi_pico/ ).

I wrote in the last refactoring post that one of my goals was to create a class to manipulate the Featherwing’s OLED display. That class would initialize the display and provide convenience methods to change the text across three horizontal lines on the OLED display.

Why only three lines of text? The OLED display has a pixel resolution of 132 pixels long by 32 pixels high. A single line of text has a height of 8 pixels. Add a 1 pixel space at the top, and another at the bottom, and a line of text across the OLED now takes 10 pixels of height. With only 32 pixels total, I can at best clearly display only three lines of horizontal text. The OLED control class shows those three lines when the software restarts, as you can see above. Those lines are part of the initialization routine, which I’ll show later.

Now to test. I’ve reached over and pressed the ‘A’ button on the edge of the Featherwing. That actions causes ‘A button PRESSED’ to be displayed on the first line.

When I release the ‘A’ button, ‘A button released’ is displayed on line 1. The ‘B’ button modifies line 2, and the ‘C’ button modifies line 3 with similar text messages. Meanwhile the NeoPixels are doing their thing while all this is happening. My current system isn’t perfect. If you pay close attention to the spinning NeoPixel ring, you’ll see a very brief stop in the circulation, then it picks back up again. Releasing the button causes the same issue. Now let’s look at the code.

import timefrom oled_control import Oledfrom oled_buttons import Buttonsimport neopixel_control as ncoled = Oled()buttons = Buttons()buttons.a_pressed_func = lambda : oled.display_line1('A button PRESSED')buttons.a_released_func = lambda : oled.display_line1('A button released')buttons.b_pressed_func = lambda : oled.display_line2('B button PRESSED')buttons.b_released_func = lambda : oled.display_line2('B button released')buttons.c_pressed_func = lambda : oled.display_line3('C button PRESSED')buttons.c_released_func = lambda : oled.display_line3('C button released')while True:nc.cycle_colors(lambda : buttons.check_button_states())

The main code body, code.py, is considerably smaller than the last version. The Python code is used to “wire” the button states (pressed and released) to respective functions on the display class, Oled. Note how the while True loop has been reduced to just two lines of code. As I had originally planned, I modified the call cycle_colors() to take check_button_states() as an argument so that it could be called within the inner loop setting the NeoPixel ring LEDs. The response to button presses and releases now appears to be nearly instantaneous as the text on the OLED changes according to the button presses. But as I noted above it’s not perfect, everything is still executing in linear order, and is not true multitasking nor threading nor concurrent.

The code is in a good enough shape. It could stand more comments, but from a practical standpoint it’s suitable to build upon for my next project. I’m done with this stage. I know it’s not perfect, but as I read somewhere, “Perfect is the enemy of done.”

import boardimport displayioimport terminaliofrom adafruit_display_text import labelimport adafruit_displayio_ssd1306class Oled():def __init__(self):# Initialize the I2C bus connected to the display.# Initialize the display.#displayio.release_displays()self.i2c = board.I2C()self.display_bus = displayio.I2CDisplay(self.i2c, device_address=0x3C)self.display = adafruit_displayio_ssd1306.SSD1306(self.display_bus, width=128, height=32)# Fill the background with black.# This is a monochrome display, so there can be only black# or white.#self.splash = displayio.Group()self.display.show(self.splash)self.color_bitmap = displayio.Bitmap(128, 32, 1)self.color_palette = displayio.Palette(1)self.color_palette[0] = 0x000000  # Blackself.background_sprite = displayio.TileGrid(self.color_bitmap, pixel_shader=self.color_palette, x=0, y=0)self.splash.append(self.background_sprite)self.label1 = label.Label(terminalio.FONT, text="Line 1", color=0xFFFFFF, x=0, y=3)self.splash.append(self.label1)self.label2 = label.Label(terminalio.FONT, text="Line 2", color=0xFFFFFF, x=0, y=13)self.splash.append(self.label2)self.label3 = label.Label(terminalio.FONT, text="Line 3", color=0xFFFFFF, x=0, y=23)self.splash.append(self.label3)def display_line1(self, text):self.label1._update_text(text)def display_line2(self, text):self.label2._update_text(text)def display_line3(self, text):self.label3._update_text(text)

The Oled class is mostly initialization and setup for the OLED display. The public convenience methods display_line1, display_line2, and display_line3 are wrappers around calling _update_text.

import boardfrom digitalio import DigitalInOut, Direction, Pull# Declare a class for all three buttons, A, B, and C.#class Buttons():def __init__(self):self.a_pressed = Falseself.b_pressed = Falseself.c_pressed = Falseself.a_pressed_func =  lambda : Noneself.a_released_func = lambda : Noneself.b_pressed_func =  lambda : Noneself.b_released_func = lambda : Noneself.c_pressed_func =  lambda : Noneself.c_released_func = lambda : Noneself.a_button = DigitalInOut(board.D9)self.a_button.direction = Direction.INPUTself.a_button.pull = Pull.UPself.b_button = DigitalInOut(board.D6)self.b_button.direction = Direction.INPUTself.b_button.pull = Pull.UPself.c_button = DigitalInOut(board.D5)self.c_button.direction = Direction.INPUTself.c_button.pull = Pull.UP# Check when a button has been pressed, and when it's# released after being pressed.#def check_button_states(self):if (self.a_button.value is not True):if (not self.a_pressed):self.a_pressed_func()self.a_pressed = Trueelse:if (self.a_pressed):self.a_released_func()self.a_pressed = Falseif (self.b_button.value is not True):if (not self.b_pressed):self.b_pressed_func()self.b_pressed = Trueelse:if (self.b_pressed):self.b_released_func()self.b_pressed = Falseif (self.c_button.value is not True):if (not self.c_pressed):self.c_pressed_func()self.c_pressed = Trueelse:if (self.c_pressed):self.c_released_func()self.c_pressed = False

The class Buttons code should be quite familiar as that’s what’s been carried along now since it was originally part of code.py. Now that code has been removed and used to build the class. I much prefer this because there’s no need to declare any variables as global. Scope is now within the class.

import timeimport boardimport neopixel# For the single neopixel on the Feather itself.#s_neopixel = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=0.2, auto_write=False, pixel_order=neopixel.GRB)# For the 12 neopixel ring attached to the Feather.#neopixel_ring = neopixel.NeoPixel(board.D10, 12, brightness=0.2, auto_write=True, pixel_order=neopixel.GRB)# All the NeoPixel colors we want to display.# Even though there are four values in each color tuple,# the library code will know how to handle the late value,# which is white, and not send it to the GRB only# NeoPixels on the ring.#neopixel_colors = [(64,0,0,0), # red(0,64,0,0), # green(0,0,64,0), # blue(64,16,0,0),# orange(0,32,32,0),# cyan(0,0,0,0)   # black]# Send colors to all our NeoPixels.#def cycle_colors( remote_func = lambda : None):for color in neopixel_colors:s_neopixel.fill(color)s_neopixel.show()for i in range(len(neopixel_ring)):neopixel_ring[i-1] = (0,0,0,0) # turn LED offneopixel_ring[i] = colorneopixel_ring.show()remote_func()time.sleep(.03)

Finally, the code for running all the NeoPixels. This isn’t a class, just the function and data used by that function. Note that passing in a callable function to cycle_colors() is optional. If nothing is passed in then when remote_func() is called it defaults to a no operation.

When the code is executing, pressing any of the buttons will print “Button … pressed” only once on the REPL. When that button is released then “Button … released” is printed. This is simple early code without anything substantial hooked into those button checks, but the framework presented here should inspire something more interesting.

The next stage will be to add code back in to manipulate the OLED display. I hope that code will be a bit more streamlined than my earlier example.

import timeimport boardimport neopixelfrom digitalio import DigitalInOut, Direction, Pull# Define all three buttons, A, B, and C.#a_pressed = b_pressed = c_pressed = Falsea_button = DigitalInOut(board.D9)a_button.direction = Direction.INPUTa_button.pull = Pull.UPb_button = DigitalInOut(board.D6)b_button.direction = Direction.INPUTb_button.pull = Pull.UPc_button = DigitalInOut(board.D5)c_button.direction = Direction.INPUTc_button.pull = Pull.UP# For the single neopixel on the Feather itself.#s_neopixel = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=0.2, auto_write=False, pixel_order=neopixel.GRB)# For the 12 neopixel ring attached to the Feather.#neopixel_ring = neopixel.NeoPixel(board.D10, 12, brightness=0.2, auto_write=True, pixel_order=neopixel.GRB)def cycle_color(color):s_neopixel.fill(color)s_neopixel.show()for i in range(len(neopixel_ring)):neopixel_ring[i-1] = (0,0,0,0) # turn LED offneopixel_ring[i] = colorneopixel_ring.show()time.sleep(.05)while True:if (a_button.value is not True):if (not a_pressed):print('Button A pressed')a_pressed = Trueelse:if (a_pressed):print('Button A released')a_pressed = Falseif (b_button.value is not True):if (not b_pressed):print('Button B pressed')b_pressed = Trueelse:if (b_pressed):print('Button B released')b_pressed = Falseif (c_button.value is not True):if (not c_pressed):print('Button C pressed')c_pressed = Trueelse:if (c_pressed):print('Button C released')c_pressed = Falsecycle_color((64,0,0,0)) # redcycle_color((0,64,0,0)) # greencycle_color((0,0,64,0)) # bluecycle_color((64,16,0,0)) # orangecycle_color((0,32,32,0)) # cyancycle_color((0,0,0,0)) # black (LED off)

Two posts back I wrote about adding a NeoPixel stick with eight NeoPixels to the Black Adafruit Feather RP2040. In this quick post I take the code from the Feather STM32 driving the NeoPixel stick and quickly “port” it to the Feather RP2040 driving a NeoPixel ring with 12 NeoPixel LEDs. Both Feathers are running their specific version of Circuit Python version 7.1.1. The story behind how I acquired the NeoPixel ring is interesting. One day last year, while visiting the Parallax website ( https://www.parallax.com ) I came across a sale of a mystery box of components (Adafruit has the equivalent). So I bit and bought one, just to see what I’d get. When the mystery box arrived it had a lot of interesting components, one of which was the NeoPixel ring. I had no use for the ring at the time and put it back in the box and put the box on the shelf with a lot of other boxes with components I keep in case… Forward six months or so and I came across a sale of the NeoPixel sticks, so I bought one along with the STM32 Feather.

Today as I was cleaning and reorganizing I came across that mystery box and remembered I had the NeoPixel ring in it. I pulled it out, soldered some wires to it, plugged it into the Feather RP2040 using the same pins as with the Feather STM32 and copied the STM32’s code over to the RP2040. I had to make two changes to one line of code at line 14:

1. Change the number of NeoPixel LEDS from 8 to 12, and
2. Change the NeoPixel type from neopixel.GRBW to neopixel.GRB because there is no white on the NeoPixel ring.

Once that was done the behavior of the NeoPixel ring was essentially identical with the NeoPixel stick.

import timeimport boardimport neopixel # For the single neopixel on the feather itself.#sneopixel = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=0.2, auto_write=False, pixel_order=neopixel.GRB) # For the eight neopixel board attached to the feather.#pixelboard = neopixel.NeoPixel(board.D5, 12, brightness=0.2, auto_write=True, pixel_order=neopixel.GRB) def cycleColor(color):sneopixel.fill(color)sneopixel.show()for i in range(len(pixelboard)):pixelboard[i-1] = (0,0,0,0) # turn LED offpixelboard[i] = colorpixelboard.show()time.sleep(.05) while True:cycleColor((64,0,0,0)) # redcycleColor((0,64,0,0)) # greencycleColor((0,0,64,0)) # bluecycleColor((64,16,0,0)) # orangecycleColor((0,32,32,0)) # cyancycleColor((0,0,0,0)) # black (LED off)

And once again the video clip was made with my iPhone 11 Pro, and it’s as crappy as the last one. I will work diligently to learn how to do a much better job of videoing these types of devices. They look far better in person.

In December 2021 I wrote about bringing up the Adafruit STM32F405 Feather ( /2021/12/12/bringing-up-an-adafruit-stm32f405-feather-express/ ). Since that time I added an external Neopixel Stick from Adafruit ( https://www.adafruit.com/product/2869 ). This is the four “color” version of the stick with red, green, blue and white LEDs on each device. I cleaned up and shortened the code from the last post and got a bit more creative strobing the LEDs. The stick strobes a single LED from end to end, while the on-board LED shows the same color being strobed on the stick. Once again it’s Circuit Python version 7.1.1. Wiring for the stick has the stick’s ground attached to the feather’s GND pin, the stick’s 5V pin attached to the feather’s USB pin, and the feathers DIN (data in) pin attached to the Feather’s D5 pin, and configured in the call to neopixel.NeoPixel(...) (code line 13).

import timeimport boardimport neopixel# For the single neopixel on the feather itself.#sneopixel = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=0.2, auto_write=False, pixel_order=neopixel.GRB)# For the eight neopixel board attached to the feather.#pixelboard = neopixel.NeoPixel(board.D5, 8, brightness=0.2, auto_write=True, pixel_order=neopixel.GRBW)def cycleColor(color):sneopixel.fill(color)sneopixel.show()for i in range(len(pixelboard)):pixelboard[i-1] = (0,0,0,0) # turn LED offpixelboard[i] = colorpixelboard.show()time.sleep(.05)while True:cycleColor((64,0,0,0)) # redcycleColor((0,64,0,0)) # greencycleColor((0,0,64,0)) # bluecycleColor((64,16,0,0)) # orangecycleColor((0,32,32,0)) # cyancycleColor((0,0,0,0)) # black (LED off)

The video was produced on my iPhone 11 Pro with Apple’s iMovie. I know it’s crap as in it won’t earn any awards unless there’s a special Raspberry for iPhone clips, but I didn’t feel like firing up one of my regular cameras and going through the rigamarole of filming, transfer, post-processing, then posting. Making the short clip on the iPhone was incredibly easy and fast. Going through one of my cameras (either the E-M1.2 or the Lumix G9) wouldn’t have looked any better, and probably worse. The problem is that the LEDs in the video clip don’t show the bright saturated colors I see with my own eyes. And that’s with any of the cameras. I stuck with the iPhone output because it actually looked the best of the three cameras with less effort. But there’s still tremendous room for improvement.

The majority of this code was copied from an example on the Adafruit website ( https://learn.adafruit.com/adafruit-oled-featherwing/python-usage ), starting with the instructions on how to set up the RP2040’s CircuitPython runtime environment.  I copied the example code a few lines at a time to see what happened as each block was pasted in. It was interesting how everything behaved as each block was pasted in and the entire body restarted.

My version of the code has a problem, and it all started with an innocent desire to change the text inside the Label text_area (see line 45). Every other user interface framework that defines label classes provides a simple class method to change the label’s text. I looked but couldn’t find a good public method. Instead I used what is, but Python convention, a somewhat private internal method _update_text() (lines 63 and 65). This coding convention is spelled out in PEP 8:

A name prefixed with an underscore (e.g. _spam) should be treated as a non-public part of the API (whether it is a function, a method or a data member). It should be considered an implementation detail and subject to change without notice.

My use is thus a poor example. But I’ve yet to find the “proper” example. If and when I ever do, then I’ll update the code. But for the mean time I’ll live with it.

I need that capability for my next stage, which is to show via the OLED display when I press button ‘A’, ‘B’, or ‘C’.

import boardimport displayioimport terminaliofrom adafruit_display_text import labelimport adafruit_displayio_ssd1306import time# Initialize the I2C bus connected to the display.# Initialize the display.#displayio.release_displays()i2c = board.I2C()display_bus = displayio.I2CDisplay(i2c, device_address=0x3C)display = adafruit_displayio_ssd1306.SSD1306(display_bus, width=128, height=32)# Fill the background with white. # This is a monochrome display, so there can be only black # or white.#splash = displayio.Group()display.show(splash)color_bitmap = displayio.Bitmap(128, 32, 1)color_palette = displayio.Palette(1)color_palette[0] = 0xFFFFFF  # Whitebackground_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, x=0, y=0)splash.append(background_sprite)# Draw a black inner rectangle.#inner_bitmap = displayio.Bitmap(122, 28, 1)inner_palette = displayio.Palette(1)inner_palette[0] = 0x000000  # Blackinner_sprite = displayio.TileGrid(inner_bitmap, pixel_shader=inner_palette, x=3, y=2)splash.append(inner_sprite)# Create a text label in the center of the inner rectangle.# This is a monochrome display, so there can be only black# or white.#text1 = "Hello World!"text2 = "Hello Python!"text_area = label.Label(terminalio.FONT, text=text1, color=0xFFFFFF, x=28, y=15)splash.append(text_area)# I wanted to show more than one string on the display.# Looking into the source for label.Label showed _set_text()# and _update_text().# I chose the latter because it only required one argument,# the new text to display.## What is bothersome to me is that _set_text requires two arguments,# the text string followed by a scale value, an integer. When I found# the source on GitHub, the scale argument wasn't being used. To add# insult to injury, that unused argument is required for the function# call.#while True:time.sleep(2)text_area._update_text(text2)time.sleep(2)text_area._update_text(text1)

I’ve also set up my copy of Visual Studio Code as a Circuit Python development environment. I tried to install the one lone plugin that’s supposed to provide this, but it doesn’t work. In the mean time when I want to code I open the file on the devices flash drive and then open a terminal at the bottom and start screen /dev/ttyACM0 115200 which gives me the serial REPL as well as output from any print messages. Please note that /dev/ttyACM0 is the device on my computer, which is running Pop!_OS 21.10. Also note that I’ve also got VSCode set up for Pico MicroPython development which will only support Pico MicroPython development. Another post, perhaps.

I purchased an Adafruit STM32F405 Feather ( https://www.adafruit.com/product/4382 ). I purchased it because it has an STM32, a SoC built around an ARM M4 with hardware floating point, clocked at 168MHz. You can check the full specs on the provided link. Because it’s an Express board, it will run Adafruit’s Circuit Python ( https://github.com/adafruit/circuitpython ), Adafruit’s fork of MicroPython ( http://micropython.org ). In this post I’m going to install the latest version of Circuit Python (as of the date of this post) on the Feather and test it with a simple Python application that flashes the on-board NeoPixel different colors.

All of this is hosted on a 2020 M1 13″ MacBook Pro running macOS Monterey version 12.0.1.

We’ll start by installing a helper application that will program the STM32 with the Circuit Python binary. I’ll use Homebrew ( https://brew.sh ) to install dfu-util (brew install dfu-util). I’ll then go to https://circuitpython.org/board/feather_stm32f405_express/ and download the latest version of Circuit Python, which as of right now is 7.0.0.  Save it somewhere you will remember for later. The file I downloaded was adafruit-circuitpython-feather_stm32f405_express-en_US-7.0.0.bin

Plug the Feather into one of the Mac’s USB-C ports. You’ll need a USB-C to USB-C cable for this; the STM32 Feather (finally!) is equipped with USB-C instead of micro USB.

Take a wire and connect the B0 pin to 3.3V (see image below). This is the bootloader wire. Press the reset key to put the Feather into bootloader mode.

On your host computer open a shell. I use iTerm which in turn uses zsh, the shell for macOS. Change directory to where you stored the downloaded binary (bin) file and use dfu-util to program the Feather with this file. Execute the following:

dfu-util -a 0 --dfuse-address 0x08000000 -D adafruit-circuitpython-feather_stm32f405_express-en_US-7.0.0.bin

When Feather programming finishes, unplug the Feather from USB-C, remove the bootloader wire, and reconnect the Feather. The Feather will now appear as a flash device on the Mac and it will execute Circuit Python programs stored on the flash device. What follows is the Feather’s flash filesystem:

When first booted after the initial Circuit Python programming, there is no file in the lib folder. You’ll need to add this yourself. Go to https://github.com/adafruit/Adafruit_CircuitPython_NeoPixel and download, from releases, adafruit-circuitpython-neopixel-7.x-mpy-6.2.3.zip. Unzip this file and look for lib/neopixel.mpy. Drag neopixel.mpy into the Feather’s lib directory, so that it looks like the image above.

Test Code

Using the code editor of your choice, open the file code.py on the Feather and delete everything you find. Then copy and paste the following:

import timeimport boardimport neopixelneopixel = neopixel.NeoPixel(board.NEOPIXEL, 1, brightness=0.2, auto_write=False, pixel_order=neopixel.GRB)while True:neopixel.fill((64,0,0)) # redneopixel.show()time.sleep(1)neopixel.fill((0,64,0)) # greenneopixel.show()time.sleep(1)neopixel.fill((0,0,64)) # blueneopixel.show()time.sleep(1)neopixel.fill((64,16,0)) # orangeneopixel.show()time.sleep(1)neopixel.fill((0,32,32)) # cyanneopixel.show()time.sleep(1)neopixel.fill((0,0,0)) # blackneopixel.show()time.sleep(5)

All you have to do is save the file, and the Feather will start to execute it immediately.

I managed to build LiteIDE X37.1 from the GitHub sources by following the projects clear, simple directions. They were:

$ git clone https://github.com/visualfc/liteide.git$ cd liteide/build$ ./update_pkg.sh$ ./build_linux_qt4.sh## Run it. While within the build folder from above: ##$ cd liteide/bin$ ./liteide

They are part of the website’s installation directions. The website is here: http://liteide.org/

The directions were written for Ubuntu 16.04, but they work just as well for Ubuntu 18.04. It should be noted that Qt5 doesn’t need to be installed. Just start with the git clone of the source and go from there. I’m running it out of where it was built. I haven’t run the installation and for my uses I don’t intend to.

For the record I have the latest version of Go, 1.14.3 for linux-arm64 (ARMv8).

This isn’t the first time I’ve built this tool. I built an earlier version under Raspbian Buster on the Raspberry Pi 4. It built and worked fine there, too.

As for usefulness, it is quite useful, at least for my purposes. In the example above it found all my files under the default GOPATH (go env GOPATH) and I was able to quickly navigate to my work and open one of my files I developed on the Raspberry Pi. It’s my hope to build and attempt to run the software and Adafruit hardware I used on the Raspberry Pi.

Right now I’m in the process of fulfilling a promise I made to my wife to clean out a good portion of our house and begin to do some home improvements. I’ve accrued a lot of “homeowner dept” that I need to pay down quite a bit. I’m retired and back to living in the regular world. These little reports will be short and sweet, and perhaps infrequent. But I won’t mind. I do all of this because I enjoy it, when I feel like it. Not because I have to. And that’s alright.

All of this work is done on my MacBook Pro with macOS Mojave 10.14.6 (I haven’t upgraded beyond Mojave yet because I don’t see the need on the MacBook, and if I need macOS 10.15 it’s installed on my Mac Mini).

First, let’s sort out my (miss) adventures with Arduino IDE. It started a few days ago when I decided to do something with the Feather, a device I’d purchased nearly a year prior. I’d plugged it in several times when it first arrived and I’d used the Arduion IDE’s Serial Monitor (Tools > Serial Monitor) to check it. It shipped with the StandardFirmataBLE sketch compiled and installed, so I was able to see the device’s internal configuration on the Serial Monitor as well as test it with Adafruit’s Bluefruit LE Connect app. I then put it aside and wound up forgetting about it until just recently. Adafruit still sells the device today, which is good.

It was during this restart I noticed that my version of the Arduino IDE was at 1.8.7, but the website had released 1.8.10. So I downloaded the latest IDE software and installed it.

After the IDE updated I updated the Feather’s bootloader software. That went off without a hitch. Then I started to look at the sample sketches for the board that Adafruit provides. Since it already came with the Firmata sketch installed and running, I found the source in the samples and attempted to recompile and upload. That’s when everything went screwy. Here’s an example of the error output.

Arduino: 1.8.10 (Mac OS X), Board: "Adafruit Bluefruit Feather nRF52832, 0.2.13 SoftDevice s132 6.1.1, Level 0 (Release)"/Users/wbeebe/Git/arduino/libraries/Servo/src/nrf52/Servo.cpp: In member function 'void Servo::writeMicroseconds(int)':/Users/wbeebe/Git/arduino/libraries/Servo/src/nrf52/Servo.cpp:92:12: error: 'g_APinDescription' was not declared in this scope  instance=(g_APinDescription[pin].ulPWMChannel & 0xF0)/16;^~~~~~~~~~~~~~~~~/Users/wbeebe/Git/arduino/libraries/Servo/src/nrf52/Servo.cpp: In member function 'int Servo::readMicroseconds()':/Users/wbeebe/Git/arduino/libraries/Servo/src/nrf52/Servo.cpp:123:12: error: 'g_APinDescription' was not declared in this scope  instance=(g_APinDescription[pin].ulPWMChannel & 0xF0)/16;^~~~~~~~~~~~~~~~~Multiple libraries were found for "Firmata.h" Used: /private/var/folders/d9/n152_yx519121c0nlmlds71c0000gn/T/AppTranslocation/2101D1AD-76B6-4A4E-A36D-936C2672D030/d/Arduino.app/Contents/Java/libraries/FirmataMultiple libraries were found for "Adafruit_LittleFS.h" Used: /Users/wbeebe/Library/Arduino15/packages/adafruit/hardware/nrf52/0.14.6/libraries/Adafruit_LittleFSMultiple libraries were found for "InternalFileSystem.h" Used: /Users/wbeebe/Library/Arduino15/packages/adafruit/hardware/nrf52/0.14.6/libraries/InternalFileSytemMultiple libraries were found for "bluefruit.h" Used: /Users/wbeebe/Library/Arduino15/packages/adafruit/hardware/nrf52/0.14.6/libraries/Bluefruit52LibMultiple libraries were found for "Servo.h" Used: /Users/wbeebe/Git/arduino/libraries/Servo Not used: /private/var/folders/d9/n152_yx519121c0nlmlds71c0000gn/T/AppTranslocation/2101D1AD-76B6-4A4E-A36D-936C2672D030/d/Arduino.app/Contents/Java/libraries/Servo Not used: /Users/wbeebe/Library/Arduino15/packages/adafruit/hardware/nrf52/0.14.6/libraries/ServoMultiple libraries were found for "Wire.h" Used: /Users/wbeebe/Library/Arduino15/packages/adafruit/hardware/nrf52/0.14.6/libraries/Wireexit status 1Error compiling for board Adafruit Bluefruit Feather nRF52832.

Lots of error messages. The key to a solution is line 20, but I’ll get to that. In the meantime I went slumming on the Internet for solutions, none of which really worked, so that don’t bear repeating here. What finally got me out of this mess and allowed the sketch to compile is the removal of the libraries folder pointed to in line 20 (which none of the on-line experts never mentioned). I don’t know what happened except that something got out of sync in the upgrade to Arduino IDE 1.8.10, and that caused a cascade effect in the error messages. When I removed the libraries folder and then reloaded the Adafruit nRF52 specific libraries again, everything was just fine. The libraries folder was recreated by the IDE.

In the mean time I decided to try to run a sketch that simply flashed the LEDs on the Feather board. The listing follows.

#include <Arduino.h>void setup() {// whb Nov 2019// This must be performed first or else nothing else will work.// No, I don't know exactly why.//Serial.begin(115200);// LED_RED & LED_BLUE pins are already initialized outputs.// Create loop2() using Scheduler to run in 'parallel' with loop()//Scheduler.startLoop(loop2);}void loop() {digitalToggle(LED_RED); // Toggle LED delay(1000);// wait for a second}void loop2() {digitalToggle(LED_BLUE); // Toggle LED delay(300);  // wait for a half second  }

There’s far more comments than code, and that’s after not including the boilerplate block comment at the start of the code. This is from an example sketch provided when you install the Adafruit libraries. So I compiled and uploaded it, and the lights didn’t flash. Ok. I went online to Adafruit’s Feather documentation and copied an even simpler sketch that just flashed the red LED. Again, compiled and uploaded and nothing happened. The red LED just glimmered, like it did while the upload to the Feather was taking place.

I went back and looked at the major Firmata sketch, and at setup specifically, and that’s when the light went off. So I added line 15 above, and bingo, the lights started to flash like they’re supposed to. I played with a number of other sketches like this one. Load them without the Serial.begin() and nothing worked. Add that single line and it worked as advertised.

I also like this sketch because it points to the use of freeRTOS in the code. Keep in mind that the processor in the feather is a 32-bit ARM Cortex M4 processor running at 64MHz with 64K of RAM and 256K of Flash. It’s more than enough for basic embedded work, including freeRTOS. When I think back to the late 1970s and early 1980s I would have given anything to have this back when all that was available were Commodore 64s and Apple ][s and TRS-80s and the original IBM PC. This even blows the original Macintosh away with its 8MHz Motorola 68000. And here it all is now, on a board not much bigger than a stick of chewing gum and all for just $25 instead of the hundreds to thousands back then. Anyway…

The Arduino and its environment are now stable again, and I can build (in C, and possible C++) “sketches” for the Feather. This goes along with my Circuit Playground and my little Adafruit 32U4 powered robot. All of my code is checked into my Github location, https://github.com/wbeebe/arduino

Working with the Raspberry Pi 4B continues. I installed the Arduino IDE version 1.8.9 (https://www.arduino.cc/en/Main/Software) and was able to quickly start it and have it working with a Circuit Playground Express. I found a sample C++ program on GitHub (https://github.com/adafruit/Adafruit_CircuitPlayground/tree/master/examples/FidgetSpinner) and created a simple project, compiling it, but not uploading it. That will come later. I just wanted to check out the basic installation to see if it worked up to a point, and it all does. My only comment is that when you download the IDE that you choose the ARM 32-bit version. It’s a standard tar file, no compression. Once untarred, then execute install.sh. It will not only place everything where it needs to be, but set up permissions, groups, and add a menu entry under Programming.

The IDE seems fully functional. One aspect of using the IDE natively on the RPi 4B with 2GB is that compiles are noticeably slower than they are on my MacBook Pro. But that’s to be expected, and the time taken is not excessive. Just noticeable.

During this period of testing I’ve also managed to force Raspbian to hit the swap space. Unlike the 1GB RPi 4B, the 2GB version’s use of swap is one to two orders less than the 1GB version with the same application load. Right now I’m seeing 4.5MB out of 2GB of swap being used, or essentially next to nothing.

Finally, I installed two more software packages, Swift for ARM and PowerShell Version 7 Preview 2 for ARM.

In order to install Swift on Raspbian Buster, you neeed to add a reference to the repo, then install Swift from that repo. Those steps are:

curl -s https://packagecloud.io/install/repositories/swift-arm/release/script.deb.sh | sudo bashsudo apt install swift5=5.0.2-v0.4

Once installed you can run this basic test:

pi@raspberrypi:~ $ swiftc --versionSwift version 5.0.2 (swift-5.0.2-RELEASE)Target: armv6-unknown-linux-gnueabihfpi@raspberrypi:~ $

You can read about Swift ARM here: https://swift-arm.com/
Note that you should check to see what the current version of Swift ARM is when you install. I chose 5.0.2-v0.4 because that was what was published in the announcement on the web site.

PowerShell Core for Raspbian Buster is available as a regular tar file here: https://github.com/PowerShell/PowerShell/releases

Once downloaded, create a directory on your login home. In my case I simply created ~/powershell. Step into it and untar the newly downloaded archive into the newly created directory. Once untarred simply run pwsh. For example:

pi@raspberrypi:~/powershell $ ./pwsh PowerShell 7.0.0-preview.2Copyright (c) Microsoft Corporation. All rights reserved.https://aka.ms/powershellType 'help' to get help.PS /home/pi/powershell> $PSVersionTableName   Value----   -----PSVersion  7.0.0-preview.2PSEdition  CoreGitCommitId7.0.0-preview.2OS Linux 4.19.58-v7l+ #1245 SMP Fri Jul 12 17:31:45 BST 2019Platform   UnixPSCompatibleVersions   {1.0, 2.0, 3.0, 4.0…}PSRemotingProtocolVersion  2.3SerializationVersion   1.1.0.1WSManStackVersion  3.0PS /home/pi/powershell> 

And that’s about it.

One more thing. The Flirc case runs warm, but not excessively so. CPU temperatures seem to run between 45°C and 50°C. I’m still working on a 40-pin ribbon cable connector that will easily fit inside the case over the GPIO header.

New toys arrived today. One of them was a new Raspberry Pi 4.

I ordered a second Raspberry Pi 4 with twice as much memory as the first one, for $10 more. That’s right, the 2GB version costs $45. I picked it up through Adafruit. Once it arrived I pulled out the micro SDXC card I’d been using on the 1GB version and placed it within the 2GB version. Moved over the cables and the wireless keyboard and mouse dongles, plugged in the power, and booted into the Raspbian Buster desktop. With the extra memory it appears to be a bit faster all around.

I still had to program the latest USB firmware into the chip.

As you can see in the screenshot, the amount of swap space was automatically set clamped to 2GB. Based on my simple formula (2 times available memory), it should have been 2 times 1.8GB, or 3.6GB of space. But it’s clamped to 2GB. That’s not a problem as I discovered.

I opened up Chromium and terminal and a number of other desktop applications, and I never touched swap once. I therefore have to recommend that if you want to use the Raspberry Pi 4 as a legitimate desktop, then purchase at least the 2GB version.

I discovered that the processor temperatures are the same as the 1GB version with the heat sinks attached. That tells me the heat sinks I had aren’t useful at all. I ordered a new case from Flirc for the Raspberry Pi 4, one that has a part of the case extend down and touch the processor itself. The case is supposed to act as a big passive heat sink. They’re on sale right now for about $12/case, which is quite affordable. They should arrive next Monday. In the mean time I’ll just leave the box open and let it do its thing uncovered. Oh, I nearly forgot, the Flirc case has a slot cut in the side for the GPIO pins to be connected to external circuitry. Unfortunately for some, there are no slots for the camera cable.

Prerequisites

A Raspberry Pi 3B+ or 4 with Raspbian Buster installed and connected to an Adafruit Circuit Playground Express via a micro USB to USB cable and with CircuitPython installed on the Circuit Playground Express (see working with the adafruit circuit playground express using the raspberry pi 4).

Circuit Python Programming Example 6

With the Circuit Playground Express still plugged in from Example 5, and with Example 5’s main.py running, we’re now going to run a Python application on the Raspberry Pi that reads the button presses from the CPE and displays them on the terminal. Here’s the code to run on the Raspberry Pi, named cpe-monitor.py:

#! /usr/bin/env python3## Circuit Playground Express example, Raspberry Pi side#import glob, serial, time, signal, sys# Use glob function to return all device file names of the form /dev/ttyACM*# I was supprised during development when /dev/ttyACM0 became /dev/ttyACM1# So we deal with the possibility of a name change in the last digit.# device = glob.glob("/dev/ttyACM*", recursive=False)[0]serUSB = serial.Serial(device, 115200, timeout=1)# Control C handler. Exit gracefully and close the USB serial device.#def sigint_handler(signum, frame):serUSB.close()print()sys.exit(0)signal.signal(signal.SIGINT, sigint_handler)# Tell the user what device name we're using, and perform a close and then# an open. Many times /dev/ttyACM* is already open when we get here.#print("Start monitoring output from Circuit Python Express on %s" % device)serUSB.close()serUSB.open()# Endless loop.#while True:usbdata = serUSB.read_until()# The USB serial device times out every second and returns if it has# not recieved any data.# If it does time out check for zero data returned.#if len(usbdata) > 0:# It's a byte array, convert to string and strip CR/LF.#print(usbdata.decode('UTF-8').rstrip())

There are far more comments than there are actual lines of code. The key lines are 12,33, 39, and 43.

• Line 12 opens the USB connector as a serial tty device. The glob statement just above the open statement is due to the fact that it would appear that ttyACM0 isn’t cast in stone. During one run, for reasons I still don’t understand, /dev/ttyACM0 was replaced by /dev/ttyACM1.
• Line 33 reads in the data as a byte array,.
• Line 39 checks to see if real data has been returned. That’s because the USB serial line was opened in line 12 with a 1 second timeout. Timeouts are good because if there’s no activity you can exit and do something else. It’s a crude form of multitasking at the Python level.
• Line 43 prints out that data after converting the byte array received in line 33 into a string and stripping off any CRs and LFs from the end of the string.

A typical run looks like this. First the A and B buttons are pressed, then the switch is turned on and the A and B buttons are pressed again.

pi@raspberrypi:~/circuit-python-express $ ./cpe-monitor.py Start monitoring output from Circuit Python Express on /dev/ttyACM0Button A pressedButton A releasedButton B pressedButton B releasedButton A pressedSwitch onButton A releasedButton B pressedSwitch onButton B released

Not too much to get excited about yet. But think about how Python code other than the print() statement might make use of these simple strings. We now have an external input device, the CPE, telling the application running on the Raspberry Pi that events are taking place. Now all we have to do is open a serial channel on the CPE to read any data that the Raspberry Pi application might want to write back as some form of confirmation of reception.

Next time…

Prerequisites

A Raspberry Pi 3B+ or 4 with Raspbian Buster installed and connected to an Adafruit Circuit Playground Express via a micro USB to USB cable and with CircuitPython installed on the Circuit Playground Express (see working with the adafruit circuit playground express using the raspberry pi 4).

Circuit Python Programming Example 5

Using the same setup with the Adafruit Circuit Playground Express (CPE) and the Raspberry Pi 4 we used in the last two posts, I’ve writen another Python application that senses and uses push buttons A and B and the slide switch on the CPE.

Using the push buttons and the small slide switch, the Python application will light up all the NeoPixels in various colors. The application will react to single button pushes as well as having both pushed simultaneously. The listing for the application is at the end of the post.

The CPE comes with a number of interesting inputs. Three of them are two push buttons, labeled A on the left and B on the right, with a small slide switch just above the JST battery connector at the bottom center of the CPE. It’s a surface mount single pole single throw (SPST) slide switch. If slid to the right, it’s off. If it’s slid to the left, then it’s on, and on means it’s detectable as such in code.

When the code in this example is saved to the CPE as main.py, then the application works as follows:

The push buttons combined with the switch provide six lit NeoPixel display states as shown in the table above.

The application also illustrates another aspect of programming the CPE. If you want the application to run continuously, then you write and endless loop. Line 71 uses a ‘while True’ to keep the application running. It will only stop if you turn the power off to the CPE or it has a programming error of some type.

# Circuit Playground Express example.# Uses the NeoPixels, the A and B pushbuttons, and the switch.#import board, neopixel, timefrom digitalio import DigitalInOut, Direction, Pull# This is the small slide switch located in the center of# the circuit board, just above the JST Battery Connector.#switch = DigitalInOut(board.D7)switch.direction = Direction.INPUTswitch.pull = Pull.UP# This is the 'A' push button, the left push button on the circuit board.#buttonA = DigitalInOut(board.BUTTON_A)buttonA.direction = Direction.INPUTbuttonA.pull = Pull.DOWN# This is the 'B' push button, the right push button on the circuit board.#buttonB = DigitalInOut(board.BUTTON_B)buttonB.direction = Direction.INPUTbuttonB.pull = Pull.DOWN# Basic NeoPixel colors to play with.#RED = (31, 0,  0)YELLOW  = (31, 31, 0)GREEN   = (0,  31, 0)AQUA= (0,  31, 31)BLUE= (0,  0,  31)PURPLE  = (31, 0,  31)WHITE   = (31, 31, 31)BLACK   = (0,  0,  0)# An instance of the NeoPixels to work with programmatically.#pixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=.2)pixels.fill(BLACK)# To support guard logic around printing push button states.# We only want to print out when a button press is first# detected, and then we want to print out when the button is# released.#Apressed = FalseBpressed = False# A simple polling loop. The loop runs forever once it's entered# because of while True:, and it is constantly checking the state# of A and B pushbuttons, acting according to what it detects.## 1. If neither push button is pressed, the NeoPixels are dark.## 2. If Button 'A' is pressed and the switch is on,#turn on all NeoPixels as RED.# 3. If Button 'A' is pressed and the switch is off,#turn on all NeoPixels as YELLOW.# 4. If Button 'B' is simultaniously pressed, then only fill#the NeoPixels on Button A's side based on switch position.## 5. If Button 'B' is pressed and the switch in on,#turn on all NeoPixels as GREEN.# 6. If Button 'B' is pressed and the swith is off,#turn on all NeoPixels as BLUE.# 7. If Button 'A' is simultaniously pressed, then only fill#the NeoPixels on Button B's side based on switch position.#while True:if (buttonA.value):if (not Apressed):print('Button A pressed')Apressed = Trueif (switch.value):print('Switch on')if (not Bpressed):pixels.fill(RED)else:pixels[0:5] = [RED] * 5else:if (not Bpressed):pixels.fill(YELLOW)else:pixels[0:5] = [YELLOW] * 5else:if (Apressed):print('Button A released')Apressed = Falseif (not Bpressed):pixels.fill(BLACK)else:if (switch.value):pixels[0:5] = [GREEN] * 5else:pixels[0:5] = [BLUE] * 5if (buttonB.value):if (not Bpressed):print('Button B pressed')Bpressed = Trueif (switch.value):print('Switch on')if (not Apressed):pixels.fill(GREEN)else:pixels[5:10] = [GREEN] * 5else:if (not Apressed):pixels.fill(BLUE)else:pixels[5:10] = [BLUE] * 5else:if (Bpressed):print('Button B released')Bpressed = Falseif (not Apressed):pixels.fill(BLACK)else:if (switch.value):pixels[5:10] = [RED] * 5else:pixels[5:10] = [YELLOW] * 5

All the highlighted code is the logic I added to only perform an action once when either push button is pressed or released. Without that guard logic in place, those print statements would stream on the serial debug console. This makes tracking actions very difficult, if not impossible, to do. It also keeps the logic running in the loop to a bare minimum and allows it to run as fast as possible. Not only would the print statement stream without the logic, but manipulation of the NeoPixels would be non-stop. We only want actions to be performed once on a button state transition (non-pressed to pressed, and released).

The REPL

The screen command can still be used to connect to the device as shown in the earlier posts, but when it first connects nothing will be displayed unless an explicit ‘print()’ statement sends it out. To open the REPL while this application is running type [Ctrl] C and then Enter. To exit the REPL type the usual [CTRL] D and the application will start running again.

A Raspberry Pi 3B+ or 4 with Raspbian Buster installed and connected to an Adafruit Circuit Playground Express via a micro USB to USB cable and with CircuitPython installed on the Circuit Playground Express (see working with the adafruit circuit playground express using the raspberry pi 4).

Setting Up and Tearing Down the REPL

Attach the Circuit Playground Express (CPE) to the Raspberry Pi. The CIRCUITPY storage device icon will appear on the desktop and a dialog will appear simultaneously asking if you want to open removable media in a file manager. You can click OK if you wish, or Cancel to remove the dialog. If you cancel the dialog but wish to open the removable media portion you can double click on the desktop icon. If you open the file manager you’ll see the following:

It’s fairly empty at the moment. Now, open an LXTerminal and type ‘screen /dev/ttyACM0 115200‘ at the prompt.

Auto-reload is on. Simply save files over USB to run them or enter REPL to disable.Press any key to enter the REPL. Use CTRL-D to reload.

Don’t type anything. Instead, using the mouse, click the up arrow that has appeared on the upper right task bar. This is the media eject control. Clicking it will produce a menu with at least the CIRCUITPY as an entry (you may have more depending on what other removable media you have plugged in. Select the CIRCUITPY entry to remove accessibility to CIRCUITPY. Then physically disconnect the CPE. Your console will now display the following:

pi@raspberrypi:~ $ screen /dev/ttyACM0 115200[screen is terminating]pi@raspberrypi:~ $

I’ve just shown how to set up and tear down the serial port into the CPE. For writing code in an editor and saving it on the CPE as main.py, it will print out any syntax errors and other data as needed to the terminal.

Circuit Python Programming Example 1

In this example I’ll show you how syntax errors will appear on the terminal. If you’ve detached the CPE, plug it back in so that it’s seen as removable media. Restart the screen utility so that you see the intro text in the terminal. Now start a text editor (VIM, gedit, text editor, whatever). Type a single line into the editor, ‘import fubar‘. Then save what you just typed as main.py onto CIRCUITPY and then look at your terminal.

Auto-reload is on. Simply save files over USB to run them or enter REPL to disable.main.py output:Traceback (most recent call last):  File "main.py", line 1, in <module>ImportError: no module named 'fubar'Press any key to enter the REPL. Use CTRL-D to reload.

There obviously is no fubar module, and Circuit Python prints out that fact as an error message on the terminal.

Circuit Python Programming Example 2

Let’s print something on the terminal. Replace the import statement with ‘print('Hello terminal')‘ and save the file. Now the terminal will show:

Auto-reload is on. Simply save files over USB to run them or enter REPL to disable.main.py output:Hello terminalPress any key to enter the REPL. Use CTRL-D to reload.

The Circuit Python is waiting for changes to main.py. Every time you save it you change it (you change the file’s timestamp, the last time the file was modified), CPE will attempt to run it. Either it’ll run, or it will stop with errors. You can use print statements to debug a program as it runs and see those print statements on the terminal.

Circuit Python Programming Example 3

Now lets code something a bit more ambitious. Let’s copy the following code into your editor and then save it out as main.py again.

import board, neopixel, timepixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=.2)RED = (63, 0, 0)pixels.fill(RED)time.sleep(1)GREEN = (0, 63, 0)pixels.fill(GREEN)time.sleep(1)BLUE = (0, 0, 63)pixels.fill(BLUE)time.sleep(1)BLACK = (0, 0, 0)pixels.fill(BLACK)

If you’ll recall this is essentially the same code we typed in by hand at the end of the last post, except this time we’re going to write it into main.py and save it. When you do, you’ll see all the NeoPlixel LEDs light up in red, then green, then blue, then go dark. We’ve added three sleep commands for one second so that it doesn’t run through all the fill commands. Save this version of main.py and watch the NeoPixels light up.

What if you want to have the application repeat? You can save it again, or you can hit any key in the terminal to enter the REPL and then [Ctrl] D to exit, and the CPE will execute main.py all over again. This might be useful for simple programs, or you might want to get a bit more sophisticated for repetitive applications.

Circuit Python Programming Example 4

Let’s add to our existing application. Let’s add some looping and some print statements.

import board, neopixel, timepixels = neopixel.NeoPixel(board.NEOPIXEL, 10, brightness=.2)for letter in "ABCDE":print(" %c loop" % letter)RED = (63, 0, 0)pixels.fill(RED)time.sleep(0.5)GREEN = (0, 63, 0)pixels.fill(GREEN)time.sleep(0.5)BLUE = (0, 0, 63)pixels.fill(BLUE)time.sleep(0.5)BLACK = (0, 0, 0)pixels.fill(BLACK)

I’ve changed the sleep time, lowering it to 1/2 second so the loop will go faster than the single pass used in example 3. I’m using simple iteration of a string of characters. In every loop I print out the letter of each loop. Save the file and watch the NeoPixels cycle through red, green, and blue five times. Here’s what the terminal looks like.

Auto-reload is on. Simply save files over USB to run them or enter REPL to disable.main.py output: A loop B loop C loop D loop E loopPress any key to enter the REPL. Use CTRL-D to reload.

You’ve now got an application that manipulates some of the CPE’s devices (the NeoPixels) as well as printing out what loop it’s in on the terminal while it’s running.

The CPE is a powerful little board, with a lot more than just NeoPixels to manipulate. Perhaps next time I’ll dive in and add both CPE input and output, and find a way to feed some of the CPE’s inputs back to the Raspberry Pi.