There are plenty of problems that are easy for humans to solve, but are almost impossibly difficult for computers. Even though it seems that with modern computing power being what it is we should be able to solve a lot of these problems, things like identifying objects in images remains fairly difficult. Similarly, identifying specific sounds within audio samples remains problematic, and as [Eivind] found, is holding up a lot of medical research to boot. To solve one specific problem he created a system for counting coughs of medical patients.

This was built with the idea of helping people with chronic obstructive pulmonary disease (COPD). Most of the existing methods for studying the disease and treating patients with it involves manually counting the number of coughs on an audio recording. While there are some software solutions to this problem to save some time, this device seeks to identify coughs in real time as they happen. It does this by training a model using tinyML to identify coughs and reject cough-like sounds. Everything runs on an Arduino Nano with BLE for communication.

While the only data the model has been trained on are sounds from [Eivind], the existing prototypes do seem to show promise. With more sound data this could be a powerful tool for patients with this disease. And, even though this uses machine learning on a small platform, we have seen before that Arudinos are plenty capable of being effective machine learning solutions with the right tools on board.

Both Arduino and MicroPython are giants when it comes to the electronics education area, and each one of them represents something you can’t pass up on as an educator. Arduino offers you a broad ecosystem of cheap hardware with a beginner-friendly IDE, helped by forum posts explaining every single problem that you could and will stumble upon. MicroPython, on the other hand, offers a powerful programming environment ripe for experimentation, and doesn’t unleash a machine gun fire of triangle brackets if you try to parse JSON slightly incorrectly. They look like a match made in heaven, and today, from heaven descends the Arduino Lab for MicroPython.

This is not an Arduino IDE extension – it’s a separate Arduino IDE-shaped app that does MicroPython editing and uploads code to your board from a friendly environment. It works over a serial port, and as such, the venerable ESP8266-based boards shouldn’t be be left out – it even offers file manager capabilities! Arduino states that this is an experimental effort – it doesn’t yet have syntax checks, for instance, and no promises are made. That said, it already is a wonderful MicroPython IDE for beginner purposes, and absolutely a move in the right direction. Want to try? Download it here, there’s even a Linux build!

High-level languages let you build projects faster – perfect fit for someone getting into microcontrollers. Hopefully, what follows is a MicroPython library manager and repository! We’ve first tried out MicroPython in 2016, and it’s come a long way since then – we’ve seen quite a few beginner-friendly MicroPython intros, from a gaming handheld programming course, to a bipedal robot programming MicroPython exploration. And, of course, you can bring your C libraries with you.

The one thing that separates the pros on Twitch from the dilettantes is the production values. It’s all about the smooth transitions, and you’ll never catch the big names fiddling with dodgy software mid-stream. The key to achieving this is by having a streamdeck to help control your setup, like this straightforward design from [Electronoobs]. (Video, embedded below.)

The build relies on an Arduino Micro, which is a microcontroller board perfectly equipped to acting as a USB macro keyboard. It’s paired with a Nextion LCD touchscreen that displays buttons for various stream control features, like displaying a “Be Right Back” screen or cuing up video clips. The build also features bigger regular buttons for important quick-access features like muting a mic. It’s all wrapped up in a 3D printed housing, with some addressable RGB LEDs running off another Arduino to add some pizazz. The neat trick is that the build sends keycodes for F13-F24, which allows for the streamdeck’s hotkeys to avoid conflicting with any other software using conventional keyboard hotkeys.

It’s a useful tool that would be of use to anyone streaming on Twitch or other platforms. Alternatively, you could repurpose an old phone to do a similar job. Video after the break.

Home automation systems are all well and good, so long as the person who built it all is around to drive it. Let’s face it, they’re quite often a complex web of interconnected systems, all tied to the specifics of one’s home — and someone less familiar with it all could get a little irritated if, on a chilly day, the interface to the boiler is via a Python script, and something won’t work. Just saying. Home Buttons by [Matej Planinšek] over on Hackaday.IO is a nicely polished project, which aims to take some of the hackiness out of such automation by providing a sleek front end to those automation routines, enabling anyone to rock on over and set one in action without hassle.

The PCB is based around the ESP32-S2-mini which deals with WiFi connectivity and integration with Home Assistant using the usual MQTT protocol. We expect integration with other flavors of home automation would not be difficult to achieve. The center of the unit holds a simple E-Ink display, for that low-standby power. Specifically, the unit chosen is a Good Display GDEY029T94 2.9″ which this scribe can confirm is easy to interface and pretty cheap to purchase from the usual Chinese online vendors. This was matched up with six clicky Alps SKRB-series low-profile tact switches, which sit on either side of the display, and corresponds to a flexure-type affair on the 3D printed front casing. Neat and simple.

The PCB design was provided in Altium format, which you can find on the project GitHub page. This shows a straightforward design, with a few nice little details here and there. The internally mounted 186550 cell is reportedly good for at least a year of operation, but when time, it can be charged via USB. A Xysemi XB8608AF (PDF) protection chip provides appropriate limiting for the 186550 cell, shielding it from the perils of overcharging, discharging, and whatnot. Not that that is likely in this current setup. A Sensiron SHTC3 humidity and temperature sensor is also in there, hanging off the I2C bus, which makes sense for this application.

Home Automation hacks are plenty on these pages, like this scroll-wheel interface, for instance. If all this stuff is looking quite overbearingly complicated to get into, how about starting with a Pico W?

Even though some devices now use WiFi and Bluetooth, so much of our home entertainment equipment still relies on its own proprietary infrared remote control. By and large (when you can find them) they work fine, but what happens when they stop working?  First port of call is to change the batteries, of course, but once you’ve tried that what do you do next? [Hulk] has your back with this simple but effective IR Remote Tester / Decoder.

By using a cheap integrated IR receiver/decoder device (the venerable TSOP4838), most of the hard work is done for you! For a quick visual check that your remote is sending codes, it can easily drive a visible LED with just a resistor for a current-limit, and a capacitor to make the flickering easier to see.

For an encore, [Hulk] shows how to connect this up to an Arduino and how to use the “IRremote” library to see the actual data being transmitted when the buttons are pressed.

It’s not much of a leap to imagine what else you might be able to do with this information once you’ve received it – controlling your own projects, cloning the IR remote codes, automating remote control sequences etc..

It’s a great way to make the invisible visible and add some helpful debug information into the mix.

We recently covered a more complex IR cloner, and if you need  to put together a truly universal remote control, then this project may be just what you need.

For those that haven’t heard, ultrasonic levitation is a process by which two or more ultrasonic transducers are set opposite to each other and excited in such a way as to create a standing wave between them. The sound is, as the name implies, ultrasonic — so outside the range of human hearing — but strong enough so that the small, light objects can be positioned and held fixed in mid-air where there’s a pressure minimum in the standing wave. [Olimex] has created a small ultrasonic levitation kit that exemplifies this phenomena.

The kit itself is made using through-hole components, with an ATTiny85 as the core microcontroller to drive two TCT40-16T ultrasonic speakers, and a MAX232 to provide a USB interface. Two slotted rectangular PCB pieces that solder connect to the main board, provide a base so that the device stands upright when assembled. The whole device is powered through the USB connection, and the ultrasonic speakers output in the 40KHz range providing enough power to levitate small Styrofoam balls.

The project is, by design, an exercise in minimalism, providing a kit that can be easily assembled, and providing code that can be easily flashed onto the device, examined and modified. All the design files, including the bill of materials, KiCAD schematics, and source code are provided under an open source hardware license to allow for anyone wanting to know how such a project works, or to extend it themselves, ample opportunity. [Olimex] also has the kit for sale for those not wanting to source boards and parts themselves.

We’ve featured ultrasonic levitation devices before, from bare bones system driven by a NE555 to massive phased arrays.

With surface-mount components quickly becoming the norm, even for homebrew hardware, the resistor color-code can sometimes feel a bit old-hat. However, anybody who has ever tried to identify a random through-hole resistor from a pile of assorted values will know that it’s still a handy skill to have up your sleeve. With this in mind, [j] decided to super-size the color-code with “The Great Resistor”.

At the heart of the project is an Arduino Nano clone and a potential divider that measures the resistance of the test resistor against a known fixed value. Using the 16-bit ADC, the range of measurable values is theoretically 0 Ω to 15 MΩ, but there are some remaining issues with electrical noise that currently limit the practical range to between 100 Ω and 2 MΩ.

