Calculator Case To Scratch-Built Pocket E-Reader

March 11, 2026 by Matt Varian 7 Comments

E-readers are an awesome creation allowing you to display digital information in a way that requires little battery life. While there’s plenty of very impressive models to chose from on the commercial market, it’s also possible to build one yourself — which is exactly what [kaos-69] did in his Mimisbrunnur project, creating a truly unique e-reader from scratch.

While looking through old junk at home, [kaos-69] came across a case that held a calculator and pen at one point in the distant past. The pen was gone and the calculator no longer functioned but the case held promise. He removed the calculator and got some parts on order. For the e-paper display he went with a 5.83-inch unit that just fit inside the spring-loaded case. The Mimisbrunnur is powered by a 2000 mAh LiPo battery, with a micro SD card reader for storing what will be displayed. The brains come from an RP2040 microcontroller on an Adafruit Feather breakout board, which worked out great as it already takes care of battery management and the 24-pin interface for the e-paper display.

There are also eight buttons that live below the display for user interface, and even some LEDs to aid in reading in the dark. The depth of the case allowed all this to be connected with the use of a perfboard and some risers to set the screen forward, allowing the battery to live behind it. Using the Mimisbrunnur is pretty straightforward with the eight buttons sitting below icons on the screen giving you clear guidance on how to turn the page, add a bookmark, or browse the SD card for another file to open.

We’ve seen some impressive DIY e-readers over the years, such as the dual-screen Diptyx and the Open Book. But this project is an excellent reminder that a device doesn’t have to be complex to get the job done.

RP2040 Powers A MIDI-Controlled Soundboard

February 19, 2026 by Lewin Day 5 Comments

When you’re livestreaming, it can be tempting to fire off all kinds of wacky sound effects like you’re a morning radio DJ back in the heady days of 1995. If that’s who you want to be, you might like this soundboard project from [Biker Glen].

The build is based around an RP2040 microcontroller. It’s paired with an I2S digital-to-analog converter for sound output, which in turn feeds a small amplifier hooked up to a speaker or a line output. The RP2040 is programmed to respond to MIDI commands by playing various sounds in response, which are loaded off a microSD card. It’s able to act as a USB MIDI host, which allows it to work seamlessly with all sorts of off-the-shelf MIDI controllers like the MIDI Fighter or the Novation Launchpad.

It’s an interesting hardware solution to a problem that you could probably also solve with software on your streaming machine, especially if you’ve already got a USB MIDI controller. However, there’s something to be said for lightening the load when your streaming computer is already doing lots of hard work to truck video up to the cloud already. Files are on Github if you’re eager to replicate the build.

Soundboards are just fun, which is why we’ve featured them before. Meanwhile, if you’re whipping up your own streaming accessories at home, be sure to let us know on the tipsline!

Storing Image Data As Analog Audio

February 12, 2026 by Bryan Cockfield 15 Comments

Ham radio operators may be familiar with slow-scan television (SSTV) where an image is sent out over the airwaves to be received, decoded, and displayed on a computer monitor by other radio operators. It’s a niche mode that isn’t as popular as modern digital modes like FT8, but it still has its proponents. SSTV isn’t only confined to the radio, though. [BLANCHARD Jordan] used this encoding method to store digital images on a cassette tape in a custom-built tape deck for future playback and viewing.

The self-contained device first uses an ESP32 and its associated camera module to take a picture, with a screen that shows the current view of the camera as the picture is being taken. In this way it’s fairly similar to any semi-modern digital camera. From there, though, it starts to diverge from a typical digital camera. The digital image is converted first to analog and then stored as audio on a standard cassette tape, which is included in the module in lieu of something like an SD card.

To view the saved images, the tape is played back and the audio signal captured by an RP2040. It employs a number of methods to ensure that the reconstructed image is faithful to the original, but the final image displays the classic SSTV look that these images tend to have as a result of the analog media. As a bonus feature, the camera can use a serial connection to another computer to offload this final processing step.

We’ve been seeing a number of digital-to-analog projects lately, and whether that’s as a result of nostalgia for the 80s and 90s, as pushback against an increasingly invasive digital world, or simply an ongoing trend in the maker space, we’re here for it. Some of our favorites are this tape deck that streams from a Bluetooth source, applying that classic cassette sound, and this musical instrument which uses a cassette tape to generate all of its sounds.

An RP2040 Powered ADS-B Receiver

January 7, 2026 by Fenix Guthrie 34 Comments

If you’ve ever heard the sound of an aircraft passing overhead and looked at an online plane tracker to try and figure out what it was, then you’ve interacted with ADS-B. It’s a protocol designed to enable easier aircraft monitoring, and it just so happens you can decode it yourself with the right hardware and software — which is how [John McNelly] came to develop ADSBee, an open source ADS-B receiver based around an RP2040.

ADS-B uses on–off keying (OOK) at 1 Mbps, and operates at 1090 MHz. This might seem like a rather difficult protocol to decode on a microcontroller, but the RP2040’s PIO is up to the task. All it takes is a bit of optimization, and a some basic RF components to amplify and digitize the signals.

However, not all aircraft utilize the 1090 MHz ADS-B implementation, and instead use a related protocol called UAT. Operating at 978 MHz, a second receiver is needed for decoding UAT traffic data, which is where the CC1312 comes into play. ADSBee may even be the first open source implementation of a UAT decoder!

What’s quite impressive is the various form factors the module is available in. Ranging from small solder-down modules to weatherproof outdoor base stations, nearly every potential need for an ADS-B receiver is covered. With POE or ESP32 S3 options available, there is no shortage of networking options either!

