There are so many new cool MCUs coming out, and you want to play with all of them, but, initially, they tend to be accessible as bare chips. Devboards might be hard to get, not expose everything, or carry a premium price. [Willmore] has faced this problem with an assortment of new WCH-made MCUs, and brings us all a solution – a universal board for TSSOP20-packaged MCUs, breadboard-friendly and adaptable to any pinout with only a few jumpers on the underside.

The board brings you everything you might want from a typical MCU breakout – an onboard 3.3V regulator, USB series resistors, a 1.5K pullup, decoupling capacitors, and a USB-C port. All GPIOs are broken out, and there’s a separate header you can wire up for all your SWD/UART/USB/whatever needs – just use the “patch panel” on the bottom of the board and pick the test points you want to join. [Willmore] has used these boards for the CH32Vxxx family, and they could, no doubt, be used for more – solder your MCU on, go through the pin table in the datasheet, do a little point-to-point wiring, and you get a pretty functional development board.

Everything is open-source – order a few of these boards from your fab of choice, and you won’t ever worry about a breakout for a TSSOP20 MCU or anything that would fit the same footprint. It could even be used in a pinch for something like an I2C GPIO expander. This is also a technique worth keeping in mind – a step above the generic footprint breakouts. Looking for more universal breakouts to keep? Here’s one for generic LCD/OLED panel breakouts.

[Poking Technology] doesn’t think much of his new smartwatch. It is, by his admission, the cheapest possible smartwatch, coming in at about $3. It has very few useful features but he has figured out how to port MicroPython to it, so for a wrist-mounted development board with BLE, it might be useful. You can check it out in the video below.

The first step is a teardown, which reveals surprisingly little on the inside. There’s a tiny battery, a few connections, a display, and a tiny CPU board. There are, luckily, a few test pads that let you get into the CPU. What do you get? A 24 MHz Telink CPU with 512k of flash and 16k of RAM, along with all the other hardware.

Of course, even if you just want a display with some smarts, $3 might be in your price range. The whole thing wound up taped down to a PCB. But the usual debugger didn’t want to connect. Grabbing an oscilloscope revealed that the output from the board had some level problems. He eventually wrote his own debugger interface using a Pi Pico.

He was able to find the onboard CPU’s development tools. The CPU claims to be proprietary but looks suspiciously like a slightly modified ARM. A short investigation shows that the object code is extremely similar to the ARM Thumb instruction set but with a few extra bits set and different mnemonics. But once you put Python on board, who really cares?

The only downside is that it doesn’t appear that the BLE is practically usable because of memory limitations. But there are still places you might use the little watch in a project.

If you want a smartwatch, maybe build your own. While many DIY watches are simple, you can get pretty complicated if you like.

If you’re pairing a tiny Linux computer to a few peripherals — perhaps you’re building a reasonably custom Pi-powered device — it’s rightfully tempting to use something like an STM32 for all your low-level tasks, from power management to reading keyboard events.

Now, in case you were wondering how to tie the two together, consider HID over I2C, it’s a standardized protocol with wide software and peripheral support, easily implementable and low-power. What’s more, [benedekkupper] gives you an example STM32 project with a detailed explanation on how you too can benefit from the protocol.

There are several cool things about this project. For a start, its code is generic enough that it will port across the entire STM32 lineup nicely. Just change the pin definitions as needed, compile it, flash it onto your devboard and experiment away. Need to change the descriptors? The hid-rdf library used lets you define a custom descriptor super easily, none of that building a descriptor from scratch stuff, and it even does compile-time verification of the descriptor!

The project has been tested with a Raspberry Pi 400, and [benedekkupper] links a tutorial on quickly adding your I2C-HID device on an Linux platform; all you need is DeviceTree support. Wondering what’s possible with HID? We’ve seen hackers play with HID aplenty here, and hacking on the HID standard isn’t just for building keyboards. It can let you automate your smartphone, reuse a laptop touchpad or even a sizeable Wacom input surface, liberate extra buttons on gamepads, or build your own touchscreen display.

