This is a two factor authentication token to generate TOTP login codes for up to four accounts. You can select which account by pressing a key on the 4-key NeoKey keypad. The design is intended for desktop use in a safe location (wall power + no worries of physical tampering) but where you do want to prevent secrets from leaking over the network due to mis-configured cloud-sync backup features or whatever.

Design Goals and Features:

1. Make the codes really easy to read and type, even in low light, by using a dimmable backlit TFT display with a relatively large font.
2. Support 4 TOTP account slots (one for each key of a 4-key NeoKey keypad).
3. The NeoPixel under the key for the currently selected account slot lights up. Pressing a different key switches the selected account. Pressing the selected key a second time puts the token in standby mode (backlight and NeoPixels off).
4. Store secrets in an I2C EEPROM rather than in the CLUE board's flash. This makes it so the secrets aren't trivially accessible to a connected computer as USB mass storage files. This way, they won't get accidentally sucked into backups, and malware would have to work harder to access them.
5. Set DS3231 RTC time from the USB serial console by opening the REPL, importing the util module, then calling util.set_time().
6. Add and manage TOTP accounts in the EEPROM's database of account slots by using similar REPL functions (import util then util.menu()).
7. Use the token fully airgapped after initial setup by powering it from a phone charger and reading codes off the TFT display.

Overview

This is an enclosure I designed for an angled desktop notification display with a Metro ESP32-S3 and a 2.8" TFT display shield. I'm using this as an IRC client to run my irc-display-bot code for LoRa temperature monitoring, but the same hardware build would easily work for other CircuitPython IoT projects where you want a little desktop status display.

I designed this in Blender using geometry nodes to build up a model of the negative space for the Metro, display shield, and cutouts for the viewable screen area and cable ports. The only mildly tricky thing about it was that it's important to use the "Mesh Boolean" node with the "Exact" algorithm to join objects. If you use the Geometry Join node, or a different algorithm, the resulting geometry will be messed up and not usable as a cutting tool with the boolean difference modifier.

To learn about the code I'm running for the IRC display bot, check out my IRC Display Bot Playground guide.

Overview

I admit many (if not most) of my projects have virtually no "practical" applications. This is different.

My wife and I play Super Big Boggle almost every day - it's good mental exercise and a great way to exercise and expand your vocabulary. (My skill is in building up a lexicon of  archaic vulgar words). (Note: said skill has not given me the edge. I usually lose ):

Now, after many hundreds of games, the little "hourglass" 3 minute egg timer has started to stick - kind of annoying when you finally notice after 4 minutes that the timer  hasn't moved.

The obvious solution might be to "buy a new timer," but not for me. I've got a lot of Circuit Playground Express devices (I REALLY like the CPX!) so it made sense to me to just program a timer with the CPX, so I did. 

The Makecode project is here

To use it,

1. download it to your CPX
2. press A to start the timer (or restart)
3. press B to pause/un-pause the timer
4. "Shake" the CPX to stop, clear the current timer and get it ready to start another 3 minutes

When running, a pixel blinks clockwise around the CPX, first Green, then Yellow and for the last minute Red. When it's done the "Magic Wand" sound plays.

 

This project uses 900 MHz RFM95W LoRa FeatherWing modules to transmit temperature measurements from greenhouses and receive them at a base station about half a kilometer away. The base station hardware outputs sensor reports over USB serial, an optional 2x16 Character LCD, and an optional ESP-NOW gateway.

The LoRa radio settings are tuned for extended battery life at a range of up to 500m in suburban or rural conditions (non line of sight with limited obstructions). With a fully charged 400 mAh LiPo battery and a 9 minute reporting interval, typical sensor runtime should be about 4 weeks (~22µA deep sleep current, ~2667ms of time per wake cycle, ~0.222 coulombs of charge per wake cycle).

