Tuesday Tooling is back with a veritable cornucopia of Commodore fixing tools all in one package! All for $/£/€ 0!

My OG Commodore 64 and two Commodore 64 Ultimates. I'll find a pic of my C16 and VIC20 and replace this after work

I love my Commodores, yes plural. I've got a VIC 20, Commodore 16, a real Commodore 64 and the new Commodore 64 Ultimate. Apart from my VIC 20, all of the machines work, but with this new tool I should be able to diagnose and repair my VIC 20. one day!

I spotted this tool thanks to More Fun Fixing It / More Fun Making It. I've subscribed to this channel for a long time and I love his content.

So What Is It?

The Commodore Repair Toolbox (CRT), from HovKlan-DH (Dennis) is a Windows application for retro electronics repairers who specialise in Commodore machines. CRT specialises in the many Commodore 8-bit machines such as

• Commodore VIC-20
  • 250403 (CR)
• Commodore 64
  • 250407 (long board)
    • Covers all components
    • Oscilloscope baseline measurements for PAL and NTSC
  • 250425 (long board)
    • Covers all components
    • Oscilloscope baseline measurements for PAL and NTSC
  • 250466 (long board)
    • Covers all components
    • Oscilloscope baseline measurements for PAL and NTSC
  • 250469 (short board)
    • Covers all components
    • Oscilloscope baseline measurements for PAL and NTSC
• Commodore 128 and 128D
  • 310378 (C128 and C128D, plastic cabinet)
    • Covers all components
    • Oscilloscope baseline measurements for PAL and NTSC
  • 250477 (C128DCR, metal cabinet)
    • Covers all components

CRT isn't just a collection of screenshots! There are schematics for the aforementioned computers and their board revisions. Some of the schematics have been reworked and modernised from the original source material. This is great news as some of the older schematics were a bit "fuzzy" after being scanned, printed, scanned over the last 40+ years!

Need to know about a chip? Click on it! Yes, you can click on a chip and learn the pinout, but that's not all! At the bottom of the window are example oscilloscope waveforms that you can use to diagnose your own Commodore!

Above is the waveform for pin 7 of the 6510 CPU inside the Commodore 64. It shows an example of a working CPU that we can use for diagnosing issues.

There is even a pinout for the humble 7805 5V voltage regulator, damn useful!

Need a quick overview of the components and their values? Click on the Overview tab and you get a handy table with all of the details.

Need some extra resources? Click on the Resources tab and dig into the wealth of Commodore resources from Zimmers, Ray Carlsen and Sven Petersen!

So How Do I Install It?

You don't need to! Just download the latest release, extract the contents and click on the executable. Windows may warn you that the app is from an unknown source, but it should be good. I ran a virus check before extracting, I do this with every file that I get from the Internet.

So it only runs on Windows?

Nope! It also runs on my Ubuntu 24.04.3 laptop. I just needed to install Wine, the compatibility layer for Linux that enables Linux to run some Windows applications. I then installed wine-mono-7.4.0-x86.msi and then downloaded, extracted and ran CRT on Ubuntu. All went well!

To get win-mono I ran this command from a terminal.

wget "https://dl.winehq.org/wine/wine-mono/7.4.0/wine-mono-7.4.0-x86.msi"

Then to install I ran.

wine start wine-mono-7.4.0-x86.msi

To run Commodore Repair Toolkit I ran this command in the same directory as the extracted files.

wine Commodore-Repair-Toolbox.exe

Happy Hacking / Repairing!

The Raspberry Pi share price has risen sharply in recent days and it seems that AI is behind this while also fueling many to make large share purchases.

The Raspberry Pi stock price has seen a surge this week, and it seems that the "Apple Mac Mini" effect, where everyone hoarded Apple's tiny PCs to run their own local AI service has finally reached the beloved single board computer.

Fun Trade Idea: Long $RPI (Raspberry Pi)

Reason: 🦞 Openclaw / Picoclaw / Nanobot + Hoarding.

Everyone has been openly hoarding Apple Mac Minis and were long Apple.

But $APPL is already a $3.7T+ company. Product mass-buying won't make a dent.

Raspberry Pi, however, is a… https://t.co/yRKh37HQ5n pic.twitter.com/IH8wXsCctW

— Serenity (@aleabitoreddit) February 16, 2026

The catalyst for this situation seems to be a "Fun Trade Idea" post from X user "aleabitoreddit" . This post has kickstarted the interest in running Openclaw / Picoclaw on a Raspberry Pi, resulting in enthusiasts buying and building their own rigs using Raspberry Pi hardware. All of this has seemingly pushed Raspberry Pi's share price to hit 545.5p on Wednesday 18 February, with it ultimately closing the day at 410p. Despite Raspberry Pi's recent price increases, they are still cheaper than a Mac Mini, but not as powerful.

The Rollercoaster Raspberry Pi Share Price

Source:London Stock Exchange

It seems that Raspberry Pi's stock price has been on a bit of a rollercoaster lately. At the time of writing (Feb 19) the price hit 408.76, but just two weeks ago (Feb 4) the price was 257.20. That's a 45.5% increase in price. So what's happened between these dates to drive up the price of Raspberry Pi stock? Has there been a new release? No. New software? No. So what was it? The answer could be Artificial Intelligence, AI. But lets take a look at the value of Raspberry Pi shares.

Monthly Value

Source:London Stock Exchange
With a monthly value of £56.14 million, February 2026 is the best month for Raspberry Pi since September 2025, where it hit £49.14 million. The next best month was March 2025, £47.18 million.

Daily Value

Source:London Stock Exchange

The daily value sees the rollercoaster riding upwards. February 18 2026 saw the value rise to £22.56 million. February 17 was £17.96 million, and Febraury 16 "just" £3.65 million.
Now, let this sink in. The daily value for Raspberry Pi on Febraury 18 2026 was £22.56 million, just under half the monthly value for September 2025.

In recent days there has been a large number of trades, and that includes Raspberry Pi co-founder and CEO Eben Upton. This isn't unusual nor is it illegal. As a senior position in Raspberry Pi LTD, Upton has to follow strict rules and all of the transactions are reported, and publicly available via the London Stock Exchange website.

Lets take a look at the details.

For all of the purchases, a PDMR (Person Discharging Managerial Responsibilities) was filed for the purchase of shares. This is a normal, regulatory practice and is necessary for an individual who has a senior position in a publicly listed company. A PDMR is used to ensure that no insider trading takes place, and all trades are reported to the company and the regulator. Hence we see the transaction are all linked to Upton, because he legally has to report his purchases. Other purchases, by the public or less senior individuals at Raspberry Pi, do not have to be reported as strictly. The sales are all logged, but not accessible via a PDMR.

Since January 30 (the date of the PDMR, but the purchase was on January 29), Upton has purchased 80,386 shares in total, and paid £132,612.087 for all of those shares. That is a lot of money and the PDMR means that the public can see these purchases, and when the CEO of a company makes a purchase the market is sure to catch wind of it and want in on the action. Looking through the trades for February 19, in the first three hours of trading there have been 606,899 shares purchased, at an aggregated value of £2,485,147.34p. This imposing figure towers over Upton's purchases. But the question still remains, "Why has the Raspberry Pi share price risen so sharply?"

The claws of AI grab a piece of the Pi

There is no escaping AI, it seems to be everywhere and there are even specific AI add-on boards for the Raspberry Pi made by Haileo which use its custom NPU (Neural Processing Unit) to off-load work from the Raspberry Pi 5's quad-core Arm CPU. And this is where things get interesting. As most of us are already aware, the price of RAM, CPUs, SSDs (storage in general) and GPUs has sky-rocketed in the last six months. Date centres and manufacturers are stockpiling hardware like the entire world did with toilet paper during the Covid pandemic. They are doing that for a possible future where more AI processing power is required, and AI customers are now a priority as they buy in bulk! This ultimately means that lower spec hardware, like the Raspberry Pi becomes the next target for AI enthusiasts.

The Raspberry Pi 5 — which comes with 1,2,4,8 or 16GB RAM configurations — has a Broadcom BCM2712 System on Chip (SoC) that is powered by an Arm Cortex A76, quad-core, 64-bit CPU running at 2.4GHz that can be easily overclocked to 3GHz. That is plenty of power for a small server and despite the horrendous price increases (again thanks to AI) they are a cost-effective alternative to Apple hardware.
Could older Raspberry Pi hardware be used? Upton has spoken to Bloomberg regarding the raised share price and also commented that he understands that interested parties are testing older models of Raspberry Pi to see where the performance drops off.

What is OpenClaw?

Formerly known as Clawdbot and Moltbot, OpenClaw is an autonomous, local AI agent and personal assistant that can be used with WhatsApp, Telegram, Discord, Slack and other service. It is proactive, and can look into your inbox, summarise your messages and even interact with smart home devices. Released in November 2025, OpenClaw has seen rapid growth in January 2026, with many enthusiasts purchasing Apple Mac Minis to run more powerful OpenClaw instances. Now it seems that their lust for AI-powered perfection is driving the rollercoaster share price of Raspberry Pi.

The Rising Price of Raspberry Pi

The Raspberry Pi is not immune to the rising price of RAM, in the last few months, the price has risen twice, with the price of the Raspberry Pi 5 16GB rising from $120 to $205! Raspberry Pi has also issued a number of PCN (Product Change Notifications) for the Raspberry Pi 5 and the older flagship Raspberry Pi 4.

PCN 46: Pi 5 Alternative sources of RAM PDF
PCN 30: Pi 4 Alternative sources of RAM PDF

The popularity of the Raspberry Pi for AI projects could see the prices further rise as demand increases. Could we see demand exceed supply? Maybe. The Covid pandemic saw demand soar as the world closed down. This drove up the price and made Raspberry Pi a hot commodity, the same could happen again because of AI.

Main image sourced from pexels.com
Please note that this post should not be used to determine financial decisions, I am a keen tech journalist who wanted to examine the situation and have no specialism in finance. Don't risk your money based on my writing.