There’s no shortage of Geiger counter projects based on the old Soviet SBM-20 tube, it’s a classic circuit that’s easy enough even for a beginner to implement — so long as they don’t get bitten by the 400 volts going into the tube, that is. Toss in a microcontroller, and not only does that circuit get even easier to put together and tweak, but now the features and capabilities of the device are only limited by how much code you want to write.

Luckily for us, [Omar Khorshid] isn’t afraid of wrangling some 0s and 1s, and the result is the OpenRad project. In terms of hardware, it’s the standard SBM-20 circuit augmented with a LILYGO ESP32 development board that includes a TFT display. But where this one really shines is the firmware.

With the addition of a few hardware buttons, [Omar] was able to put together a very capable interface that runs locally on the device itself. In addition, the ESP32 serves up a web page that provides some impressive real-time data visualizations. It will even publish its data via MQTT if you want to plug it into your home automation system or other platform.

Between the project’s Hackaday.io page and GitHub repository, [Omar] has done a fantastic job of documenting the project so that others can recreate it. That includes providing the schematics, KiCad files, and Gerbers necessary to not only get the boards produced and assembled, but modified should you want to adapt the base OpenRad design.

This project reminds us of the uRADMonitor, which [Radu Motisan] first introduced in 2014 to bring radiation measuring to the masses. This sort of hardware has become far more accessible over the last decade, bringing the dream of a globally distributed citizen-operated network of radiation and environmental monitors much closer to reality.

If you are used to writing software for modern machines, you probably don’t think much about computing something like one divided by three. Modern computers handle floating point quite well. However, in constrained systems, there is a trap you should be aware of. While modern compilers are happy to let you use and abuse floating point numbers, the hardware is often woefully slow. It also tends to eat up lots of resources. So what do you do? Well, as [Low Byte Productions] explains, you can opt for fixed-point math.

In theory, the idea is simple. Just put an arbitrary decimal point in your integers. So, for example, if we have two numbers, say 123 and 456, we could remember that we really mean 1.23 and 4.56. Adding, then, becomes trivial since 123+456=579, which is, of course, 5.79.

But, of course, nothing is simple. Multiplyting those two numbers gives you 56088 but that’s 5.6088 and not 560.88. So keeping track of the decimal point is a little more complicated than the addition case would make you think.

How much more complicated is it? Well, the video covers a lot but it takes an hour and half to do it. There’s plenty of code and explanations so if you haven’t dealt with fixed point math or you want a refresher, this video’s worth the time to watch.

Want to do 3D rendering on an ATMega? Fixed point is your friend. We’ve done our own deep dive on the topic way back in 2016.

When word first got out that the Chinese board houses were experimenting with full color silkscreens, many in our community thought it would be a boon for PCB art. Others believed it would be akin to cheating by removing the inherent limitations of the medium. That’s not a debate that will be solved today, but here we have an example of a project that’s not only making practical application of the technology, but one that arguably couldn’t exist in its current form without it: a single-PCB ZX Spectrum emulator developed by [atomic14].

There basics here are, well, they’re pretty basic. You’ve got an ESP32-S3, a TFT display, a micro SD slot, and the handful of passives necessary to tie them all together. What makes this project stand out is the keyboard, which has been integrated directly into the PCB thanks to the fourteen pins on the ESP32-S3 that can be used as touch sensor input channels. There are issues with detecting simultaneous keypresses, but overall it seems to work pretty well.

But what makes the keyboard really special is that [atomic14] has used the color silkscreen capability to put all the necessary labels directly onto the keys. Technically this could have been done using a traditional single color silkscreen, but it would have been a hell of a lot harder to fit all the necessary information on there while keeping it readable. Plus, you’d miss the little rainbow in the corner.

As good as it looks already, the project is still in the early stages of development. Some components, such as the TFT display, still need to be better integrated into the board. In terms of software, the board is running a ZX Spectrum emulator that [atomic14] developed previously. Judging by the gameplay in the video below, it’s doing a solid job of bringing this classic system (and its games) back to life.