To optimize the transmitter for running on a small LiPo cell, I used a Nordic nRF-PPK2 power analyzer to tune the firmware. Some of the power saving tricks I used include reducing the cpu frequency, putting the RFM95W radio in sleep mode, putting the MAX17048 fuel gauge in hibernate mode, and using ESP32-S3 deep sleep. To compare the impact of different changes, I took extensive measurements using Nordic's Power Profiler app with the PPK2 connected to the Feather board's battery jack and GPIO outputs.

Transparency note: Adafruit provided some of the parts I used for this guide (Thanks Adafruit!).

Related Projects

For logging, charting, and IRC status notifications, check out my related projects:

• serial-sensor-hub
• irc-display-bot.

Overview

About this Pager

You can build this touchscreen off-grid pager that uses LoRa and optionally GPS for location and tracking. This device lets you create (or join) a group of up to 90 devices in a private mesh network where you can send/receive messages, share location, and more.

You never know when you're going to need to be able to send messages between nearby family or friends, where cell phones don't work. You can also use these in combination with other devices (T-Deck, T-Beam, etc) and figure out where different devices are - even without having phones/internet/data. That can be really handy if you're hiking or camping in a far-out location.

How it's Built

• I designed a very simple PCB that accepts a few Adafruit components, that when combined with specialized firmware, become an off-grid communication device ready to be dropped into a 3D printed enclosure
• You can make the PCB (gerber files are included in this project) or order it from PCBWay
• The Adafruit parts are listed further down, but include Adafruit's RFM95W LoRa, 2.8" TFT Touchscreen with EYESPI & SD, Realtime Clock,  FRAM, and a few other things
• After assembling these things, you'll need to flash it with firmware, which takes only a minute or so

Assembling the Pager

Here's a video demo of assembling the pager. Full detailed instructions are also available at my website:

Full DIY Instructions

A CircuitPython IRC bot for Metro ESP32-S3 to show status notifications on a small dedicated screen.

This uses a 2.8" TFT display shield to show the topic of an IRC channel in large text. Combined with a local Raspberry Pi hosted IRC server, you can use this to make a wireless status notification system for environmental sensors or whatever. Once you put the wifi and IRC server details in your settings.toml, the display will connect automatically. Then you can use any IRC bot or client you like to set the channel topic to whatever should be shown on the display. For example, I built this to work with my serial-sensor-hub project which forwards USB serial sensor reports from my lora-greenhouse-monitor sensors.

Overview

Overview

A local production company is working on filming the first of a three-part sci-fi movie and needed a piece of scientific equipment for a laboratory scene. The executive producer/director found an obsolete flow cytometer analyzer in a government surplus sale, winning the bid for US$12. The device had the potential to look like a working DNA synthesizer with the addition of lighting and a bit of animation.

In its day, the analyzer was a high-quality device that was robustly built to provide exceptional mechanical stability for its sensitive optical components. It was therefore quite heavy in spite of its size, requiring at least two persons to lift and position, which would increase the challenge to modify for use in the film. It was not a typical theatrical prop made from foam and balsa wood, for certain.

I was tasked with installing color lighting to enhance the device’s operational appearance for its brief appearance on-screen. To achieve this, I devised a plan to incorporate several NeoPixel LED strips, which would be controlled by a CircuitPython-based microcontroller, such as the Adafruit M4 Express Feather. The multi-colored NeoPixel LEDs could be strategically positioned both within and outside the device, thereby providing ambient illumination and symbolizing various functions, including sample loading and the incubation process.

Given that the initial device employed industrial-grade servos (specifically, three IMS MDI-17 Drive Plus Motion Control motors) for sample positioning and operating the sample fluid “sipper” needle, there was a preliminary aspiration to incorporate robotic physical movements beyond the lighting sequence. However, this objective was deferred due to the imminent project deadline, so a short puppetry cable would likely be attached to the sample positioning cam to animate movement of the test tube rack.

Py-Boom

Py-Boom is a fast-paced, 8-bit-style arcade game written in CircuitPython for the Adafruit Fruit Jam and other compatible display boards.

