Overview

Welcome to the Adafruit guide on creating a stunning Badger Mountain themed art piece! In this guide, we'll show you how to bring your artistic vision to life using the powerful Feather RP2040 microcontroller, along with an array of components including audio jacks, buttons, and LED strips.

Circuit Diagram

This article is for Circuit Python developers that use PIP and CircuitPython-Stubs in a Windows environment. 

Stubs are helpers for code completion hints with IDE's such as PyCharm, VSCode, and others.

Unfortunately PIP & CircuitPython-Stubs do not automatically stay updated.  These are things you must manually update when a new version of Circuit Python is released or whenever your heart dictates you want to update it.  This is a problem because I never remember to keep them updated and recently found out my version of stubs was last updated in Circuit Python 7.3.3 (we're now at Circuit Python 9.0.1). 

This is assuming you already have PIP and CircuitPython stubs installed.

The manual way to update them is:

python -m pip install --upgrade pip

pip install circuitpython-stubs --upgrade

These are the types of things I do not want to be required to remember to update.  I consider these things minutia that should automatically stay updated.

Windows Task Scheduler can automate the process of keeping both PIP and circuitpython-stubs up to date every time you log into Windows.  First we need to create a batch script and put it in a directory/folder that will always be available to Windows. 

I chose to put it in the following folder:

\Downloads\CircuitPython-Stubs_Updater

You can name the script whatever you'd like.  You can edit a .bat file as easly as a .txt file, you don't need a special IDE to do it, Notepad works fine for it.

I named my batch file:

circuitpython-stubs.bat

It resides inside of the CircuitPython-Stubs_Updater folder and includes the following code in the .bat file.

Introduction

Astronomy is my primary hobby and taking photographs of night-sky objects is my particular interest.  A downside to this hobby is that it is very weather dependent.  If it’s cloudy nothing can be seen.  Weather reports are important to monitor but they just serve the general area.  The sky conditions at my specific location are better monitored with an AllSky Camera.

An AllSky Camera is simply a camera with a fisheye lens that’s pointed up into the sky.  A program takes pictures of the sky all night long so checking the sky conditions can be done by looking at the latest sky image.  Is it too cloudy to take images?  Are clouds starting to move in?  Just check the AllSky Camera!

The Issue with Dew

Unfortunately, the dome of the AllSky Camera is prone to have dew forming on it when the humidity gets high.  Once that happens, the Allsky images are totally unusable.  To combat dew, many AllSky Cameras have a dew heater built into them.  The heater in my camera is very simple:  Apply 12 VDC and the heater is on.  Remove the voltage and the heater is off.  This applies about 10 W of power to the heater, and it does get hot enough to keep dew from forming on the dome.  Sometimes it gets too hot.

If the humidity is moderate the 10 W of power is way more than needed to keep the dome clear.  An unwanted side effect of too much heat is that cameras don’t like it.  The hotter a camera gets the noisier, or grainer, its picture becomes.  This is especially apparent with long exposures and AllSky Cameras can take up to 60-second exposures under a dark sky!  The better solution is to vary the amount of power applied to the heater so that only enough is applied to keep dew from forming, and no more.

 

The goal of this project is to build a Python based handheld and battery powered scientific calculator the size of a cigarette box (well, pocket calculator). Scientific, as in "reasonable precision". Float32 (single precision) is certainly acceptable for a display precision of, say 6 or 7 digits, but the follow-up rounding errors are not - at least not for me. I experimented with Decimal math before but ended up having to fight memory constraints with jepler-udecimal (https://github.com/jepler/Jepler_CircuitPython_udecimal) and my own extensions even on a Feather RP2040 with 256kB of user RAM. So I eventually decided to make a custom CircuitPython build and try to enable float64 (double precision) math. (Thanks to the Adafruit folks for their help!). Needless to say that float64 is entirely handled in C without the help of a potential floating-point unit (FPU) but then this approach is still much more CPU and memory efficient than implementing everything in Python.

The code for this project is on https://github.com/h-milz/circuitpython-calculator/ and will be discussed in this article.

The terminal window displays a couple of features of this tiny machine, from top to bottom: calculating pi using arctan(1), the arsinh of a complex argument, multiplying two numbers with uncertainties, and multiplying two fractions including reducing it to lowest (positive) denominator.

The dongle on the lower right is a PCF8523 RTC hanging off the Keyboard Featherwing's STEMMA Qt connector (which, sadly, is unusable if you want a handheld with a back cover ... What did arturo182 think?)

On the backside you can see the Adafruit Feather M4 Express and the LiPo battery, which is fixed to the Featherwing using a double-sided adhesive foam strip.

Introduction

The flight simulator industry has spawned dozens of custom controllers for those who are looking for a more realistic and entertaining experience. These controllers range from yokes and throttles to communication and GPS systems and their price can rival the costs of actual aviation equipment.

Thankfully there is a way to create your own controllers using low cost microcontrollers, buttons, encoders and many other input devices. There are even ways to output settings to LEDs, LED segments and displays but this guide does not cover output scenarios.

For this hookup guide I am using a controller I made for myself. The G1000 glass cockpit has a dual-rotary encoder in the lower right corner labeled FMS (Flight Management System) that is a pain to control with a mouse, even more so while the plane is in the air. So I decided to build my own controller to simulate the G1000 corner. My controller includes the FMS encoder knobs and the 6 buttons that tend to be used at the same time.

You can find the source files and STL files I used on GitHub.

The Controller

For my FMS controller I found the PEC11D-4120F-H0015, a dual concentric rotary encoder (meaning it has an inner and outer encoder ring that can turn). This is not the FAA approved version on the actual G1000 but works the same and cheaper. The dual rotary encoder is similar to a single encoder except has two sets of A/B/C pins. The encoder also has a push switch. The push buttons above the encoder are standard push buttons.

The encoder and buttons are wired to a Feather board but almost any board that can run CircuitPython with USB HID enabled will work.

I just couldn't bring myself to use the standard practice of soldering pins onto breakout boards using a solderless breadboard in spite of the recommendations and endorsements of some famous solder artists. I would cringe thinking that the heat would eventually warp the plastic portion of the board. It is a solderless breadboard after all.

Fortunately, after placing many Adafruit orders over the years, I had build up quite a collection of free half-sized Perma-Proto breadboards. The solution for creating a non-destructive soldering jig became obvious. Stack four Perma-Proto PCBs together, use a couple of M3 nylon screws and nuts, and place some rubber feet on the bottom. Voilà!

Sadly, the Perma-Proto board is no longer offered as a free product promotion. That's okay; I still have enough in the inventory for many future projects. And coasters. I have coasters.

If you've been playing the awesome new co-op game Helldivers 2, you'll be familiar with the "stratagem" gameplay mechanic in which you summon various weaponry from airborne and satellite craft. This mechanic requires you to hold down a key/button to activate the stratagem input mode, while entering a sequence of directional key input.

Often during the game I tend to get overstimulated in the middle of a heated battle and my mind goes completely blank when trying to recall the one of the myriad codes I need to use to summon the effect I want. Even though the game UI displays them, it's still pretty hectic to precisely enter the sometimes lengthy codes when a giant scorpion is trying to rip my head off. To help spread liberty and democracy in the most efficient way possible, I thought I'd try to see if I could set up some stratagem macros using the awesome MACROPAD Hotkeys project from Phillip Burgess. NOTE: For simplicity, this particular setup mimics keyboard input, so until I hear otherwise I'm assuming this only works on the PC version of Helldivers II.

Custom Code

It took a few tries to figure out how to set up the macros so that the game would consistently accept them. Thankfully, the MACROPAD Hotkeys project is incredibly versatile and I was able to do this using the built-in features of the project without having to modify any of the core code. The main factors involved in getting this to work seemed to be:

1. After pressing the stratagem input button, a significant delay was needed before the game would accept the directional input. I'm assuming this is due to needing to wait for the UI to fully present in-game before allowing further input. With experimentation it seems like the smallest delay possible is about 0.4 seconds.
2. Each directional key needed to be pressed for a certain duration. The smallest duration I've tried for this so far is 0.05 seconds.
3. A small delay is needed after each direction key is released. The smallest duration I've tried for this so far is 0.05 seconds.

In the /macros folder on my macropad CIRCUITPY drive, I created a new file named helldivers-2.py. Since I anticipate changing this file frequently as I progress through the game, I wanted to make it as simple as I could to add/edit new macros, so that I could even edit them in real-time as I played the game. To make this a little easier, I wrote a bit of custom code at the top of the file.

The arbitrary waveform capability along with ADSR envelopes and filters has made it very easy to create custom musical voices with CircuitPython synthio. And if you use an additive synthesis tool like WaveBuilder, you'll begin to quickly amass quite a few custom musical voices as you experiment with the nearly infinite number of oscillator combinations.

Hearing Voices

Up to this point, I've been keeping track of the numeric specifications for WaveBuilder oscillators and synthio.Envelopes in project code or scribbled on a note pad. That means that when building a new project that needs to use a previously created voice, I'll cut and paste the voice definition code into the new project. The process works, but isn't ideal. What if a synthio musical voice could be loaded from a collection in a file folder, kind of like working with a font file?

So a concept for the WaveStore project began to develop. Here are the initial requirements.

• Library File Management -- We'll make it easy at first and just work with a collection stored on an SD card. No need to tax the brain to conjure up a way to write to the CircuitPython root directory just yet. After creating and storing a voice to a file, we'll manually copy the files from the SD card in order to use and share between projects.
• Files -- In the spirit of keeping it simple, only files representing waveforms and envelopes will be created. Those objects form the fundamental elements of a musical voice. Perhaps we can add filters and other effects later.
• Library File Names -- Waveforms will be stored in a standard wave file with a .wav extension,  thanks to the awesome Adafruit_CircuitPython_Wave library. Envelopes and filters definitions will be stored in plain text files with .adsr and .fltr extensions but will transform to synthio.Envelope and synthio.BiQuad objects when retrieved.
• Icons -- Imagine being able to select a musical voice waveform or envelope by touching a screen icon. Functions will be provided to save and retrieve bitmap images of waveforms and envelopes as well as capturing the contents of an entire screen. We'll start with 64x64 pixel bitmaps created by WaveViz. A graphical frequency response representation of a bi-quad filter's coefficients is in the works but is a bit beyond today's skillset. There's a potential workaround, but I'd rather derive it directly from the numbers. Hoping for an epiphany soon.

In the future, more features will likely be added to WaveStore such as support for filters and on-screen icon buttons -- as my experience and Python skill set grows. What would you add?

Enter WaveStore

WaveStore GitHub repository

WaveStore is under development but is available for testing. The current alpha version of the WaveStore class provides the following helpers:

• Wavetables
  • read_wavetable -- Read a .wav file and return a memory view object.
  • read_wavetable_ulab -- Read a .wav file and return a ulab.numpy array object. The ulab array can be mixed with other wavetable array files.
  • write_wavetable -- Format a wavetable and write it as a standard .wav file.
• Envelopes
  • read_envelope -- Read an .adsr file and return a synthio.Envelope object.
  • write_envelope -- Write a text interpretation of a synthio.Envelope object to an .adsr file.
• Bitmaps
  
  • read_bitmap -- Read a .bmp file and return the bitmap as a TileGrid object that can be added to a displayio.Group object.
  • write_bitmap -- Write a bitmap image to a .bmp file.
  • write_screen -- Write the screen contents to a .bmp file on the SD card.
• Utilities
  • get_catalog -- Returns a list of files in a specified folder.

This note describes a method to output Eurorack CV (control voltage) signals from CircuitPython synthio using the PCM510x I2S DAC.

Rather than employing CV-like object controls such as Envelope and LFO to only adjust the parameters of other synthio objects, it would be useful to also control physically external devices such as the CV inputs of Eurorack modules. To do that we'll need to configure the synthio.Note object to ignore its typical behavior as an oscillator. Oh, and it would be handy to have an I2S DAC on-hand with a DC-coupled output that's capable of positive and negative output voltage that can be connected to a Eurorack module.

Here's the test setup:

1. Create a Note.waveform (wave shape table) object containing the maximum wave value (16-bit signed). This is an array filled with a single value that acts like a fixed DC voltage.
2. Set the Note wave shape oscillator frequency to an arbitrary value such as 440Hz. The frequency value is unimportant since the oscillator waveform output will simply be a fixed value.
3. Define a synthio.LFO object to output the LFO signal. If outputting an ADSR envelope is desired, define a synthio.Envelope object.
4. Create a synthio.Note object where the amplitude parameter is controlled by the ADSR envelope or LFO.
5. "Press" the note to output the ADSR envelope or LFO signal from the I2S DAC.

Instead of the I2S DAC, CV output signals can be created in this manner using audiopwmio and audioio to use PWM or analog DAC output pins. Boards like the QT PY RP2040 and Grand Central M4 Express could be used for PWM or analog DAC outputs. Keep in mind that, unlike the 0 volt baseline of the I2S DAC, the baseline of a PWM or analog DAC signal is biased to approximately +1.65 volts.

I2S DAC Output

Inspiration

I needed a soldering lamp that didn't cast strong shadows and was an opportunity to salvage the LEDs from a broken TV left by the dumpster.

There are lots of ways to make a good soldering lamp from LEDs.  I happened to pick a difficult path that required some reverse engineering but I hope you'll find the journey... illuminating. ;-)

WaveViz is a CircuitPython class to create a positionable displayio.TileGrid graphics widget from a synthio.waveformwave table or synthio.Envelope object (or any one-dimensional list for that matter). The class also makes the underlying bitmap and palette objects available for other uses such as saving the widget to an image file.

The long-term objective is to be able to save and import sounds and ADSR envelopes from a library of synthio wave table files and envelope objects. The first step in the process is to create a visualizer to help characterize the sounds graphically. We'll worry about saving and retrieving waveform and envelope objects sometime in the future (watch for a new class, WaveStore to appear soon). For now, let's work on getting images of wave tables and envelopes.

Awhile back Adafruit featured a story on their blog about a really cool fidget toy built using a rotary encoder and a NeoPixel-compatible LED ring. I loved the idea so much that I wanted to make my own version, and spent a few days designing my own with parts I had on-hand. As it turns out, I wasn't the only one: the Ruiz Brothers built an incredibly stylish take on this idea using an ANO rotary encoder and published an excellent learn guide for it!

While there are physical differences between the two versions, the hardware is similar enough that I wanted to write a CircuitPython firmware that would work their version as well as mine. I wanted the firmware to have multiple modes, with the ability to add more in the future as ideas came to me. Ideally it would be something others could build on as well.

Update: You can see a live demo of the firmware running on the Ruiz brothers' fidget toy in this episode of 3D Hangouts