There’s no shortage of devices out there for creating electronic music, but if you’re just looking to get started, the prices on things like synthesizers and drum machines could be enough to give you second thoughts on the whole idea. But if you’ve got a well stocked parts bin, there’s a good chance you’ve already got most of what you need to build your own Crunch-E.

Described by creator [Roman Revzin] as a “keychain form factor music-making platform”, the Crunch-E combines an ESP32, an MAX98357 I2S audio amplifier, an array of tactile buttons, and a sprinkling of LEDs and passives. It can be built on a perfboard using off-the-shelf modules, or you can spin up a PCB if you want something a bit more professional. It sounds like there’s eventually going to be an option to purchase a pre-built Crunch-E at some point as well.

But ultimately, the hardware seems to be somewhat freeform — the implementation isn’t so important as long as you’ve got the major components and can get the provided software running on it.

The software, which [Roman] is calling CrunchOS, currently provides four tracks, ten synth instruments, and two drum machine banks. Everything can be accessed from a 4 x 4 button array, and there’s a “cheat sheet” in the documentation that shows what each key does in the default configuration. Judging by the demo video below, it’s already an impressively capable platform. But this is just the beginning. If everything goes according to plan and more folks start jamming on their own Crunch-E hardware, it’s not hard to imagine how the software side can be expanded and adapted over time.

Over the years we’ve seen plenty of homebrew projects for producing electronic music, but the low-cost, simple construction, and instant gratification nature of the Crunch-E strikes us as a particularly compelling combination. We’re eager to see where things develop from here.

Over the last several years, DIY projects utilizing e-paper displays have become more common. While saying the technology is now cheap might be overstating the situation a bit, the prices on at least small e-paper panels have certainly become far more reasonable for the hobbyist. Pair one of them with a modern microcontroller such as the RP2040 or ESP32, sprinkle in a few open source libraries, and you’re well on the way to creating an energy-efficient smart display for your home or office.

But therein lies the problem. There’s still a decent amount of leg work involved in getting the hardware wired up and talking to each other. Putting the e-paper display and MCU together is often only half the battle — depending on your plans, you’ll probably want to add a few sensors to the mix, or perhaps some RGB status LEDs. An onboard battery charger and real-time clock would be nice as well. Pretty soon, your homebrew e-paper gadget is starting to look remarkably like the bottom of your junk bin.

For those after a more integrated solution, the folks at Soldered Electronics have offered up a line of premium open source hardware development boards that combine various styles of e-paper panels (touch, color, lighted, etc) with a microcontroller, an array of sensors, and pretty much every other feature they could think of. To top it off, they put in the effort to produce fantastic documentation, easy to use libraries, and free support software such as an online GUI builder and image converter.

We’ve reviewed a number of previous Inkplate boards, and always came away very impressed by the attention to detail from Soldered Electronics. When they asked if we’d be interested in taking a look at a prototype for their new MOTION 6 board, we were eager to see what this new variant brings to the table. Since both the software and hardware are still pre-production, we won’t call this a review, but it should give you a good idea of what to expect when the final units start shipping out in October.

Faster and Stronger

As mentioned previously, the Inkplate boards have generally been differentiated by the type of e-paper display they’ve featured. In the case of the new MOTION, the theme this time around is speed — Soldered says this new display is capable of showing 11 frames per second, no small feat for a technology that’s notoriously slow to refresh. You still won’t be watching movies at 11 FPS of course, but it’s more than enough to display animations and dynamic information thanks to its partial refresh capability that only updates the areas of the display where the image has actually changed.

But it’s not just the e-paper display that’s been swapped out for a faster model. For the MOTION 6, Soldered traded in the ESP32 used on all previous Inkplates for the STM32H743, an ARM Cortex-M7 chip capable of running at 480 MHz. Well, at least partially. You’ll still find an ESP32 hanging out on the back of the MOTION 6, but it’s there as a co-processor to handle WiFi and Bluetooth communications. The STM32 chip features 1 MB of internal SRAM and has been outfitted with a whopping 32 MB of external DRAM, which should come in handy when you’re throwing 4-bit grayscale images at the 1024 x 758 display.

