Inspiration

This project was born from two desires. One, see if our dog could be taught to use buttons without spending piles of money. Two, to make use of an ancient Raspberry Pi.

Lots of people have done a project like this, and it isn’t necessary to use a Raspberry Pi. That just happened to be the only unused piece of electronics I had on hand with audio output. But, I will say that I definitely recommend this approach for a couple reasons. Firstly, it’s very easy to get running in Python with Adafruit’s Blinka library. Second, it leaves lots of room for growth (both in number of buttons and features like button presses sending digital messages).

Be sure to read all the way to the bottom for a cute puppy photo!

Materials Used

• Raspberry Pi (low cost model A)
  • Gifted by a coworker who was going to throw it out
• 16GB (full size) SD card
  • Came with my 3D printer, but is overkill for that purpose
• Audio cable
  • From a box of junk computer parts
• Audio amplifier
  • Included in a box of junk that got shipped to me
• Speakers
  • From an old CRT TV
• Jumper wires
  • Reused from multiple projects
• Keyboard breakout
  • Hand made from salvaged diodes, jumper headers, perf-board, wires, and solder.  Let's call it 50% recycled.
• 3D printed buttons (and some hotglue)
  • Technically new, but I don't count 3D prints if they displace buying other plastic
• Electronic buttons inside the prints (also a boot button shutdown switch)
  • All salvaged from ewaste or otherwise discarded
• Wooden mounting board
  • Had to buy it from a hobby store

Salvage percentage ~83%!  Hard to give an exact number... do you measure by count?  By volume?  By mass?  By value?  Do you count new tools you had to buy?  Whatever, I'm going to call it 83%.

C3P0 can talk. R2D2 expresses what he's thinking with beeps and boops. What can you do with a Neo Trinkey?

 

How about.....Morse code? It's simple, and four neopixels is more than enough to say anything! Here's how I set about doing it.

The great thing about Circuit Python is you can just plug in a device and use any editor on the code, but I like to use thonny as my IDE. Thonny gives you easy access to the REPL and you can have plenty of print() statements for debugging.

 

I love using the random library - it's a simple way to introduce variety into simple programs and here's one example, what I call "Spock on a Chip." Here's a link to the repository.

Copy the files to a NeoTrinkey, changing "spock.py" to "code.py" - when it runs, it occasionally blinks lights, but when you touch one of the pads, it will blink and then pick a random quote out of the "spock" file and print it. If REPL=True, you'll need to be in an editor like mu to see the text. IF you change REPL to be False, then it will use HID support to send the text as if typed on a keyboard! Just the way to jazz up your email! Edit the "spock" file to add your own favorite quotes from everyone's favorite Vulcan.

 

What's going on?

There are two functions that are used to deliver the quotes. len_file(filename),

def file_len(filename):
    with open(filename) as f:
        for i, _ in enumerate(f):
            pass
    return i + 1

 

and wisdom(file_name).

def wisdom(filename):

    qs = open(filename)
    for i in range(random.randrange(file_len(filename))+1):
        quote = qs.readline()
        quote = quote.rstrip()
    cmpthink()
    qs.close()
    return (quote.rstrip())

 

Give a file name, wisdom() calls len_file() to determine how big the file is, then uses random.randrange() to select the text - that means you can add or subtract from the "spock" file without needing to update the program.

 

The fun thing with this code is, it can be reused for other purposes. I've already used it to put together a "story" program that uses multiple source files (aliens, suns, planets, etc.) that can be drawn from to generate story lines. It could be used for a diceware style passphrase generator. And, of course, it doesn't have to be Spock on a chip - you can fill the "spock" file with any quotes you choose.

 

 

It's no secret I think the NeoTrinkey is wonderful. It's small, it's cheap and it runs CircuitPython! Who could ask for more??

As I played with it, one thing I found handy was making some helper modules to assist in building programs - three that are particularly handy are:

• morse.py  - translate text to Morse code, also defines touch pads for input
  • def docode(text): # display given text in Morse code
  • def blinknum(num,color): #count out a number in a color
  • def compthink(): #blink out all the colors when computer "thinking"
• prt.py - provides a function to print text to the REPL *OR* using HID to send it as typed text.
  • def prt(text, REPL): #prints text to REPL if REPL=True; otherwise uses HID to send as typed text
• ncount.py - blinks numbers, or displays 0-15 in binary.
  • def docolor(color): #briefly set all pixels to color
  • def blinknum(num,color): #blinks num times in color
  • def binnum(num,color): #display num%16 in binary on pixels with color

Using The Modules

Here's a very short program that blinks out, in Morse code some Bible verse fragments (in Klingon - my "nickname" is mrklingon, after all):

