TechyMagThings

Magnetic fields are all around us. We can’t really feel or see them ourselves, per se, but we can map them with the right hardware, like this device built by [edosari50].

The build uses an ESP32 microcontroller, which is built on to a board with an integrated 4.3″ touchscreen LCD. It’s paired with an Arduino Nano, which does the work of actually talking to a pair of EMS100 Fluxgate magnetic sensors. The slower, less capable Arduino handles the low-level chatter and then passes the readouts to the ESP32 over a UART connection. Power is courtesy of a pair of 18650 lithium-ion cells, and a XL4005 DC-DC converter. A lithium-ion charging module is on hand to keep the batteries topped off safely.  Scan results are visualized on the device itself using a heatmap representation, and can also be exported to SD card for later analysis if so desired.

Unless you’re in the geological field or otherwise hunting for stuff underground, this probably isn’t a tool you’ll have a lot of use for. However, if you like finding magnetic anomalies and investigating them, it might be very much in your wheelhouse. We’ve featured other tools for magnetic visualization before, too. Video after the break.

Even [maurycyz] doesn’t think it is a good idea, but it is possible to use an AVR 8-bit CPU to serve web pages. Of course, it is a vastly simplified web server, but it does serve pages — OK, technically just one page — to the public Internet.

Working backward, it is fairly easy to get the microcontroller to note an HTTP request and then simply spit out a prerecorded HTTP response to provide the page. The hard part is connecting the little processor to the network. The server is dead simple, just a CPU and a scant number of components like filter caps and LEDs. The trick is to use SLIP, an ancient protocol used to connect dial-up modem terminals to the network.

Linux supports SLIP, so the MCU connects to a Linux computer via SLIP. Then the Linux computer uses WireGuard to network with the remote web server that serves [maurycyz’s] site. The SLIP implementation assumes that IP packets aren’t fragmented, which is normally true these days. TCP was a bit more complicated since you have to track the connection state and possibly re-transmit lost packets. Still, nothing the AVR with 8 K of RAM and 64 K of flash can’t handle.

Practical? No. Cool? Sort of. Funny that a disposable vape has more CPU power. Of course, something like an ESP32 is an obvious choice.

One of the problems with good science fiction is that it introduces us to all kinds of cool devices that we can’t actually have in real life. [Huy Vector] has tried to fix that a little with this fantastic smartwatch build inspired by everybody’s favorite wrist computer from the Fallout series.

The build is based around a Xiao ESP32-S3 board, which hosts the capable microcontroller and has all that useful wireless connectivity built in. It’s hooked up to a MAX30102 heart rate sensor to collect the wearer’s vital signs, as well as a 1.54″ LCD screen for displaying the fantastic Pip Boy themed interface. Power is courtesy of a small lithium-ion cell tucked in behind the display. A little copper tubing and brass hardware helps tie everything together, with the latter serving as capacitive touch points for controlling the device. A simple leather watch strap completes the build.

It’s a bit of a diversion from the classic Pip Boy design, in that it’s a small smartwatch instead of a chunky device that takes up most of the wearer’s forearm. However, this isn’t so bad in reality—it’s far more practical while still rocking those classic green-on-black graphics that we all love so much.

If you’re craving a more authentic Pip Boy recreation, we’ve featured a few of those, too.

Everyone loves those rather bouncy wooden lounge chairs that got popularized by a certain Swedish seller of furniture, but as tough as they are, the laminated wood can still break at some point. The chair that [John’s Furniture Repair] got in for repair had cracked right around where a bolt hole had been drilled, apparently creating a weak spot that over the years turned into a crack.

The way to fix this issue is to recreate the one piece of curved, laminated wood as demonstrated in the video. This starts with tracing the contours of the original part on a piece of MDF, which then gets doubled up by a second plate of MDF. After cutting out the contours this then creates the two halves of a mold for the laminated part.

Next is preparing the layers of wood that will become the new part, making sure to keep the same final thickness as the original. With everything glued up the layers are put into the mold, clamped down and the glue left to dry.