The Inkplate MOTION 6 also features an impressive suite of sensors, including a front-mounted APDS-9960 which can detect motion, proximity, and color. On the backside you’ll find the SHTC3 for detecting temperature and humidity, as well as a LSM6DSO32 accelerometer and gyroscope. One of the most impressive demos included in the MOTION 6’s Arduino library pulls data from the gyro and uses it to rotate a wireframe 3D cube as you move the device around. Should you wish to connect other sensors or devices to the board, you’ve got breakouts for the standard expansion options such as I²C and SPI, as well as Ethernet, USB OTG, I²S, SDMMC, and UART.

Although no battery is included with the MOTION 6, there’s a connector for one on the back of the board, and the device includes a MCP73831 charge controller and the appropriate status LEDs. Primary power is supplied through the board’s USB-C connector, and there’s also a set of beefy solder pads along the bottom edge where you could wire up an external power source.

For user input you have three physical buttons along the side, and a rather ingenious rotary encoder — but to explain how that works we need to switch gears and look at the 3D printed enclosure Soldered has created for the Inkplate MOTION 6.

Wrapped Up Tight

Under normal circumstances I wouldn’t go into so much detail about a 3D printed case, but I’ve got to give Soldered credit for the little touches they put into this design. Living hinges are used for both the power button and the three user buttons on the side, there’s a holder built into the back for a pouch battery, and there’s even a little purple “programming tool” that tucks into a dedicated pocket — you’ll use that to poke the programming button when the Inkplate is inside the enclosure.

But the real star is the transparent wheel on the right hand side. The embedded magnet in the center lines up perfectly with a AS5600 magnetic angle encoder on the Inkplate, with an RGB LED just off to the side. Reading the value from the AS5600 as the wheel rotates gives you a value between 0 and 4048, and the library offers macros to convert that to radians and degrees. Combined with the RGB LED, this arrangement provides an input device with visual feedback at very little cost.

It’s an awesome idea, and now I’m looking for an excuse to include it in my own hardware designs.

The 3D printed case is being offered as an add-on for the Inkplate MOTION 6 at purchase time, but both the STLs and  Fusion 360 files for it will be made available with the rest of the hardware design files for those that would rather print it themselves.

An Exciting Start

As I said in the beginning of this article, the unit I have here is the prototype — while the hardware seems pretty close to final, the software side of things is obviously still in the early stages. Some of the libraries simply weren’t ready in time, so I wasn’t able to test things like WiFi or Bluetooth. Similarly, I wasn’t able to try out the MicroPython build for the MOTION 6. That said, I have absolutely no doubt that the team at Soldered Electronics will have everything where it needs to be by the time customers get their hands on the final product.

There’s no denying that the $169 USD price tag of the Inkplate MOTION 6 will give some users pause. If you’re looking for a budget option, this absolutely isn’t it. But what you get for the price is considerable. You’re not just paying for the hardware, you’re also getting the software, documentation, schematics, and PCB design files. If those things are important to you, I’d say it’s more than worth the premium price.

So far, it looks like plenty of people feel the same way. As of this writing, the Inkplate MOTION 6 is about to hit 250% of its funding goal on Crowd Supply, with more than 30 days left in the campaign.

Microcontroller dev boards are wonderfully useful items, in testament to which most of us maintain an ample collection of the things. But dragging one out to do a simple job can be a pain, what with making sure you have the whole toolchain set up to support the device, not to mention the inevitable need to solder or desolder header pins. Wouldn’t it be nice if there was a simple plug-and-play way to add a few bits of GPIO to your desktop or laptop machine?

[Nick Bild] thinks so, and came up with the USBgpio. The hardware in the dongle is pretty much what you’d expect — an Arduino Nano 33 IoT. Yes, you could just bust out a Nano and do this yourself, but [Nick] has done all the heavy lifting already. Eleven of the Nano’s IO pins plus 3.3V and ground are broken out to header pins that stick out of the 3D-printed enclosure, and the dongle is powered over the USB cable. [Nick] also built a Python library for the USBgpio, making it easy to whip up a quick program. You just import the library, define the serial port and baud rate, and the library takes care of the rest. The video below shows a quick blinkenlight test app.

