The Idea

I've lately been dabbling with AI coding assistance and have been impressed with what it can do. So, I thought I'd do a whole project from scratch using several boards I have been meaning to do something with. I thought I'd also take you all on the journey and maybe you will find this useful. I will use this Playground article to document the process. I will go through the components and assembly, list the prompts I used with the AI tool to build the code, and share what value this new tool gives me. 

The Build

The project is a GPS tracker. In a nutshell a GPS module, an OLED display and an AdaLogger board. Here are the components I used:

Design Choices

I chose these components for simplicity. Choosing an AdaLogger for the microprocessor gives me an SD card to log the output and gives me one Neopixel, a separate LED I can use as an indicator and an extra input button with board.BUTTON. The OLED display, although small (128x32), can convey a lot of information if done well, plus it gives me three input buttons for controls. The GPS board just works well with little effort.  

Assembly

Since the Feather ecosystem is perfectly modular, assembly was simple:

• Solder headers on to the microprocessor, GPS FeatherWing and the OLED FeatherWing
• Solder the sockets on to the Feather Tripler
• Prepare the AdaLogger by inserting a formatted SD card and attach the LiPo battery to the connector. 
• Insert a coin cell into the GPS module
• Plug the three boards into the Tripler - U used a couple of rubber bands and a small piece of foam on the bottom to hold it all together

That's all there is to it! With that - we are (almost) ready to code.

For newer versions, CircuitPython will display a small purple Blinka snake and some initial information when displaying the REPL on a display. This isn't just a cutesy way to put a mascot on your screen. It's a window into using CircuitPython on displays both to put CircuitPython REPL information and the user's information.

