Do you have a pair of Adafruit LED Glasses? Have you noticed there is a ton of cool examples and starter projects out there for them? Have you ever wished you didn't have to juggle installing different projects in order to use each one? Do you want to use a Wii Nunchuck for wireless game-like controls? Would you like to also be able to use the Adafruit Bluefruit Connect app to do things like change colors or other settings? Did you ever wish those settings would be saved, even when you turn the glasses off? Do you wish you could install it by simply dragging and dropping a file?

Motivation/Goals

I wrote a bare-bones demo a few years ago using the Wii Nunchuck to control an adaptation of the classic Adafruit roboface project, played with it for a few minutes, and then promptly forgot about it. I recently rememberedI had the glasses kit, and with Halloween around the corner I thought it would be fun to wear them this year, sporting a more robust firmware than my original demo.

I wanted to have a small suite of different modes available to use, and be able to control them wirelessly. The first part of the project was building a small adapter I could use to allow my Nunchuck to pair and communicate with my glasses using Bluetooth Low Energy. With that complete, it was time to write the firmware for the glasses. I wanted the firmware to have the following features:

• It should have the ability to pair with the BLE nunchuck adapter and use the nunchuck for wireless control
• It should have the ability to connect to the Adafruit Bluefruit Connect app to change colors and other settings
• The glasses should still work well even without some form of wireless control
• It should have modes that take advantage of the built-in accelerometer and microphone on the glasses driver board
• It should have an application/firmware architecture that makes it simple to add new modes in the future.
• Optionally, it should have the ability to connect an EEPROM breakout to the remaining Stemma QT port on the other side of the glasses to save changed settings, even when the glasses are powered off.

It is NOT true that I lay awake at night thinking of odd things to do with the NeoTrinkey*....

That said, here's a project I've been thinking about for a while - making an RPN calculator (well more of an adding machine) with the NeoTrinkey.

The project code is here and consists of two CircuitPython modules, babbage.py (renamed to code.py when in use) and a helper module, ncount.py.

One of the great features of the NeoTrinkey is the four neopixels - they provide a very flexible output display. Considering the range of colors you could present with the neopixels, you could easily represent any number from 0 to 999 (assuming ten colors). For this project, we're sticking to binary and using the ncount.py function binnum(color, number) - it will display the values from 0-15, using the neopixels:

Given a number, binnum(color,num) will display the binary value from 0-15 (for zero all pixels are set to faint white; otherwise the pixels are set to color for the value of num.).

So... how to use this for a calculator? 

I defined an array to be a stack, then set four states for the calculator: wait, enter, add, subtract, and pop.

To toggle between states, one touches the#1 pad. When you do you'll see the current state appear (and clear) with the color "gold.":

 

Overview

A few years ago I got this nifty LED glasses kit in an Adabox. The kit comes with a specially-designed nRF52840 BLE microcontroller to drive the LEDs wirelesslly with Bluetooth Low Energy. I wanted to build a simple controller that I could pair with it for easy use, without having to dig out my phone and use an app, so I built a an adapter to essentially convert a Wii Nunchuck into a wireless Bluetooth controller.

This controller doesn't strictly have to be used to control LED glasses though. You can use it to control virtually any gadget with BLE capabilities. The Nunchuck features 2 buttons, an analog stick, and an accelerometer, so it makes a capable and handy input device for many tasks. Since it uses a Feather nRF52840 Express, you can program it in Arduino or CircuitPython to behave just how you want!

Difficulty: Intermediate. Some soldering is required.

Parts

• Feather nRF52840 Express 
• Wii Nunchuck adapter breakout
• Mini on/off push-button switch
• 400 mAh Li-Po rechargeable battery
• Black 2.5mm nylon standoff screw kit
  • 4 M2.5 6mm screws
  • 4 M2.5 6mm male-to-female hex standoffs
  • 8 M2.5 hex nuts
• Wii Nunchuck controller

This demonstrates a visual USB gamepad tester using using an Adafruit USB Host FeatherWing, an ESP32-S3 TFT Feather, and sprites created in Krita.

Video Demo

The other day I decided to level up my understanding of how these popular "HUB75" style RGB LED matrices work. So I sat down with the intent to write the most basic bit bang example I could come up with. Here I share the resulting code, written in CircuitPython.

There are plenty of Google discoverable write ups on these that go into lots more detail, discussing the shift registers, scan lines, etc. It's worth reading a few of those first. We found these to be useful:

• Everything You Didn't Want to Know About RGB Matrix Panels - A good write up with some nice animations by Nick Poole at Sparkfun who needed to also understand how these work to modify an Arduino library for an unsupported panel type.
• RGB LED Panel Driver Tutorial - read the "Theory of Operation" section.
• Driving a 64*64 RGB LED panel with an FPGA - read everything up to "Driving the matrix".