Earth-shattering stuff? Perhaps not; [Nick] admits as much by noting the performance doesn’t really dazzle. But that’s hardly the point of the project, and if you need a couple of pins of IO on the desktop for a quick tactical project or some early-stage prototyping, USBgpio could be your friend.

The good news is that more and more people are working from home these days. The bad news is that some of the more draconian employers out there aren’t too happy about it, to the point of using spyware software to keep tabs on their workers. Better make that bathroom break quick — Big Brother is watching!

One simple way to combat such efforts is a mouse jiggler, which does…well it does exactly what it sounds like. If you find yourself in need of such a device, the WorkerMouse from [Zane Bauman] is a simple open source design that can be put together with just a handful of components.

The WorkerMouse is designed to be assembled using through-hole parts on a scrap of perfboard, but you could certainly swap them out for their SMD variants if that’s what you have on hand. The circuit is largely made up out of passive components anyway, except for the ATtiny85 that’s running the show.

[Zane] decided to embrace modernity and couple the circuit with a USB-C breakout board, but naturally you could outfit it with whatever USB flavor you want so long as you’ve got a cable that will let you plug it into your computer.

The project’s C source code uses V-USB to connect to the computer and act as a USB Human Interface Device (HID). From there, it generates random speed and position data for a virtual mouse, and dumps it out every few seconds. The end result is a cursor that leaps around the screen whenever the WorkerMouse is plugged in, which should be enough to show you online while you step away from the computer. As an added bonus, [Zane] has put together a nice looking 3D printable enclosure for the board. After all, the thing is likely going to be sitting on your desk, might as well have it look professional.

If you’ve got the time to get a PCB made, you might also be interested in the MAUS we covered last year, which also keeps the ATtiny85 working so you don’t have to.

MicroPython is a wonderful Python interpreter that runs on many higher-end microcontrollers, from ESP8266 to STM32 to the RP2040. MicroPython lets you build devices quickly, and its latest release, 1.23, brings a number of improvements you should be aware of.

The first one is custom USB device support, and it’s a big one. Do you want to build HID devices, or play with MIDI, or do multiple serial streams with help of PIO? Now MicroPython lets you easily create USB devices on a variety of levels, from friendly wrappers for creating HID or MIDI devices, to low-level hooks to let you define your own USB descriptors, with user-friendly libraries to help all the way through. Currently, SAMD and RP2040 ports are supported in this part of code, but you can expect more in the future.

There’s more – support for OpenAMP, an inter-core communication protocol, has received a ton of improvements for systems where MicroPython reigns supreme on some of the CPU cores but also communicates with different systems on other cores. A number of improvements have made their way through the codebase, highlighting things we didn’t know MicroPython could do – for instance, did you know that there’s a WebAssembly port in the interpreter, letting you run MicroPython in your browser?

Well, it’s got a significant overhaul in this release, so there’s no better time to check it out than now! Library structure has been refactored to improve CPython compatibility, the RP2040 port receives a 10% performance boost thanks to core improvements, and touches upon areas like PIO and SPI interfaces.

We applaud all contributors involved on this release. MicroPython is now a decade old as of May 3rd, and it keeps trucking on, having firmly earned its place in the hacker ecosystem. If you’ve been playing with MicroPython, remember that there are multiple IDEs, graphics libraries, and you can bring your C code with you!

Are you tired of the same old music, but can’t afford any new tunes, even if they’re on dead formats? Boy, do we know that feeling. Here’s what you do: build yourself a GlobeTune music player, and you’ll never want for new music again.

The idea is simple, really. Just turn what we assume is a nice, clicky knob, and after a bit of static (which is a great touch!), you get a new, random radio station from somewhere around the globe. [Alexis D.] originally built this as a way to listen to and discover new music while disconnecting from the digital world, and we think it’s a great idea.

