Michael Sobolak was inspired by the hardware dedicated to Ableton digital audio software, along with the DIY MIDI Fighter pads that others have constructed, to make his own light-up version. 

His device is cut out of ¼-inch MDF, housing a 4×4 array of main buttons, 18 smaller buttons on the bottom and eight potentiometers, four of which are surrounded by NeoPixel rings.

To handle this massive array of inputs, he turned to the use of multiplexers, creating a spaghetti-like—though functional—wiring arrangement hidden underneath. The pad uses an Arduino Uno to control the NeoPixels, while a separate board is tasked with the MIDI interface. 

You can see Sobolak’s project crank out music in the video below, with LEDs that react to potentiometer input settings.

Arduino boards are used in a wide—massive even—variety of projects. Sometimes, however, all you need is something to give your project the ability to blink an LED, sound an alarm, or accomplish some other simple task. 

For this purpose, maker Jeremy S. Cook has developed a sort of standard method for using these devices, with a 4-position DIP switch soldered to inputs D9-D12, and a double-CR2032 battery pack attached with shrink wrap.

This standardization makes for a very compact setup that can be implemented in a project very quickly. The configuration also highlights the use of “INPUT_PULLUP” in Arduino code, with switches wired to ground. Cook’s technique avoids floating inputs without the need for external resistors.

The modern keyboard enthusiast is blessed with innumerable choices when it comes to typing hardware. There are keyboards designed specifically for gaming, fast typing, ergonomics, and all manner of other criteria. [iot4c] undertook their own build for no other reason than nostalgia – which sounds plenty fun to us.

An Arduino Leonardo is pressed into service for this hack. With its USB HID capabilities, it’s perfectly suited for custom keyboard builds. It’s built into a working Atari 65XE computer, and connected to the keyboard matrix. The Keypad and Keyboard libraries are pressed into service to turn keypresses on the 80s keyboard into easily digseted USB data.

There’s plenty of room inside the computer for the added hardware, with the USB cable neatly sneaked out the rear. [iot4c] notes that everything still works and the added hardware does not cause any problems, as long as it’s not used as a computer and a keyboard at the same time.

It’s possible to do a similar hack on the Commodore 64, too. If you’re doing tricky keyboard builds yourself, you know where to send ’em.

Students at the University of Illinois at Urbana-Champaign have a brain-computer interface that can measure brainwaves. What did they do with it? They gave it to Alma, a golden labrador, as you can see in the video below. The code and enough info to duplicate the electronics are on GitHub.

Of course, the dog doesn’t directly generate speech. Instead, the circuit watches her brainwaves via an Arduino and feeds the raw data to a Raspberry Pi. A machine learning algorithm determines Alma’s brainwave state and plays prerecorded audio expressing Alma’s thoughts.

Alma’s collar duplicates — to some degree — the fictional collar from the movie Up. Of course, Dug was a bit more loquacious. It isn’t very clear from the video how many states the program classifies. A quick peek at the code reveals five audio clips but only one appears to be wired to the recognizer — the one for a treat. We think it might be a harder problem to figure out when the dog does not want a treat.

The last time we saw a talking dog collar it was phone-controlled. If you really want to probe a brain — canine or human — you could do worse than to check out OpenHardwareExG.

Oh. By the way. Good dog! Very good dog!

Part of the joy of owning a dog is feeding it. How often do you get to make another living being that happy? However, sometimes you can’t be there when your best friend is hungry. [El Taller De TD] built an auto dog feeder using an Arduino and stepper motor. The video and links are in Spanish, but if your Spanish is rusty, YouTube’s caption autotranslation isn’t bad and Google Translate can help you with the web site.

The electronics are reasonably simple: an Arduino, a Bluetooth module, and a stepper motor driver. Mechanically, the motor and some PVC pipe are all you need. There’s a small phone application to drive the Bluetooth using App Inventor.

This would be a pretty straightforward first project and — of course — could be useful for any kind of animal. For dog use, we might have hardened the external wires and circuit boards a bit though. In addition there are plenty of things you could do in software, for example you could feed every 8 hours. It seems like you could add a sensor to tell when you are out of food, or perhaps if the food was not feeding for some reason.