Captain Kirk called the Commodore VIC 20 "The wonder computer of the 1980s" and it makes me wonder if he hacked the Kobayashi Maru simulator with one of these? If you want to relive the home computer boom of the early 1980s, this browser based emulator is just for you.

Lane Ewing's browser based JVic VIC20 emulator is sheer fun! As you can probably guess from the name, JVic is a Commodore VIC 20 emulator written in Java and designed with mobile devices in mind.

The user interface is a series of pages which you can move through by swiping, or for desktop users there are buttons to navigate. Each page has different games and demos can be selected by pressing the thumbnail. Dig Dug, Donkey Kong, Elite, Gorf, Manic Miner, Pac-Man, the gang are all here, ready to be played.

Is your favourte missing from the list? No problem, you can drag and drop any VIC 20 .d64, .prg, .crt, .tap or .zip file and JVic will run it!

Tweak your VIC!

You can pass URL parameters to tweak the config of the virtual VIC 20. In the GIF above, I have used the URL https://vic20.games/#/basic?RAM=32K to run the BASIC interpreter and boost my VIC 20 to a whopping 32KB of RAM. Other tweaks are for the TV region, PAL or NTSC and the type of file being loaded, CART, DISK, PRG or TAPE.

Running JVic

There are many ways to use JVic. You can install the web app as JVic uses the Progressive Web App (PWA) spec. In my Chrome browser I get the icon in the address bar. You can also install JVic to your Android phone using this method, in fact, this is how Ewing prefers to install on to their Android device.

You can also install the Java version to your computer. The .jar file is executable and because its Java, it can run on Windows, Mac and Linux. If you have an Android device, then there is a signed APK file that you can install. Note that there is no JVic app in the Google Play Store so beware of fakes!
Lastly, you can install JVic on to your own web server and run the emulator for your visitors.

Would you like to learn more?

Ewing has a helpful Github repository that details the project and all of the features mentioned, but in greater detail.

The crowdfunding campaign for PicoIDE, an "open source IDE/ATAPI drive emulator for vintage computers" is live and at the time of writing it is 225% funded, raising nearly $80,000, well over its $35,000 target!

Created by the Ian Scott, who also created PicoGUS (an emulated Gravis UltraSound / Sound Blaster 2, AdLib sound card) the two devices share something in common, and the "Pico" should give the game away. At the heart of the projects is the Raspberry Pi Pico. In the case of PicoIDE it is the RP2350 used in the Raspberry Pi Pico 2 and Pico 2W.
PicoIDE has been created to address the biggest issue with aging retro computing hardware. They break!
The IDE / ATAPI hard drives and CD ROM drives of the 1980s and 1990s are prone to issues, and some just die as soon as power is applied. Old CD ROM drives commonly die as the laser diode gives out. Hard drives may spin, but errors may soon appear. So clone those drives ASAP!

So how do we preserve and use old PC hardware? We can use SD card / Compact Flash card adapters to create hard drives. We can use Gotek drives to emulate floppy and CD ROM drives. I've used both and they both work well, but with PicoIDE we get it all in one package, and best of all it comes in an injection molded 3.5 inch case that would look great in an old PC case. The on board Raspberry Pi RP2350 System on Chip (SoC) proves that the RP2350 and the older RP2040 SoC are still extremely versatile to the maker and retro computing communities.

There are two versions of PicoIDE:

Image Credit: Polpotronics / Ian Scott
PicoIDE Base $69: Full IDE/ATAPI emulation in an injection molded 3.5-inch enclosure with microSD storage, CD audio output, and configuration via host utility or config file.

PicoIDE Deluxe (Beige or Black) $110: Everything in Base, plus a front panel with OLED display, navigation buttons, and ESP32-powered Wi-Fi for wireless image management.

Looking at the front of the Deluxe versions case, we can see a bright OLED display, and next to it are the controls to select our disk image. Just to the right is a micro SD card slot that enables us to insert cards with disk images. This is much easier than some SD and Compact Flash card solutions that require us to either open the case or reach around the back of the PC to access the card. A 3.5mm headphone jack provides an audio output.

PicoIDE supports disk images in

• Hard disk
  • .img, .hda, .vhd
• CD ROM
  • .bin/.cue, .iso

Image Credit: Polpotronics / Ian Scott

The Deluxe version also comes with an on board ESP32-C3 that enables remote management of disk images via a web interface. There is also a QWIIC (Maker Port, StemmaQT) I2C interface for use with compatible components such as sensors or additional screens.

PicoIDE is an open source project

According to the crowdsupply page, the project is open source and released using licences to "protect your freedom to use, modify and build upon the project." The hardware, covering the PCB and the enclosure, is released under a CERN-OHL-S-v2 licence. Firmware for the RP2350 us under the GPLv2. Comprehensive documentation covers both consumers and developers who want to use or improve PicoIDE. There is also a Github repository where you can learn more.

Crowdfunding

Image Credit: Polpotronics / Ian Scott

As this is a crowdfunded project, I have to give a general warning. Supporting a crowdfunded project is not purchasing a retail product. You are backing a project because you want it to succeed. There may be delays and logistics issues so only support the project if you are willing to take the risk!

PicoIDE ships from the United States, so remember to take any taxes, fees, duties etc into consideration.

PicoIDE starts from $69 over on CrowdSupply.

Main Image Credit: Polpotronics / Ian Scott

The venerable Commodore Amiga 500 has an incredibly popular scene these days. Many users refuse to give up on the slab of plastic!

One of those who refuses to give up on the Amiga is Arananet, who has created the Lazarustorm PCB that breaks out PiStorm (an accelrator to really turbo-charge your A500) to inteface with the Zorro II slot on the left side of the A500. No fiddly hacks inside the case, just connect Lazarustorm to the slot, and your A500 gets a much need boost.

Image Credit: Arananet

Lazarustorm brings a completely reversible mod, all of the soldering — bar one solder joint on the A500 — is on the Lararustorm PCB. You will need a PiStorm and a Raspberry Pi 3A. PiStorm provides an interface between the Raspberry Pi and your Amiga. The Pi is there to emulate a Motorola 68000 CPU at a much higher clock speed! As an added bonus, the micro SD card can be used to create virtual hard disks for your huge collection of games and utilities.

Upgrading the CPU on an Amiga 500 was damn near impossible, but fast forward to the 21st century and the ability to mimic a more powerful CPU was made possible with PiStorm and a Raspberry Pi 3A+. Yes, this combination could super-charge your Amiga 500 to ludicrous speeds, but you had to get your hands dirty and desolder the Motorola CPU. With Lazarustorm, we don't have to do too much soldering, thats because the Zorro II slot, hidden on the left side of the Amiga 500 and 500+, directly connect to the CPU. In its heyday, the Zorro II slot provided access for add-ons such as an Intel 286 PC "sidecar" board, RAM expansion and even SCSI hard drives. I had a GVP unit that brought all three of these features and provided a faster CPU, but that cost a fortune back in the 1990s! PiStorm is much cheaper and also much faster!

Amiga and retro computing enthusiast TME Retro has a great video showcasing the full install process.

The Commodore Amiga 500 has a special place in my heart and my computing history. I got the famous Batman pack which coincided with the release of Tim Burton's Batman and the video game. My parents bought it for me from Alan Heywoods in Blackpool, along with a ten-pack of games. It was my first computer with a mouse, heck, I learnt how to use a mouse with my Amiga 500 and Amiganoid (an Arkanoid / Breakout clone). For its time, the Amiga 500 was a beast, made up of custom chips and a Motorola 68000 CPU that ran between 7.09 MHz (PAL) and 7.16 MHz (NTSC).

Head over to Arananet's GitHub repository to get all the details and Gerber files to make your own Lazarustorm boards!

Main image is a still taken from TME Retro's YouTube video.

It has been a while, hasn't it? Sorry about that. Life has been challenging the past few years, but lets not dwell on that. Instead lets hack around with something. I'll be hacking around all day on September 13 2025.

You don't "knead" this, but you will want it!

The ESP32 has been around for a while. I've got a drawer full of various ESP devices, but when I saw the Baguette S3 from The Pi Hut, I had to get one.

Post by @recantha@mastodon.social

View on Mastodon

Full disclosure, I paid for this piece of kit out of my own money.

The Baguette S3 "is a compact ESP32-S3 development board designed for prototyping ESP-based projects on a breadboard" (The Pi Hut listing text). and for £11.50 it is a little more expensive than the generic ESP32 that I typically buy from Aliexpress. But In this case I am paying for the convenience of the form factor.
You see, the Baguette S3 is designed for use with a half-size breadboard, unlike some ESP32 boards which dominate a breadboard and make it difficult to prototype with.

The Baguette S3 provides us with a plethora of GPIO options.

• 23 GPIO pins (in order!)
• I2C, Serial
• Qwiic / Stemma QT
• Micro SD card
• RGB LED "NeoPixel"
• USB C

The ESP32 S3 at the heart of the board is an ESP32-S3-MINI-1-N8 with 8MB of flash, 384KB ROM and 512KB of SRAM. Wi-Fi and Bluetooth (5 and LE) works via the onboard antenna.

Software support for the Baguette S3 is currently officially listed as Arduino and ESPHome, but the ESP32 S3 is supported by MicroPython CircuitPython, and The Pi Hut are still working on guides to support this.

But, I am impatient and wanted to tinker with CircuitPython on my new toy. So join me as I do just that.

Here is the process I'll be following

• Set up the software
• Solder the GPIO
• Build a project

So join me as I embark on the first step, flashing CircuitPython on to the Baguette S3.

12:07PM BST CircuitPython Setup!

This is the goal for this section!

Adafruit's CircuitPython is a personal favourite of mine. Ever since I was introduced to it by Kattni Rembor at PyCon in 2018, I have loved it. So I wanted to use it with Baguette S3 and because it uses an ESP32 S3, I can.