[Alexis D.] has production in mind, so after a Raspberry Pi Zero W prototype, they set about redesigning it around the ESP32. The current status seems to be hardware complete, software forthcoming. [Alexis D.] says that a crowdfunding campaign is in the works, but that the project will be open-sourced once in an acceptable state. So stay tuned!

Speaking of dead-ish formats, here’s an Internet radio in a cassette form factor.

These days, when most folks think of a computer they imagine a machine with multiple CPUs, several gigabytes of RAM,  and a few terabytes of non-volatile storage for good measure. With such modern expectations, it can be difficult to see something like a microcontroller as little more than a toy. But if said MCU has a keyboard, is hooked up to a display, and lets you run basic productivity and development software, doesn’t that qualify it as a computer? It certainly would have in the 1980s.

With that in mind, [Olimex] has teased the RVPC, which they’re calling the “world lowest cost Open Source Hardware All-in-one educational RISC-V computer” (say that three times fast). The tiny board features the SOIC-8 variant of the CH32V003 and…well, not a whole lot else. You’ve got a handful of passives, a buzzer, an LED, and the connectors for a PS/2 keyboard, a power supply, and a VGA display. The idea is to offer this as a beginner’s soldering kit in the future, so most most of the components are through-hole.

On the software side, the post references things like the ch32v003fun development stack, and the PicoRVD programmer as examples of open source tools that can get your CH32V computer up and running. There’s even a selection of retro-style games out there that would be playable on the platform. But what [Olimex] really has their eye on is a port of VMON, a RISC-V monitor program.

When paired with the 320×200 VGA text mode that they figure the hardware is capable of, you’ve got yourself the makings of an educational tool that would be great for learning assembly and playing around with bare metal programming.

It might not have the timeless style of the Voja4, but at least you can fit it in a normal sized pocket.

Thanks to [PPJ] for the tip.

Speech recognition was once the stuff of science fiction, but it’s now possible with relatively modest hardware. Just how modest, you ask? How about a 10 cent microcontroller?

[Brian Smith] has achieved a very basic form of speech recognition on a CH32V003 RISC-V microcontroller. It may only recognize spoken digits, but that it does so at all on such a modest platform is impressive in itself.

For training purposes it enlists the help of a desktop Linux computer, however the recognition process is purely in the ten cent chip. He goes into much detail about how it achieves this on a system without floating point arithmetic, as well as the other shortcomings of such a limited platform.

We’ve become used to thinking of super-cheap chips as of limited use, but the truth is they’re surprisingly more capable than expected. We’re seeing them starting to appear as subsidiary processors on some badges, so it will be interesting to see them proliferate in more projects now their availability problems have eased. Go on – for ten cents, what do you have to lose?

[Felipe Tavares] wasn’t satisfied with the boring default fonts on an HD44780-based display. And while you can play some clever tricks with user-defined characters, if you want to treat the display as an array of pixels, you’ve got to get out your scalpel and cut up a data line.

The hack builds on work from [MisterHW] who documented the bits going from the common display driver to the display, and suggested that by cutting the data line and sending your own bits, you could send arbitrary graphics. The trick was to make sure that they’re in sync with the display, though, which means reading the frame sync line in user code.

This done, it looks like [Felipe] has it working! If you can read Rust for the ESP32, he has even provided us with a working demo of the code that makes it work.

We can’t help but wonder if it’s not possible to go even lower-level and omit the HD44780 entirely. Has anyone tried driving one of these little LCD displays directly from a microcontroller, essentially implementing the HD44780 yourself?

Any way you slice it, this is a cool hack, and it opens up the doors to DOOM, or as [MisterHW] suggests, Bad Apple on these little displays . If you do it, we want to see it.

If your needs aren’t so exotic, the classic HD44780 display is a piece of cake to get working, and an invaluable tool in anyone’s toolbox.

Despite what you might have heard, even the most devout Hackaday readers may eventually find themselves getting married. Should you ever find yourself in a situation where you need to send out invitations for your big day, or any other major celebration for that matter, you could do worse than follow the example [Mokas] and their partner set with these memorable electronic wedding invitations.