ADSBees have been placed in numerous locations, ranging from base stations to drones. One user even built out a tiny flight display cluster complete with traffic indicators into an FPV drone.

This isn’t the first time we have seen ADS-B receivers used by drone enthusiasts, but this is certainly the most feature rich and complete receiver we have come across.

Tired Of Burnt Fingers? Try PID Tuning The Hot Glue Gun

January 6, 2026 by Tyler August 24 Comments

Hot glue guns are pretty simple beasts: there’s an on/off switch, a heating element, and a source of current, be it battery or wired. You turn it on, and the heater starts warming up; eventually you can start extruding the thermoplastic sticks we call “hot glue”. Since there’s no temperature control, the longer you run the gun, the warmer it gets until it is inevitably hotter than you actually want– either burning you or oozing thermoplastic out the tip. [Mellow_Labs] was sick of that after a marathon hot-glue session, and decided to improve on his hot glue gun with PID tuning in the video embedded below.

PID tuning is probably a familiar concept to most of you, particularly those who have 3D printers, where it’s used in exactly the same way [Mellow_Labs] puts it to work in the hot glue gun. By varying the input (in this case the power to the heater) proportional both to the Parameter (in this case, temperature) as well as the Integral and Derivative of that value, you can have a much steadier control than more naive algorithms, like the simple “on/off” thermostat that leads to large temperature swings.

In this case [Mellow_Labs] is implementing the PID control using a thermistor that looks like it came from a 3D printer, and a MOSFET driven by an RP2040. Microcontroller gets its power via the hot glue gun’s battery fed through a buck converter. Since he has them, a small OLED screen displays temperature, which is set with a pair of push-buttons. Thus, one can set a temperature hot enough to melt the glue, but low enough to avoid oozing or third degree burns.

He does not share the code he’s running on the RP2040, but if you are inspired to replicate this project and don’t want to roll your own, there are plenty of example PID scripts out there, like the one in this lovely robot. No, PID isn’t reserved for thermostats– but if you are controlling heat, it’s not reserved for electric, either. Some intrepid soul put built a PID controller for a charcoal BBQ once. Continue reading “Tired Of Burnt Fingers? Try PID Tuning The Hot Glue Gun” →

The clock and the rebuilt calculator from which its VFD was donated.

An RPN Calculator And A Bonus VFD Clock From Casio Revival

January 5, 2026 by Tyler August 15 Comments

Have you heard the saying “the problem is the solution”? It seems to originate in the permaculture movement, but it can apply equally well to electronics. Take the problem [shiura] had: a Casio Mini CM-602 that had let out the magic smoke. The solution was a twofer: rebuild the Casio into a modern number cruncher with Reverse Polish Notation (RPN), and save the Vacuum Fluorescent Display (VFD) for a gorgeous WiFi clock.

[shiura]’s write-up includes a helpful guide for reverse engineering the pins on this sort of VFD, if you don’t happen to have the same model calculator (or VFD tube) they’re working with. If you’ve done this sort of thing, you know what to expect: power it up and kill power to the pins, one by one, to map out which segments or characters go out, thereby identifying the anodes and grid electrodes. The cathodes had already been ID’d from looking at the PCB. After that it’s just a matter of wiring the VFD to an ESP32 via a transistor array to get the voltages right, and voila! Clock. The code and case design files for this clock — including an editable .blend — are available via GitHub.

The calculator half of the project is an incredibly elegant hack that relies on the fact that the Casio’s CPU has the same pin pitch as modern micros: 2.54 mm, or 0.1″, so an RP2040 zero can sit in the footprint of the original CPU, scanning the keypads with its GPIO. Then an I2C display is separately wired up to replace the clockified VFD. Perhaps some driver circuitry for the VFD died, or [shiura] salvaged the display before deciding to save the calculator, because otherwise we see no reason why this brain transplant couldn’t be done while keeping the original display. Admittedly having two lines on the display instead of one make the “new” calculator a tad more usable. The code for that is also available on GitHub, and while the readme is in Japanese, machine translations have gotten pretty good and the code is quite readable on its own.

Longtime readers will likely be familiar with [shiura]’s work, with a number of finely crafted clocks having been featured from the Japanese maker, along with vintage pocket computer repairs. Bringing both together makes this twin hack particularly on-brand.

Continue reading “An RPN Calculator And A Bonus VFD Clock From Casio Revival” →

Different Algorithms Sort Christmas Lights

December 29, 2025 by Bryan Cockfield 10 Comments

Sorting algorithms are a common exercise for new programmers, and for good reason: they introduce many programming fundamentals at once, including loops and conditionals, arrays and lists, comparisons, algorithmic complexity, and the tradeoff between correctness and performance. As a fun Christmas project, [Scripsi] set out to implement twelve different sorting algorithms over twelve days, using Christmas lights as the sorting medium.

The lights in use here are strings of WS2812 addressable LED strips, with the program set up to assign random hue values to each of the lights in the string. From there, an RP2040-based platform will step through the array of lights and implement the day’s sorting algorithm of choice. When operating on an element in the array the saturation is turned all the way up, helping to show exactly what it’s doing at any specific time. When the sorting algorithm has finished, the microcontroller randomizes the lights and starts the process all over again.

For each of the twelve days of Christmas [Scripsi] has chosen one of twelve of their favorite sorting algorithms. While there are a few oddballs like Bogosort which is a guess-and-check algorithm that might never sort the lights correctly before the next Christmas (although if you want to try to speed this up you can always try an FPGA), there are also a few favorites and some more esoteric ones as well. It’s a great way to get some visualization of how sorting algorithms work, learn a bit about programming fundamentals, and get in the holiday spirit as well.