So lets do just that!

I'm going to connect my Baguette S3 to a laptop running Ubuntu 24.04 using a USB A to C cable.

I downloaded the version of CircuitPython for the ESP32 S3, specifically the .bin file as I wanted to flash it to the Baguette S3 using esptool. I chose CircuitPython 9 as that is the current stable release. There is also a version 10, but that is still in Beta.

Then I opened a terminal and created a Python virtual environment to contain esptool away from the system Python install.

virtualenv esptool

Then I changed directory to esptool

cd esptool

Lastly I activated the virtual environment.

source bin/activate

Now I am working in a Python virtual environment, and I won't destroy my precious system.
I install esptool, a tool to flash and manage ESP devices, such as the ESP32.

pip install esptool

After installation, I checked that it worked.

esptool -h

Now it is time to use esptool to erase the flash storage on the Baguette S3. Warning, make sure that you do not have any other ESP devices attached to the computer otherwise you risk wiping those too!

In the terminal I tell esptool to erase the flash.

esptool erase_flash

After a short while, the Baguette S3's flash will be wiped and ready for new software, in this case it is CircuitPython.

To get CircuitPython onto the Baguette S3, we need to press and hold the RESET and BOOT buttons. Then release the RESET button, and hold the BOOT button for five seconds. This will force the Baguette S3 into BOOTLOADER mode.

With that done, let's go back to the terminal and use esptool to write CircuitPython to the Baguette S3. I invoke the command to write the CircuitPython.bin file to the start (0) of the flash storage. I copied the .bin image into the same directory as my virtual environment, but you can just pass the absoute path /home/les/Downloads/circuitpython.bin if you wish.

esptool --baud 460800 write_flash 0 adafruit-circuitpython-espressif_esp32s3_devkitc_1_n8-en_GB-9.2.9.bin

The process will take a few moments, leave it to do its work. When done you'll have CircuitPython on the Baguette S3. I used tio to access the REPL via a USB serial interface.

I can list the GPIO pins too, so with that excellent segue, I shall solder the GPIO pins and then we can do some testing.

12:32PM BST Soldering Time!

I own a lot of soldering irons, but I reached for the nearest and it just happened to be the iFixit Smart Soldering Station that I recently resurrected from the dead.
It turns out the older firmware and leaving a battery for months will make the unit "die" but you can resurrect it by flashing the latest firmware onto the soldering station and the smart soldering iron.

I placed the Baguette S3 onto the header pins, and used a half-size breadboard to steady it all. Five minutes and a little isopropyl alcohol later, the board was soldered and ready for tinkering.

The Baguette S3's design means that it uses all of the rows in a half-size breadboard, and I can keep the board out of the way.

Compare this to an ESP32 devkit, and you have to choose which side of GPIO pins that you want to use. Or, use two half-size breadboards and make some unholy creature!
Lunch, then time to make some LEDs blink.

1:29PM BST Hello World of Electronics — How to Blink an LED

In the world of programming, Hello World is often the first project that we undertake. Why? It is quick and easy to write, and provides a basic test of input and output.

The input is our code, the output is what we told the computer to do with our code. In the world of electronics, Hello World is usually an LED, blinking on and off in a loop. So I did just that, but I used some LED noodles from Pimoroni instead because they are gorgeous!

I connected the cathode end of the noodles to GND, and the anode end to GPIO pins 15,16 and 17 on the Baguette S3 via a half-size breadboard.

I then installed Thonny and set it up to connect to a CircuitPython device (Tools >> Options >> Interpreter and then set the interpreter to CircuitPython and select the Baguette S3 from the PORT dropdown).

Then I wrote a simple script to control the three GPIO pins to which my LED noodles are connected.

I started by importing three modules
time: to control the delay
board: to use the GPIO pins
digitalio: to control the GPIO pins

import time
import board
import digitalio

Then I setup each GPIO pin to be an output (so current flows from the GPIO pin). There is probably a better way to do this, but this is simple enough to get the job done.

led1 = digitalio.DigitalInOut(board.IO15)
led1.direction = digitalio.Direction.OUTPUT
led2 = digitalio.DigitalInOut(board.IO16)
led2.direction = digitalio.Direction.OUTPUT
led3 = digitalio.DigitalInOut(board.IO17)
led3.direction = digitalio.Direction.OUTPUT

I then created a variable called delay and stored 0.2 inside of it. This refers to a 0.2 second delay to control the how long the LED is on and off for.

delay = 0.2

Using a while True loop (to run the code indefinitely) I then turned on each LED, one after the other. As one would turn on, the others would go off, creating an animated effect. Controlling how long an LED is on/off for, I used a time.sleep() and passed the delay variable to set the 0.2 second delay.

while True:
    led1.value = True
    led2.value = False
    led3.value = False
    time.sleep(delay)
    led1.value = False
    led2.value = True
    led3.value = False
    time.sleep(delay)
    led1.value = False
    led2.value = False
    led3.value = True
    time.sleep(delay)

I saved the code to the Baguette S3 as blinky.py and then clicked on Run (green arrow) to start the code. The LED noodles came to life and I had a mini light show / cyberpunk rave running!

Complete Code Listing

import time
import board
import digitalio

led1 = digitalio.DigitalInOut(board.IO15)
led1.direction = digitalio.Direction.OUTPUT
led2 = digitalio.DigitalInOut(board.IO16)
led2.direction = digitalio.Direction.OUTPUT
led3 = digitalio.DigitalInOut(board.IO17)
led3.direction = digitalio.Direction.OUTPUT
delay = 0.2

while True:
    led1.value = True
    led2.value = False
    led3.value = False
    time.sleep(delay)
    led1.value = False
    led2.value = True
    led3.value = False
    time.sleep(delay)
    led1.value = False
    led2.value = False
    led3.value = True
    time.sleep(delay)

Next step, get the Baguette online!

3:29PM BST Getting the Baguette S3 online

I never expected to try and get a "bageutte" online...

At the most basic level, getting the Baguette S3 online is a piece of cake. We just need to create a file called settings.toml and save it to the root of the CircuitPython filesystem

Saving that file and restarting the Baguette S3 saw the device automatically connect to my network. To say that I was shocked is an understatement! That was so easy.

What I have really done is connect the Baguette S3 to my router via Wi-Fi, now I need to write some code to make it do something and for that I need a little help in the form of the official CircuitPython libraries (pre-written code / modules) so that I could get the Baguette S3 to do something with an Internet connection. Because I am using CircuitPython 9, I downloaded the library pack <direct ZIP download> for that release and then extracted the contents to a directory on my computer.

I then copied from extracted libraries the following files

adafruitconnectionmanager.mpy
and
adafruitrequests.mpy

to the /lib/ directory on my CIRCUITPY drive. Here you can see what that looks like on my Windows PC, but it will be the same no matter your OS.

These files enable the Baguette S3 to go make a connection, and then request web data.

So what am I going to do with it?

I'm going to do what I normally do to test a new boards networking capabilities. Look up who is currently on the International Space Station. Handily this data is freely available and it comes in a JSON format, so it is easy to work with.

Open Thonny and lets start coding on the Baguette S3.
Quick nod to Ladyada Limor Fried's excellent script for checking connectivity. I have based my code on that script

We start by importing modules to use the underlying CircuitPython OS, make network connections, use the Wi-Fi hardware and to make HTTP (web) requests in Python.

import os
import adafruit_connection_manager
import wifi
import adafruit_requests

The next step is to read the Wi-FI AP and password details from the settings.toml file that we created earlier.

ssid = os.getenv("CIRCUITPY_WIFI_SSID")
password = os.getenv("CIRCUITPY_WIFI_PASSWORD")

Then we create objects to handle the Wi-Fi and to setup an HTTPS session.

pool = adafruit_connection_manager.get_radio_socketpool(wifi.radio)
https = adafruit_requests.Session(pool, ssl_context = adafruit_connection_manager.get_radio_ssl_context(wifi.radio))

Using the Wi-Fi object we connect the code to the Internet.

wifi.radio.connect(ssid, password)

We set the URL (the link on the Internet) where the ISS astronaut data is stored. Using the URL we request the information and store it in an object called response and then format the data into a JSON format.

url = "http://api.open-notify.org/astros.json"
response = https.get(url)
data = response.json()

We then print the number of people who are onboard the ISS, and start the process of naming them.

print("Number of people in space:", data["number"])
print("Names of astronauts currently on the ISS:")

Using a for loop we iterate over the names of the people onboard the ISS craft.

for person in data["people"]:
    if person["craft"] == "ISS":
        print("-", person["name"])

Finally we close the response object, ending the connection.

response.close()

Save the code to the Baguette S3 as wifi-test.py and click on Run >> Run Current Script, or press the green play button. The Baguette S3 will connect to your Wi-Fi (using the settings.toml file) and then get the data.

Your Baguette S3 is now online and can communicate with devices / services via a network connection.

Complete Code Listing

import os
import adafruit_connection_manager
import wifi
import adafruit_requests

ssid = os.getenv("CIRCUITPY_WIFI_SSID")
password = os.getenv("CIRCUITPY_WIFI_PASSWORD")

pool = adafruit_connection_manager.get_radio_socketpool(wifi.radio)
https = adafruit_requests.Session(pool, ssl_context = adafruit_connection_manager.get_radio_ssl_context(wifi.radio))

wifi.radio.connect(ssid, password)

url = "http://api.open-notify.org/astros.json"
response = https.get(url)
data = response.json()

print("Number of people in space:", data["number"])
print("Names of astronauts currently on the ISS:")

for person in data["people"]:
    if person["craft"] == "ISS":
        print("-", person["name"])

response.close()

4:22PM BST Tinkering with I2C and an OLED screen

