Music, food, and coding style have one thing in common: we all have our own preferences. On the other hand, there are arguably more people on this planet than there are varieties in any one of those categories, so we rarely fail to find like-minded folks sharing at least some of our taste. Well, in case your idea of a good time is calling a service hotline for some exquisite tunes, [Fuzzy Wobble] and his hold music jukebox, appropriately built into a telephone, is just your guy.

Built around an Arduino with an Adafruit Music Maker shield, [Fuzzy Wobble] uses the telephone’s keypad as input for selecting one of the predefined songs to play, and replaced the phone’s bell with a little speaker to turn it into a jukebox. For a more genuine experience, the audio is of course also routed to the handset, although the true hold music connoisseur might feel disappointed about the wide frequency range and lack of distortion the MP3s used in his example provide. Jokes aside, projects like these are a great reminder that often times, the journey really is the reward, and the end result doesn’t necessarily have to make sense for anyone to enjoy what you’re doing.

As these old-fashioned phones gradually disappear from our lives, and even the whole concept of landline telephony is virtually extinct in some parts of the world already, we can expect to see more and more new purposes for them. Case in point, this scavenger hunt puzzle solving device, or the rotary phone turned virtual assistant.

Engineers create something out of nothing, and no where is this more apparent than in the creation of customized computer hardware. To make a simple MIDI controller, you need knowledge of firmware design and computer architecture, you need knowledge of mechanical design, and you need to know electronic design. And then you need the actual working knowledge and experience to wield a tool, be it a hammer, laser cutter, or an IDE. [Mega Das] brought together all of these skill to build a MIDI controller. Sure, it’s for bleeps and bloops coming out of a speaker, but take a step back and realize just how awesome it is that any one person could imagine, then implement such a device.

The electronics for this build include a printed circuit board that serves to break out the connections on an Arduino nano to a dozen arcade push buttons, four slide pots, two rotary pots, and a handful of screw terminals to connect everything together. Mechanically, this is a laser-cut box engraved with some fancy graphics and sized perfectly to put everything inside.

Yes, we’ve seen a lot of MIDI controllers built around the Arduino over the years, but this one is in a class by itself. This is taking off-the-shelf parts and customizing them to exactly what you want, and a prodigious example of what is possible with DIY hardware creation. You can check out the build video below.

Anansi in African folktale is a trickster and god of stories, usually taking physical form of a spider. Anansi’s adventures through oral tradition have adapted to the situation of people telling those stories, everything ranging from unseasonable weather to living a life in slavery. How might Anansi adapt to the twenty-first century? [odd_jayy] imagined the form of a cyborg spider, and created Asi the robot companion to perch on his shoulder. Anyone who desire their own are invited to visit Asi’s project page.

Asi was inspired by [Alex Glow]’s Archimedes, who also has a project page for anyone to build their own. According to [Alex] at Superconference 2018, she knew of several who have done so, some with their own individual customization. [odd_jayy] loved the idea of a robot companion perched on his shoulder but decided to draw from a different pool of cultural folklore for Asi. Accompanying him to various events like Sparklecon 2019, Asi is always a crowd pleaser wherever they go.

Like every project ever undertaken, there is no shortage of ideas for Asi’s future and [odd_jayy] listed some of them in an interview with [Alex]. (Video after the break.) Adding sound localization components will let Asi face whoever’s speaking nearby. Mechanical articulation for legs would allow more dynamic behaviors while perched, but if the motors are powerful enough, Asi can walk on a surface when not perched. It’s always great to see open source projects inspire even more projects, and watch them as they all evolve in skill and capability. If they all become independently mobile, we’ll need clarification when discussing the average velocity of an unladen folklore robot companion: African or European folklore?

Potentially, one of the great things about having a device connected to the network is that you can update it remotely. However, how do you make that happen? If you use the Arduino setup for the ESP8266 or ESP32, you might try [scottchiefbaker’s] library which promises to make the process easy.

