OpenMIDIStomper Makes Sure Your Gear Does What Your Foot Says

If you’re a solo musician, you probably have lots of gear you’d like to control, but you don’t have enough hands. You can enlist your feet, but your gear might not have foot-suitable interfaces as standard. For situations like these, [Nerd Musician] created the OpenMIDIStomper.

The concept is simple enough—the hardy Hammond enclosure contains a bunch of foot switches and ports for external expression pedals. These are all read by an Arduino Pro Micro, which is responsible for turning these inputs into distinct MIDI outputs to control outboard gear or software. It handles this via MIDI over USB. The MIDI commands sent for each button can be configured via a webpage. Once you’ve defined all the messages you want to send, you can export your configuration from the webpage by cutting and pasting it into the Arduino IDE and flashing it to the device itself.

We’ve featured some great MIDI controllers over the years, like this impressive parts bin build.

Continue reading “OpenMIDIStomper Makes Sure Your Gear Does What Your Foot Says”

A C-shaped wooden frame is shown surrounding a circular tongue drum. The wooden frame holds eight black adjustable arms, at the ends of which are mounted solenoids, positioned just above the surface of the drum.

Giving A Drum MIDI Input With Lots Of Solenoids

As far as giving mechanical instruments electronic control goes, drums are probably the best candidate for conversion; learning to play them is challenging and loud for a human, but they’re a straightforward matter for a microcontroller. [Jeremy Cook]’s latest project takes this approach by using an Arduino Opta to play a tongue drum.

[Jeremy]’s design far the drum controller was inspired by the ring-shaped arrangement of the Cray 2 supercomputer. A laser-cut MDF frame forms a C-shape around the tongue drum, and holds eight camera mount friction arms. Each friction arm holds a solenoid above a different point on the drum head, making it easy to position them. A few supports were 3D-printed, and some sections of PVC tubing form pivots to close the ring frame. [Jeremy] found that the the bare metal tips of the solenoids made a harsh sound against the drum, so he covered the tips of six solenoids with plastic caps, while the other two uncoated tips provide an auditory contrast.

The Arduino Opta is an open-source programmable logic controller normally intended for industrial automation. Here, its silent solid-state relays drive the solenoids, as [Jeremy]’s done before in an earlier experiment. The Opta is programmed to accept MIDI input, which [Jeremy] provided from two of the MIDI controllers which we’ve seen him build previously. He was able to get it working in time for the 2024 Orlando Maker Faire, which was the major time constraint.

Of course, for a project like this you need a MIDI controller, and we’ve previously seen [Jeremy] convert a kalimba into such a controller. We’ve seen this kind of drum machine at least once before, but it’s more common to see a purely electronic implementation.

A black PCB is shown, with an Arduino Nano mounted in the bottom left corner. The rest of the space on the PCB is used up by ten DIP integrated circuits and a few resistors and diodes. Several black and red wires connect different parts of the PCB.

Meowsic Keyboard MIDI Adapter Aims For Purrfection

Both small children and cats have a certain tendency to make loud noises at inopportune times, but what if there were a way to combine these auditory effects? This seems to have been the reasoning behind the creation of the Meowsic keyboard, a children’s keyboard that renders notes as cats’ meows. [Steve Gilissen], an appreciator of unusual electronic instruments, discovered that while there had been projects that turned the Meowsic keyboard into a MIDI output device, no one had yet added MIDI input to it, which of course spurred the creation of his Meowsic MIDI adapter.

The switches in the keys of the original keyboard form a matrix of rows and columns, so that creating a connection between a particular row and column plays a certain note. [Steve]’s plan was to have a microcontroller read MIDI input, then connect the appropriate row and column to play the desired note. The first step was to use a small length of wire to connect rows and columns, thus manually mapping connections to notes. After this tedious step, he designed a PCB that hosts an Arduino Nano to accept input, two MCP23017 GPIO expanders to give it enough outputs, and CD4066BE CMOS switches to trigger the connections.
Continue reading “Meowsic Keyboard MIDI Adapter Aims For Purrfection”

When Wireless MIDI Has Latency, A Hardwired Solution Saves The Day

[Moby Pixel] wanted to build a fun MIDI controller. In the end, he didn’t build it just once, but twice—with the aim of finding out which microcontroller was most fit for this musical purpose. Pitted against each other? The ESP32 and Raspberry Pi Pico.

The MIDI controller itself is quite fetching. It’s built with a 4 x 4 array of arcade buttons to act as triggers for MIDI notes or events. They’re assembled in a nice wooden case with a lovely graphic wrap on it. The buttons themselves are wired to a microcontroller, which is then responsible for sending MIDI data to other devices.

At this point, the project diverges. Originally, [Moby Pixel] set the device up to work with an ESP32 using wireless MIDI over Bluetooth. However, he soon found a problem. Musical performance is all about timing, and the ESP32 setup was struggling with intermittent latency spikes that would ruin the performance. Enter the Raspberry Pi Pico using MIDI over USB. The hardwired solution eliminated the latency problems and made the controller far more satisfying to use.

There may be solutions to the latency issue with the wireless ESP32 setup, be they in code, hardware configuration, or otherwise. But if you want to play with the most accuracy and the minimum fuss, you’ll probably prefer the hardwired setup.