CircuitPython calls using the display in the same node as the REPL the CircuitPython Terminal. It seems like a handy mode, especially for displaying text (which I want to do in a game I'm porting).

But there is not a great deal of information on how to use this capability for DVI/HDMI displays. This note provides additional information.

In addition, when the Terminal is inadequate for use, such as using custom fonts, displayio is used instead.

Using the CircuitPython Terminal with a DVI (HDMI) Display

This is a twisty-lines CircuitPython graphics toy inspired by screensavers from the 1990's (Macintosh After Dark 2 NightLines, Windows 95 Mystify, etc). To make the trail of lines, the code keeps track of two bouncing-ball style points and draws a line between them. Each new line gets added to a list, and the oldest line gets dropped off the end. The line colors cycle through a color swirl palette generated from a gradient using the LCh color space. This is meant for picodvi video output on RP2350 boards including Metro RP2350 and Fruit Jam.

To learn more about how I generated the rainbow swirl color palette, check out my Fruit Jam Color Gradient Generator Playground guide from last week.

This code was developed and tested on CircuitPython 10.0.0-alpha.7 with a Metro RP2350 (no PSRAM version) and a pre-release revision B Fruit Jam prototype. Keep in mind that things may change by the time CircuitPython 10.0.0 is released.

Transparency note: Adafruit provided the Fruit Jam rev B prototype board I used for this guide (Thanks Adafruit!).

Video Demo

This generates rainbow swirl color palettes in the LCh color space for picodvi displays on RP2350 boards. You can use the WASD keys on the serial console to adjust the Lightness and Chroma, but hue angle is generated automatically. The point of this is to make palettes for Metro RP2350 or Fruit Jam that will look good for making color swirl animations.

The default picodvi video mode is hardcoded to 320x240 16-bit, using an 8-bit bitmap and a palette of 256 colors selected from the 65536 possible RGB565 colors. On boards with PSRAM (Fruit Jam), you can edit the code to use 320x240 32-bit for smoother gradients.

This code was developed and tested on CircuitPython 10.0.0-alpha.7 with a Metro RP2350 (no PSRAM version) and a pre-release revision B Fruit Jam prototype. Keep in mind that things may change by the time CircuitPython 10.0.0 is released.

Transparency note: Adafruit provided the Fruit Jam rev B prototype board I used for this guide (Thanks Adafruit!).

Overview

This draws hypotrochoid spirals (like Spirograph) for a picodvi display on Fruit Jam or Metro RP2350. I tested this on a Fruit Jam rev B prototype and a Metro RP2350 (no PSRAM version). The 320x480 8-bit video mode works on both, but 640x480 8-bit seems to need a board that has a PSRAM chip. The curves get plotted as individual pixels using a color ramp that cycles through the entire 8-bit RGB332 palette. This might be useful to people looking for sample code showing how to configure picodvi displays for RP2350 boards.

For more details on the math for Hypotrochoid curves, you can check out the Wikipedia or Wolfram MathWorld Hypotrochoid pages.

Transparency note: Adafruit provided the Fruit Jam rev B prototype board I used for this guide (Thanks Adafruit!).

Overview

I enjoy programming little projects on the Microbit and CircuitPlayground because I find it easy to work on them "on the go"! This project meant I was able to start working on a computer, then continue the initial Makecode work using the iOS Makecode app - saving work to Github when switching from PC to phone and back.

It came about because I recently was reading through the Shannara stories, and that lead me to come up with some Microbit programs for this simple "Sword of Shannara" game in python and Makecode.

This is a vastly (!) simplified version of the classic fantasy "The Sword of Shannara."

Github Repository Here

Screen above shows "you," representing the hero, Shea Ohmsford, who is searching for the Sword of Shannara. You move left/right through a scrolling landscape (100 cells wide) displayed on the 5x5 LED micro:bit screen.

Overhead are dots that represent the "Skull Bearers" (think Tolkien's Nazgul). If you delay when one is overhead, it will attack and you can lose one of your five lives. So either move past quickly, or hit A+B to unleash the Elfstones to eliminate the Skull Bearer. Faint dots along the bottom of the "screen" represent landscape and serve to show your movement left/right.

Somewhere in the middle of the 100-element landscape is the "Sword" represented by three lit pixels.

This color checker is part of my quest to improve color matching from sprite editor apps to sprites displayed by CircuitPython. I wrote code to generate several color charts that explore how RGB332 and RGB565 colors on Fruit Jam's DVI output compare to the colors on a regular computer. 

For previous projects, I've used sprite editor apps on iOS or Linux to prepare sprites for CircuitPython. In each of those cases, I've noticed color shifts, but so far I haven't fully understood what was going or how to correct it. This time, I want to do better.

Transparency note: Adafruit provided the Fruit Jam rev B prototype board I used for this guide (Thanks Adafruit!).

Overview

Things You Need

Soldering Tools

You will need some basic soldering supplies for connecting wires to one another and to the T-Deck (although I'm working on a DIY design that does NOT require soldering). Heat shrink wrap is also recommended.

 

Other Supplies

There may be other miscellaneous supplies/tools not mentioned here.

3D Print Your Case

Download printable enclosure files (includes 3MF and STL formats).  The printable enclosure is a slightly modified version of an enclosure originally designed by Alley Cat.

I use Black ABS for the front and colored PLA for everything else, but obviously you can get creative here.

Build the ¥enPocket 80 – A Retro Handheld Console from a VHS Tape!

Hi, I'm Miguel (aka @miguel_drmr), a 16-year-old indie creator from Brazil, and I’m super excited to share my DIY console:

The ¥enPocket 80 — a tiny retro-style handheld game console made from recycled VHS tapes, powered by an Arduino UNO, and super easy to build!

No 3D printer? No soldering experience? No problem. Let’s bring retro vibes to life with just a few cheap parts and some creativity.

 

What You’ll Need:

• 1x Arduino UNO (clone works!) The brain of the console
• 1x OLED Display 0.96" (I2C) The tiny screen
• 1x Pushbutton To control the game
• Jumper wires (male-male) For wiring everything up
• 1x Old VHS tape (used) The console shell! Reuse & recycle!
• 1x Simple box (optional) To pack or transport

Wiring the Console:

Let’s wire it up!

OLED Display:

VCC → 5V

GND → GND

SCL → SCL

SDA → SDA

 

Pushbutton:

One leg → Digital Pin 2

Other leg → GND

(We’ll use INPUT_PULLUP in the code)

 

Step 1: Prepare the Shell

Grab your VHS tape and open it up (trust me, this part is fun). Remove the reels and internal gears carefully.

Cut a hole where the screen will go — usually in the middle window of the tape.

Add a small hole for the button, and maybe one more for the USB cable if needed.

 

Step 2: Connect Everything

Use jumper wires to hook up the display and the button to your Arduino.

You can test the display using any basic I2C screen sketch.

Once it’s working, fix the screen behind the VHS window using glue or tape. Do the same for the button.

 

Step 3: Upload the Game

Use the Arduino IDE to upload the built-in game. You can use a Dino Run clone, a reaction tester, or any 1-button game.

I’ll link my open-source version here: ¥enPocket-Github

 

Step 4: Close It Up

Reassemble the tape and seal it — either with the original screws or with tape.

You now have a fully working game console inside a VHS tape!

Share Your Games:

You can share your games made for your ¥enPocket 80 on my Official Forum:

DRMRVerse Forums

This is a visual gamepad tester for CircuitPython on Fruit Jam. The tester can detect and map buttons for several common gamepad types, including the Adafruit SNES-like gamepad. The tester can also display hexdumps of input event reports from HID boot-compatible keyboards and mice. Other HID devices may also work as long as their report lengths are short enough to fit on the screen (about 8 bytes).

I wrote the code on CircuitPython 10.0.0-alpha.4 through 10.0.0-alpha.6 on a rev B Fruit Jam prototype. Using a Metro RP2350 with USB hub would probably work too. I haven't tried that, so it's possible you might need to make minor tweaks to the code for pin names (e.g. boot button and DVI out).

To learn more about the spritesheet animation I use for the gamepad visualizer, check out my Feather TFT Gamepad Tester with Sprites guide from last year. This version of the tester for Fruit Jam is based on the Feather TFT version. For Fruit Jam, I added support for the larger display and more gamepad types. 

Transparency note: Adafruit provided the Fruit Jam rev B prototype board I used for this guide (Thanks Adafruit!). Adafruit makes good stuff, please support them by buying from the Adafruit shop.

Overview

Wanting to investigate a slightly Heath-Robinson idea to improve my CNC work setup process, I grabbed a digital dial guage (0-25.4mm) for probing things... The device had a cable option which I initially skipped, but the connector was a pain and rather than destroy my device to solder in a socket I bought the cable (for £1.99+tax).

It's supposedly 1.37volt logic, but the cable converts to RS232, and they included a USB-RS232 adapter. The device and cable came with 2x 8cm Compact-Discs (CDs) for software drivers and official software. I do actually still have a DVD/CD combo drive in one laptop, but forget about that. The instructions showed it in Chinese and windows only, and I plan to use a Raspberry Pi, so I went straight to an LLM to make a prototype web-serial demo.

Claude started the project, then I moved to claude-code in the hope claude would read the serial output too, but I/it got distracted with it nearly working for ages. In the end claude-code took it down an alley of insanity, and I switched to vscode in Agent mode to start afresh at the same time. VsCode sorted it right out first time. Then a quick correction for the initial boot messages received, and finally glam it up a bit along with adding scaling to the dial. Of course to use it with the Pi it would need converting to python/node, so I did that and tested via WSL.

Source Code / Readme etc: 

https://github.com/tyeth/digital-dial-gauge-web-serial

Interactive Webpage:

https://tyeth.github.io/digital-dial-gauge-web-serial/

 

Live embedded iframe/oEmbed version:

These removable non-volatile memory cartridges should work with the new Fruit Jam board and many other Adafruit microcontroller boards with I2C. The 3D printed shells hold a perma-proto PCB with a 4-pin magnetic connector and an I2C FRAM breakout board. To avoid I2C bus glitches, the base includes TCA4307 hot-swap I2C buffers and a PCA9546 4-channel I2C multiplexer. The multiplexer makes it possible to use two FRAM chips with the same I2C address at the same time.

The CircuitPython code for this project is just a simple demo of writing to and reading from FRAM using the byte array interface provided by the adafruit-circuitpython-fram library. To use these memory cartridges for game save files, you would need to come up with a way to encode whatever data you want to store into a byte array of 32KB or less.

Transparency note & shameless plug: Adafruit provided most of the parts I used for this guide (Thanks Adafruit!). Adafruit makes good stuff, please support them by buying from the Adafruit shop.

Overview

Blockly has been slowly worming it's way into Adafruit IO, with a first edition replicating the old Action forms.
Now the latest release brings the wealth of features we've been dreaming of, allowing great complexity!

Will you be the first to bring down the house of cards/servers? Let us know in the forums if you do (or run into other issues)! Let's start off with something simple, how to subtract one from a feed value (as a countdown)...

We'll explore a quick yet complex multi-action example, changing LED colour based on air quality, and additionally a Utility Light mode using the onboard button to request 30seconds of Bright White Light (useful in a kitchen).

Setup a Wippersnapper device

Adafruit IO has a devices page, which shows the special "Wippersnapper" devices, these run the arduino firmware that allows wifi connected boards to easily connect and configure components (inputs/outputs/sensors) with no code. Each component then has associated feeds for interacting with, so using the on board button becomes child's play.

Install wippersnapper, you're best off finding the learn guide for your board and then locate the Wippersnapper pages. Alternatively there is a quick start guide, or just do the usual hacky thing and have a go with no prior knowledge...

Visit this link (https://io.adafruit.com/devices/new) when signed in to be taken to the New Device setup page, then select your board and follow the onscreen instructions.
(You need an IO page open when the board first connects to accept the registration request).

VarSpeedServoRA4M1 is a library for Arduino tha enables precise control over servo motors, including speed, position, and movement sequences.

Developed by Kaled Souky in 2024, based on the Servo library (developed by Michael Margolis in 2009) and VarSpeedServo library (developed by Korman in 2010 and updated by Philip van Allen in 2013). Specifically designed for the Renesas RA4M1 microcontroller architecture (Arm Cortex-M4), present on the Arduino UNO R4 Minima and Arduino UNO R4 WiFi boards. 

VarSpeedServoRA4M1 is an interrupt-driven library using 16-bit timers, allowing the use of up to 12 servos moving asynchronously or synchronously. In addition to setting the position, you can set the speed of a movement, optionally wait until the servo movement is completed, and create sequences of movements that execute asynchronously or synchronously.

The 32-bit Renesas RA4M1 processor operating at 48 MHz elevates servo control to a new level, providing higher PWM resolution compared to the ATmega328P used in Arduino UNO R3. Thanks to this power, VarSpeedServoRA4M1 fully exploits the microcontroller's capabilities. With its simple and intuitive syntax, this library facilitates precise control over servo position and speed, even for beginners. Creating complex movement sequences is straightforward with just a few commands.

 

Features :

• Supports up to 12 servos.
• Allows synchronous and asynchronous movement of  all servos.
• Allows you to configure the "position" and "speed" of each servo individually.
• Includes a "wait" parameter to wait for the servo to complete its movement. Philip van Allen, in his update, incorporated it as a boolean variable within the write() function, and also as the independent wait() function. This parameter is not included as a variable in Korman's slowmove() function.
• The write() function now includes the "speed" and "wait" parameters, which can optionally be used in conjunction with the "position" parameter to control servo movement.
• The slowmove() function is retained for compatibility with the Korman version. It only handles the "position" and "speed" parameters. In this case, the waiting time must be configured (using, for example, the function delay(), delayMicroseconds(), micros() or millis()), so that the servo completes the position and maintains it for the desired time. The slowmove() function does not incorporate the "wait" variable introduced by Philip van Allen in the write() function.
• Allows the creation of position sequences. 
  

 

Examples of use: 

Sample code 1: Sweeps a servo motor from 0 to 180 degrees at fast speed and back from 180 to 0 degrees at slow speed, in an infinite loop.

The write() function now includes the "speed" and "wait" parameters, which can optionally be used in conjunction with the "position" parameter to control servo movement.

The "wait" parameter is used to wait for the servo to complete its movement. It is also available as a standalone wait() function.

Image taken from the official Arduino website: https://docs.arduino.cc/learn/electronics/servo-motors/

 

Overview

As we get closer to launching the new Adafruit IO Actions, it has been fun thinking of the many fun ways it can be used. Here is a really simple project that has a ton of potential without writing a single line of code. With this project, I simply added a NeoPixel to a simple arcade button (using the below Learn guide), and then use that LED and button to communicate information in different ways. The more I play around with this project, the more ideas I come up with. So be sure to check back here often as I will post more ideas as I come up with them.

Parts Used

I used the NeoPixel Mini Button as shown in the guide above, but used the QT Py ESP32-S3 board with the NeoPixel BFF to drive the NeoPixel, then just soldered one side of the button to 3V on the QT Py, and the other side of the button to A2.

You could also simply skip modifying the arcade button, and just use the built in NeoPixel on the QT Py. You could even just use the built in pushbutton on the QT Py and skip the Arcade Button all together. This guide isn't so much about the specific project, as it is about the possibilities of the new Adafruit IO Actions. You can set this up with any NeoPixel and button.

With that in mind, here are the products I used: