When [Sami Pietikäinen] realized that the Bluetooth built into his car didn’t support audio, he didn’t junk it and buy a Tesla. Instead, he decided to remedy the problem by building a small Bluetooth device that plugged into the Aux socket. To do this, he used a Raspberry Pi Zero with a pHAT DAC (Digital to Audio Converter). That’s perhaps using a sledgehammer to crack a walnut, but sometimes you work with what you have. The interesting part is to be found in what he did next: he used Yocto to optimize the device down to make it as simple and straightforward as possible.
To the uninitiated an electric guitar seems fairly simple: you pluck a string and the electronics send the corresponding audio signal on the 6.3 mm jack output, all ready for for the amplifier to work its magic. Much of what makes a guitar like that sound good depends on the pickups, however. These are the devices which are placed between the guitar body and the strings. Depending on the guitar there can be one, two, or more of them, of varying types and configurations.
As a Gibson fan who upon getting introduced to a Fender Telecaster just had to replace its pickups with humbucking types, [Ken Willmott] found himself thrown into the wonderful world of pickup design and characterization. After two years of working through a number of designs and approaches, he eventually settled on a preamplifier design featuring a JFET opamp (LT1058) on a custom PCB which amplifies the pickup response from a test signal, acting as a front end signal conditioner.
Drum machines may seem like one of the many rites of passage for hardware makers, they’re a concept you can implement simply or take into the extreme making it as complex as you want. [Matt’s] DrumKid is one of them, and its long development history is wonderfully documented in the project logs.
[Matt’s] original intention was to use the automatic drummer as part of his band, wanting “the expressiveness of a good drummer but without the robotic tendencies of a simple drum machine”. For that, he created the first iteration of the DrumKid, a web-based project using the Web Audio API. The interface consisted of bars showing levels for different settings which could be intuitively tweaked, changing the probability of a drum sound being played. This gave the “drummer” its unpredictability, setting itself apart from any regular old drum machine.
Fast forward a few years, and [Matt] now wants to recreate his DrumKid as a proper piece of musical gear, porting the concept into a standalone hardware drum machine you can plug into your mixer. He decided to go with the Arduino framework for his project rather than the Teensy platform in order to make it cheaper to build. The controls are simplified down to a few buttons and potentiometers, and the whole thing runs off of three AAA batteries. Also, targeting the project for hardware like this allowed for new features to be added, such as a bit-crush filter.
We already saw the first prototype here on Hackaday when it was featured in a Hackaday Prize mentor session, and it’s nice to see how the project evolved since. After a number of revisions, the new prototype takes design cues from Teenage Engineering’s “Pocket Operator” drum machine, using the main PCB as its own faceplate rather than a 3D printed case in a familiar way we’ve seen before. Unfortunately, the latest board is non-functional due to a routing mistake, but you can see the previous working prototypes in his project logs.
Concrete is great if you feel like making something heavy on the cheap. [Marek Unger] decided to have a go, using the material to cast speaker cabinets for a home hi-fi rig (Youtube link, embedded below).
Initial attempts involved creating a laser-cut MDF outer mold, with a styrofoam core inside to be removed later. This was unsuccessful, and [Marek] developed the design further. The second revision used an inner core also made from lasercut MDF, designed to be left inside after casting. This inner mold already includes the mounting holes for the speaker drivers, making assembly easier too.
Once cast, the enclosures were fitted with Tang-Band W4-1320SIF drivers. These are a full-range driver, meaning they can be used without needing crossovers or other speakers to fill in the frequency range. Each cabinet weighs just over 10kg, and they’re ported for extra response in the lower frequency bands. Sound tests are impressive, and the rough-finished aesthetic of the final product looks great in [Marek]’s living room.
Audio systems in Linux are terrible. You’ve never known true pain until you’ve tried to set up a recording or broadcasting workstation running Linux. I did, twenty years ago, and nothing has changed since. This wasn’t really a problem when Linux was either used in server spaces or some nerd’s battle station, but now we have small single board computers that everyone uses and wants to turn into a modular synth. Welcome to paintown, because the Linux audio stack is terrible.
For the past ten years, [Dynobot] has been working on improving audio in Linux. This is a decade of reading manuals from IBM and Oracle, and a deep knowledge of how to adjust settings so audio actually works. All of this work is now combined into a single script that improves everything. This means the priority of the Audio group is changed, the thread priority is better, the latency is better, and for anyone who wants to set up a local streaming service, the network latency is better. It’s not everything, and there’s no mention of recording multitrack audio, but we’ll accept the baby steps here.
There are two relevant Github repositories for this, the first containing audio adjustments for Debian-based systems, including the Raspberry Pi. This should work on any single board computer running Debian, and has been tested on all the Raspberry Pis, the Allo Sparky, ASUS Tinkerboard, and the Odroid C2. There’s also a version for TinyCore-based Linux systems that improves the priority of the audio threads, changes the thread scheduling from ‘whatever’ to FIFO, and improves the latency. If you’re running Linux, and you’re doing something with audio, this is what you need.
When it comes to audio, the number of speakers you want is usually governed by the number of tracks or channels your signal has. One for mono, two for stereo, four for quadrophonic, five or more for surround sound and so on. But all of those speakers are essentially playing different tracks from a “single” audio signal. What if you wanted a single audio device to play eight different songs simultaneously, with each song being piped to its own speaker? That’s the job [Devon Bray] was tasked with by interdisciplinary artist [Sara Dittrich] for one of her “Giant Talking Ear” installation project. He built a device to play multiple sound files on multiple output devices using off the shelf hardware and software.
But maybe a hack like this could be useful in many applications other than just art installations. It could be used in an Escape room, where you may want the various audio streams to start in synchronicity at the same time, or as part of a DJ console, sending one stream to the speakers and another to the head phones, or a game where you have to run around a room full of speakers in the right sequence and speed to listen to a full sentence for clues.
His blog post lists links for the various pieces of hardware required, although all of it is pretty generic, and the github repository hosts the code. At the heart of the project is the Sounddevice library for python. The documentation for the library is sparse, so [Bray]’s instructions are handy. His code lets you “take a directory with .wav files named in numeric order and play them over USB sound devices attached to the host computer over and over forever, looping all files once the longest one finishes”. As a bonus, he shows how to load and play sound files automatically from an attached USB drive. This lets you swap out your playlist on the Raspberry Pi without having a use a keyboard/mouse, SSH or RDP.
Check the video after the break for a quick roundup of the project.
Small microcontrollers can pack quite a punch. With the right code optimizations and proper use of the available limited memory, even small microcontrollers can do things they were never intended to. Even within the realm of intended use, however, there are still lots of impressive uses for these tiny cheap processors like [Lukasz]’s audio amplifier which uses one of the smallest ATtiny packages around in the video embedded below.
Since the ATtiny is small, the amplifier is only capable of 8-bit resolution but thanks to internal clock settings and the fast PWM mode he can get a sampling rate of 37.5 kHz. Most commercial amplifiers shoot for 42 kHz or higher, so this is actually quite close for the limited hardware. The fact that it is a class D amplifier also helps, since it relies on switching and filtering to achieve amplification. This allows the amplifier to have a greater efficiency than an analog amplifier, with less need for heat sinks or oversized components.
All of the code that [Lukasz] used is available on the project site if you’ve ever been curious about switching amplifiers. He built this more as a curiosity in order to see what kind of quality he could get out of such a small microcontroller. It sounds pretty good to us too! If you’re more into analog amplifiers, though, we have you covered there as well.