[j] is measuring the supply voltage to help counteract the noise, but intends to move to an oversampling/averaging method to improve the results in the next iteration.

The measured value is shown on the OLED display at the front, and in resistor color-code on an enormous symbolic resistor lit by WS2812 RGB LEDs behind.

Precision aside, the project looks very impressive and we like the way the giant resistor has been constructed. It would look great at a science show or a demonstration. We’re sure that the noise issues can be ironed out, and we’d encourage any readers with experience in this area to offer [j] some tips in the comments below. There’s a video after the break of The Great Resistor being put through its paces!

If you want to know more about the history of the resistor color code bands, then we have you covered.  Alternatively, how about reading the color code directly with computer vision?

We’re used to seeing all manner of seven-segment displays, be they mechanical, electronic, or something in between. But what all these displays have in common is that they’re, you know, displays. Using them as inputs would just be crazy talk, right?

Perhaps, but we like where [Dave Ehnebuske] is going with “InSlide,” the seven-segment input device. The idea for this comes from the “DigiTag” display, which we covered back in October, and divides a standard seven-segment character into three vertical strips — two skinny ones for the outside vertical segments, and one wide strip holding the horizontal elements. By sliding these strips up and down relative to each other, the standard nine digits, plus a few other characters, can be composed.

[Dave]’s take on this theme started by building his display from laser-cut plywood pieces, which is a nice choice because of the good contrast between the white wood and the engraver segments. Next, he embedded rare earth magnets in the slides and installed seven Hall effect sensors in the frame. The sensors are connected to an Arduino Nano via a 74HC165 parallel-load shift register, which lets multiple modules be daisy-chained together. He also built an Arduino library to read the current state of the segments; it supports the full hexadecimal character set, or even duodecimal if you like.

[Dave] has shared the library, and it looks like you can get the build files for the mechanism from the original project. That’s good, because this looks ripe for hacking. It looks like it would be pretty easy to motorize a display like this by adding rack-and-pinion gearing and steppers — something like that could make an interesting clock.

How many of us have an everyday tool that’s truly unique? Likely not many of us; take a look around your desk and turn out your pockets, but more often than not, what you’ll find is that everything you have is something that pretty much everyone else on the planet could have bought too. But not so if you’ve got this beautiful custom RPN calculator in a wooden case.

This one comes to us from [Shinsaku Hiura], who generally dazzles us with unique mechanical clocks and displays. This calculator solves a more practical problem — the dearth of RPN calculators on the market with the correct keyboard feel, specifically with the large keys and light touch he desired. Appropriately, the build started with a numeric keypad, which once liberated of its USB interface was reverse-engineered to figure out how the matrix was wired. Next up, a custom PCB to connect the keypad to an Arduino and a 20×4 LCD display was milled up, while a test case was designed and printed to check fitment. The final case was milled from a block of solid walnut and fitted with an acrylic window, for a sharp look with clean lines and pleasing colors.

As for the calculator itself, the demo below shows it going through its paces. The code is clever because it leverages the minimal number of keys available by hiding all the scientific and engineering functions behind a “secret silver key” that was once the equals key and obviously not needed in RPN. Hats off to [Shinsaku] for a handsome and unique addition to his desk.

Shooting good video can be an arduous task if you’re working all by yourself. [Pave Workshop] developed a series of gesture-responsive tools to help out, with a focus on creating a simple intuitive interface.

The system is based around using a Kinect V2 to perceive gestures made by the user, which can then control various objects in the scene. For instance, a beckoning motion can instruct a camera slider to dolly forward or backwards, and a halting gesture will tell it to stop. Bringing the two hands together or apart in special gestures indicate that the camera should zoom in or out. Lights can also be controlled by pulling a fist towards or away from them to change their brightness.

The devil is in the details with a project that works this smoothly. [Pave Workshop] lays out the details on how everything Node.JS was used to knit together everything from the custom camera slider to Philips Hue bulbs and other Arduino components.

The project looks really impressive in the demo video on YouTube. We’ve seen some other impressive automated filming rigs before, too.