An invention was patented in 1948 that has assisted millions in making decisions. Long before widespread access to computers, this device - completely mechanical gave instant answers to questions - no AI or LLM required. 

I refer to ... the Magic 8 Ball.

It doesn't take much of a web search to find examples of programs to recreate the Magic 8 Ball. It's an easy exercise - for example, here's one at geeksforgeeks.org that made a fun starting point for me to adapt for some Adafruit fun.

It wasn't hard to adapt that code into CircuitPython for the NeoTrinkey. I put together Magic8.py. Load that on a NeoTrinkey - copied to code.py. When run, it will display a blinking idle pattern. Touch either touch pad and it will go to Green (yes), Yellow (maybe) or Red (no). If you are running it in an IDE like Mu or Thonny, the REPL will print an answer appropriate to the verdict. Touch the pad again to return to the idle pattern.

But, why not make a better, smarter tool - something that you can use to calculate the answer? And why not have it SPEAK the answer?

In my DecisionMaker repository you'll find all you need to do that.

Starting with MakeCode I created a two-mode DecisonMaker for Circuit Playground Express. With the switch to the right, press the "A" button and it will give you a Green/Yellow/Red verdict. In addition, IF it is plugged in to a computer with a usb cable, touching A4 will give you a verdict and TYPE the appropriate message text. (note: If the CPX is not connected to a computer, touching A4 will crash the program; also, if you copy DecisionMaker.js into MakeCode, you'll need to add the Keyboard Extension; it's already in the version at this link).

The other mode is what you get when you move the switch to the left. This lets you give more input for the program to evaluate your question. Essentially, break your question into factors (as many as you want) and give each factor a value good or bad, then ask the DecisionMaker to weigh in. With each factor press A from one to five times (for Good) and B from one to five times (for Bad). After scoring the factor, touch A1 to add it in.

For example, lets say your question is "Should I go see the new movie Super Space Blockbuster XIII?" and you break down the factors to:

1. I love Super Space Blockbusters - read all the books and comics and have all the action figures
2. I didn't like the last three that much
3. I hear they added famous actor Kirk Handsome
4. I think it will be streaming in a couple of months.

So, here's the steps in the evaluation:

 

Put all those together, and hit the A2 touch to get the verdict.......

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

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

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!

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

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

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

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

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

Rock an Old Atrix Screen/Keyboard/Trackpad Dock Like It's 2012

Back in 2012, folks were getting their first Raspberry Pi single board computers. They initially used a monitor or television, a USB keyboard and a USB mouse, most often items they might of had around the house. This worked fine but it was far from portable. Folks wanted something a bit more laptop-like to develop on the go.

Enter surplus Motorola gear. Motorola made the Atrix line of cell/mobile phones they marketed as dual use as portable phone and computer. To make it a computer, you used a dock which looked like a laptop but had no processor, only USB and HDMI connections. Such docks were being sold wholesale at $60 each.

Folks used a combination of Far Eastern cables and adapters to connect the micro connections on the dock to the full size connectors on the Pi. As you can see below, two adapters and three cables were used. Some guides talked about splicing cables. Here is one guide from Instructables.

The setup worked faily well. Most often the adapters to the Atrix were too big, so some filing of the plastic was needed to get the cables to go on without interferring with each other. It was a slick setup but it could be fragile.

Over time, most folks moved on from using this solution as the Atrix dock supply dried up and new Pi models came along.

The 2024 Atrix Solution

I got my Atrix Dock out to use with a Pi 5 for Adafruit's Show and Tell. Things had changed since the Pi 1 when now using a Pi 5. The one full size HDMI connector is now a pairt of microHDMI connectors. There are more USB ports on the Pi 5.

I wanted a solution with no adapters and no trimming of the plug housings. I went on to Amazon (US) and through brute force (Amazon search is not the most robust) found the following cables:

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.":

 

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.

Remixing the guide from the Ruiz brothers: https://learn.adafruit.com/aqi-case/overview and retrofitting it for the Feather RP2040 & the Adafruit FeatherWing OLED - 128x32 OLED Add-on For Feather

The OLED is quite limited in colors & the Feather RP2040 has a single LED available. Given these constraints this is what I was able to achieve.

All the text on the third row are my own interpretations of the values of each of the categories. Here's an example of how I assigned a text value to the data around the PM2.5 data.

def rate_pm25(pm25_data):
    if pm25_data <= 12:
        pm25_color = green
        pm25_extra = "OK"
    elif pm25_data <= 35:
        pm25_color = yellow
        pm25_extra = "MID"
    else:
        pm25_color = red
        pm25_extra = "BAD"
    return pm25_color, pm25_extra

 

Deadline: We need it tonight

Just eight hours left until tonight's classic rock band rehearsal session and we need some pre-recorded sound effects for three songs. The sound effects (SFX) playback machine design should be easy to use, battery-powered, providing a stereo output for the band's PA system. Sound fidelity is important, but since the sound effect recordings aren't "musical" per se, there's some bit-rate wiggle room to help with storing the sound files.

The band retired six years ago. Because it didn't look like there would be a reunion tour, the previous sound effects machine (the FXM-8 shown above) was stripped for parts and repurposed. The old unit used a dedicated SFX board (Adafruit #2220) with .ogg sound files stored on-board -- something that worked and sounded good, but it wasn't easy to update the stored files. The simple and obvious FXM-8 tactile user interface was also pretty nice in retrospect.

And of course the band's plans changed. We were asked to come out of retirement and play one more gig.

We're going to need a new SFX machine.