Environment: Ubuntu 23.10 on a Raspberry Pi 5 8 GiB with the full Rust toolchain installed.

I’ve been exploring the world of Rust recently. Rust isn’t just a language, it also seems to be an environment for nurturing interesting creativity. I’ve been working with products of that Rust-inspired creativity: zellij, bat, and dust.

zellij ( https://zellij.dev/ ) is an alternative to tmux ( https://github.com/tmux/tmux/wiki ). I’ve begun to use it here, with nvim, as a very lightweight alternative to full blown Visual Studio Code for rust development. I can also use it to quickly cobble together a set of views in one terminal to keep track of multiple tools looking at a wide range of system statuses. Having it all fit in multiple zellij panes is easier on the resources than having multiple independent terminals I have to keep track of on the desktop. I personally find zellij easier to use than tmux. In the first screen capture, I’ve got neofetch, btop, and duf in three individual panes in a single terminal instance. Installation is cargo install zellij.

I’m contrasting bat ( https://github.com/sharkdp/bat ) with nvim to show how close, yet how different they are visually. I prefer bat over cat, and have cat aliased to bat in my environment. Sometimes all I want to do is just read a text file, and bat does it so well. Installation is cargo install bat.

Finally there’s the Rust version of du, dust ( https://github.com/bootandy/dust )With dust I get a much clearer view of disk usage at any point in the filesystem. Regular du only provides byte sizes, while dust gives you a relative size graph to the right and a partial tree along with the space usage in each branch of the tree. And dust is fast. It’s the fastest utility of its type I’ve ever used. I won’t say it’s fast because of Rust, but probably a combination of clever design, coding, and Rust. Installation is cargo install du-dust.

I’m no Rust language expert. But I am growing to appreciate it as a personal tool builder as well as the foundation for excellent command line tools. I am exploring more every day as I grow to trust the current batch I’ve got installed on all my systems, both Linux and macOS.

This is the lightest of lightweight comparison of Vim 9 and Neovim stable release 0.9.5 running under Ubuntu 23.10 on a Raspberry Pi 5.

Vim 9 is the regular package installation bundled with Ubuntu 23.10, while Neovim was built from source. Neovim was built from source because the latest neovim version available was 0.7.2 (via apt show neovim); if you’ve been following Neovim then you will know how much has changed since stable release 0.8, so that makes 0.7.2 pretty much a non-starter.

Vim 9 is running with the Afterglow color scheme and PowerLine for the status line layout at the bottom. I’ve written about this already. The code common to both examples is a simple command-line utility I wrote in Rust, which is also installed on this Raspberry Pi. I’ve been a vi user since at least the early days when I was exposed to BSD Unix via DEC Ultrix running on a MicroVAX, back around 1985. Once exposed I stuck with it because anything else back then for editing source code was horrific to use by comparison. Of course there was no coloration back then. If you wanted color you either used a white, green, or orange monitor. Your choice.

I should note that VIM 9.1 was released on 2 January 2024, but the way distributions are managed you won’t see it in the regular distributions unless you, the user, take extraordinary actions, such as using an alternative repo, use Flatpack or Appimage, or build from source. Because the Raspberry Pi 5 is ARM based, there is no Flatpack or Appimage except for x86_64. As for Snaps, well, nothing there for this platform, and if there were I wouldn’t touch it. Vim 9 is sufficiently stable that it’s good enough as is.

I found the color scheme Afterglow to be easy on the eyes and quite helpful reading and writing source code. Where-ever I use Vim, I have Afterglow installed side-by-side.

I built Neovim because I wanted to give it a try on the Raspberry Pi. There are instructions to install from source on the Neovim website. They’re quite clear and it took very little time to build my copy and install it for use.  To make it easier on me I executed the following:

make CMAKE_BUILD_TYPE=RelWithDebInfo CMAKE_INSTALL_PREFIX=/home/pi/tools/neovim-0.9.5/

There are instructions in the Neovim documentation that illustrate almost the same command sequence. I’ve reached a point where I have a ~/tools folder in my home folder to install whatever, so that I don’t have to use sudo to make it all available. Yes, I have to add a bit extra to my $PATH, but the little extra effort makes my regular environment much cleaner as a consequence, especially if I want to clean it all out later.

After building and installing my local neovim binary, I installed the AstroNvim Neovim configuration. And one other piece to install: I had to download and fully install all the Hack Nerd fonts from GitHub (see link below). I downloaded Hack.zip, unzipped everything, then copied all the Hack font files into ~/.local/share/font, logged out and then back in again to pick up all the fonts. If you don’t download the full set then you wind up with oddball square glyphs instead of the special characters that Neovim and AstroNvim use.

Then I started nvim and got to work.

I particularly like the way that Neovim plus AstroNvim works, creating a quite powerful IDE-like environment. In the example above I’ve used the predefined key sequence [SPACE] e to open a file view column to the left. I can use either the arrow keys plus the space bar to select any item, or I can click with the mouse. It can handle multiple open and tabbed files to the right, and it still has the complete vi key sequence to work with.

I believe that regular Vim, especially versions 9 and later, is a perfectly decent vi clone. But given the choice between vim and neovim, I’ve started to install and use neovim over vim.

Links

Vim Home — https://www.vim.org/

Vim Afterglow color scheme — https://vimcolorschemes.com/danilo-augusto/vim-afterglow/

Neovim Home — https://neovim.io/

AstroNvim — https://github.com/AstroNvim/AstroNvim

Nerd Fonts (just download Hack.zip) — https://github.com/ryanoasis/nerd-fonts/releases

…

Once upon a time, say back around 2016 or so, I purchased a monstrous (for the time) 6 TiB drive called the Seagate Backup Plus Hub Drive. I don’t recall how much I spent, but I’m pretty sure I purchased it from my local Costco, a brand they sold for many years until recently. I’m sure it was on sale at the time, being the cheap person I am. I used it for a few years, at least up until 2019, when I stopped using it and put it away in one of my cabinets. I can’t recall why I stopped using it, but it sat unused for about the next five years until today.

In the last post I wrote about backing up my iPhone 11. That’s all well and good, but until today I didn’t have a backup drive for this newest MacBook Pro. I’d tried to purchase another 5 TiB Seagate Backup Plus Portable from Costco, but the warehouse no longer carries them. When they did I could purchase them for $99, which isn’t bad at all. I have four of them already, for each of my various Macs. Looking online at both Amazon and Walmart, I can purchase a new one for about $160. When I saw the cost of those my memory was jogged a bit and I went and pulled out this now-old Seagate Backup.

The first thing I did was plug it into my MacBook, and sure enough it mounted and I was able to at least read the drive contents. The drive had come preformated as NTFS, because at the time I was still using my 17.2″ Samsung notebook computer and that backup drive’s primary use was meant for Windows 10 Pro. I used it for that purpose a number of times, but around late 2019 I began a hard switch to Linux and, of course, macOS. That switch is the reason why I pulled the Windows 10 SSD out of the Samsung and put in a fresh blank SSD, and then installed Linux Mint on it. Except for a Parallels VM with Windows 11 installed, I don’t run Windows on any of my personal systems any more.

Once the Seagate was plugged in and mounted, I attempted to reformat the drive as APFS with case sensitivity. Long story short, that’s the file system you should format on any drive meant for any contemporary Mac. I’ve read enough older junk on the web saying Apple created this so it would run efficiently on an SSD, and that may have been true to start with, but any version of macOS that came after 2014 used this, so I might as well get with the program.

The only problem was I decided to select the option where the entire drive would be scrubbed with binary zeroes, with a total of seven passes. I chose poorly. After waiting nearly four hours, the first pass had barely started. I killed the Disk Utility process, then proceeded to reboot my Mac because the act of killing Disk Utility made working with the Seagate null and void. Once the Mac was rebooted, I restarted the Disk Utility and allowed it to sanely format the drive, which it promptly performed in less than a minute.

So now the Seagate’s attached and Time Machine has performed it’s first full backup of this Mac; about 140 GiB in about 20 minutes. That Mac backup includes my iPhone backup to the Mac, so now I’m (I hope, fingers crossed) doubly backed up.

By the way, the name of the backup drive is named BACKUP6T (for terabyte). I don’t expect anything terrible to happen with this older backup drive. You can still purchase them with capacities up to 14 TiB. I also need to read one more time what the two USB A ports are used for. According to the flashy documentation I can use those front ports to backup “your files, precious photos and videos while connecting to and recharging your tablet, smartphone or camera.” I can certainly appreciate backing up my iPhone, but since I’ve never done that kind of backup before it will be another adventure!

Links

Seagate Backup Plus Hub Drive — https://www.seagate.com/products/external-hard-drives/backup-plus-hub/

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

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

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

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

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

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

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

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

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

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

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

Links

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Links

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

The great upgrade from Linux Mint v 21.2 to v 21.3 occurred early this morning while I was fixing breakfast. I get up early to open the house, and check on the creatures as well as my machines. I found the notice to upgrade on the Linux Mint Upgrade Manager, so I just kicked it off while I finished my morning chores. So far nothing is amiss, and if you sat me in front of two systems, one running 21.2 and one running 21.3, I wouldn’t be able to tell the two apart unless I cheated (cat /etc/os-release). And that, for me, is a wonderful thing. I’ve grown rather conservative about allowing change in my primary computer platforms. It would appear I’m in good company (in a way);

Just a note that I’m currently bisecting into this merge for a horrendous performance regression.

It makes my empty kernel build go from 22 seconds to 44 seconds, and makes a full kernel build enormously slower too.
…
This is on a 32-core (64-thread) AMD Ryzen Threadripper 3970X, fwiw.

This from Linus Torvalds. As the author of the Phoronix article notes, Linus is still “rocking” a Ryzen Threadripper system from four-going-on-five years ago, something the author finds surprising. I don’t think it’s surprising at all. After the high cost of moving to new hardware, there’s the equally high cost of time invested in the system to get it work the way you are comfortable with. And finally, you get to know that system and how it’s supposed to work; when something doesn’t work quite right you instinctively know and can start looking for what’s wrong, which Linus did.

Anyway, the update is now on the system and everything works just fine as it did before (so far).

Links

Linux Mint New Features — https://www.linuxmint.com/rel_virginia_whatsnew.php

Linus Torvalds Hits Nasty Performance Regression With Early Linux 6.8 Code — https://www.phoronix.com/news/Linux-6.8-Sched-Regression

AMD Threadripper 3970X and 3960X Review: High-End Domination — https://www.tomshardware.com/reviews/amd-threadripper-3970x-review

I bring up Ken Thompson’s talk because today I was reminded of why he said he was leaving Apple in that talk. After starting Visual Studio Code on my brand new M1 Max MacBook Pro I attempted to check for VS Code updates and was gobsmacked with the following error dialog:

Look in the lower right corner at the dialog with the red circled ‘X’ about running on a read-only volume. There’s a link to mitigate the issue, but the the statement that “This might mean the application was put on quarantine by macOS” just royally pisses me off. This is the very first time I’ve been hit with the “quarantine application” issue on macOS, but not the first time I’ve run into a show-stopping problem on macOS that shouldn’t have happened.

I followed the link in the message, and based on the post I performed the following to get things straightened out.

sudo chown $USER Library/Caches/com.microsoft.VSCode.ShipItxattr -dr com.apple.quarantine ~/Applications/Visual\ Studio\ Code.app

My VSCode is located locally in my account folder, not under global /Applications. I’m sure that chown isn’t needed, but still it’s good to have around. Once those changes were made, I quite VSCode and restarted it via Launchpad as always, then checked again for updates, and it worked just fine (VSCode was already up to date anyway).

It’s obstacles thrown up like that that make developers like me who actually know how to get work done want to just walk away from Apple. I’m sure Apple will point to XCode, but I don’t want to develop with XCode because I do a lot of wide-ranging work well beyond Apple and macOS. It’s not as bad as Microsoft, who have basically driven me away from Windows permanently with their shenanigans with regards to Windows 11. But it’s getting close. If it gets bad enough I may indeed contemplate migrating to Asahi Linux; that’s another reason why I chose this M1 Max over a later version of Apple Silicon; Asahi Linux was originally developed on, and for, the M1.

Links

Code won’t update on macOS #7426 — https://github.com/microsoft/vscode/issues/7426

I suddenly find I have need to do a little Java development. It’s been a long time since I dipped my fingers, as it were, into writing Java code. This was back around Java 9 (September 2017) and it was such as mess with the way Oracle had blown up Java’s libraries that I just basically walked away from Java. I still install it when I need it because I have some tools that depend upon the Java runtime.

Here I am trying to come up to speed, which at this point in my life may be impossible. I haven’t changed so much as Java has. Right now I’ve installed Java 21, what now passes for an LTS. I’ve installed the JDK and an IDE to work with it on my M1 Max MacBook Pro. Here’s what I did to get something working.

First I tried to install the JDK. I went searching for the latest LTS that would run on aarch64/arm64. When I searched on Duck Duck Go, I got nothing but hits on installing the Oracle version, which is not what I wanted. Instead I had to remember to search for Adoptium ( https://adoptium.net ). Rather than take the default offered on the landing page I chose to go to the alternate downloads page and pick it that way;

As you can see I whittled my choices down to two. I went with the .pkg because it’s a Mac, so that should be a no-brainer installation. That was a mistake. It installed alright, I just don’t know where. I came back and downloaded the tar.gz archive, unpacked it in a location in my local folder, defined JAVA_HOME to point to the location and then added it to my path. Once that was all done I could do a java --version and get the LTS version release.

I then decided to install NetBeans 20. I was a long-time NetBeans user and felt comfortable trying it again. The problem is that it would never find my installation of Java. I finally went into the app directory structure and ran, from the command line, ./netbeans --jdkhome $JAVA_HOME, at which point it finally came up. I was able to set up a decent look-and-feel and began to get comfortable with it. I even checked to see if NetBeans knew about the local Java installation, and it appeared to. However, when I closed NetBeans and tried to start it via Launchpad, it failed to start just like before. After that I removed NetBeans and installed IntelliJ IDEA 2023.3.2 (Community Edition) and immediately got to work learning how to get productive with it. I’ve used IntelliJ tools in the past for a number of years and I’ve never been disappointed. This time I chose to use the Community Edition because I didn’t need the full-blown suite, and I don’t have the funds right now to pay for a full commercial license. Maybe if this bit of work leads to something more substantial then I’ll expense it. Right now I’m just getting started.

So far the choices I’ve made appear pretty solid, and IntelliJ IDEA is a very nice environment.

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

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

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

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

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

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

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

Links

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

designing the esp32-s3/max7219 device

There are already consequences showing up from this huge rise in global temperature anomalies. For one example, the crazy bad weather over Orlando this evening as you can see in the screen capture at the start.

And then this weather warning from Orange County:

Severe Thunderstorm WarningBeginning: 2024-01-09T22:21:00Ending: 2024-01-09T23:00:00New AlertTHE NATIONAL WEATHER SERVICE IN MELBOURNE HAS ISSUED A* SEVERE THUNDERSTORM WARNING FOR...SEMINOLE COUNTY IN EAST CENTRAL FLORIDA...CENTRAL LAKE COUNTY IN EAST CENTRAL FLORIDA...ORANGE COUNTY IN EAST CENTRAL FLORIDA...VOLUSIA COUNTY IN EAST CENTRAL FLORIDA...NORTHWESTERN OSCEOLA COUNTY IN EAST CENTRAL FLORIDA...* UNTIL 600 PM EST.* AT 521 PM EST, SEVERE THUNDERSTORMS WERE LOCATED ALONG A LINEEXTENDING FROM NEAR PIERSON TO ZELLWOOD TO 12 MILES WEST OF FOURCORNERS, MOVING NORTHEAST AT 70 MPH.HAZARD...60 MPH WIND GUSTS.SOURCE...RADAR INDICATED.IMPACT...EXPECT DAMAGE TO ROOFS, SIDING, AND TREES.* LOCATIONS IMPACTED INCLUDE...ORLANDO, DELTONA, DAYTONA BEACH, KISSIMMEE, AND PORT ORANGE.PRECAUTIONARY/PREPAREDNESS ACTIONS...REMAIN ALERT FOR A POSSIBLE TORNADO! TORNADOES CAN DEVELOP QUICKLYFROM SEVERE THUNDERSTORMS. IF YOU SPOT A TORNADO GO AT ONCE TO ASMALL CENTRAL ROOM IN A STURDY STRUCTURE.FOR YOUR PROTECTION MOVE TO AN INTERIOR ROOM ON THE LOWEST FLOOR OF ABUILDING.A TORNADO WATCH REMAINS IN EFFECT UNTIL 900 PM EST FOR EAST CENTRALFLORIDA

All this on 9 January. I’ve lived here since 1984, and I’ve never seen or experienced anything like this, until today. This is now the new normal, and it’s not good at all.

Links

First results are in: 2023 temperatures were stunningly warm — https://arstechnica.com/science/2024/01/first-results-are-in-2023-temperatures-were-stunningly-warm/

I’m designing a circuit that uses an ESP32-S3-DevKit1 to drive a MAX2719/7221 and 1088AS, just as I promised in the last post. The broad steps are:

1. Write software to communicate with the MAX7219 and 1088AS,
2. Write software that enables Bluetooth on the ESP32-S3,
3. Write software on both the ESP32-S3 and Raspberry Pi 5 to communicate status and messages to display on the 1088AS.

In order to create the schematic diagram in KiCad I had to import symbols for the Espressif components. There’s a link at the bottom that leads to Espressif’s GitHub repo, complete with instructions on how import those symbols into KiCad 7. The Espressif instructions are short, sweet, clear, and they work without exception.

I’m also reading Espressif’s documentation on how to work with the ESP32-S3’s SPI port.

Links

• Espressif KiCad Libraries — https://github.com/espressif/kicad-libraries
• SPI Master Driver — https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/api-reference/peripherals/spi_master.html

It bothered me quite a bit that my last few schematic diagrams were missing the 8×8 LED matrix display. As it turns out, the part number for the 8×8 LED display is printed on the side: 1088AC. When I went looking for any part sheets for it, all I found was a single page with this printed on it

It was a PDF with a copy of a copy of the circuit diagram. I could barely make out the column, row, and physical pin numbers. I then went looking for an open source KiCad part for the 1088AC and found one on GitHub, which I forked and then cloned from my fork. I was able to quickly ascertain that the part was designed for KiCad 6. From there I used KiCad’s part library manager to import the part and then convert to KiCad 7 format. I had to do a bit more work with it before I could use it. For example, all the LED symbols were reversed, pointing up (as common anode) instead of down (common cathode). A little work to select and flip each diode symbol took care of that. I also change all the row pins from input to output, as they were all defined as input.

I am aiming to order a dozen or so MAX7221 parts from e-bay. The MAX7221 has a few additions internally over the MAX7219, one of which is that it support QSPI format data communications. Same price as the MAX2719, same pinout.

What’s interesting about the MAX7219/MAX7221 part sheet, it mentioned on the front page that it was suitable for LED matrix displays, but all the circuit diagram examples only show seven-segment by eight character displays, such as the one on the right above.

More learned with KiCad 7; better control with the schematic diagram, the ability to import parts, and the ability to convert from KiCad 6 to KiCad 7. When I’m finished with the 1088AC KiCad drawing part I’ll update my GitHub version and post a link to it in another post.

Links

My copy with updates and migration to KiCad 7. Note that only the 1088AS part has been updated. — https://github.com/wbeebe/kicad-LED_DotMatrix

You’re looking at a very simple circuit diagram, where I’ve wired a HiLetgo MAX7219 Dot Matrix Module to the Raspberry Pi 5 via its 40 pin connector. In spite of the add for the module on Amazon (see below) it works just fine with the Raspberry Pi and a Python library, Luma.LED_Matrix, I found on the web (see links below).

All I wanted to do was hook up one of these inexpensive four-character modules to a Raspberry Pi 5 and scroll text across it using Luma.LED_Matrix. It does not work with Ubuntu 23.10. It works just fine with the latest release of Debian GNU/Linux 12, a.k.a. Raspberry Pi OS. The problem is that Ubuntu 23.10 does not enable the SPI kernel drivers. Raspberry Pi OS does.

The screen capture above shows what the SPI devices will appear as in the dev file system if the kernel drivers are properly configured for the SPI peripherals. When you try this on Ubuntu all that is shown is /dev/spidev10.0. The other two devices are missing.

There’s not much more to say at this point except I am extremely aggravated to have to back down to Raspberry Pi OS. Ubuntu 23.10 is a gorgeous UI and a highly performant distribution on the Raspberry Pi 5. Getting it set up was no different than on an x86-64 system, and once set up was indistinguishable from normal Ubuntu. All the tools worked, especially Visual Studio Code, and I was developing command line tools written in Rust. It was a breeze doing anything non-trivial. Until I tried physical computing, at which point Ubuntu’s limitations in those areas became evident.

It’s not a problem to physically switch between operating systems. I just don’t want to, and based on my experience so far with Ubuntu 23.10, I will be dragged back kicking and screaming to Raspberry Pi OS on the Raspberry Pi 5. As soon as I can come up with a good solution to this mess, I’ll post it.

Links

Luma.LED_Matrix — https://github.com/rm-hull/luma.led_matrix

moving back to raspbian 64 bit, dropping work on wiringpi

Once upon a time, way back in 2004 (yes, 20 years ago now), I signed up for a Live Journal account and then completely forgot about it. That is, until 31 December 2023 when Live Journal sent me this reminder of my 19th anniversary. Lucky me. I don’t normally check on my Yahoo mail account all that often. It is, shall we say, my low-value email account I give to low-value organizations such as Live Journal. Or Disney… but I digress.

Anyway, I decided to check out what it was like, because believe me, I had totally forgotten it was there. So I clicked the link to look, and got the following:

Live Journal wanted me to log in, and amazingly I still remembered the password, which is a massive security no-no; if you can remember a password from 20 years ago, it means you should change it ASAP if for no other reason than it’s probably all over the dark web by now. And Live Journal agreed with that sentiment, telling me it was “out of date” and to reset it. So I did.

I accepted the new and improved user agreement, which among other things allowed Live Journal and its agents to harvest my organs when I die, among other actions.

Once in I discovered that I’d created exactly four entries, two of them dupes, back on 31 December 2004. The handle invader_moose was my youngest daughter, who was a big fan of Invader Zim and riffed off the show’s name. The first entry at the bottom explains it all. Unfortunately, after trying out exactly four posts I promptly forgot about it and moved on with other more exciting life adventures.

I will not post anything new to Live Journal, unless it’s to troll, and I’ve got better things to do with my time. If you want to know why Live Journal is so radioactive social-media wise (even more than Twitter X), then read the link below.

Links

Whatever Happened to LiveJournal? — https://thehistoryoftheweb.com/postscript/whatever-happened-livejournal/

What a surprise this morning when I went to search with Brave ( https://search.brave.com/ ) only to get an Internal Error 500 from the Brave search engine. It appeared to briefly succeed, as I could see results flash up briefly before being presented with the error screen you see at the start of this post. According to what Google search told me about the error;

What does “HTTP 500 Internal Server Error” mean?

Error 500, also known as the Internal Server Error, is a common HTTP status code that indicates an issue on the web server’s side. When you encounter an error 500, it means that the server has encountered an unexpected condition or configuration problem that prevents it from fulfilling the request made by the browser or client.

https://www.siteground.com/kb/internal_server_error_500/

In the mean time I’m back to using Duck Duck Go.

The MicroPython organization released version 1.22 on 27 December 2023. I missed it until today because it was Christmas time and I was, believe it or not, taking time off from some of the nerdier aspects of software development. But I downloaded it today and installed it and for once in a very long time it worked straight “out of the box.” I didn’t have to download source and build an image myself. What’s more the binary I downloaded for this board has been built to support octal addressed PSRAM, something that’s been missing completely since version 1.19.

So far everything seems to work, especially my stand-along WiFi access point (see above) written entirely in MicroPython. I obviously have a lot to do investigating it, and I will given enough time. By the way, the full version shows that this release was build with Espressif’s ESP-IDF versoin 5.0.4. Espressif has released a 5.0.5, but I can attest that MicroPython will not build with 5.0.5. So if you want or need to build from MicroPython source then make sure you have the proper toolchain installed.

For the curious this is running on an ESP32-S3-DevKitC-1 N8R8 (8 MiB non-volatile flash, 8 MiB PSRAM).

Links

MicroPython Download — https://micropython.org/download/ESP32_GENERIC_S3/