When you’re a machinist, your stock in trade is precision, with measurements in the thousandths of your preferred unit being common. But when you’re a diemaker, your precision game needs to be even finer, and being able to position tools and material with seemingly impossibly granularity becomes really important.
For [Adam Demuth], aka “Adam the Machinist” on YouTube, the need for ultra-fine resolution machinist’s jacks that wouldn’t break the bank led to a design using off-the-shelf hardware and some 3D printed parts. The design centers around an inch-metric thread adapter that you can pick up from McMaster-Carr. The female thread on the adapter is an M8-1.25, while the male side is a 5/8″-16 thread. The pitches of these threads are very close to each other — only 0.0063″, or 161 microns. To take advantage of this, [Adam] printed a cage with compliant mechanism springs; the cage holds the threaded parts together and provide axial preload to remove backlash, and allows mounting of precision steel balls at each end to make sure the force of the jack is transmitted through a single point at each end. Each full turn of the jack moves the ends by the pitch difference, leading to ultra-fine resolution positioning. Need even more precision? Try an M5 to 10-32 adapter for about 6 microns per revolution!
While we’ve seen different thread pitches used for fine positioning before, [Adam]’s approach needs to machining. And as useful as these jacks are on their own, [Adam] stepped things up by using three of them to make a kinematic base, which is finely adjustable in three axes. It’s not quite a nanopositioning Stewart platform, but you could see how adding three more jacks and some actuators could make that happen.
Arduinos have been the microcontroller platform of choice for nearly two decades now, essentially abstracting away a lot of the setup and lower-level functions of small microcontrollers in favor of sensible IDEs and ease-of-use. This has opened up affordable microcontrollers to people who might not be willing to spend hours or days buried in datasheets, but it has also obscured some of those useful lower-level functions. But if you want to dig into them, they’re still working underneath everything as [Jim] shows us in this last of a series of posts about interrupts.
For this how-to, [Jim] is decoding linear timecodes (LTCs) at various speeds. This data is usually transmitted as audio, so the response from the microcontroller needs to be quick. To make sure the data is decoded properly, the first thing to set up is edge detection on the incoming signal. Since this is about using interrupts specifically, a single pin on the Arduino is dedicated to triggering an interrupt on these edges. The rest of the project involves setting up an interrupt service routine, detecting the clock signal, and then doing all of the processing necessary to display the received LTC on a small screen.
The project page goes into great detail about all of this, including all of the math that needs to be done to get it set up correctly. As far as general use of interrupts goes, it’s an excellent primer for using the lower-level functionality of these microcontrollers. And, if you’d like to see the other two projects preceding this one they can be found on the first feature about precision and accuracy, and the second feature about bitbanging the protocol itself.
We often take our “SoftwareSerial” libraries for granted, and don’t investigate what goes on under the hood — until they fail us, at least. Would you like to learn how to harness the power of interrupt-driven bitbanging? [Jim Mack] teaches us how to make our protocol implementations fly using the LTC protocol as a springboard.
LTC (Linear/[Longitudinal] TimeCode) is a widely-used and beautifully-crafted protocol that tends to fly under our radar, and is one that hackers could learn plenty from. It’s used for synchronization of audio/video devices during media production and playback. LTC’s signal is almost digital but not quite: it doesn’t need a clock, and it has no polarity. Additionally, it mimics an audio signal really well, you can decode it at any playback speed, and many other benefits and quirks that [Jim] outlines. You do need to maintain the timings, though, and [Jim]’s article shows us how to keep them right while not inconveniencing your primary tasks.
Do you ever have to ensure that an exact amount of time passes between two tasks in your microcontroller code? Do you know what’s the difference between precision and accuracy? Today, [Jim Mack] tells us about pushing timers and interrupts to their limits when it comes to managing time, while keeping it applicable to an ever-popular ATMega328P target! Every now and then, someone decides to push the frontiers of what’s possible on a given platform, and today’s rules is coding within constraints of an Arduino environment. However, you should check [Jim]’s post out even if you use Arduino as a swearword – purely for all of the theoretical insights laid out, accompanied by hardware-accurate examples!
This will be useful to any hacker looking to implement, say, motor encoder readings, signal frequency calculations, or build a gadget processing or modifying audio in real time. To give you a sample of this article, [Jim] starts by introducing us to distinctions between precision and accuracy, and then presents us with a seemingly simple task – creating exactly 2400 interrupts a second. As much as it might look straightforward, problems quickly arise when clock crystal frequency doesn’t cleanly divide by the sampling frequency that you have to pick for your application! This is just a taste of all the examples of hidden complexity presented, and they’re accompanied with solutions you can use when you eventually encounter one of these examples in your hacker pursuits. In the end, [Jim] concludes with links to other sources you can study if you ever need to dig deeper into this topic.
Keeping our projects true to the passage of time can be an issue, and we’ve been at it for ages – calibrating your RC oscillator is a rite of passage for any ATTiny project. If you ever decide to have an interrupt peripheral help you with timing issues, we’ve gone in-depth on that topic in the past, with a three-part series describing the benefits, the drawbacks and the edgecases of interrupts. Going for a more modern target? Our piece on using interrupts with STM32 is a great path for trying out tools of the modern age.
After pulling late hours in my school machine shop for a few years, I couldn’t help but wonder, who measures the measurement tools? How did they come to be? I’d heard anecdotes from other students and engineers while they inspected my freshly machined parts, but these stories were one-offs. What I wanted was a tale of industrial precision from start to finish. Years later, I found it.
Perhaps you’ve seen them, demonstrations of a machined piece of metal that upon further inspection is actually two pieces machined so perfectly that they appear as one. With extremely tight tolerances, it’s not possible to determine where one piece of metal ends and another begins — that is, until the secret is revealed. Inspired by such pieces of art, [Andrew Klein] sought to put this high level of machine work to practical use. And so it was that his as-yet-unnamed Screw With No Slot came to be.
The screw’s disc-like appearance looks as if it’s a metal trim piece to cover a bolt hole. But in the video below [Andrew] shows us the trick, pushing a brass rod into the middle of the disc to reveal the hidden three-point slot. The center of the disk is actually a separate bit of finely machined metal that is spring loaded to stay flush. A specially designed wrench keys into the rounded concave triangle shape cut into the face.
The wrench is made with brass to avoid marring the precision surface. It uses three magnets to hold tight to the screw’s 410 magnetic stainless steel. [Andrew] didn’t spill the beans on how this was done, but we haven’t seen any process other than electrical discharge machining (EDM) that can achieve this level of mating precision. If that topic is new to you, we recommend checking out [Ben Krasnow’s] lab experiments on the topic.
We can’t help but be taken in by the beauty of the fastener, and it immediately sent our imaginations into a National Treasure induced dream-like state. [Andrew Klein] has yet to name this fastener, and he’s soliciting ideas for names in the video below the break. If you have such an idea, you can comment on his video. He’s also exploring the viability of the as-yet-named fastener as a commercial product for high end furniture builders.
If you’ve watched as many machining videos as we have, no doubt you’ve seen someone commit the cardinal sin of metalworking: using caliper jaws to scratch a mark into metal. Even if it’s a cheap Harbor Freight caliper rather than an expensive Starrett or Mitutoyo tool being abused, derision and scorn predictably rain down upon the hapless sinner’s head.
The criticism is not without its merit, of course. Recognizing this, [Nelson Stoldt] came up with these clamp-on nosepieces designed to turn calipers into a better marking tool. Using stock calipers as marking gauges always introduces some error, since the jaws are equal lengths and thus have to be held at a slight angle to the workpiece in order to make a mark. The caliper jaws correct for this admittedly negligible error by extending one jaw, allowing it to ride on a reference face while the other jaw remains perpendicular to the workpiece. As a bonus, the short jaw has a slot to mount a steel marking knife, saving the caliper jaws from damage.
[Nelson] chose to 3D-print his caliper jaws, but they could just as easily be milled from solid stock to make them a little more durable. Then again, you could always 3D-print the calipers in the first place, and integrate these jaws right into them.