The Case Against Calibration Cubes

Calibration cubes have long been a staple for testing and adjusting 3D printers, but according to [Stefan] of CNC Kitchen, they’re not just ineffective—they could be leading us astray. In the video after the break he explains his reasoning for this controversial claim, and provides a viable alternative.

Such cubes are often used to calibrate the steps per millimeter for the printer’s steppers, but the actual dimensions of said cube can be impacted by over or under extrusion, in addition to how far the machine might be out of alignment. This can be further exacerbated by measuring errors due to elephant’s foot, over extruded corners, or just inaccuracies in the caliper. All these potential errors which can go unnoticed in the small 20 x 20 mm cube, while still leading to significant dimensional errors in larger prints

So what’s the solution? Not another cube. It’s something called the “CaliFlower” from [Adam] of Vector 3D. This is not a typical calibration model — it’s carefully designed to minimize measurement errors with ten internal and external measuring points with stops for your calipers. The model costs $5, but for your money you get a complete guide and spreadsheet to calculate the required of corrections needed in your firmware or slicer settings.

If you regularly switch materials in your 3D printer, [Stefan] also advises against adjusting steps per millimeter and suggests defining a scaling factor for each material type instead. With this method validated across different materials like PLA, PETG, ABS, and ASA, it becomes evident that material shrinkage plays a significant role in dimensional inaccuracy, not just machine error. While [Stefan] makes a convincing case against the standard calibration cube for dimensional calibration, he notes that is is still useful for evaluating general print quality and settings.

[Stefan] has always done rigorous testing to back his claims, and this video was no different. He has also tested the effects of filament color on part strength, the practicality of annealing parts in salt, and even printing custom filament.

Continue reading “The Case Against Calibration Cubes”

Hackaday Prize 2023: Over-the-Top Programmable Resistor Looks The Part And Performs

Every once in a while we get wind of a project that we’re reluctant to write up for the simple reason that it looks too good to be true. Not that projects need to be messy to be authentic, mind you, but there are some that are just so finished and professional looking that it gives us a bit of pause. [Sebastian]’s programmable precision resistor is a shining example of such a project

While [Sebastian] describes this as “a glorified decade resistance box,” and technically that’s exactly right — at its heart it’s just a bunch of precision resistors being switched into networks to achieve a specific overall resistance — there’s a lot more going on here than just that. The project write-up, which has been rolling out slowly over the last month or so, has a lot of detail on different topologies that could have been used — [Sebastian] settled on a switched series network that only requires six relays per decade while also minimizing the contribution of relay contact resistance to the network. Speaking of which, there’s a detailed discussion on that subject, plus temperature compensation, power ratings, and how the various decades are linked together.

For as much that’s interesting about what’s under the hood, we’d be remiss to not spend a little time praising the exterior of this instrument. [Sebastian] appears to have spared no expense to make this look like a commercial product, from the rack-mount enclosure to the HP-esque front panel. The UI is all discrete pushbuttons and knobs with a long string of 16-segment LEDs — no fancy touch-screens here. The panel layout isn’t overly busy, and looks like it would be easy to use with some practice. We’d love to hear how the front and rear panel overlays were designed, too; maybe in a future project update.

This honestly looks like an instrument that you’d pay a princely sum to Keithley or H-P to own, at least back in the late 1990s or so. Kudos to [Sebastian] for the attention to detail here.

Learn How Impossibly Close-fitting Parts Are Actually Made

Most of us have seen those demonstrations of metal parts that mate together so finely that, once together, they have no visible seam at all. But how, exactly, is this done? [Steve Mould] has a video that shows and explains all, and we’ve never seen the process explained quite like he does.

The secret ingredient is wire EDM, or Electrical Discharge Machining, but that’s only one part of the whole. Wire EDM works a bit like a hot-wire cutter slicing through foam, but all by itself that’s not enough to produce those impossibly close-fitting parts we love to see.

EDM is capable of astounding precision in part because — unlike a cutting tool — nothing physically contacts the material. Also, there isn’t a lot of friction and heat causing small distortions of the material during the machining process. EDM is as a result capable of fantastically-precise cuts, but not invisible ones.

It’s pretty neat to see a water jet used to thread the fine wire through the workpiece.

In all good manufacturing, the capabilities (and limitations) of the tool are taken into account, and this is also true for making those close-fitting pieces. The hole and plug are actually made in two separate stages.

The hole is cut separately from the plug, and because EDM is capable of such finesse, the cuts can be made in such a way that they complement one another with near-perfection. After that, grinding and polishing takes care of the surface finish. The result is the fantastically-smooth and apparently seamless fitment we like so much.

The video is embedded below, and there are some great details about EDM and how it actually works in there. For example, we see how a wire EDM machine can use a jet of water to help thread the wire through a hole in the part to start a job, and we learn that the wire is constantly moving during the process.

As cool as wire EDM is, it is not magic and we’ve seen some pretty remarkable efforts at bringing the technology into the home workshop.
Continue reading “Learn How Impossibly Close-fitting Parts Are Actually Made”

Metric And Inch Threads Fight It Out For Ultra-Precise Positioning

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.

Continue reading “Metric And Inch Threads Fight It Out For Ultra-Precise Positioning”

The Inner Machinations Of The Arduino Are An Enigma

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.

Diagram of the LTC protocol, showing the difference between 1 bits and 0 bits - both transmitted using one up and one down pulse, but with '1' bit pulses being half as short.

Animate Arcane Protocols With Interrupt-Backed Bitbanging

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.

Continue reading “Animate Arcane Protocols With Interrupt-Backed Bitbanging”

A graph visualising approximation errors - the specific principle pictured is described well by the linked article

Time And Accuracy In Las ATMegas

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.