This game is a modern take on a classic "catcher" formula, featuring both a single-player mode against an AI and a competitive two-player versus mode.

Game Modes

At the title screen, you can select your game mode:

• 1-Player Mode: You control the Bucket (P1) at the bottom of the screen. An AI-controlled Bomber moves at the top, dropping bombs at an increasing rate. Your goal is to catch as many bombs as possible to survive the level.

• 2-Player Mode: Player 1 controls the Bucket, and Player 2 controls the Bomber. P1's goal is to survive, while P2's goal is to drop bombs strategically to make P1 miss.

How to Play

P1 (Bucket) - The Catcher

• Goal: Catch every bomb that is dropped. If you miss a bomb, you lose one of your buckets (lives). If you lose all three, the game is over.

• Winning: If you (P1) successfully catch all bombs in a level (e.g., 10 bombs in Level 1), you win the round and advance to the next, more difficult level.

P2 (Bomber) - The Attacker

• Goal: Make P1 miss! You have a limited number of bombs per level. Use your movement and timing to drop bombs where P1 isn't.

• Winning: If you (P2) successfully make P1 lose all three of their buckets, you win the game!

Controls

Action	Player 1 (Bucket)	Player 2 (Bomber)
Move Left	A key	Left Arrow key
Move Right	D key	Right Arrow key
Drop Bomb	N/A	Down Arrow key
Start / Ready	Space bar	Enter key

Other Controls

• Select Mode: On the title screen, press the 1 or 2 key.

• Restart Game: On the "Game Over" screen, press the R key to return to the title screen.

Required Files

To run this game, you will need the following files on your CircuitPython device:

• code.py: The main game code.

• The Fruit Jam OS library package. 

• pyboom.bmp: The title screen logo.

• bomb_icon.bmp: The bomb sprite icon (used in development).

Download at: Pyboom Git Hub

 

 

Background

This project was started on Microsoft Make Code for my Pygamer and was called Prison Break. With the introduction of the Fruit Jam I wanted to port this over to Circuit Python. The graphics in Make Code (MC) are saved in a TypeScript file so I had to copy the codes for the sprites over to my Circuit Python. I used the AI tools that are part of Visual Studio Code (VS) the develop functions to map the sprites maps into bitmaps and tile grids. I continued to use the AI tools to help convert the Python code from MC. I mostly used Gemini as I have 3 months of premium from purchasing my phone. Though there were times where Gemini would get stuck on fixing issues it was making so I would switch to the free tokens in VS and use Claude or Chat-GPT. I ran out of free tokens in VS and moved on to Gemini for versions 2 and 3 of the game. I am in the process of uploading my prompts that I still have access to (I lost my VS conversations :( ) and hope to have them done in the next week. I also hope to get controllers setup and maybe make paddle controllers in the future.

I found this a fun project to learn Circuit Python and coding with AI. I'm still learning the concepts of using classes and learned a lot while looking at the errors the AI was coming up with.

With my recent retro mac classic inspired enclosure project for the Fruit Jam, I got the crazy idea to display my own images on the mac emulator. Sure, you can run MacPaint, but wouldn't it be cool to display custom graphics like the Fruit Jam logo? Well, it turns out there's a bit of a process to get images to display on System 7.5, specifically on 68K architecture (which is what the pico-mac emulator is based on).

Image File Formats

JPEG, PNG and GIF images are the norm with modem day computers. But, in 1984, these image formats were not yet a thing. I thought, surely displaying a bitmap image on Mac OS System 7 shouldn't be too hard, right?

After searching google, easiest approach seemed to be: Use the Graphic Converter mac app to convert a JPEG into a MacPaint document. This however, didn't quite seem to work. When I import the converted macpaint image file into Mini vMac, it wouldn't open in MacPaint. Weird, Ok, lets try a native image file format. Again, that's not really a thing. Enter the world of the .PICT (QuickDraw picture).