Building An M7 Pan Tilt Head Controller

October 15, 2026 by Zoe Skyforest No comments

The Soonpho M7 Pan Tilt Head is a useful photography tool for remotely aiming a decently-sized camera. Only, [Kyle Housley] wanted a little more control than was available out of the box. Hence, he built a custom controller that could deliver just that.

The project is based around an ESP32-S3 paired with an NRF24L01 wireless module. The ESP32-S3 is hooked up to a computer to receive commands over serial on what movements to make. It then transmits over the NRF24L01 to another NRF24L01 module that has been hacked into the original M7’s controller. In doing so, it can command the M7 to move to a given specific pan and tilt position, or to make a smooth motion along a vector. It can also trigger shutter release in the attached camera as needed, to capture whatever is being looked at.

[Kyle] has used this rig to create a motion tracking system for aircraft photography. With a Yolo vision model running on a laptop, the pan-tilt head can be commanded to track aircraft passing by and photograph them when they’re in frame. It’s a pretty slick setup; we’d love to see similar done with the aid of ADS-B data, too—perhaps even with automatic image tagging and upload. Continue reading “Building An M7 Pan Tilt Head Controller” →

Hackaday Links: September 27, 2026

September 27, 2026 by Al Williams 7 Comments

It isn’t quite hailing frequencies open, but researchers from Harvard claim they’ve picked up a radio signal directly from a nearby exoplanet. Before you get too excited, planets in our solar system also emit RF, so no one credible is claiming these are extraterrestrial reruns of their version of I Love Lucy, but it is the first time they’ve localized a radio signal to an exoplanet, in this case, Beta Pictoris B.

Speaking of space, the asteroid formerly known as 1981 EC26 is now sporting a new moniker: (14331) Alyankovic. If you think that sounds like (Weird) Al Yankovic, you aren’t wrong. The Tucson Star reports that, thanks to the efforts of several planetary scientists who are also Weird Al fans, the International Astronomical Union made the name official. Apparently, another asteroid now bears a name in honor of Weird Al’s predecessor, Tom Lehrer.

If you follow open mobile phone software, you probably know the name postmarketOS, a Linux distribution based on Alpine aimed at mobile phones and tablets. Well, now you can forget it. The project announced a name change, so we’re now talking about Nura. Why Nura? According to the team, it is a shortened form of Nuraghe, some granite structures in Sardinia that are over 5,000 years old. The FAQ mentions that postmarketOS was hard to remember. We aren’t sure Nura is that much more memorable. Perhaps they should have pivoted to Phonz OS.

Continue reading “Hackaday Links: September 27, 2026” →

Going On A Tangent With The Intel 8087’s Hybrid CORDIC Algorithm

September 27, 2026 by Maya Posch 4 Comments

Continuing their reverse-engineering of Intel’s 8087 FPU, [Ken Shirriff] and friends took a look at one of the trigonometric functions, specifically FPTAN. The most exciting part with such reverse-engineering is probably figuring out which algorithm was used in the implementation, while trying to determine the reasoning behind the final hardware design.

If you’re running a simple MCU or MPU like the 6502 or Z80 without hardware functions you’d likely use an algorithm such as CORDIC or similar, as this requires only basic hardware features like addition, subtraction, bitshift, and look-up tables. One can also use polynomial approximation if there’s hardware support for a potential speed-up, or as is the case in the 8087, create a hybrid approach that targets speed and accuracy.

In the article the exact implementation to get to 64 bits of accuracy is detailed, starting with the 16 bits calculated using CORDIC before switching to the Padé approximant technique involving the ratio of two polynomials. Since after calculating the brunt of the final value with CORDIC the remainder is a fairly small value, this polynomial approximation is not just very accurate but also fast.

This approach allows the FPTAN and similar trigonometric functions in this FPU to hit a very high level of accuracy and not require the look-up table sizes and additional time required to work through the remaining bits with CORDIC. For those who want to see the full algorithm Intel’s engineers used, [Ken] has the full microcode listing with comments in the article as well.

As for the exact speed-up from this approach, [Ken] calculates for one value that FPTAN would spend 33% on CORDIC pseudo-division, 47% on CORDIC pseudo-multiplication and a mere 15% on the polynomial approximation along with about 5% overhead.

With the Pentium series of CPUs Intel moved completely away from CORDIC, as it’s clear that as accurate as it may be, it’s hard to scale to a significant number of bits without incurring significant time penalties. With the introduction of SIMD instructions the x87 ISA has further seen its functionality reduced, but this analysis shows once again why the 8087 made such an impact when it was released.

