An Orbital Sanders Crash Course And The Threat Of HAVS

This is your hand on bad vibrations. (Credit: Five Duck Studio, YouTube)
This is your hand on bad vibrations. (Credit: Five Duck Studio, YouTube)

Most people know about orbital sanders, as the cousin of sheet sanders, with many people using them every day to make wood and other surfaces smooth. Yet if you have ever wondered at the slightly numb and tingling feeling in your hands after using them for a while, you really want to watch this deep dive by [Five Duck Studio] on how orbital sanders work and why not all vibrations are good vibrations.

First, the basic workings of an orbital sander are explained in the video, including the way that the orbital sanding pattern is created by the spinning disc. These patterns aren’t the same size for each sander, with the ‘finisher’ ~2.5 mm pattern being decidedly more suitable for fine work, while the roughly 5 mm pattern is better for coarser work.

From here, the details spiral into the various brake mechanisms, which prevent the disc from spinning wildly when not on a surface. This can be as simple as an O-ring providing some friction.

Continue reading “An Orbital Sanders Crash Course And The Threat Of HAVS” →

A Bambu Labs 3D printer is shown printing a cube. The cube has a division between yellow and purple plastic running at an angle through the cube. The printer is printing the purple section, and the face on which it is printing is angled at nearly 40 degrees to the print bed.

Printing Smooth Upper Surfaces With A Non-Planar Slicer

One of the most tantalizing prospects for 3D printing has been non-planar printing, which promises smoother surfaces without a staircase pattern, reduced or eliminated support structures in some incarnations, and the possibility of greater strength in others. One of the biggest limits to its adoption has been the lack of non-planar slicer programs, a gap which [Zimeng Xiong] of [Alpaca Engineering] has worked to eliminate with the non-planar PancakeSlicer.

PancakeSlicer is designed to work with standard 3-axis printers (a Bambu Labs A1 Mini in this case), so the non-planar paths available to it are limited by the print head’s clearance on each side of the nozzle. In the case of the A1 Mini, this could be substantially improved by removing the cooling shroud from the print head, relying instead on a remote static cooling system (RSCS), which blows cooling air in from the sides of the print bed. Being meant for 3-axis printers, the main goal of PancakeSlicer is to print smooth top surfaces without a stair-step pattern.

Continue reading “Printing Smooth Upper Surfaces With A Non-Planar Slicer” →

An MP3 Player, Implemented As A Factorio Blueprint

Factorio is a factory simulation game that leads its players into many happy hours of building ever more complex factories, but it comes with a snag. Its built-in music is a fairly simple synthesiser, and that doesn’t really cut it for the musical experience. This irked [Nablanaut] to the extent that he created his own MP3 player. Not just any MP3 player, this one is implemented as a Factorio blueprint, using only those in-game speaker elements as output.

The synth has a range of built-in instrument voices and not much else, so he had to find a way to reproduce complex sounds using only those tools. As you can imagine, the result looks a lot like Fourier analysis, but with the added complication that those voices are not the discrete tones needed in such a system. The video below the break is a deep dive into the tricks and compromises required to not only play an MP3, but play it well, as we hear the various versions of the output as bit by bit they get better.

The blueprint itself isn’t created by hand, of course; instead, it’s generated procedurally by a script. As far as we can see, it contains both the audio samples and the playback logic, making for a very complex factory. We especially like the song at the end of the video.

Continue reading “An MP3 Player, Implemented As A Factorio Blueprint” →

Reverse Engineer That USB Device In Style

Proprietary device drivers, dedicated applications, and their ilk are the bane of the open-source hacker. If only we could snoop on every device out there, recording the “secret” USB transactions as they go over the wire, we’d have a chance.

[Emir Mrkaljević]’s tool, usb-rea, aims to make this process a whole lot less painful. The workflow is like this: you start capturing on USB, make an annotation about what action you’re taking, press the button a few times, and then move on to the next action.

sudo modprobe usbmon
usb-rea capture start -o lamp.pcapng
usb-rea mark -m lamp.pcapng.actions.json "brightness 0%"    # then click it in the vendor app
usb-rea mark -m lamp.pcapng.actions.json "brightness 50%"   # ...repeat for 3+ values per setting
usb-rea capture stop
usb-rea report lamp.pcapng -o report.md
usb-rea scaffold lamp.pcapng -o lamp_driver.py
usb-rea dissector lamp.pcapng -o lamp.lua      # Wireshark dissector for the same protocol