Finally, the part is freed from the mold, cut to its final size, and sanded down to prepare it for final treatment and installation on the lounge chair. Perhaps the only negative one can say about this kind of fix is that after you’re done, you really get that itch to sand down and re-lacquer all of the other parts as well so that they also look new and shiny.

Like many people who read Hackaday, we are fairly fluent in a number of computer languages, but we have to admit it is easier to pick up languages that look like they group with things like Fortran. Sure, modern languages have all sorts of features, but the idea that you have a text file that executes in some order, variables, statements, and so on runs through most popular languages, but not all of them. Lisp and its variants are a different way of looking at things. And then there’s Prolog. [Alexander Petros] has an interesting way of explaining Prolog as a Pokémon game.

Prolog was “the next big thing” when AI meant expert systems. It is more of a specialized database where you define facts and rules that the computer can infer answers to queries. For example, if the facts say that Paul and Anna both have Mary as a parent, and a rule says that people with the same parent are siblings, then a query asking whether Paul and Anna are siblings will indicate that they are.

How does this relate to Pokémon? The classic card game pits teams of different characters against each other, and each has particular traits and moves. Prolog is well-suited to expressing situations like this, where there are many facts and rules about how they relate to one another.

In the example, characters like Bulbasaur and Squirtle are known to be pokemon. Each character can have one or more types (e.g., Bulbasaur is both a grass and poison type). Then, rules can define things like the types of moves and traits each character has. The way Prolog works, you can provide a variable as part of a query and get lists of matches, much like a database.

We didn’t see [Alex] mention the cut operator, and many people do not like to use it. There are probably other parts of Prolog left out, too, like backtracking. However, this is as good a place to start as any, and the example is exactly the sort of problem that Prolog is good at.

If you really prefer C, you can mix C and Prolog. We can’t imagine how it worked, but there was even a computer with a Prolog operating system.

Electroplating 3D prints is a good way to get a pretty nice coating on even a basic PLA part, but generally you’re expected to dunk the entire part into a big vat with electrolyte after coating it with the requisite conductive paint layer. This is great for small parts, like a ring you’d put on a finger, but gets rather silly when it’s a much larger part, such as the one in [Hendrik]’s recent video. Out of curiosity he tried to see whether rotating the part through a much smaller vat would still get you an even coating, or not.

Perhaps ironically this process required building a custom vat out of acrylic, as well as an entire rig to hold up the part and gently rotate it. This highlights the main disadvantage of this approach, in that unless you’re doing a small production run or otherwise get to re-use the rig a lot it’s a lot of extra effort.

That said, the rotation is controlled by an ESP32 and a stepper motor along with a requisite stepper driver, with the most exotic part being the whole custom PCB and enclosure, all of which can be used repeatedly. With all of that tested and confirmed working, the part to be plated was sanded, sprayed with conductive paint and hooked up to the rotating rig for an overnight run.

Following that the part’s new copper coating was polished before more layers of electroplating were applied to get the desired two different colors from different metals. Along the way no issues were found with this method of rotating electroplating, so if you regularly struggle with oversized parts to electroplate, this would seem to be a viable method.

You could make a clock with three hands spinning about nested central shafts. If you did that, we probably wouldn’t publish it on Hackaday unless you really found a way to make it interesting. Make a clock out of voltmeters, however, and that usually catches our eye. [lcamtuf] has done just that.

The heart of the build is an AVR128DB28 microcontroller, an 8-bit microcontroller that is still currently in production. It runs at 8MHz, and drives a series of three Baomain 65C5 voltmeters to display hours, minutes, and seconds. Each has a custom printed face with the correct number of 13 or 61 divisions as needed. The voltmeters are driven by a continuous stream of 1-bit pulses with a software-controlled duty cycle determining exactly how far the needle moves. Yes, it’s using simple pulse width modulation, coded by hand by [lcamtuf] to do the job. All the components are wrapped up in a beautiful wooden case, with delicately kerf-bent panels to create the attractive curved lines.

We’ve featured similar builds before, too. As it turns out, hackers just really love clocks and old-school dials. Video after the break, which is worth watching for the rollover behaviour alone.