Adding it looks to be simple. You’ll need an include, of course. If you don’t mind using port 8080 and the path /webota, you only need to call handle_webota() from your main loop. If you want to change the defaults, you’ll need to add an extra call in your setup. You also need to set up a few global variables to specify your network parameters.

The only caveat is that long delay statements in your loop can block things from working and aren’t a great idea anyway. If you have them, you can replace all your delay calls with webota_delay which will stop the system from ignoring update requests.

The code started from a different online tutorial but packaged the code up nicely for reuse. To do an update, simply navigate to the device with a web browser and use the correct port number and path. From there you can upload a new binary image taken from the Arduino IDE with the export compiled binary command.

The only concern we saw was the code didn’t appear to authenticate you at all. That means anyone could load code into your ESP. That might be ok on a private network, but on the public Internet it is surely asking for trouble. The original tutorial code did have a hardcoded user and password, but it didn’t look very useful as the password was in the clear and didn’t stop you from uploading if you knew the right URL. Dropping it from the library probably makes sense, but we would want to build some kind of meaningful security into anything we deployed.

If you have a network connection, we’ve seen the same trick done with a normal Arduino with a wireless chip. You can even do it over WiFi but using an ESP8266 which you’ll then want to be able to update, too.

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.

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.

Sometimes it’s necessary to make do with whatever parts one has on hand, but the results of squashing a square peg into a round hole are not always as elegant as [Juan Gg]’s programmable DC load with rotary encoder. [Juan] took a design for a programmable DC load and made it his own in quite a few different ways, including a slick 3D-printed enclosure and color faceplate.

The first thing to catch one’s eye might be that leftmost seven-segment digit. There is a simple reason it doesn’t match its neighbors: [Juan] had to use what he had available, and that meant a mismatched digit. Fortunately, 3D printing one’s own enclosure meant it could be gracefully worked into the design, instead of getting a Dremel or utility knife involved. The next is a bit less obvious: the display lacked a decimal point in the second digit position, so an LED tucked in underneath does the job. Finally, the knob on the right could reasonably be thought to be a rotary encoder, but it’s actually connected to a small DC motor. By biasing the motor with a small DC voltage applied to one lead and reading the resulting voltage from the other, the knob’s speed and direction can be detected, doing a serviceable job as rotary encoder substitute.

The project’s GitHub repository contains the Arduino code for [Juan]’s project, which has its roots in a design EEVblog detailed for an electronic load. For those of you who prefer your DIY rotary encoders to send discrete clicks and pulses instead of an analog voltage, a 3D printed wheel and two microswitches will do the job.

[Edward], creator of the Cave Pearl project, an underwater data logger, needed a way to measure temperature with a microcontroller. Normally, this problem is most easily solved by throwing a temperature sensor on the I2C bus — these sensors are cheap and readily available. This isn’t about connecting a temperature sensor in your Arduino. This build is about using the temperature sensor in your clock.

The ATMega328p, the chip at the heart of all your Arduino Uno clones, has within it a watchdog timer that clicks over at a rate of 110 kHz. This watchdog timer is somewhat sensitive to temperature, and by measuring this temperature sensor you can get some idea of the temperature of the epoxy blob that is a modern microcontroller. The trick is calibrating the watchdog timer, which was done with a homemade ‘calibration box’ in a freezer consisting of two very heavy ceramic pots with a bag of rice between them to add thermal mass (you can’t do this with water because you’re putting it in a freezer and antique crocks are somewhat valuable).

By repeatedly taking the microcontroller through a couple of freeze-thaw cycles, [Edward] was able to calibrate this watchdog timer to a resolution of about 0.0025°C, which is more than enough for just about any sensor application. Discussions of accuracy and precision notwithstanding, it’s pretty good.

This technique measures the temperature of the microcontroller with an accuracy of 0.005°C or better, and it’s using it with just the interrupt timer. That’s not to say this is the only way to measure the temperature of an ATMega; some of these chips have temperature sensors built right into them, and we’ve seen projects that use this before. However, this documented feature that’s clearly in the datasheet seems not to be used by many people.

Thanks [jan] for sending this in.