Usb-rea records all the USB traffic, timestamps it relative to your actions, and gives you a report, a driver, and a Wireshark protocol dissector out the back side. There is even an MCP file so that you can hand off the grunt work to the bots, possibly enabling this to work closed-loop?

Of course, you don’t want to reinvent the wheel, so it’s fun to see that there’s also a usb-rea lookup command to see if your VID:PID is already in the dataset. Most of the devices are CPU coolers, RGB controllers, and other blinged-out computer peripherals, but we imagine that it’s a lot more broadly applicable. We looked for our mouse on the list, but it’s sadly not there.

Usb-rea is not a silver bullet to bring back abandoned peripherals from the grave, because you still need to run the proprietary driver during the recording. But if you get ahead of the game and document the protocols before the manufacturers abandon them, you stand a chance. Get recording!

ESP-Guardian

Bringing A Cloud Based Monitor Home

When setting up to grow plants hydroponically, it’s important to keep an eye on the numbers, temperature, pH, and electrical conductivity, to name a few. To do this, [Joziti] bought a Bluelab Guardian monitor, which worked well but had a fatal flaw: it required an internet connection. To free the Guardian from the cloud, [Joziti] developed an ESPHome connection for the Bluelab Guardian.

As far as hardware projects go, this one is pretty straightforward. It involves replacing the built-in wireless chip with an ESP32-S3. [Joziti] used an Adafruit ESP32-S3 Feather, though other ESP32-S3s should work for this purpose too. Once you’ve opened up the Guardian and removed the factory Wi-Fi board, it’s a simple matter of tapping into the +5V/GND/TX/RX pins with your flashed ESP32-S3. Once the hardware is in place, the ESP32-S3 should be reaching out to your Home Assistant instance with all the data the Guardian used to send to the cloud is now sitting on just your local network.

The great part about this hack is that it opens up even more capabilities for your growing setup. With the data sitting in Home Assistant, you can now control automations using that data. Too cold? Flip on some lights. pH out of bounds? Maybe have it send you a message to check it out. Thanks for sharing this improvement on a product, [Joziti]. It’s always great to see a hack that turns a product you bought into a product you own. Be sure to check out some of our other ESPHome hacks we’ve featured over the years.

RPN Loved Honk If (or, Write Your Own PostScript Interpreter)

Maybe you like old laser printers. Maybe you were a fan of [Don Lancaster]. Maybe you like Forth, HP calculators, and everything RPN. Whichever it is, why not write your own PostScript interpreter? That’s what [beyondloom] did (and we shamelessly stole their joke for the post title, too).

PostScript started out as a language to describe pages for laser printers but went on to have a life of its own, including a stripped-down version being at the core of PDF files. If you are a fan of RPN, you’ll love PostScript, which operates on several stacks.

Continue reading “RPN Loved Honk If (or, Write Your Own PostScript Interpreter)” →

DIVINER: Occult Synth Firmware For The Cardputer

We see some strange software around these parts, but this is probably the strangest. DIVINER is a firmware for the M5 Cardputer, which is an interesting device in its own right, being essentially a tiny ESP32-S3 dev kit with an even tinier screen, keyboard, some GPIOs, I2C, and an audio jack for output. It is essentially a blank canvas that can do anything if you write the firmware for it.

And that’s what DIVINER does: a little of everything. It’s part standalone synthesizer and sequencer, taking advantage of the I2S audio out, part visualization engine, part WiFi and Bluetooth scanner and monitor (what?), with an LLM interface and an IR blaster thrown in for good measure. [voidrane Splicer] even explores the Channel-State Information to do presence detection, like we’ve seen recently elsewhere. Byte-beat player anyone?

The Hackaday.io page talks about the underlying system layer before it even gets to the applications, and we get the feeling that all of the different apps, called “rites”, were crammed in to exercise it and show off the “blood and ember”, Diablo-esque visual style. But that doesn’t stop us from enjoying the audio engine, demonstrated in the video below, or the awesome graphics.

Do these apps hang together more than visually? Do they need to? Is the sum of the parts so large that you don’t even worry about the whole? We don’t know, but it’s also got a simulator so you can try that out while your Cardputer is shipping.

Continue reading “DIVINER: Occult Synth Firmware For The Cardputer” →