Latency is a vibe killer in music as we’ve explored previously.

Continue reading “When Wireless MIDI Has Latency, A Hardwired Solution Saves The Day”

It’s MIDI For The TRS-80!

The Radio Shack TRS-80 was a much-loved machine across America. However, one thing it lacked was MIDI. That’s not so strange given the era it was released in, of course. Nevertheless, [Michael Wessel] has seen fit to correct this by creating the MIDI/80—a soundcard and MIDI interface for this old-school beast.

The core of the build is a BluePill STM32F103C8T6 microcontroller, running at a mighty 75 MHz. Plugged into the TRS-80s expansion port, the microcontroller is responsible for talking to the computer and translating incoming and outgoing MIDI signals as needed. Naturally, you can equip it with full-size classic DIN sockets for MIDI IN and MIDI OUT using an Adafruit breakout module. None of that MIDI Thru nonsense, though, that just makes people uncomfortable. The card is fully capable of reproducing General MIDI sounds, too, either via plugging in a Waveblaster sound module to the relevant header, or by hooking up a Roland Sound Canvas or similar to the MIDI/80s MIDI Out socket. Software-wise, there’s already a whole MIDI ecosystem developing around this new hardware. There’s a TRS-80 drum tracker and a synthesizer program, all with demo songs included. Compatibility wise, The MIDI/80 works with the TRS-80 Model I, III, and 4.

Does this mean the TRS-80 will become a new darling of the tracker and chiptune communities? We can only hope so! Meanwhile, if you want more background on this famous machine, we’ve looked into that, too. Video after the break.

Continue reading “It’s MIDI For The TRS-80!”

Pi Pico Throws Us For A (MIDI) Loop

Modern micro-controllers are absolute marvels, but it isn’t too many projects use one and nothing else. For an example of such simplicity, take a look at [oyama]’s Pi Pico MIDI looper.

It uses the PicoW to interface with a synth via MIDI-BLE, which can be anything from pro equipment to an app on your smartphone. The single control button is already provided by the Pico W– the bootsel button is wearing a lot of hats here, allowing one to select betwixt 4 tracks (all different drums), set the tempo, and input notes on the selected track.

The action is simple: pound out the rhythm for each track, and it will repeat forever, or at least until you press the single button again to change it. There’s also a nice serial interface so you can see what’s going on via UART or USB. For what it does, it is amazingly simple: the BOM is one item, the Pi Pico W. To see it in action, check out the demo video below.

Given the ADC chops on the Pico, it would probably be easy to extend this build with a speaker to make a tiny stand-alone, one-button synth. Or you could add more buttons buttons, but then it’s no longer the beautifully simple single-line BOM project that [oyama] showed us.

Of course, everything is open-source on GitHub, under the BSD license, and forking is encouraged, so [oyama] would doubtless be more than happy to see you go nuts hacking and extending this tiny MIDI looper.

We’ve actually seen the MIDI-BLE standard used before, like this hack adding it to a Eurorack. If you like synths, you may be interested to see what it takes to design one from scratch, sans microcontroller. Continue reading “Pi Pico Throws Us For A (MIDI) Loop”

Shellcode Over MIDI? Bad Apple On A PSR-E433, Kinda

If hacking on consumer hardware is about figuring out what it can do, and pushing it in directions that the manufacturer never dared to dream, then this is a very fine hack indeed. [Portasynthica3] takes on the Yamaha PSR-E433, a cheap beginner keyboard, discovers a shell baked into it, and takes it from there.

[Portasynthinca3] reverse engineered the firmware, wrote shellcode for the device, embedded the escape in a MIDI note stream, and even ended up writing some simple LCD driver software totally decent refresh rate on the dot-matrix display, all to support the lofty goal of displaying arbitrary graphics on the keyboard’s dot-matrix character display.

Now, we want you to be prepared for a low-res video extravaganza here. You might have to squint a bit to make out what’s going on in the video, but keep in mind that it’s being sent over a music data protocol from the 1980s, running at 31.25 kbps, displayed in the custom character RAM of an LCD.

As always, the hack starts with research. Identifying the microcontroller CPU lead to JTAG and OpenOCD. (We love the technique of looking at the draw on a bench power meter to determine if the chip is responding to pause commands.) Dumping the code and tossing it into Ghidra lead to the unexpected discovery that Yamaha had put a live shell in the device that communicates over MIDI, presumably for testing and development purposes. This shell had PEEK and POKE, which meant that OpenOCD could go sit back on the shelf. Poking “Hello World” into some free RAM space over MIDI sysex was the first proof-of-concept.

The final hack to get video up and running was to dig deep into the custom character-generation RAM, write some code to disable the normal character display, and then fool the CPU into calling this code instead of the shell, in order to increase the update rate. All of this for a thin slice of Bad Apple over MIDI, but more importantly, for the glory. And this hack is glorious! Go check it out in full.

MIDI is entirely hacker friendly, and it’s likely you can hack together a musical controller that would wow your audience just with stuff in your junk box. If you’re at all into music, and you’ve never built your own MIDI devices, you have your weekend project.

Continue reading “Shellcode Over MIDI? Bad Apple On A PSR-E433, Kinda”