We’ve looked at using App Inventor with Bluetooth before and it is pretty easy. We might have been tempted to go with Blynk to have more options for communication, but either way is pretty easy.

Rubik’s Cubes seem to have been most popular in the 1980s, but never really went away. As such, if you have one lying around your house unsolved, why not ‘simply’ construct a machine to do this for you? 

One possibility is the Q-Bot, outlined here. While it won’t break any world records, it’s a solid-looking assembly that appears to be relatively easy to build.

The Q-Bot features six NEMA 17 stepper motors, four of which turn one face at a time. When needed, the other two use timing belts to alternatively pull opposed stepper motor pairs back, allowing the other two to rotate the entire assembly. An Arduino Mega is utilized to control the steppers via a custom shield, with a computer running the Kociemba’s Algorithm.

If you’ve ever considered constructing your own wireless RC transmitter, be sure to check out this build by Electronoobs.

The device uses an nRF24L01+ module to transmit inputs from a pair of joysticks and toggle switches, along with an Arduino Nano for interface and control. 

What sets this project apart from his previous versions, however, is the very nice 3D-printed enclosure for the electronics and a pair of high-quality joysticks that allow for precise input. 

Additionally, Electronoobs’ latest design features tuning buttons to properly center the sticks, and an OLED display to show the actual input value that it’s sending to the receiver (a simple Nano/nRF24L01+ setup for demo purposes). 

Yes, I’ve made another radio controller. Why? well, I wanted to have a more commercial look. So, I’ve designed a 3D case, then I’ve used some high quality joysticks in order to have better analog read, It has an OLED screen so we could see the data we send and we could also digitally adjust the data. It also has 2 modes, linear and exponential

Code and more details can be found in Electronoobs’ tutorial.

When your car door isn’t shut quite correctly, you’ll normally look down at the dash to see what the problem is. What if, instead of a small 2D picture of your doors, you had a tiny actuated version of your vehicle on your dash?

Mathis Ochsenmeier’s Analogous Door Display is exactly that. It mirrors his VW van’s front and rear doors using an Arduino Nano to take in sensor information and actuate three servo motors to mimic door positions. 

Now when the van’s front doors or rear hatch open or close, the little van on the dash’s doors follow suit—both a useful diagnostic tool, and an entertaining model.

These days, you could be forgiven for thinking driving an LCD from a microcontroller is easy. Cheap displays have proliferated, ready to go on breakout boards with controllers already baked in. Load up the right libraries and you’re up and running in a matter of minutes. However, turn your attention to trying to drive a random LCD you’ve yanked out of a piece of old equipment, and suddenly things get harder. [Ivan Kostoski] was in just such a position and decided to get down to work.

[Ivan]’s LCD was a 320×240 STN device salvaged from an old tape library. The display featured no onboard controller, and the original driver wasn’t easily repurposed. Instead, [Ivan] decided to drive it directly from an Arduino Uno.

This is easier said than done. There are stringent timing requirements that push the limits of the 8-bit platform, let alone the need for a negative voltage to drive the screen and further hardware to drive the backlight. These are all tackled in turn, with [Ivan] sharing his tips to get the most flexibility out of the display. Graphics and text modes are discussed, along with optimizations that could be possible through the varied use of available RAM and flash.

The code is available on Github. If you need inspiration for your own controllerless LCD driver. [Ben Heck] has done similar work too, using FPGA grunt to get the job done.

While you may or may not want a gigantic backlit skull cutout haunting the wall of your workshop, this was perfect for Jay and Jamie of the “Wicked Makers” YouTube channel. 

Their device is cut of two 30” squares of plywood with a CNC router. This forms a base layer that holds everything off the wall, while an outer layer provides a nice circuit/skull texture.

They affixed WS2812B LED strips to the base layer, controlled by an Arduino Micro. These strips shine off the wall for a glow through the edges, along with circuit board style cutouts inside the skull, diffused using wax paper. 

Arduino code and the circuit diagram are found in the project’s write-up if you’d like to construct your own!