There's also a brief description in the Adafruit Learn System here:

These discussions can quickly get a bit complex, since there are a lot of pieces that work together in concert. However, there are a lot of things that are redundant. For example, how each red/green/blue LED is controlled is the same. Also, the matrices are typically split into upper and lower halves, but each is updated in the same way - R1/G1/B1 for the upper half, R2/G2/B2 for the lower half. So to keep things as simple as possible, this example does the following:

• Only use a single color
• Only work with the upper half of the matrix

This greatly reduces the total number of pins needed. It also really helps focus on the basic way in which data is moved into the matrices. By using just the upper half, the R2, G2, B2 pins can be left unused. And by focusing on just one color, we can use any one of R1, G1, or B1.

A Feather RP2040 was used with the following pin connections (Feather to Matrix):

• 13 to R1 (or G1 or B1 - your choice!)
• SCK to CLK
• MOSI to LAT
• MISO to OE
• A0 to A
• A1 to B
• A2 to C
• A3 to D
• GND to GND

There's nothing special about these pin choices - any digital pins could be used.

The matrix used was an Adafruit 32x32 4mm pitch panel (PID 607).

There might come a time when you want a project running 24/7 permanently online.  Weather and Real Time Clock (RTC) updates are common uses.  It's not enough to code a request to an API, you must know how to avoid every possible scenario that might crash your script. That's where error exception handlers come in.

Learning how to use exception handlers is the most important aspect of an always online script. 

If you're a beginner please read Networking in Circuit Python then Web API's & You first. 24/7 Online Requests is a follow up guide for intermediate level Circuit Python coders. Some parts of this guide infer you already know the basics for getting your board online & interacting with Web API's.

The above code is as basic as it gets for attempting to connect to WiFi but what happens if your WiFi access point is down or the credentials are wrong?  Your script will cease to function and will crash with an error to a console.  The error could be any number of possible errors such as out of sockets, out of retries, failure to get host, and so on.

Basics of Try/Except

By wrapping the WiFi connection request in a try/except, instead of crashing to REPL, it opens some important options which include (but not limited to):

• print the error to serial console
• ignore the error completely
• retry from where try was initiated
• reload code.py
• restart the microcontroller

Have you always wanted to get your Circuit Playground Bluefruit working with Home Assistant? Have some Circuit Playground Bluefruit devices sitting around and you'd like to use them as temperature sensors or use the buttons to control aspects of your home?

Well, you can. Using Circuit Python and the BTHome specification for advertising data over Bluetooth, you can broadcast the temperature from a Circuit Playground over Bluetooth to your Home Assistant.  

The BTHome website has a nice, quick primer on the advertisement format for BLE. An even shorter primer is here. BLE defines the format for advertisements and data packets. We're interested in the Advertisement payload format, which is part of the overall data packet.

The advertisement payload consists of a series of advertising (AD) elements. Each AD element has a length (1 byte), an ID (1 byte), followed by ad element specific data (variable length). 

Last January I spied an Arstechnica article,  "1D Pac-Man is the best game I’ve played in 2024 (so far)", and it got me thinking. I've done more than a few little arcade games with my Pybadge - but I wondered if I could do something on the CircuitPlayground.... Hmmmm.....

So I came up with StarFighter Patrol. Basic premise: Hyperspace lanes are plagued by navigational hazards - asteroids - that you need to blast to clear for safe passage. A "lane" is a 100 element array in the program - on the CPX you see ten elements - your ship at pixel 4 or 5 (depending on which direction you are heading). The stars and asteroids move clockwise initially - the lane is a circle, if you wait long enough the same elements will come toward you.

Pressing B reverses direction, A fires your lasers. You need to clear the purple asteroids that are a hazard to hyperspace navigation. You can move to a new region by hitting A4. Or if you choose restart the game with A3. When you've been hit 5 times your score (number of asteroids cleared) will show before the game restarts. (the score is digit-by-digit, so 13 would show one pixel, then three pixels. Zero is all green pixels). In the CircuitPython version you restart when you hit A or B. The Makecode/Javascript version will restart after a pause.

The Circuit Playground display shows your spaceship as a green dot, and the stars and asteroids heading toward you in a 10 pixel-wide display - this is a portion of the 100 pixel wide hyperspace lane you patrol (think of the "lane" as a circle - you move left or right in in and will wrap all the way around if you play long enough). Your ship fires toward oncoming objects - so when you reverse course the laser blasts (yellow dots) move towards the oncoming objects.