A 7-Segment Clock Built With No Digital Electronics

September 24, 2026 by Zoe Skyforest 29 Comments

If you wanted to build a clock with a 7-segment display, there are a wide variety of ways you might go about it. You could grab some 74-series logic chips and create a whole bunch of counters and decoders to drive the display, or you could wire up a microcontroller with an RTC and have it do the hard work. Or, as a Japanese company once did… you could create a “digital” looking clock with no digital electronics whatsoever.

The geared mechanism and switch contacts are visible; they switch the neons of the various segments on and off at the correct times. Credit: YouTube video

[Mark Furneaux] set about tearing down a Lumitime clock, built by the Japanese company Tamura. From the outside, it appears to be a rather stylish digital clock, with a bold red 7-segment display lit with neons. And in some regards, it is. Only, the secret of this clock is that it doesn’t use digital electronics to do the job. There are no counters inside, no real-time clock module, no transistor-based logic chips doing the counting with the output of a 32.768 KHz crystal. Instead, a motor drives a series of gears that turn metal plates that move under sliding finger contacts. The gear train and the metal plates are designed such that the contacts turn the various segment neons on in the correct sequence to display the current time. It’s like a player piano, only instead of playing a tune, it’s switching the segments of a display on and off to display the right numerals at the right time.

It’s a neat way to do a “digital” clock from an era when proper digital electronics were still very expensive. We’ve seen all kinds of whacky 7-segment clocks before, too, like this amusing water-based build. Video after the break.

Continue reading “A 7-Segment Clock Built With No Digital Electronics” →

Hackaday Podcast Episode 387: Superhuman Clocks, CAN In USB-C, And The Joys Of Bare Metal

September 18, 2026 by Tom Nardi 1 Comment

This week, Hackaday Editors Elliot Williams and Tom Nardi start the episode off by discussing the latest CircuitPython developments before covering some impressive reverse engineering efforts, the benefits of modeling your projects in 3D, and some of the most incredible timepieces that have ever graced the pages of Hackaday.

You’ll also hear about the fascinating potential of combing 3D and UV printing, Linux on the ESP32, and a virtual TV station that pulls from the Internet Archive. The episode wraps up with a Hackaday Europe double-feature: one talk extols the virtues of keeping things simple through bare metal development, while the other covers off-world hacks and fixes that will make you want to sign up for Space Camp.

Check out the links if you want to follow along, and as always, tell us what you think about this episode in the comments!

Direct download, the MP3 way.

Continue reading “Hackaday Podcast Episode 387: Superhuman Clocks, CAN In USB-C, And The Joys Of Bare Metal” →

Analyzing The FScale Instruction In Intel’s 8087 FPU

September 13, 2026 by Maya Posch 6 Comments

During his continuing analysis of the architecture and microcode of Intel’s highly influential 8087 floating point unit (FPU) co-processor, [Ken Shirriff] has now arrived at the point where he can put together how the 8087’s microcode implements various x87 instructions. One of these, the FSCALE instruction turned out to be far more complicated than assumed, with one might assume to be a straightforward powers-of-two scaling turning out to entail over 140 micro-instructions and three levels of sub-routine calls just to handle all cases.

The annotated die shot in the heading image shows the functional blocks that are used by this one x87 instruction, to give some kind of idea of what amount of hardware even ‘just’ scaling a floating point number involves.

Much like with the x86’s CISC-style ISA, these 8087 instructions break down into individual steps that involve everything from loading values into registers, performing operations, checking for and handling error conditions as well as stack management. As can be seen in [Ken]’s breakdown of the FSCALE implementation in the 8087 it’s all very logical, taking a high-level instruction and doing all that’s needed for a robust implementation, without bothering the developer with the details.

Of note is that the 8087’s implementations led to the IEEE 754 floating point standard, providing what definitely at the time was one of the most mathematically accurate FPUs that somehow still was financially responsible enough to make it into a relatively affordable PC.

FLOSS Weekly Episode 879: Easy Like Butter

August 26, 2026 by Jonathan Bennett No comments

This week Jonathan chats with Nathan Freitas of the Guardian Project! What is going on at the forefront of Open Source and privacy advocacy? Where are we on a true Tor browser on iOS? And what’s the ideal solution to the Android Lockdown issue? Watch to find out!

Continue reading “FLOSS Weekly Episode 879: Easy Like Butter” →