Final update for today! I wanted to test how easy it would be to connect and use an OLED screen with the Baguette S3. It turns out it was easy, but I did trip up along the way. I based my experiment on Adafruit's awesome guide to using OLED screens with CircuitPython and tweaked it to meet my needs. The goal of this project is to show some text, inside of a box on a tiny 128x64 OLED screen that I picked up from Aliexpress many years ago.

The connections between the screen and the Baguette S3 are clearly marked. Just connect

• VCC to 3V
• GND to GND
• SDA to SDA
• SCL to SCL

Now on to the software, and we're going to need the following libraries copied from the previously downloaded libraries archive.

• adafruit_bus_device (this is a folder, copy the folder and its contents to the Baguette S3
• adafruit_display_text (another folder, copy just like the previous)
• adafruit_displayio_ssd1306.mpy

The Baguette S3's lib folder should look something like this now.

Open Thonny and on the Baguette S3 create a new file. We'll start the code by importing modules to work with the GPIO, use I2C, make working with OLED screens easiers, show fonts, draw graphics and to use the I2C bus.

import board
import busio
import displayio
import terminalio
from adafruit_display_text import label
from i2cdisplaybus import I2CDisplayBus
import adafruit_displayio_ssd1306

We then release any previous connections to a display.

displayio.release_displays()

Setup an I2C object and point the object to the GPIO pins used for the connection. This is where I tripped up. Sometimes you can just tell the code to use board.i2c() and it does all the work. But this time I had to specifically tell the code which pins I was using. IO48 is SCL and IO47 is SDA.

i2c = busio.I2C(board.IO48, board.IO47)

We then create an object to tell the code where our OLED screen is on the I2C bus. Then we create an object to setup the resolution (128x64) of the screen.

display_bus = I2CDisplayBus(i2c, device_address=0x3C)
display = adafruit_displayio_ssd1306.SSD1306(display_bus, width=128, height=32)

Next up we create an object called splash and set it up ready for use.

splash = displayio.Group()
display.root_group = splash

Then we setup the screen with a bitmap, and set the color palette to white, so that we can draw on the black background.

color_bitmap = displayio.Bitmap(128, 32, 1)
color_palette = displayio.Palette(1)
color_palette[0] = 0xFFFFFF

Using the previous setup we create and use a sprite.

bg_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, x=0, y=0)
splash.append(bg_sprite)

We repeat the process, but this time for a black centre rectangle that is slightly smaller.

inner_bitmap = displayio.Bitmap(118, 24, 1)
inner_palette = displayio.Palette(1)
inner_palette[0] = 0x000000  # Black
inner_sprite = displayio.TileGrid(inner_bitmap, pixel_shader=inner_palette, x=5, y=4)
splash.append(inner_sprite)

Then we create an object called test and store a string, in my case "biglesp"

text = "biglesp"

Then we update the text area, the centre of the screen to show the text dead centre.

text_area = label.Label(terminalio.FONT, text=text, color=0xFFFF00, x=42, y=15)
splash.append(text_area)

Finally we use a while True loop to keep the screen active.

while True:
    pass

Save the code to the Baguette S3 as oled-test.py and click on Run >> Run Current Script, or press on the green play button to start. Look to the screen and you will see your text clearly printed upon it.

Complete Code Listing

import board
import busio
import displayio
import terminalio
from adafruit_display_text import label
from i2cdisplaybus import I2CDisplayBus
import adafruit_displayio_ssd1306

displayio.release_displays()
i2c = busio.I2C(board.IO48, board.IO47)
display_bus = I2CDisplayBus(i2c, device_address=0x3C)
display = adafruit_displayio_ssd1306.SSD1306(display_bus, width=128, height=32)

splash = displayio.Group()
display.root_group = splash

color_bitmap = displayio.Bitmap(128, 32, 1)
color_palette = displayio.Palette(1)
color_palette[0] = 0xFFFFFF

bg_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, x=0, y=0)
splash.append(bg_sprite)

inner_bitmap = displayio.Bitmap(118, 24, 1)
inner_palette = displayio.Palette(1)
inner_palette[0] = 0x000000
inner_sprite = displayio.TileGrid(inner_bitmap, pixel_shader=inner_palette, x=5, y=4)
splash.append(inner_sprite)

text = "biglesp"
text_area = label.Label(terminalio.FONT, text=text, color=0xFFFF00, x=42, y=15)
splash.append(text_area)

while True:
    pass

That is all for today!

I've had fun tinkering with the Baguette S3 today. The form factor is pleasing, and very convenient for use with a breadboard. I can see The Pi Hut shifting a few of these boards, especially those of us who want to tinker with an ESP32 and a breadboard.

17/9/2025 9:40am BST: QWIIC Test ;)

If you've followed my early work over at Tom's Hardware, then you may know that I am a big fan of StemmaQT, QWIIC, Maker Port connections. Essentially breaking out the I2C connection into a simple connector. They make rapid prototyping really easy and with companies such as Adafruit, Pimoroni, Sparkfun, Cytron making add-on boards packed with sensors and other delights, they lower the barrier to getting started with electronics.

I wanted to test Baguette S3's QWIIC port and so I dug into my stock on boards and pulled out the mighty MPR121 capacitive touch sensor board.

Connecting to the Baguette was simple, just plug in the cable and the green light on the MPR121 lights up!

I used Adafruit's excellent MPR121 example for CircuitPython.

The only change that I needed to make was to change the default

i2c = busio.I2C(board.SCL, board.SDA)

to

i2c = busio.I2C(board.IO48, board.IO47)

and to copy the adafruit_mpr121.mpy file to the /lib/ directory on my CIRCUITPY drive (the Baguette S3).

Save the code and click run, then touch the inputs. All working.
Another successful test.

Happy Hacking

Need to make a lot of fake user data quickly? You need Faker.

So What Is It?

Faker, by Daniele Faraglia, is a Python module that generates fake data. Not for nefarious means, rather it is there to help you generate data to test your databases etc.

Thanks

Hat tip to Mike Driscoll for alerting me to this very handy module. Mike is a prolific Python educator who uses Twitter / X as a quick and digestible means to learn new Python techniques and modules.

So How Do I Install It?

Via pip!
On my Ubuntu laptop I chose to install it inside a virtualenv so first I had to create the venv.

python3 -m venv faker

Then change directory to the venv.

cd faker

Then I activated the venv, essentially enabling the me to use the Faker module without it touching the Python install on my laptop.

source bin/activate

Now my Terminal session tells me that I have activated the venv, I can see the (faker) text at the start of the prompt.

Now I use pip to install.

pip install faker

So How Do I Use It?

We'll start with the basics. Generating a fake user. For this we need their name. We import the Faker module.

from faker import Faker

Then we create an object called fake and use it as a means to work with the Faker() module.

fake = Faker()

Then I can generate a fake name.

print(fake.name())

I use a for loop to generate a few names to illustrate how it can be automated.

So What Else Can It Do?

Faker is not just about names. We can generate...

• Fake addresses
• Fake registration (license) plates
• Fake barcodes
• Fake ISBN book numbers
• Fake email addresses

And much more. Take a look at the Standard Providers section of the documentation to learn more.

These are not "fake" as in counterfeit. Instead they are fake, pseudo-random creations to test databases, not for illegal activities.

Keeping It Local

Data can be generated using many different languages, so if you need to generate names using different languages, Faker can do just that.

When creating the 'fake' object we can set the locales as arguments.

from faker import Faker
fake = Faker(['it_IT', 'en_US', 'ja_JP'])
for _ in range(10):
    print(fake.name())

Quick Demo: Generating a CSV to Import Into a Database

Our scenario is that our boss wants 100 names, addresses and countries to add to a test database. We could sit there and generate them all manually, heck, we have done that in the past. But with Faker we can do it all in a few lines of Python, and then export the data to a CSV.

We start by importing the csv and faker modules, then we create the 'fake' object.

import csv
from faker import Faker
fake = Faker()

We then open (or create if it does not exist) a new file called fakedb.csv. This file is writable ('w').

with open('fakedb.csv', 'w', newline='') as file:

We then create an object called 'writer' and use that as a means to write data to the CSV file.

    writer = csv.writer(file)

Then we create the column headings for the CSV file. We need the name, address and country. Note that there are commas between the words. CSV needs commas. These names (fields) are written to the CSV file, only once as they are the headings.

    field = ["Name", "Address", "Country"]
    writer.writerow(field)

Using a for loop which iterates 100 times we generate the fake name, address and country for our fake users.

    for i in range(100):
        writer.writerow([fake.name(), fake.address(), fake.country()])

Complete Code Listing

import csv
from faker import Faker
fake = Faker()

with open('fakedb.csv', 'w', newline='') as file:
    writer = csv.writer(file)
    field = ["Name", "Address", "Country"]
    writer.writerow(field)
    for i in range(100):
        writer.writerow([fake.name(), fake.address(), fake.country()])

I ran the code and it went through cleanly. No errors. Then I imported the data into LibreOffice Calc and here we go.

I now have 100 Fake user details for our database test. Using the Standard Providers I could add fake bank details, credit cards, even fake passport data. This is an exceptionally powerful tool for database admins, or interns looking to take a few hours off ;)

Happy Hacking

No seriously, we're using ice cream.

Its been a while. How have you all been? In my world the last year has been "interesting" and not in a good way. I'm happy to say that all is getting better, and don't worry it is not health / family or work related.

So What Are We Talking About Today?

Debugging Python is all about print statements right?

print("This is the start")
for i in range(10):
    print(i)
    print("This should be the value of i")

Not really, but if it helps you solve a problem, then fair play. The right tool for the job is what you are comfortable with.
Earlier today I learnt about Icecream. Not the sweet and delicious treat, but a tool to debug Python code.

Icecream Info

Icecream is the work of Ansgar Grunseid and it has the following features.

• It prints both expressions/variable names and their values.
• It's 60% faster to type.
• Data structures are pretty printed.
• Output is syntax highlighted.
• It optionally includes program context: filename, line number, and parent function.

I already love ice cream, but it seems I now also love icecream too!

How Do I Install Icecream?