from morse import *

John316 = "vaD  joH'a'  vaj loved the  qo'"
Isaiah263 = "Duvoqchugh, vaj rojna'Daq Da'av,  DuHarmo'"
Psalm231 = "DevwI'wI' ghaH joH'a''e' jIneHbe'."

 

while True:
    docode(John316)
    docode(Isaiah263)
    docode(Psalm231)

 

Pretty simple - it just blinks the code over and over. You could plug it into a power source and let it run - and you could choose your own text. Plugged into a computer running Mu, you would see the text being printed over and over as well.

Using the prt.py module, I wrote magicquest.py. This uses morse.py for the touch pad initialization, and the "compthink()" blinking. Touching pad 1 creates a fantasy character (race, class and name), and pad 2 generates a short story about the character's adventure. I used fantasynamegenerators.com  to come up with place names and more.

If you change the value of REPL in the code you can decide if the text gets printed in the REPL using Mu or Thonny, or if it is sent as if typed using a computer.

REPL = False #"printed" text from prt() goes as if typed

REPL = True #"printed" text goes to REPL

I  used the ncount.py module's binnum() function in two progams, cards.py and orbit.py.

For the cards.py program, the neotrinkey shuffles a deck of cards when you touch pad1, and pad2 draws a card and prints it in the REPL but displays it as a binary number (1-13) and color 

suits = ["diamonds","clubs","hearts","spades"]
scolor = [gold,blue,red,green]

Touching 1 and 2 together shuffles and draws three cards.

orbit.py blinks a purple NeoPixel around and around at a speed (sort-of) appropriate to the planet the ship is at - from Mercury to Pluto. This uses binnum() to light up the number 1,2,4, or 8  to move the position around and around the four NeoPixels. Touching pad 1 makes all NeoPixels flash gold (closer to the sun) and shifts to the planet that is next closer to the sun. Touching pad 2 makes all NeoPixels flash blue (farther from the sun) and shifts to the planet next farther out.

Pads 1&2 together make jump the position either to Mercury or Pluto depending on whether you are closer than Mars or at Mar or farther out.

The name of the target planet is printed to the REPL and the orbit speed speeds up or slows down depending on which direction you have moved. (Note: the "speed" is just a factor based the position (planet 1-9) divided by ten. It is not really correct for the real planets). 

 

Here's a project I had fun putting together using my NeoTrinkey toolkit to make a tiny little video game.

I call it "Galaga" - and it uses the ncount.py and morse.py helper modules.

Gameplay:

• An enemy moves back and forth at random in the 0 and 3 neopixels.
• Touch 1, or 2 to "shoot" the moving enemy (green pixel).
• If you are lined up with it, you get a hit. If not it's a miss.
• A hit blinks gold for the count of hits. If you miss, you blink the number of misses in pale blue.
• A win is 5 hits, and losing is when you have 5 misses or run out of missiles.
• Winning is followed by multicolored blinking.
• Following loss/win the number of missiles, score and miss count are reset and game restarts. 
• NOTE: connected to Thonny or Mu, you can see "boom!" and "miss" printed when you hit or miss. Plus notification when you win (or lose).

Better SD write performance is probably a common goal. My project uses the Adafruit SD Micro SDIO breakout, the Adafruit OV5640 Camera breakout and the Unexpected Maker ESP32S3 feather in a compact stack (with a custom PCB to connect them) that fits in a GoPro waterproof case. I want GoPro-like video recording but with BLE time synchronization and start/stop functions with multiple cameras. It's like a GoPro but it's not, it's a NoPro!

I'm programming with the Arduino IDE and using the SD_MMC library. The ESP32S3 has an SDIO interface with programmable pins, which the library supports. But for the longest time, I could only get sustainable write speeds of 150-200 kilobytes per second. I'm using a Sandisk Extreme V30 32GB which should get 30MB/s. For the frame rates and resolution I want, I need about 3MB/s.

I initially played with the file system buffer size but never got consistent results. I might occasionally get a few frames written at target speeds but never a whole video. So I set my code aside and started from scratch to explore how to get better speed.

There definitely seemed to be a dependence on file buffer size as well as on the size of data being written. So I tried lots of combinations and got the same results - usually about 150-200 kB/s but occasionally over 3MB/s.

But I had noticed a pattern of good performance when the write lengths were certain powers of 2 so I tried multiples of 512 bytes and got much better speeds. With a file buffer size of 4096 and data sizes over 75kB I could get consistent speed over 3MB/s, just what I need.  4096 also gets consistent small writes at over 1MB/s.  Buffer sizes of 8192 and greater actually worked worse.