Bonus: You can see MORE pixels if you attach https://www.adafruit.com/product/3811 - the 30 pixel Adafruit neopixel strip using A1 as the control - then you'll get a 30 pixel wide one-dimensional display!

 

I'm happier with the way the CircuitPython version turned out - but both versions (Makecode/Javascript or CircuitPython) pretty much work the same.

 

Switch to the right to turn off sound.

Files in the github archive:

• bach.py - provides musical tones - copy to Circuit Playground for starfighter.py
• starfighter.py - 1D starfighter patrol game. Destroy asteroid threats. copy to code.py on your Circuit Playground
• starfighter.js - Javascript version Makecode link: https://makecode.com/_RocF4AHbY19R

Game controls:

  A - fire laser
  B - reverse direction
  A4 - hyperspace
  A3 - restart game
  A7 - show last score

Persons with disabilities related to communication may utilize grid based communication systems as Alternative Augmentative Communication (AAC). One such web based and open source system is AsTeRICS Grid developed in Vienna under government funding with the goal of making this type of communication free and accessible to all. It has a wide range of features and input methods, one of which is the Huffman input method which assigns key combinations to each cell.

This got me thinking about Adafruit's NeoKey Emoji Keyboard project and what a great fit it would be for this type of input. I managed to tweak the project's file so each key press sends the numbers 1- 4 to support navigation through the cells. Thanks to Liz Clark for the code and wonderfully helpful and easy to follow tutorial!

This demonstrates a CircuitPython driver for reading XInput USB gamepad events using the Adafruit USB Host BFF (MAX3421E) and a QT Py ESP32-S3 dev board.

Demo Video

Have you ever wondered what you can do with your unused twisted-pair telephone wire running throughout your house? Well, how about using it as the transport medium for a CAN bus network of environmental sensors? This project, which I dubbed PhoneCAN, is a relatively easy project which uses Adafruit hardware and CiruitPython.  My setup uses four CAN nodes:

• A "home" node with an OLED Featherwing display on an RP2040 CAN feather with MCP2515 CAN controller that can show current values for all four nodes using the buttons on the display
• A "send" node with ESP32-S3 Feather and CAN bus Featherwing MCP2515.  This node gathers measurements from all nodes at a user-specified interval (I use 15 minutes), averages them over the interval, and pushes them to Adafruit IO.
• Two "remote" nodes which use RP2040 CAN Feathers with MCP2515 CAN controllers.
• I used two types of sensors (just because these were the ones I had on-hand) as I was interested in tracking temperature and relative humidity around my house.  Any of Adafruit's environmental sensors should work:
  • Sensirion SHT41 Sensor
  • MS8607 PHT Sensor
• Gather all those old phone patch cables that you have lying around in drawers around your house (be careful though, some cables have "swapped" wiring).  For most of my nodes I used RJ11 breakout boards to connect the three-wire CAN controller to my home phone jacks.

I have all of my nodes reading and posting measurements every second to the CAN bus.  Documentation and sample code provided on my PhoneCAN github repository.  I believe that this is a relatively easy project and was really a lot of fun to put together.  Best part?..  Using that old (abandoned by the steady march of technological progress) twisted pair phone cable sitting in the walls of my house.

This demonstrates how to add a simple menu system to your project using a single rotary encoder for input and the serial console for output.

Hardware: Parts and Tools

Recently I introduced my current project, which I've been calling the "Top-Secret Lunchbox", on Adafruit's Show and Tell stream. I wrote this playground to go into more detail about how I built it.

I mentioned in the stream that it took me about a week to design and build the lunchbox, but that's a pretty generous estimate that does not tell the entire story. For starters, it does not include writing any code beyond basic hardware bring-up (the game code is essentially an entire other project). It also doesn't account for the fact that this is my third attempt at such a project, building on roughly three months of prior learning and experimentation. I was able to reuse many solutions from that experience, including designs for 3D-printed panel mounts for various hardware. This allowed me to make more informed choices and reduced the amount of time needed for learning and experimentation.

The short time frame also belies that this is a fairly complex gadget for a hobbyist project. It uses most of the hardware features of the RP2040 Propmaker Feather, as well as all of the available GPIO (except for the servo output, which I did actually consider using at one point for something like a haptic motor). It required designing and printing several parts for basic assembly. It required a lot of soldering, and some "clever" solutions to some interesting challenges.

Given the overall complexity, and the fact that I was still "winging it" on several aspects of the project, this article will describe more "how I did it" than "how you should do it". I will provide as much detail as I can about the entire process, including designing, printing, wiring, and assembly. I will also provide CircuitPython source code for a full working game! You can find a walkthrough of the game at the end of this article.