You Can Send MIDI Over I2C If You Really Need To

February 15, 2022 by Lewin Day 11 Comments

The Musical Instrument Digital Interface has a great acronym that is both nice to say and cleanly descriptive. The standard for talking to musical instruments relies on a serial signal at 31250 bps, which makes it easy to transmit using any old microcontroller UART with a settable baud rate. However, [Kevin] has dived into explore the utility of sending MIDI signals over I2C instead.

With a bit of hacking at the Arduino MIDI library, [Kevin] was able to get the microcontroller outputting MIDI data over the I2C interface, and developed a useful generic I2C MIDI transport for the platform. His first tests involved using this technique in concert with Gravity dual UART modules. After he successfully got one running, [Kevin] realised that four could be hooked up to a single Arduino, giving it 8 serial UARTS, or, in another way of thinking, 8 MIDI outputs.

At its greatest level of development, [Kevin] shows off his I2C MIDI chops by getting a single Raspberry Pi Pico delivering MIDI signals to 8 Arduinos, all over I2C. All the Arduinos are daisy-chained with their 5V and I2C lines wired together, and the system basically swaps out traditional MIDI channels for I2C addresses instead.

There’s not a whole lot of obvious killer applications for this, but if you want to send MIDI data to a bunch of microcontrollers, you might find it easier daisy-chaining I2C rather than hopping around with a serial line in the classic MIDI-IN/MIDI-THRU fashion.

We’ve seen [Kevin]’s work before too, like the wonderful Lo-Fi Orchestra. Video after the break.

Continue reading “You Can Send MIDI Over I2C If You Really Need To” →

Breakbeats Courtesy Of The RP2040

February 9, 2022 by Lewin Day 6 Comments

While one often listens to songs or albums in full, sometimes you just want to lay down a simple beat. [todbot]’s latest project promises to do just that.

The build relies on a Raspberry Pi Pico or any other RP2040-based microcontroller board, and is programmed in CircuitPython. The PWM feature is used for audio output, and it’s loaded with different WAV samples of the classic “Amen” break.

Each measure, a random new sample is chosen and played, changing the beat. Even better, all the samples can loop, and they come in varying lengths, allowing them to overlap and lay over each other to add further depth to the mix. It’s a cinch to setup, as CircuitPython has an AudioMixer object built in.

Those wishing to tinker for themselves can find all the code and samples on Github. A build like this one is a great way to start learning about working with audio and music, after all. We’ve seen [todbot]’s work here before, too. Video after the break.

Continue reading “Breakbeats Courtesy Of The RP2040” →

Reverse Engineering: Trash Printer Gives Up Its Control Panel Secrets

January 25, 2022 by Dave Rowntree 7 Comments

Many of us hardware-oriented types find it hard to walk past a lonely-looking discarded item of consumer electronics without thinking “If only I could lug that back to the car and take it home to play with” and [phooky] from NYC Resistor is no stranger to this sentiment. An old Epson WF-2540 inkjet printer was disassembled for its important ‘nutrients,’ you know, the good stuff like funky motors, encoders and switches. But what do you do with the control panel? After all, they’re usually very specific to the needs of the device they control, and don’t usually offer up much scope for reuse.

The RP2040 PIO is quite capable of pushing out those LCD pixels

[phooky] doesn’t usually bother with them, but this time decided to have a crack at it for fun. Inside, nothing out of the ordinary, with a large single-sided PCB for the key switches and LEDs, and a small PCB hosting the LCD display. The easy part was to figure out how the keyboard scanning was done, which turned out to be pretty simple, it just uses some 74-series shift register devices to scan the columns and clock out the row lines. A Raspberry Pi Pico module was pressed into service to scan the keyboard and enable a keyboard map to be created, by pure brute-force. No need to trace the circuit.

Things got interesting when [phooky] started looking into the LCD interface, based on the Epson E02A46EA chip (good luck finding a datasheet for that one!) and quickly realised that documentation simply wasn’t available, and it would be necessary to do things the hard way. Poking around the lines from the main CPU (an Epson E01A9CA , whatever that is) the display clock was identified, as well as some control signals, and three lines for the RGB channels. By throwing a Saleae data capture into some ROM exploring software, the display configuration was determined to be a standard 320×120 unit.

The PIO unit of the RP2040 was used to generate the video waveforms and push the pixels out to the LCD controller, allowing the RP2040 board to be wired inside the case permanently, converting the control panel into a USB device ready for action!

Want to know a little more about reverse engineering junk (or not) items and repurposing them to your will? Checkout this hacking piece from a couple of weeks back. For something a little more advanced, you could try your hand at a spot of car ECU hacking.

Thanks [Perry] for the tip!

Glitch Your Way To Reverse-Engineering Glory With The PicoEMP

January 15, 2022 by Dan Maloney 9 Comments

Most of our projects are, to some extent, an exercise in glitch-reduction. Whether they’re self-inflicted software or hardware mistakes, or even if the glitches in question come from sources beyond our control, the whole point of the thing is to get it running smoothly and predictably.