Via pip!

pip3 install icecream

How Do I Use Icecream?

Open your favourite Pytohn editor and import the icecream module, specifically the ic function.

from icecream import ic

We'll write a simple function that will take two arguments and add them together. Note that we use ic to write the output to the Python shell.

def function(a,b):
    ic(a + b)

Lastly we call the function and pass two values (a + b).

function(10,20)

All of the code looks like this

from icecream import ic
def function(a,b):
    ic(a + b)

function(10,20)

When we run the code we get this output

ic| a + b: 30

How Can I Do Something Cool With It?

Here is our scenario. We have a NASA JSON API that shows us who is onboard the ISS and a connected spacecraft. The problem is that when we print this out we get this.

{'people': [{'craft': 'Tiangong', 'name': 'Jing Haiping'}, {'craft': 'Tiangong', 'name': 'Gui Haichow'}, {'craft': 'Tiangong', 'name': 'Zhu Yangzhu'}, {'craft': 'ISS', 'name': 'Jasmin Moghbeli'}, {'craft': 'ISS', 'name': 'Andreas Mogensen'}, {'craft': 'ISS', 'name': 'Satoshi Furukawa'}, {'craft': 'ISS', 'name': 'Konstantin Borisov'}, {'craft': 'ISS', 'name': 'Oleg Kononenko'}, {'craft': 'ISS', 'name': 'Nikolai Chub'}, {'craft': 'ISS', 'name': "Loral O'Hara"}], 'number': 10, 'message': 'success'}

Sure we can read it, but for large datasets it can take a bit of work, so lets get some icecream and use it to make this much easier to read.

We start by importing icecream and requests. Requests is used to grab the data from NASA's API.

from icecream import ic
import requests

Next up we create a variable, url, to store the URL for NASA's API. We don't really have to do this but it makes it very easy to read.

url = "http://api.open-notify.org/astros.json"

We use the url with requests to download the dataset, storing it in an object called "r".

r = requests.get(url)

Lastly I use ic to return the contents of the "r" object and I specify that the data is in JSON format.

ic(r.json())

I save and run the code and I am presented with this wonderful block of data.

Complete Code Listing

from icecream import ic
import requests
url = "http://api.open-notify.org/astros.json"
r = requests.get(url)
ic(r.json())

Happy Hacking!

Simulate a microcontroller, a circuit, a project, from the comfort of your sofa.

So What is it?

Wokwi is a project to simulate IoT projects in the browser. Hat tip to Heeedt for telling me about this.

So What Boards Does it Simulate?

Here's the long list, including a few surprises.

• Arduino Uno (C++)
• Arduino Mega (C++)
• ESP32 (including ESP32-S2 and ESP32-C3) (C++)
• Arduino Nano (C++)
• Raspberry Pi Pico (C++)
• MicroPython on ESP32
• ATtiny85 (one of my favourites, oh and SURPRISE!)
• TinyPICO
• Raspberry Pi Pico (SDK)
• CircuitPython on Raspberry Pi Pico (SURPRISE!)
• Franzininho Wi-Fi (ESP32-S2)

So How Does it Work?

It really is easy. You click on the board, and it opens a new simulator. For my test I opened a Raspberry Pi Pico, and I was presented with the Arduino / C++ language on the left of the screen, on the right was a virtual Raspberry Pi Pico.

The left screen has three tabs. The "sketch" where we write our code. "Diagram.json" which is a text file containing the components in our circuit. Finally we have a library manager, which shows any installed libraries for the project.

I wrote a little code to print a message to the serial console, and to flash an LED connected to GPIO 16.

void setup() {
  // put your setup code here, to run once:
  Serial1.begin(115200);
  pinMode(16, OUTPUT);

}

void loop() {
  // put your main code here, to run repeatedly:
  delay(1); // this speeds up the simulation
  digitalWrite(16, HIGH);
  Serial1.println("Biglesp woz ere");
  delay(500);
  digitalWrite(16, LOW);
  delay(500);
}

I then wired up a circuit, an LED with a 330 Ohm resistor. Wiring up is similar to Fritzing, if a little clunky. You click on a GPIO pin, component etc and then draw it to where you want to go. Clicking as you move to the destination adds a bend.
Components are contained in a list found under the + symbol.

Choose your component and then place it in the circuit. We can choose the colour of the component too.

All of the wiring and components are saved as a JSON file, which is rather handy to refer to.

{
  "version": 1,
  "author": "Anonymous maker",
  "editor": "wokwi",
  "parts": [
    { "type": "wokwi-pi-pico", "id": "pico", "top": -79.82, "left": -132.71, "attrs": {} },
    {
      "type": "wokwi-led",
      "id": "led1",
      "top": -14.63,
      "left": 68.62,
      "attrs": { "color": "red" }
    },
    {
      "type": "wokwi-resistor",
      "id": "r1",
      "top": 68.21,
      "left": 5.77,
      "attrs": { "value": "330" }
    }
  ],
  "connections": [
    [ "pico:GP0", "$serialMonitor:RX", "", [] ],
    [ "pico:GP1", "$serialMonitor:TX", "", [] ],
    [ "r1:2", "led1:C", "green", [ "v0" ] ],
    [ "r1:1", "pico:GND.5", "green", [ "v0" ] ],
    [ "pico:GP16", "led1:A", "green", [ "v2", "h156.16" ] ]
  ]
}

Projects can be saved, and downloaded as zip archives. The code can then be used on real devices.

CircuitPython on a Raspberry Pi Pico

Hidden in the main screen is an option to run CircuitPython (my favourite way to hack) on a Raspberry Pi Pico.

I downloaded the example NeoPixel code from Adafruit's excellent resources.
I tweaked the code to use GPIO 16 and connected a virtual NeoPixel ring with 16 pixels.

In order to use the NeoPixel I need to install two libraies. Wokwi doesn't provide these, sadly. So I visited circuitpython.org and downloaded the Python library package, then I uploaded neopixel.py and adafruit_pixelbuf.py to Wokwi. With all that done, I pressed start and the simulator kicked in and I saw blinkies!

Final Thoughts?

I like Wokwi. It has enough functionality to be useful when on the move and we can download our code for use with real devices.

Happy Hacking

I'm back from a hiatus and I've got a cracking Python project for you all!

So What Is It?

PyWebIO provides a series of imperative functions to obtain user input and output on the browser, turning the browser into a "rich text terminal", and can be used to build simple web applications or browser-based GUI applications without the need to have knowledge of HTML and JS. PyWebIO can also be easily integrated into existing Web services. PyWebIO is very suitable for quickly building applications that do not require complex UI.

Source: PyWebIO Github

So Why Should I Use This?