I was looking for a clock that would tell the time in words rather than just hands (analog) or numbers (digital). I found a few for sale on places like Amazon and eBay, but none of those particularly stood out, so I decided to create a customizable one myself.

I designed and built two variants. Both use the same RGB matrix panel. Both use CircuitPython on the ESP32-S3, but one uses the Matrix Portal S3, and the other uses a standalone Feather ESP32-S3 with an Adafruit RGB Matrix Featherwing Kit. The Matrix Portal version requires no soldering; the Feather version requires some simple soldering. I will show both here.

The text is left justified, vertically centered on the display and each line is in a random color which changes every time the minute changes. Since you control the CircuitPython code, you can change this formatting any way you choose, e.g. same color lines, individually horizontally centered lines, etc.

Common Hardware

If you have a lot of koozies and are looking for a custom way to store and access them, this koozie holder might just be for you.

My niece requested a koozie holder for her home so I designed and printed this for her. I've made it so it's configurable.

The text that you see in the photos is what is in the STL. 

What can be configured?

• Height - You may want bigger or smaller!
• Width - current is for what I think of when I hear "koozie"
• Depth - see above
• Text
  • Font
  • Size
  • Depth
  • Spacing
  • One side print or both
• You can also download the source code and change up anything about it

Details of this print

• 3D Printer: FlashForge Adventurer 4
• Filament: 3D Printlife Recycled PLA, color: Night
• Supports: Yes
• Nozzle temp: 220c
• Print bed temp: 55c
• Raft: No
• Ironing: Yes - This may be specific to the FlashForge slicer but it puts a smoother finish on the piece
• Total print time: ~57 hours

Where to get it

• Github
• Thingiverse

Photo shoot!

 

# Space War - Magtag

This started out as Star Trek in BASIC written by Mike Mayfield in 1972. It was completely text based, designed to run a teletype for input and output.  As did any number of computer programmers at the time, I grabbed a copy and changed and enhanced it.  Eventually renaming it to Space War so I didn't have to keep all the Star War references.  I don't have any of the original listings.  There very well may have never been a complete hardcopy listing.  A listing at 10 characters per second on roll paper wasn't something you did often.

Eventually, I converted a version to Fortran to run on an IBM mainframe on a CRT that had an addressable cursor. A while ago, I did find a listing of that version (data 1977). And I had an extra MagTag that I wanted to try doing something more interactive than display the weather, or motivational quotes.  My first thoughts were that it should be pretty easy to port the Fortran over to Python.

I make no claims that this is a 'port', or 'conversion' of that Fortran program.  That program was a convoluted mess of GOTOs and GOSUBs and clever Fortran hacks (and a serious lack of comments).  About all I actually
saved were the instructions and the program flow.

The MagTag is actually much more powerful than that GE265 or the IBM so I wasn't worried about the program size.  There are two issues that I had to spend most of my time on.

1) There is no keyboard on the MagTag.  Just 4 buttons.  So "typing in" a command was out of the question.  And if one button is used for "Next" and one for "Cancel" that meant only two left for commands.

2) The second issue was the eInk display.  More specifically, the refresh rate is approximately 3 seconds between changes.  So you really can't give feedback whena button is pressed.  This was a real challenge when the commander needed to enter a four digit coordinate to warp to.

There are addon's that could easily attach to the Magtag to address these.  But I wanted to be able to play it on a "stock" Magtag with no additional components.

And I added some comments.

I think it turned out pretty good. Though there are still some things left to implement.

https://github.com/vrtisworks/Space-War---Magtag

 

Here is the first sketch: a simple clock.

This script provides a simple digital clock display on the Feather ESP32-S2 TFT. The time is updated every 0.1 seconds, and the display shows a circle and the current time in a specified font. Built on the Desk of Distress.

Next Steps:

Temperature and Humidity (ADT7410)

My current project requires an ST powerSTEP motor driver UNO R3 shield with the Adafruit Metro RP2040 requiring SPI on the normal D10-13 pins. I am also using the AdaFruit 2.8" TFT Touch Shield in the alternate configuration with SPI on D11-13. Getting these to work turned out a little painful, as SPI on D10-13 doesn't work out of the box. I had used the ST powerSTEP motor shield in other Arduino UNO projects, and was caught by surprise when it's D10-13 SPI didn't work with the Metro RP2040.

Required is a simple hardware hack to swap pins D10 and D13 on the UNO R3 connectors. I did this with some extra headers with D10 and D13 broken out and swapped with blue wires to the Metro RP2040 pins on the back of the board.

The Arduino board files for the Metro RP2040 required enabling SPI1 since D10-13 can not be used with SPI0 on the RP2040, and swapping the D10 and D13 pin configuration to match the hardware header hack.