That’s not always the case, though. Sometimes inducing a glitch on purpose can be a useful tool, especially when reverse engineering something. That’s where this low-cost electromagnetic fault injection tool could come in handy. EMFI is a way to disrupt the normal flow of a program running on an embedded system; properly applied and with a fair amount of luck, it can be used to put the system into an exploitable state. The PicoEMP, as [Colin O’Flynn] dubs his EMFI tool, is a somewhat tamer version of his previous ChipSHOUTER tool. PicoEMP focuses on user safety, an important consideration given that its business end can put about 250 volts across its output. Safety features include isolation for the Raspberry Pi Pico that generates the PWM signals for the HV section, a safety enclosure over the HV components, and a switch to discharge the capacitors and prevent unpleasant surprises.

In use, the high-voltage pulse is applied across an injection tip, which is basically a ferrite-core antenna. The tip concentrates the magnetic flux in a small area, which hopefully will cause the intended glitch in the target system. The video below shows the PicoEMP being used to glitch a Bitcoin wallet, as well as some tests on the HV pulse.

If you’re interested in the PicoEMP and glitching in general, be sure to watch out for [Colin]’s 2021 Remoticon talk on the subject. Until that comes out, you might want to look into glitching attacks on a Nintendo DSi and a USB glitch on a Wacom tablet.

Continue reading “Glitch Your Way To Reverse-Engineering Glory With The PicoEMP” →

Digital Rain Animation Crammed Into Pi Pico

January 12, 2022 by Lewin Day 6 Comments

With a new Matrix movie now in cinemas, we’ve all been reminded of those screensavers that were just the coolest thing ever when the original film dropped in 1999. [en0b] decided to recreate the classic “digital rain” effect on the Raspberry Pi Pico, using up all the little microcontroller’s storage in the process.

Rather than rely on existing graphics libraries, [en0b] set about using a high-quality GIF for the animation. The original file was 8 MB, which was far too big to fit on the Pico. After some finagling in an image editor and with the help of a custom Python script, however, [en0b] managed to fit the 127-frame animation at 240 x 135 resolution into the 2 MB Flash onboard the chip. With the microcontroller hooked up to the 1.14″ IPS “Pico Display” from Pimoroni, the final looks great and faithfully recreates the aesthetic seen in the film.

[en0b]’s technique could reliably be used for displaying any GIF that you can cut down to 14 to 16 colors without losing too much quality. It’s not the world’s highest-end graphics format, but it does the job for little animations like these.

We’ve seen similar builds before too, using more heavy-duty hardware to build a magic 8-ball in much the same way. Meanwhile, if you’ve got your own neat little GIF hacks or Pico projects, don’t hesitate to send them in!

Raspberry Pi Pico Gets A Tiny Keyboard On Its Back

January 10, 2022 by Tom Nardi 25 Comments

With hackers and makers building custom computing devices that don’t necessarily follow conventional design paradigms, there’s been a growing demand for smaller and smaller keyboards. Many of the cyberdecks we’ve seen over the last couple of years have used so-called 60% or even 40% keyboards, and there’s been a trend towards repurposing BlackBerry keyboards for wearables and other pocket-sized gadgets. But what if you need something even smaller?

Enter this incredibly diminutive keyboard created by [TEC.IST]. With 59 keys crammed into an area scarcely larger than three US pennies, it may well be the smallest keyboard ever made. The PCB has been designed to mount directly onto the back of a Raspberry Pi Pico, which is running some CircuitPython code to read the switch matrix and act as a standard USB Human Interface Device. The board design files as well as the source code for the Pico have been released on the project’s Hackaday.io page, giving you everything you need to spin up your own teeny tiny input device.

The Pi Pico’s castellated pads make attaching the PCB a snap.

Of course, you probably won’t be breaking any speed records when banging out text on this thing. We know from past Hackaday badges that an array of microswitches make for a functional, if somewhat unpleasant, method of text entry.

Continue reading “Raspberry Pi Pico Gets A Tiny Keyboard On Its Back” →

Mico Is A USB Microphone Based On A Pi Pico

December 25, 2021 by Robin Kearey 20 Comments

When [Mahesh Venkitachalam] was experimenting with machine learning for audio applications on a Raspberry Pi, he found himself looking for a simple USB microphone. A cheap one was easy to find, but the sound quality and directionality left much to be desired. A large, studio-quality mic would be overkill, so [Mahesh] decided to simply build exactly what was needed: a compact, yet high-quality USB microphone that he called Mico.

The sensing device is a MEMS microphone that outputs a pulse density modulated (PDM) signal. There are chips available to directly interface such a microphone to a USB port, but [Mahesh] found them difficult to work with and therefore settled on something he knew already: the Raspberry Pi Pico platform. Luckily, someone had already figured out how to read out a microphone and present a USB device to a PC, so all that was needed was to put all the bits together into a convenient form factor.

The great thing about the Pico platform is that its main controller chip, the RP2040, is available as a separate component. [Mahesh] designed a sleek little PCB that holds the RP2040 along with the MEMS microphone and a USB connector. The end result looks tidy enough that it might have come out of a mass-produced gizmo. Those don’t usually come with full schematics and source code, but the Mico does: everything is available on its GitHub page for anyone to re-use and improve.

You can judge the sound quality for yourself in the video embedded below. If you like DIY USB microphones, you’re in luck: we’ve featured one based on an STM32 as well as a beautiful recreation of a studio-quality mic.

Continue reading “Mico Is A USB Microphone Based On A Pi Pico” →