Getting a robot to stand on two wheels without tipping over involves a challenging dance with the laws of physics. Self-balancing robots are a great way to get into control systems, sensor fusion, and embedded programming. This build by [mircemk] shows how to make one with just a few common components, an Arduino, and a bit of patience fine-tuning the PID controller.

At the heart of the bot is the MPU6050 – a combo accelerometer/gyroscope sensor that keeps track of tilt and movement. An Arduino Uno takes this data, runs it through a PID loop, and commands an L298N motor driver to adjust the speed and direction of two DC motors. The power comes from two Li-ion batteries feeding everything with enough juice to keep it upright. The rest of the magic lies in the tuning.

PID (Proportional-Integral-Derivative) control is what makes the robot stay balanced. Kp (proportional gain) determines how aggressively the motors respond to tilting. Kd (derivative gain) dampens oscillations, and Ki (integral gain) helps correct slow drifts. Set them wrong, and your bot either wobbles like a confused penguin or falls flat on its face. A good trick is to start with only Kp, then slowly add Kd and Ki until it stabilizes. Then don’t forget to calibrate your MPU6050; each sensor has unique offsets that need to be compensated in the code.

Once dialed in, the result is a robot that looks like it defies gravity. Whether you’re hacking it for fun, turning it into a segway-like ride, or using it as a learning tool, a balancing bot is a great way to sharpen your control system skills. For more inspiration, check out this earlier attempt from 2022, or these self-balancing robots (one with a little work) from a year before that. You can read up on [mircemk]’s project details here.

In the early 2000s, the idea that you could write programs on microcontrollers that did things in the physical world, like run motors or light up LEDs, was kind of new. At the time, most people thought of coding as stuff that stayed on the screen, or in cyberspace. This idea of writing code for physical gadgets was uncommon enough that it had a buzzword of its own: “physical computing”.

You never hear much about “physical computing” these days, but that’s not because the concept went away. Rather, it’s probably because it’s almost become the norm. I realized this as Tom Nardi and I were talking on the podcast about a number of apparently different trends that all point in the same direction.

We started off talking about the early days of the Arduino revolution. Sure, folks have been building hobby projects with microcontrollers built in before Arduino, but the combination of a standardized board, a wide-ranging software library, and abundant examples to learn from brought embedded programming to a much wider audience. And particularly, it brought this to an audience of beginners who were not only blinking an LED for the first time, but maybe even taking their first steps into coding. For many, the Arduino hello world was their coding hello world as well. These folks are “physical computing” natives.

Now, it’s to the point that when Arya goes to visit FOSDEM, an open-source software convention, there is hardware everywhere. Why? Because many successful software projects support open hardware, and many others run on it. People port their favorite programming languages to microcontroller platforms, and as they become more powerful, the lines between the “big” computers and the “micro” ones starts to blur.

And I think this is awesome. For one, it’s somehow more rewarding, when you’re just starting to learn to code, to see the letters you type cause something in the physical world to happen, even if it’s just blinking an LED. At the same time, everything has a microcontroller in it these days, and hacking on these devices is also another flavor of physical computing – there’s code in everything that you might think of as hardware. And with open licenses, everything being under version control, and more openness in open hardware than we’ve ever seen before, the open-source hardware world reflects the open-source software ethos.

Are we getting past the point where the hardware / software distinction is even worth making? And was “physical computing” just the buzzword for the final stages of blurring out those lines?

Intel has had a deathgrip on the PC world since the standardization around the software and hardware available on IBM boxes in the 90s. And if you think you’re free of them because you have an AMD chip, that’s just Intel’s instruction set with a different badge on the silicon. At least AMD licenses it, though — in the 80s there was another game in town that didn’t exactly ask for permission before implementing, and improving upon, the Intel chips available at the time.

The NEC V20 CPU was a chip that was a drop-in replacement for the Intel 8088 and made some performance improvements to it as well. Even though the 186 and 286 were available at the time of its release, this was an era before planned obsolescence as a business model was king so there were plenty of 8088 systems still working and relevant that could take advantage of this upgrade. In fact, the V20 was able to implement some of the improved instructions from these more modern chips. And this wasn’t an expensive upgrade either, with kits starting around $16 at the time which is about $50 today, adjusting for inflation.