in rp2040/3.6.2/variants/adafruit_metro/pins_arduino.h, set:

// SPI1
#define PIN_SPI1_MISO (12u)
#define PIN_SPI1_MOSI (11u)
#define PIN_SPI1_SCK (10u)
#define PIN_SPI1_SS (13u)

#define SPI_HOWMANY (2u)

in rp2040/3.6.2/variants/generic/common.h, change:

static const uint8_t D10 = (13u); // swapped D10 and D13 at pin headers
static const uint8_t D13 = (10u); // swapped D10 and D13 at pin headers

Using TouchPaint to verify the SPI hardware and configuration hacks, required changing the initialization to SPI1.

Adafruit_ILI9341 tft = Adafruit_ILI9341(&SPI1, TFT_DC, TFT_CS)

I had rewritten TouchPaint to add calibration for the touch function, since the software defined touch values worked very poorly with my board. The touch points with a small X and Y didn't pick up, leaving a good sized unusable area in that corner, and along the all the edges. Lowering the touch pressure from 300 to 100 got the full screen area touch working, but there was a several mm mis-registration between the pen contact, and the drawn pixels. I also cleaned up static defines to use the calibration values, returned hardware values, and dynamic pallet size based on an array of pallet colors.

The debug serial prints for calibration need to be moved below the two calibration calls for debugging. i just moved them into a single ifdef.

 

Would you like to have a desktop clock, weather station, dice roller, timer, etc? This project describes a hardware solution you can use. It is based on a TFT Feather and a Feather Doubler board, with a Temperature and Motion Wing.

Equipment:

• ESP32 Feather with TFT display: There are several to choose from.
  • ESP32-S2 Feather with Reverse TFT
  • ESP32-S3 with TFT
• Temperature Motion Wing which includes:
  • ADXL343 triple-axis accelerometer
  • ADT7410 precision temperature sensor
• FeatherWing Doubler is the 'frame' of the device.
• Female Headers for the Doubler:
  • Use the black ones included in the pack OR
    
  • Color Headers in your choice of colors.

I'm in a radical marching band called Brass Your Heart, and I wanted to make our instruments light up when we play them. I started this project by making one for my friend who plays a marching baritone. Below is a mostly step by step process for how I made them using: sewable neopixels, conductive thread, snaps, a Gemma M0, and an electret microphone. 

 

 

Step One:

The diameter of the baritone measured 26 inches, so I used tailor's chalk to draw the outer circle you see here. Then I drew another circle, about an inch in for the lights, so that the neopixels and the conductive thread is far away from the metal of the instrument. I also make 8 markings where the neopixels would go and started to sew them into position with regular black thread.

 

This project was a personal desire to put Adafruit IO through it's paces, and see how far I could go in recreating a project designed for ESPHome + Home Assistant. Traditionally I would have assumed it was too complex for the Actions and Dashboard of Adafruit IO if I used a Wippersnapper device, instead relying on Node-RED to string things together, but now that I work on the WipperSnapper project I was curious how far it had come / could go.

The basic idea was to take a £60 "dumb" air purifier with a 3-speed dial (£70 with carbon filter) and add a WiFi micro-controller, so that it can be switched on and the speed controlled according to the values sent from a separate Air Quality sensor (Particulate Matter <2.5µm), and a user-adjustable control panel hosted as an Adafruit IO Dashboard.

Is this another silly idea / tribute to insanity, by needlessly bolting the internet and a subscription service to a device, which usually degrades performance and adds built-in obsolescence (not to mention a 22second boot-time)?

Well maybe, or maybe it's just a way of providing people with alternatives, but either way it involves Adafruit IO as an alternative to Home-Assistant / Node-RED or the official IKEA smart-hub + smart devices, and Adafruit's open-source IOT firmware called WipperSnapper as an alternative to ESPHome.

It's possible to use on the free-plan on Adafruit IO (you do NOT need IO+), or offline with a little coding, so I don't feel bad about suggesting it...

Here's a demo video of it in action: (Adafruit IO Dashboard on left, WipperSnapper device page on right, Speed dial of Air Purifier + Wind Sock on Picture-in-Picture video)

My mom has two Christmas Cactus plants that have been doing really well for the past few months. However, with winter arriving she had been struggling to find a spot where they were getting enough light. I offered to build her a grow light using DotStar LEDs since they have a color temperature of 6000K, which these particular plants respond to. I decided to use WipperSnapper so that the lights could turn on and off on a schedule and it would be easy to troubleshoot remotely.

I designed up a wooden box in Fusion360. It was designed to be made with 1/2" plywood.