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 - I 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.

https://github.com/tyeth/omron-devhub_d6t-arduino

Brent nerd sniped me this week with his talk of a thermal sensor for Leaf VPD measurement on WipperSnapper, as I've been wanting VPD measurements of my Banana plant for a very long time.

Limor then came in with some suitable new sensor alternatives (the TMP007 being obsolete), and my mind wandered through the digikey site briefly, stumbling upon the D6T thermal sensor series from Omron.

Conveniently it uses a very similar cable to my favourite sensors, the JST-GH locking cable, but a 4pin variant. No Problem! Cut the 6pin version right through pin 5 (then removing the 5th wire and contact), and a final extra trim of the locking tab, and hey presto an instant fit!

Easy pinout, as it's I2C, but wants 5volt power/logic. The handy StemmaQT 3v to 5v logic level converter (PID 5649) quickly gets you to stemma and voltage compatibility. Then for software Omron have a library on Github.

Sadly it looks unmaintained, or at least incompatible with ESP32. So a quick fix or two (merge some old community PRs -❤️open-source), rebase it, swap the Wire (I2C) to be a passed argument, and now it's hopefully suitable for all!

This is the connector / pinout details:

Project Objective

To observe thermal conditions out in my remote laboratory (i.e., the workshop bench in the detached garage), I previously installed an Adafruit IO (AIO) connected corrosion monitoring system that watches conditions inside and outside of the garage. The corrosion monitor consists of an interior temperature/humidity sensor and, thanks to AIO Plus, correlates with exterior weather conditions. However, from the temperature/humidity sensor's perspective, if a door or window is left open it takes far too long to detect the issue. It would be ideal to be able to "see" if a relatively small area inside the workshop has experienced a temperature change relative to the bulk of the air in the space. An added benefit would be to detect human motion in the workshop area or to discover if the soldering iron was accidentally left on.

Requirements

1. Periodically capture and upload a thermal image of a critical portion of the workshop.
2. Monitor for temperature extremes and upload an image when exceeded.
3. Detect human motion and upload an image.
4. Provide a local color display with automatic brightness control.
5. Continuously update the local display image at least twice a second to quickly detect motion and respond to thermal events.
6. Upload the captured thermal image on a remotely accessible AIO dashboard page via the local WiFi network.
7. Upload bitmap image payload to AIO in less than 10 seconds.
8. Power from a USB 5-volt wall wart.

Future and Nice-to-Have

1. Blank the screen when motion has not been detected for a preset amount of time (screen saver).
2. SD Card storage of images and temperature statistics with historical view UI.
3. Trigger AIO notification events related to motion or alarm settings.
4. Upload minimum, average, maximum temperature values with image; display on dashboard.
5. Interface to Apple HomeKit.
6. Capture local audio.
7. Live MEMENTO photo overlay.

To speed up prototyping and algorithm development, CircuitPython was the choice for the software side of things. Besides, the code needed for creating images with a thermal camera and for reliable communication with AIO already exists in other projects that I've recently developed.

System Components

The thermal camera components consist of:

• ESP32-S3 4Mb/2Mb Feather.
• 2.4" TFT FeatherWing (optionally wired for display brightness control and an ambient light sensor).
• AMG8833 Thermal Camera Breakout, connected to the ESP32 Feather with a 100mm STEMMA-QT cable.
• An optional ALS-PT19 Analog Light Sensor Breakout connected to the TFT FeatherWing's +3V, GND, and A3 pads. The light sensor is used to automatically control display brightness in proportion to the ambient light level.

If display brightness control is needed, the TFT FeatherWing will require a short jumper wire soldered to connect the TX pin and LITE pads to allow PWM control of the display backlight brightness. See photo.

For automatic display brightness control, connect the ALS-PT19 light sensor output to the A3 GPIO pin pad. Also connect the sensor's power and ground to the FeatherWing's 3V and GND pads. For the prototype, three Dupont Cable 20cm Soft Silicon wires were cut in half and with the wire end soldered to the sensor breakout and the Dupont pin end inserted into the outer row of the Feather socket as shown in the wiring photos.

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).