This deep dive into the V20 isn’t limited to a history lesson and technological discussion, though. There’s also a project based on Arduino which makes use of the 8088 with some upgrades to support the NEC V20 and a test suite for a V20 emulator as well.

If you had an original IBM with one of these chips, though, things weren’t all smooth sailing for this straightforward upgrade at the time. A years-long legal battle ensued over the contents of the V20 microcode and whether or not it constituted copyright infringement. Intel was able to drag the process out long enough that by the time the lawsuit settled, the chips were relatively obsolete, leaving the NEC V20 to sit firmly in retrocomputing (and legal) history.

The progress for electronics over the past seven decades or so has always trended towards smaller or more dense components. Moore’s Law is the famous example of this, but even when we’re not talking about transistors specifically, technology tends to get either more power efficient or smaller. This MIDI keyboard, for example, is small enough that it will fit in the space of a standard business card which would have been an impossibility with the technology available when MIDI first became standardized, and as such is the latest entry in our Business Card Challenge.

[Alana] originally built this tiny musical instrument to always have a keyboard available on the go, and the amount of features packed into this tiny board definitely fits that design goal. It has 18 keys with additional buttons to change the octave and volume, and has additional support for sustain and modulation as well. The buttons and diodes are multiplexed in order to fit the IO for the microcontroller, a Seeed Studio Xiao SAMD21, and it also meets the USB-C standards so it will work with essentially any modern computer available including most smartphones and tablets so [Alana] can easily interface it with Finale, a popular music notation software.

Additionally, the project’s GitHub page has much more detail including all of the Arduino code needed to build a MIDI controller like this one. This particular project has perhaps the best size-to-usefulness ratio we’ve seen for compact MIDI controllers thanks to the USB-C and extremely small components used on the PCB, although the Starshine controller or these high-resolution controllers are also worth investigating if you’re in the market for compact MIDI devices like this one.

If you’ve ever seen artifacts on a digital picture of a computer monitor, or noticed an unsettling shifting pattern on a TV displaying someone’s clothes which have stripes, you’ve seen what’s called a Moiré pattern where slight differences in striping of two layers create an emergent pattern. They’re not always minor annoyances though; in fact they can be put to use in all kinds of areas from art to anti-counterfeiting measures. [Moritz] decided to put a few together to build one of the more unique clock displays we’ve seen.

The clock itself is made of four separate Moiré patterns. The first displays the hours with a stretching pattern, the second and third display the minutes with a circular pattern, and the seconds are displayed with a a spiral type. The “hands” for the clock are 3D printed with being driven by separate stepper motors with hall effect sensors for calibration so that the precise orientation of the patterns can be made. A pair of Arduinos control the clock with the high-accuracy DS3231 module keeping track of time, and [Moritz] built a light box to house the electronics and provide diffuse illumination to the display.

Moiré patterns can be used for a number of other interesting use cases we’ve seen throughout the years as well. A while back we saw one that helps ships navigate without active animations or moving parts and on a much smaller scale they can also be used for extremely precise calipers.

Unique clocks are a mainstay around here, and while plenty are “human readable” without any instruction, there are a few that take a bit of practice before someone can glean the current time from them. Word clocks are perhaps on the easier side of non-traditional displays but at the other end are binary clocks or even things like QR code clocks. To get the best of both worlds, though, multiple clock faces can be combined into one large display like this clock build from [imitche3].

The clock is actually three clocks in one. The first was inspired by a binary clock originally found in a kit, which has separate binary “digits” for hour, minute, and second and retains the MAX 7219 LED controller driving the display. A standard analog clock rests at the top, and a third clock called a retrograde clock sits at the bottom with three voltmeters that read out the time in steps. Everything is controlled by an Arduino Nano with the reliable DS3231 keeping track of time. The case can be laser-cut or 3D printed and [imitche3] has provided schematics for both options.

As far as clocks builds go, we always appreciate something which can be used to tell the time without needing any legends, codes, or specialized knowledge. Of course, if you want to take a more complex or difficult clock face some of the ones we’re partial to are this QR code clock which needs a piece of hardware to tell the time that probably already has its own clock on it.