Inspired by the electronic badges distributed at hacker cons, [Mokas] decided to use Adafruit’ EdgeBadge and PyBadge devices to create a similar interactive keepsake that would be a bit more exciting than a piece of paper. While it would have been enough to have the wedding information pop up on the screen when they were turned on, the final invites actually boot into a retro-style game where you walk around talking to characters to uncover information about the event and the venue.

The game was created in Microsoft MakeCode Arcade, with a sprinkling of original and commissioned sprites. Early versions of the game ended up being a bit much for the Adafruit badge’s to handle, but after doing a bit of research on creating games for computationally-constrained platforms, [Mokas] was able to optimize the performance. For those that didn’t get a physical invite (no doubt ours was simply lost in the mail), you can play the whole thing right in your browser.

It’s a very clever idea, and while using custom hardware would have allowed for a more bespoke package, we can’t blame [Mokas] for wanting to keep this one simple. Getting everything ready for your wedding is already enough stress — it’s hardly the time to spin up a new board.

For a similar reasons, another Adafruit offering was selected to power the couple’s e-ink baby development display.

Although much of the software that runs on the ESP32 microcontroller is open source, the Wi-Fi driver is not. Instead, it uses a proprietary binary blob. This was no problem for [Jasper Devreker]’s reverse-engineering of the ESP32’s Wi-Fi stack so far until he came face to face with reverse-engineering the initialization of the Wi-Fi peripheral. As it turns out, there is a lot of work involved after you call esp_phy_enable in the Espressif binary blob, with the team logging 53,286 peripheral accesses during the initialization phase. In comparison, sending a Wi-Fi packet takes about ten calls.

Currently, the way that the initialization step is handled is by having the initialization routine in the binary blob do its thing by configuring the radio and other elements before killing the FreeRTOS task and replacing it with their own version. The team is actively looking for a clean approach for moving forward that will avoid simply writing everything from scratch. For the Wi-Fi MAC, existing code (e.g., FreeBSD’s stack) could be used, but the radio code is much more of a headache. Clearly, there’s still a lot more work to be done in order to get a fully open-source Wi-Fi MAC and stack for the ESP32, but having the community (that’s you) pitch in might speed things up if there’s demand for an open-source driver.

[Jasper’s] been working on this for a while. He’s even built a Faraday cage to make the task easier.

The instrument which probably the greatest number of Hackaday readers own is likely to be the humble digital multimeter. They’re cheap and useful, but they’re single-channel, and difficult to incorporate into a breadboard project. If you’ve ever been vexed by these limitations then [Alun Morris] has just the project for you, in the world’s smallest auto-ranging multichannel voltmeter. It’s a meter on a tiny PCB with a little OLED display, and as its name suggests, it can keep an eye on several voltages for you.

At its heart is an ATtiny1614 microcontroller on a custom PCB, but for us the part we most like lies not in that but in the prototype version made on a piece of protoboard. There’s considerable soldering skill in bending surface mount components to your will on this material, and though these aren’t quite the smallest parts it’s still something that must have required some work under the magnifier.

All of the code and hardware details can be found in the GitHub repository, and for your viewing pleasure there’s a video showing it in action which we’ve placed below.

[Jens] wanted a subscriber counter for his YouTube channel. He could have gone with a simple OLED, LCD, or LED display, but he wanted something more tactile and interesting. So he built a mechanical 7-segment display instead!

Currently, [Jens]’s channel is in the four-digit subscriber range, so he planned to build a four-digit display. He started by searching for existing projects in this space, and came across the designs of [shiura] on Thingiverse. [shiura] had a 3D printed cam-driven 7-segment digit that runs on a single servo motor. Once armed with four of the digits, he hooked them up to a Pi Pico W to drive them all with four servo outputs. The Pico W is responsible for querying the channel subscriber count online, and updating the display in turn.

It’s a neat build, and [Jens] learned some things along the way—like how Super Lube seemed to ruin filament for him. Ultimately, the build came good, and it looks great. We’ve seen some other mechanical 7-segment builds before, too!