The humble web browser is everywhere and that means users can access your content anywhere. No custom tkinter interface, and no messy frameworks. Just generate some HTML and you have a basic user interface. The problem is that mixing HTML and Python can prove tricky for some. You can use Anvil to generate HTML user interfaces (I love Anvil, but it can be a little tricky to get going. Anvil is immensely powerful and well worth learning. Flask is also tricky and I've never truly got the hang of it.
PyWebIO is much simpler and starts a server directly on our machine.

A quick demo where I use PyWebIO on @Raspberry_Pi to create a Web interface to scroll messages across @pimoroni Scroll pHAT HD. I'll put the code up for people to play with. #tuesdaytooling https://t.co/hS4L5bOklB pic.twitter.com/wM40yDYRO8

— biglesp (@biglesp) June 14, 2022

I can see PyWebIO being a very useful alternative for educators and makers who want to get accessible data from their Python projects.
I'm thinking of Raspberry Pi projects such as...

• Custom user interfaces for robots
• Weather station
• Citizen science data collection
• Raspberry Pi camera controller

PyWebIO is Python, which means we can mix this code with our existing code to add a web app to our projects.

So How Do I Install PyWebIO?

PyWebIO is available via pip
Linux / Mac

pip3 install pywebio

Windows

pip install pywebio

So How Do I Use It?

1. Open your favourite text editor and we'll start with a quick "Hello World"
2. Start a server for the browser session.

from pywebio import start_server

3. Import the input and output classes. We'll need these to capture user input and display it in the browser.

from pywebio.input import *
from pywebio.output import *

4. Import the session for our web app.

from pywebio.session import *

5. Import a persistent input to keep the user input. We can refresh the page and reuse the input field.

from pywebio.pin import *

6. Create a function called main().

def main():

7. Inside the function create a variable called name and use input to capture the user's name.

    name = input("What is your name?")

8. Create a new variable, greetings which will store a personalised message to the user.

    greetings = 'Greetings',name,'!'

9. Create a popup message to greet the user. Popup is a command in PyWebIO to generate those annoying website popups. But ours is actually nice!

    popup('Greetings', greetings)

10. Create a notification that will visually alert the user. We can use emojiis in the alert, which is nice.

    toast('New message 🔔')

11. Come out of the function to finally start the server and tell it to run our function and start on port 8080.

start_server(main, port=8080, debug=True)

12. Save the code as webform.py and then run it from the terminal / IDE.

python webform.py

13. Open a browser to 127.0.0.1:8080 and the form will appear!

Complete Demo Code Listing

from pywebio import start_server
from pywebio.input import *
from pywebio.output import *    
from pywebio.session import *
from pywebio.pin import *

def main():
    name = input("What is your name?")
    greetings = 'Greetings',name,'!'
    popup('Greetings', greetings)
    toast('New message 🔔')

start_server(main, port=8080, debug=True)

Taking It Further

We're not limited to just simple tasks like this, we have access to inputs such as

• Drop down menus
• Password fields
• Checkbox
• Single choice
• Multi-line text input
• File uploads

For Outputs

• Text
• Tables
• Images
• Markdown
• Write to files

Take a look at the PyWebIO docs for more information.

Happy Hacking!

Back again with some more Friday Fun!

The weather! A source of conversation that as an Englishman I am well versed in.
Weather projects are popular citizen science projects. We can build them with an Arduino, ATtiny85, Raspberry Pi and even an ESP8266. But this blog post, (the first Friday Fun since 2020!) we'll test out the new ESP32 C3 powered by a RISC-V processor to create an all-in-one weather station that displays the weather as an icon via the onboard 5x5 WS2812 RGB LED matrix. This board comes from 01space, a company that I have only recently come across. But if this board is anything to go by, we are in good hands.

This project was inspired by an older MicroPython weather station project. for that project I used a Wemos D1 Mini (an ESP8266) along with Pimoroni's Unicorn HAT 8x8 NeoPixel LED matrix and a capacitive touch sensor to show the weather inside a plastic cloud desk toy (#Pounderland).

Thanks

Before we get too far into the project, I want to say thanks to Andy Piper who has done some remarkable work documenting this rather fun little board. Go and read Andy's great work then come back for the hack!

For this project you will need

• ESP32-CH34G-RGB
• Soft drink / coffee as this is a long post.

Quick Video to show the board in action

I collated all of the video from a Twitter thread that I used to document my progress and put them into one handy YouTube video.

Download the code

Disco Mode ACTIVATE! pic.twitter.com/7Zgwd8IicH

— biglesp (@biglesp) April 15, 2022

I've put all of the code in a GitHub repo, ready for use. So if you are in a rush, use that instead. I've also included a special version with added "disco" mode.

ESP32-C3FH4-RGB Specifications

Is it any good?

For £10 this is a great little board. MicroPython support is awesome and we can be up and running rather quickly. If you've been on the fence about the ESP32, then grab one of these and have some fun.

I tested the Stemma QT / Qwiic connector, in reality a four pin I2C connector, with an AHT20 temperature sensor and an MPR121 capacitive touch sensor. Both worked with only minimal software tweaking. I followed Andy's guidance on using SoftI2C and specified the GPIO pins for the connector. Then I tried to use upip to install the modules for the AHT20 and MPR121 but they failed to install, weird. No issue, as I downloaded the files from their respective GitHub repos and manually copied them to the board.

The one thing that this board is missing is a pinout showing the various options for the GPIO pins. There is a schematic on the 01Space Github page but I'd love to learn more about the pins.

5x5 NeoPixel Matrix

Image Credit: Andy Piper https://github.com/andypiper/fivebyfive
Andy once again saves the day, and has kindly annotated the order in which the Neopixels are laid out. At the top left is 0, bottom right is 24. We move across the pixels from left to right, then move down to the next line to repeat the process.
Thanks Andy!

Setting up your ESP32 C3

Flashing MicroPython to the board

My chosen language for the ESP32 C3 is MicroPython. I've long been a fan of this microcontroller centric version of Python 3 and it enables me to get a project done without much fuss.

The ESP32 C3 doesn't come with MicroPython preinstalled, so we need to download the latest version and flash it to our board.

1. Download the latest firmware to your computer. The latest stable release is always behind the nightly builds. I used the latest nightly build (April 14 2022) and had no issues.
2. Install esptool.py to your machine using the pip package manager. Developed as a means to flash firmware to Espressif chips, esptool.py is a command line application that is easy to use, but can be daunting for new users.

Linux
sudo pip3 install esptool
Windows
pip install esptool

3. Connect the ESP32 C3 to the computer using a USB lead. Press and hold button B and then quickly press Reset to go into bootloader mode. This will enable esptool to communicate with the ESP32.
4. In a terminal use dmesg to discover the USB port for the board. Make a note of the port as we need it for the next step On Linux this is typically /dev/ttyXXXX. The XXXX can be ACM0 or USB0. Windows users will need to look in the Device Manager to discover the COM port, os you can use this Serial Port Notifier to automatically alert you to the port.
   
5. Use the esptool command to clear the flash storage. Double check that you have the correct device before pressing ENTER. Replace the --port argument with the port of your board. In my case it was /dev/ttyACM0 . Windows users, make sure to change this to the COM port.

esptool.py --chip esp32c3 --port /dev/ttyACM0 erase_flash

6. Use the esptool to flash the new firmware. Make sure to use the correct file path and name for the firmware that you downloaded in step 1.

esptool.py --chip esp32c3 --port /dev/ttyACM0 --baud 460800 write_flash -z 0x0 esp32c3-usb-20220415-unstable-v1.18-355-g9ab66b50c.bin

7. Leave esptool to do its thing until control of the terminal is returned to you.
8. Connect to the ESP32 C3 serial console using tio. Tio is the simplest way to connect to serial console but you can also use screen. Windows users can use PuTTY to make a connection.
9. You should now have a MicroPython REPL (Read, Eval, Print, Loop) shell. I used a simple for loop to demonstrate that I can interactively run code.
   

Setting up Wi-Fi

You'd be forgiven for thinking that it would be tricky to setup Wi-Fi on such a small board, but MicroPython makes it really easy.
I'm going to create two files.

main.py
This is the code that will run when the board is powered up.

secrets.py
In here I will store my Wi-Fi credentials.

I'm going to start with secrets.py.

1. In your favourite text editor, create a new blank file called secrets.py.
2. Create two variables, SSID and PW. For SSID type in the name of your Wi-Fi access point. For PW type in your Wi-Fi password. Both should be a string.

SSID = "YOUR WIFI HERE"
PW = "YOUR WIFI PASSWORD HERE"

3. Save the file to your computer.

Now I move on to main.py. As you can guess, this is the main file for the code that powers the project.

1. In your favourite text editor, create a new blank file called main.py.
2. Import three modules. The first is network, the second is secrets and the third is time. Network contains the functions that we need to make a Wi-Fi connection. Secrets contains two variables, SSID and PW, which are used to keep Wi-Fi login details separate from the main code. The time module is used to add a pause in the code.

import network
from secrets import SSID, PW
import time

3. Create and activate a station interface, a means to use the Wi-Fi chip on the ESP32 C3.

wlan = network.WLAN(network.STA_IF)
wlan.active(True)

4. Using the SSID and PW (password) from the secrets module, connect to the Wi-Fi access point.

wlan.connect(SSID, PW)

5. Add a short pause of five seconds to enable the Wi-Fi connection to be made.

time.sleep(5)

6. Check that the connection has been made. This will print True or False to the REPL.

print(wlan.isconnected())

7. **Print the Wi-Fi connection details to the REPL. **This will print the IP address of the ESP32 C3 to the REPL.

print(wlan.ifconfig())

1. Save the code to the computer as main.py.

Main.py code listing

import network
from secrets import SSID, PW
import time
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(SSID, PW)
time.sleep(5)
print(wlan.isconnected())
print(wlan.ifconfig())

Wait! How do I get my code onto the ESP32 C3?

I've found the easiest method is to use Adafruit's ampy, a tool that I have dedicated an entire blog post to. But I'll also do a quick run through here.

1. Install Ampy to your computer via pip.

Linux
sudo pip3 install adafruit-ampy
Windows
pip.exe install adafruit-ampy

2. In the terminal, go to the directory where the main.py and secrets.py files are located.
3. Using Ampy, copy main.py to the ESP32 C3. Linux users, you will need to know the port and specify it as an argument. Windows users do not have to do this.

ampy --port /dev/ttyACM0 put main.py

4. Use the same command to copy secrets.py to the ESP32 C3.

ampy --port /dev/ttyACM0 put secrets.py

5. Press the Reset button on the ESP32 C3 to load the freshly copied code. In the REPL (Tio will keep this running, but PuTTY may need to reconnect) you will see True followed by the IP address for the ESP32 C3. If you don't see this, then there is an error and you will need to trace the issue.

Get your free Open Weather API Key

I have long been a user of Open Weather. From the back of the classroom at Picademy in 2014 I coded my first weather project. In 2019 I then made the Wemos D1 Mini version, which this ESP32 C3 project supersedes.

To use the great service, you need an API key and to get one all you need to do is sign up.

1. Go to Open Weather and sign in / sign up for a free account.
   
2. Click on your username in the top right of the window and select "My API keys".
   
3. If you already have a key, copy the key. If not, create a new key and give it a relevant name.
   
4. Use the key in the project code later in this tutorial.

So now we make a weather station!

Yes we do! We're going to edit the main.py file to create code that will autostart when the ESP32 C3 is powered up.
The startup process will be as follows

• Connect to Wi-Fi
• Create a connection to the onboard 5x5 RGB LED matrix.
• Create a series of lists to store the position of each RGB LED that is used to draw the icon on the matrix.
• If connection works
  • Make the 5 x 5 LED matrix flash green three times.
• else:
  • Make the 5 x 5 LED matrix flash red three times.
• Create a loop
• Get the weather data as a JSON object.
• Grab the main weather headline
• Use an if, elif, else conditional test to show the correct weather icon.
• Sleep for 10 seconds.
• Loop back.

1. Import a series of modules to enable the project. Network for our Wi-Fi, time to control the project's pace, urequests to download the weather data. The Pin class from machine is used to control the GPIO pins. NeoPixel to control the 5x5 RGB LED matrix and secrets for the SSID and Wi-Fi password.

import network
import time
import urequests
from machine import Pin
from neopixel import NeoPixel
from secrets import SSID, PW

2. Setup the NeoPixel RGB matrix and create a connection between the code and the LEDs. The NeoPixels are connected to GPIO pin 8, and there are 25 (55) pixels in total.

neopin = Pin(8, Pin.OUT)
pixels = 25 
np = NeoPixel(neopin, pixels)

3. Create lists that will create icons to cover the possible weather types. Each list tells the code which pixels should be lit to make the icons. We'll specify the colour later. Some icons, such as rain1, rain2 lightning_cloud, lightning and fail, fail2 have two lists so that we can animate the icons. I used a spreadsheet to work out the values for each icon.

sun = [2,6,7,8,10,11,12,13,14,16,17,18,22]
cloudy = [7,11,12,13,15,16,17,18,19]
rain_cloud = [7,11,12,13,15,16,17,18,19]
rain1 = [0,4,5,9,10,12,14,17,22]
rain2 = [2,7,10,12,14,15,19,20,24]
lightning_cloud = [2,6,7,8,10,11,12,13,14,16,18,20,22]
lightning = [3,7,11,12,13,17,21]
snow_ice = [0,2,4,7,10,11,12,13,14,17,20,22,24]
fail = [0,4,6,8,12,16,18,20,24]
fail2 = [2,7,10,11,12,13,14,17,22]

4. Setup the Wi-Fi. This is the same as in our test before.

wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(SSID, PW)
time.sleep(5)
print(wlan.isconnected())
print(wlan.ifconfig())

5. Create a loop that will flash the RGB LEDs green, three times for a successful Wi-Fi connection. The np.fill() function takes RGB colour codes, in this case R = 0, G = 16 and B = 0. This creates a low brightness green flash. Don't set it too high, these NeoPixels are really bright!

if wlan.isconnected() == True:
	for i in range(3):
		np.fill((0,16,0))
		np.write()
		time.sleep(0.1)
		np.fill((0,0,0))
		np.write()
		time.sleep(0.1)

6. Add an else condition to indicate when the ESP32 C3 fails to connect to Wi-Fi. If the Wi-Fi fails to connect, we want to see three red flashes.

else:
	for i in range(3):
		np.fill((16,0,0))
		np.write()
		time.sleep(0.1)
		np.fill((0,0,0))
		np.write()
		time.sleep(0.1)

7. Add a three second pause to the code.

time.sleep(3)

8. Create a loop to run the weather fetching part of the code.

while True:

9. Download the latest weather data as a JSON object from the Open Weather service using your API key and location. Make sure to replace --YOUR OPEN WEATHER API KEY HERE-- with your real API key. I set my location to Blackpool, UK. Make sure to change it to your location. We use urequests, a version of Python's requests for micro-controllers to get the JSON data from Open Weather's API.

    r = urequests.get("http://api.openweathermap.org/data/2.5/weather?q=Blackpool,UK&appid=--YOUR OPEN WEATHER API KEY HERE--").json()

10. Strip out the main weather type from the returned data and save it to a variable called weather then print the contents to the REPL. The JSON object is essentially a Python dictionary and we can pull exact values from the object by knowing the keys. Here we pull the "main", "weather" values and save them to the weather variable.

    weather = r["weather"][0]["main"]
    print(weather)

11. If the weather is Clear (sunny) then we use the values stores in the sun list to draw a simple sun icon and set the colour to orange (almost), then we pause for 10 seconds before turning off all the LEDs.

	if weather == "Clear":
		for value in sun:
			np[value] = (255,265,0)
			np.write()
		time.sleep(10)
		np.fill((0,0,0))
		np.write()

12. If the weather is "Clouds" then we draw a cloud to the LED matrix.

	elif weather == "Clouds":
		for value in cloudy:
			print(value)
			np[value] = (8,8,8)
			np.write()
		time.sleep(10)
		np.fill((0,0,0))
		np.write()

13. If the weather is "rain" then we use two for loops to create an animation. The first will create an icon using the values in rain 1, then pause for 0.5 seconds before using the values in rain2. By doing this quickly and looping 10 times it create a basic animation of rain.

	elif weather == "Rain":
		for i in range(10):
			for value in rain1:
				np[value] = (0,8,8)
				np.write()
			time.sleep(0.5)
			np.fill((0,0,0))
			np.write()
			for value in rain2:
				np[value] = (0,8,8)
				np.write()
			time.sleep(0.5)
			np.fill((0,0,0))
			np.write()

14. Use another series of for loops to create a thunderstorm animtion. If the weather is a thunder / lightning then we get another animation of a thunder cloud and lightning flash.

	elif weather == "Thunderstorm":
		for i in range(10):
			for value in lightning_cloud:
				np[value] = (8,8,8)
				np.write()
			time.sleep(0.5)
			np.fill((0,0,0))
			np.write()
			for value in lightning:
				np[value] = (8,8,0)
				np.write()
			time.sleep(0.5)
			np.fill((0,0,0))
			np.write()

15. Create an icon for when the weather is "Snow". This will draw a snowflake on the LED matrix.

	elif weather == "Snow":
		for value in snow_ice:
			np[value] = (0,8,8)
			np.write()
		time.sleep(10)
		np.fill((0,0,0))
		np.write()

16. Create a fail animation, triggered when the code fails to get the weather data. This animation is a rotating red cross. In reality it is a red + and x that appears to rotate.

	else:
		print("No Weather Data")
		for i in range(10):
			for value in fail:
				np[value] = (128,0,0)
				np.write()
			time.sleep(0.5)
			np.fill((0,0,0))
			np.write()
			for value in fail2:
				np[value] = (128,0,0)
				np.write()
			time.sleep(0.5)
			np.fill((0,0,0))
			np.write()

17. Finally add a pause to the loop. The demo is set to 10 seconds, but for real life projects set this to 30 minutes / one hour.

	time.sleep(10)

18. Save the code to your computer as main.py
19. Copy the code to the ESP32 C3 using Ampy. Remember to swap /dev/ttyACM0 to your port!

ampy --port /dev/ttyACM0 put main.py

Complete Code Listing

import network
import time
import urequests
from machine import Pin
from neopixel import NeoPixel
from secrets import SSID, PW # secrets.py file contains Wi-Fi details
from random import randint


#NeoPixel Setup
neopin = Pin(8, Pin.OUT)
pixels = 25 
np = NeoPixel(neopin, pixels)

#Weather Icons
sun = [2,6,7,8,10,11,12,13,14,16,17,18,22]
cloudy = [7,11,12,13,15,16,17,18,19]
rain_cloud = [7,11,12,13,15,16,17,18,19]
rain1 = [0,4,5,9,10,12,14,17,22]
rain2 = [2,7,10,12,14,15,19,20,24]
lightning_cloud = [2,6,7,8,10,11,12,13,14,16,18,20,22]
lightning = [3,7,11,12,13,17,21]
snow_ice = [0,2,4,7,10,11,12,13,14,17,20,22,24]
fail = [0,4,6,8,12,16,18,20,24]
fail2 = [2,7,10,11,12,13,14,17,22]

#Wi-Fi Setup
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(SSID, PW)
time.sleep(5)
print(wlan.isconnected())
print(wlan.ifconfig())
if wlan.isconnected() == True:
	for i in range(3):
		np.fill((0,16,0))
		np.write()
		time.sleep(0.1)
		np.fill((0,0,0))
		np.write()
		time.sleep(0.1)
else:
	for i in range(3):
		np.fill((16,0,0))
		np.write()
		time.sleep(0.1)
		np.fill((0,0,0))
		np.write()
		time.sleep(0.1)
time.sleep(3)
		
while True:
	#Get the weather data
	r = urequests.get("http://api.openweathermap.org/data/2.5/weather?q=Blackpool,UK&appid=--YOUR OPEN WEATHER API KEY HERE--").json()
	weather = r["weather"][0]["main"]
	#Change the weather here to test the conditional tests.
	#weather = "Cats and dogs"
	print(weather)
	if weather == "Clear":
		for value in sun:
			np[value] = (255,265,0)
			np.write()
		time.sleep(10)
		np.fill((0,0,0))
		np.write()
	elif weather == "Clouds":
		for value in cloudy:
			print(value)
			np[value] = (8,8,8)
			np.write()
		time.sleep(10)
		np.fill((0,0,0))
		np.write()
	elif weather == "Rain":
		for i in range(10):
			for value in rain1:
				np[value] = (0,8,8)
				np.write()
			time.sleep(0.5)
			np.fill((0,0,0))
			np.write()
			for value in rain2:
				np[value] = (0,8,8)
				np.write()
			time.sleep(0.5)
			np.fill((0,0,0))
			np.write()
	elif weather == "Thunderstorm":
		for i in range(10):
			for value in lightning_cloud:
				np[value] = (8,8,8)
				np.write()
			time.sleep(0.5)
			np.fill((0,0,0))
			np.write()
			for value in lightning:
				np[value] = (8,8,0)
				np.write()
			time.sleep(0.5)
			np.fill((0,0,0))
			np.write()
	elif weather == "Snow":
		for value in snow_ice:
			np[value] = (0,8,8)
			np.write()
		time.sleep(10)
		np.fill((0,0,0))
		np.write()
	else:
		print("No Weather Data")
		for i in range(10):
			for value in fail:
				np[value] = (128,0,0)
				np.write()
			time.sleep(0.5)
			np.fill((0,0,0))
			np.write()
			for value in fail2:
				np[value] = (128,0,0)
				np.write()
			time.sleep(0.5)
			np.fill((0,0,0))
			np.write()
	time.sleep(10)
    ```
    
# Happy Hacking!

Need to include a code snippet in a document or poster? Want it to look nice? You might want to try this.

So What is it?

Ray.so is an online tool that makes code snippets look really good.

So How Do I Use it?

Super simple, just paste your code into the editor and then tweak the settings, language, colours to meet your needs. By setting the language the tool will automatically apply syntax highlighting, useful for sharing code snippets.

So How Do I Get My Code?

Click on Export and we have four options. The first two are to save as a PNG or SVG. The PNG option works well, but the SVG options exports an SVG file which Inkscape opens as a blank file, a shame. The third option is to copy the image to the clipboard, and we can then paste it wherever we need it. The final option creates a URL that you can share with others. They get the code, in an editable format and they can tweak the image to their liking.

What This is Not

As these are basically just images, we have to be careful when using them online. Accessibility users will not be able to see the contents, so careful use of tags and alt is required. For print and posters, this tool is great.
Sharing code with others using this tool is useful, but not if you want the receiver to copy the code. With the URL it is possible, but other outputs are just images.

For use in the classroom, in posters, advertising material etc, this is a top tool.

Happy Hacking

The return of Tuesday Tooling and we start with a little Python module for when we need to "just run that one terminal command".

So What Is It?

The project is called sh and "sh is a full-fledged subprocess replacement for Python 2.6 - 3.8, PyPy and PyPy3 that allows you to call any program as if it were a function:".
Using sh we can call terminal commands direct from our Python code in the most simple and elegant manner!
Sh was created by Andrew Moffat and the project can be found on GitHub.

I discovered this module via a tweet from Mike Driscoll. Many thanks to Mike for this discovery!

So How Do I Install It?

Via pip for Linux and (I believe) Mac.

pip3 install sh

Hi reader!

I never put my blog posts behind paywalls, pop ups or include sneaky advertisements because quite frankly that is annoying and prevents anyone from accessing the content. I will always keep my blog content free of charge. But I do ask that if you are able and willing, that you buy me a "coffee" as it helps me to pay for hosting this blog, and to buy stuff to hack from Poundshops / Dollar Stores / Aliexpress which are used in free projects and reviews on this blog. It is You dear reader who make this possible, and I am immensely grateful for your support.
Thanks!

So How Do I Use It?

The hello world test for this module is to print the contents of a directory. Open a terminal and in a Python shell type.

import sh
sh.ls("/home/<YOUR USERNAME>")

For my test I used my home directory, and the output was as follows.

>>> sh.ls("/home/les")
Desktop  Documents  Downloads  Music  Pictures  Public  snap  Templates  Videos

>>> 

So I Can Run Any Terminal Command?

Well yes you can!
You can use sh.echo("Hello World") to print / echo to the shell.
More interestingly, we can also call applications directly from Python.
Here is a quick example where I use sh to open VLC and then pass a YouTube URL to VLC in the parenthesis.

sh.vlc("https://youtu.be/3jJxKvjQrRg")

So Why Not Use Subprocess?

I've used subprocess a few times, and it is immensely powerful. I like to think of sh as "subprocess zero" in a similar manner to GPIO Zero is an easier way to use the GPIO on a Raspberry Pi.

To run the same VLC command we can use subprocess.run() or we can use subprocess.Popen(). Both have the same structure.

subprocess.run(['vlc https://youtu.be/3jJxKvjQrRg'], shell = True)

Or

subprocess.Popen(['vlc https://youtu.be/3jJxKvjQrRg'], shell = True)

We call the run / Popen and then pass subprocess the name of the command to run, and in our case the URL of the YouTube video. This is passed as a string. At the end of the line we use shell = True which ensures that the arguments are passed as a string.

So subprocess can do the same job as sh. But with sh it is far easier for those of us that "just want to get the job done" or for those new to the task.

Happy Hacking!

Cover photo by Tỷ Huỳnh from Pexels

Turning a Primark beauty light into a "beautiful" light.

For the first time since the pandemic started, MrsP and I went shopping in our town centre. We popped into Primark, a discount clothes and home furnishings retailer. In its beauty section I found four LED bulbs, similar to the lights used by make up artists. The size and shape, oh and the cost caught my eye. So for £4.50 I picked one up for a hack. Looking back at the hack, this would make a great sensory toy or just something to add a little fun lighting to your room. The biggest cost in the project are the NeoPixels, but these can be bought quite cheaply from Aliexpress. I used some leftover NeoPixels from my Christmas 2019 hack and a spare Adafruit QTPy board.

So What's in the Box?

A single 30.5 x 6 x 6cm light bar which has four "bulbs". The bulbs are really diffusers for the LEDs. Power is provided via 4 x AA batteries (6V). Pop in some batteries and press the switch, and we get a bright, harsh white light.

Teardown

Access to innards is via the rear panel. There are no screws, rather we need to use a spudgers / pry tool to carefully work our way around the perimeter. Take care as the silver / chrome colour is easy to chip. So place a little more stress on the black plastic if you need to.

Inside the case and we see two wires from the batteries, Vcc (+) and GND (-). The GND wire connects via the switch, when turned off the switch breaks the circuit. Removing the circuit board requires snipping / squeezing the black plastic pegs on the back of the board. These have been "heat staked" on to hold the board. I used some flush cutters to remove them.

The circuit board is simple. Power goes through three 4.7 Ohm resistors which is then shared with four clusters of six LEDs. Four matching the number of "bulbs" on the unit. Six LEDs per bulb is quite a lot but then we do get a really bright light from them all. The LEDs are crudely placed into the centre of holes, cut into thin plastic spacers. The bulbs diffuse the light from the six LEDs.

I desoldered the connections to the battery and from the switch to the circuit board, leaving me with the bulbs and the case pieces. I removed the switch, as I can use the hole it leaves for USB access. The circuit board I've kept handy for a future project.

Hi reader!

I never put my blog posts behind paywalls, pop ups or include sneaky advertisements because quite frankly that is annoying and prevents anyone from accessing the content. I will always keep my blog content free of charge. But I do ask that if you are able and willing, that you buy me a "coffee" as it helps me to pay for hosting this blog, and to buy stuff to hack from Poundshops / Dollar Stores / Aliexpress which are used in free projects and reviews on this blog. It is You dear reader who make this possible, and I am immensely grateful for your support.
Thanks!

Just Add NeoPixels

My first task was to find some suitable NeoPixels. My first test was with some surface mounted pixels, held on a small breakout board. These worked, but had very little impact when diffused. So I dug around and found some spare "fairy light" NeoPixels which fit into the bulbs...just!

Further adventures with blinky LEDs pic.twitter.com/EhD55trGgP

— biglesp (@biglesp) September 8, 2021

I did a test fit and everything seemed to work, if a little tight. I then soldered up the connections. As I was using Adafruit's QTPy, a $7.50 SAMD21 based microcontroller, the code which I used for this project is essentially Adafruit's CircuitPython example, something that I have referred to many times. I downloaded the example project bundle, which contained the code and the neoPixel.mpy library. Placed them on the QTPy and then edited the code a little, as I just wanted a rainbow effect, so here is my version of the code.

"""CircuitPython Essentials NeoPixel example"""
import time
import board
import neopixel

pixel_pin = board.A1
num_pixels = 8

pixels = neopixel.NeoPixel(pixel_pin, num_pixels, brightness=1, auto_write=False)


def wheel(pos):
    # Input a value 0 to 255 to get a color value.
    # The colours are a transition r - g - b - back to r.
    if pos < 0 or pos > 255:
        return (0, 0, 0)
    if pos < 85:
        return (255 - pos * 3, pos * 3, 0)
    if pos < 170:
        pos -= 85
        return (0, 255 - pos * 3, pos * 3)
    pos -= 170
    return (pos * 3, 0, 255 - pos * 3)


def color_chase(color, wait):
    for i in range(num_pixels):
        pixels[i] = color
        time.sleep(wait)
        pixels.show()
    time.sleep(0.5)


def rainbow_cycle(wait):
    for j in range(255):
        for i in range(num_pixels):
            rc_index = (i * 256 // num_pixels) + j
            pixels[i] = wheel(rc_index & 255)
        pixels.show()
        time.sleep(wait)


RED = (255, 0, 0)
YELLOW = (255, 150, 0)
GREEN = (0, 255, 0)
CYAN = (0, 255, 255)
BLUE = (0, 0, 255)
PURPLE = (180, 0, 255)

while True:
    rainbow_cycle(0)  # Increase the number to slow down the rainbow

This is the circuit, except my NeoPixels came prewired. The 5V and GND are taken directly from the QTPy, and the data pin (DIN) is pin A1 on QTPy. That is all the wiring! Super simple. I connected the pixels to QTPy by soldering the wires to jumper wires, snipped and tinned so that I could solder them directly to the pins on QTPy.

A little heat-shrink makes sure that my soldering crimes are concealed, and prevent accidental shorts.

Using the hole left by the power switch I threaded a USB C cable into the case and then tied a knot in it, to act as strain relief should the cable get snagged.

That was it! I tested the NeoPixels before I put the back panel on the light bar, then sat back and gazed upon a quick and easy hack.

Happy Hacking!

An image / pixel editor written in Python, in your terminal. Why do we need it? We probably don't but this was a something different that caught my eye.

So What is it?

Created by knosmos, cmdpxl is a command line pixel / image editor which uses WASD to control the cursor, enabling us to create simple pixel images.

So How Do I Install it?

Via pip!

pip install cmdpxl

So How Do I Use it?

We run the cmdpxl command from the terminal and we are asked to specify the path to which we want to save the image. There is no auto-complete, so either save the file to the current directory or make sure you know the correct path. We are then asked for the image dimensions (width x height). I chose an 8 x 8 pixel image size.

You can skip this bit by giving these values when running the command.
cmdpxl -f cool_icon.png -res 8,8
We can also open files using the -f switch.

To draw an image we first need to pick a colour, the hue (top left) sets the main colour using the u and j keys. Setting the saturation is via the i and k keys and the "val", which seems to be the brightness is set using o and l. In the top right we can see the currently chosen colour.

Once we have a colour we can used wasd to navigate the canvas, and press e to put a pixel of colour on the canvas. If we make a mistake, press z, add filters with t and fill the canvas with f.

Pressing esc will exit cmdpxl, but before it lets you go, it will ask you to save and exit, or exit without saving.

Why?

Well as the readme.md says, "Good Question."
There isn't a real need for a terminal based image editor, it lacks the tools found in GIMP or Photoshop. But it is fun and quirky and yes we could make an image on a remote machine via an SSH connection.

Happy Hacking

Hi reader!

I never put my blog posts behind paywalls, pop ups or include sneaky advertisements because quite frankly that is annoying and prevents anyone from accessing the content. I will always keep my blog content free of charge. But I do ask that if you are able and willing, that you buy me a "coffee" as it helps me to pay for hosting this blog, and to buy stuff to hack from Poundshops / Dollar Stores / Aliexpress which are used in free projects and reviews on this blog. It is You dear reader who make this possible, and I am immensely grateful for your support.
Thanks!