If you want to make a good first impression on someone, it seems like the longer you can keep them talking, the better. After all, if they want to keep talking, that’s a pretty good sign that even if you don’t become business partners, you might end up friends. What better way to make an acquaintance than over a friendly game of tic-tac-toe?

This one will probably take them by surprise, being a 4×4 matrix rather than the usual 3×3, but that just makes it more interesting. The front of the card has all the usual details, and the back is a field of LEDs and micro switches. Instead of using X and O, [Edison Science Corner] is using colors — green for player one, and red for player two. Since playing requires the taking of turns, the microcontroller lights up green and red with alternating single-button presses.

Speaking of, the brains of this operation is an ATMega328P-AU programmed with Arduino. If you’d like to make your own tic-tac-toe business card, the schematic, BOM, and code are all available. Be sure to check out the build and demo video after the break.

Camera sliders are great creative tools, letting you get smooth controlled shots that can class up any production. [Anthony Kouttron] decided to build one for an engineering class, and he ended up mighty satisfied with what he and his team accomplished.

As an engineering class project, this wasn’t a build done on a whim. Instead, [Anthony] and his fellow students spent plenty of time hashing out what they needed this thing to do, and how it should be built. An Arduino was selected as the brains of the operation, as a capable and accessible microcontroller platform. Stepper motors and a toothed belt drive were used to move the slider in a controllable fashion. The slider’s control interface was an HD44780-based character LCD, along with a thumbstick and two pushbuttons. The slider relied on steel tubes for a frame, which was heavy, but cost-effective and easy to fabricate. Much of the parts were salvaged from legendary e-waste bins on the university grounds.

The final product was stout and practical. It may not have been light, but the steel frame and strong stepper motor meant the slider could easily handle even heavy DSLR cameras. That’s something that lighter builds can struggle with.

Ultimately, it was an excellent learning experience for [Anthony] and his team. As a bonus, he got some great timelapses out of it, too. Video after the break.

In the turmoil of today’s world, drones are getting bigger, badder, and angrier. [Max Imagination] has gone the other way with his work, though, building a teeny Arduino drone that can fit in the palm of your hand. Even if you have a small hand!

The drone is based around an Arduino Pro Mini, and uses an MPU6050 IMU for motion sensing and flight control. Communication with the drone is via an NRF24L01. Four small coreless motors are used for propulsion, driven by tiny MOSFETs, and the whole assembly is run via a teeny 220 mAh lithium-polymer battery. Oh, and there’s an FPV camera so you can put on some goggles and see where it’s going!

Control is via MultiWii software, written specifically for building multirotor craft. [Max] flies the craft using a controller of his own creation, again using an NRF24L01 for communication.

It’s a neat build, and a titchy one too! Tiny drones have a character all their own, even if they can’t really stand up to windier outdoor environments. Video after the break.

“There goes the neighborhood” isn’t a phrase to be thrown about lightly, but when they build a police station next door to your house, you know things are about to get noisy. Just how bad it’ll be is perhaps a bit subjective, with pleas for relief likely to fall on deaf ears unless you’ve got firm documentation like that provided by this automated noise detection system.

OK, let’s face it — even with objective proof there’s likely nothing that [Christopher Cooper] is going to do about the new crop of sirens going off in his neighborhood. Emergencies require a speedy response, after all, and sirens are perhaps just the price that we pay to live close to each other. That doesn’t mean there’s no reason to monitor the neighborhood noise, though, so [Christopher] got to work. The system uses an Arduino BLE Sense module to detect neighborhood noises and Edge Impulse to classify the sounds. An ESP32 does most of the heavy lifting, including running the UI on a nice little TFT touchscreen.

When a siren-like sound is detected, the sensor records the event and tries to classify the type of siren — fire, police, or ambulance. You can also manually classify sounds the system fails to understand, and export a summary of events to an SD card. If your neighborhood noise problems tend more to barking dogs or early-morning leaf blowers, no problem — you can easily train different models.

While we can’t say that this will help keep the peace in his neighborhood, we really like the way this one came out. We’ve seen the BLE Sense and Edge Impulse team up before, too, for everything from tuning a bike suspension to calming a nervous dog.