Getting good 3D prints has become easier and faster than ever. But ironically, the faster our printers become, the more important it is to properly tune the materials that we are using. If you own a Bamboo Lab machine, you are pretty spoiled in that regard. The original X1 automatically calibrated material flow using its LAR scanner, while newer machines use a different routine involving a sensor inside the hotend. Still, almost no other machines do similar calibration. But what if we can use the sensor that is already built into other printers for bed leveling to automatically calibrate pressure advance as well? And what if the same sensor could also determine maximum flow rate, detect nozzle crashes, identify partial clocks, and eventually even provide actual process monitoring for your 3D prints. I built a small tool to find exactly that out. Good tag everybody. I'm Stefan and welcome to CNC Kitchen. This video is sponsored by Zeofeld.
[00:01:00] Pressure advance is one of the most important settings on modern high-speed 3D printers. It is what prevents these ugly overextruded corners and the corresponding underextrusion after the sudden acceleration. The reason we need it is that the extrusion system behaves like a spring. Even though filament feels quite stiff, it still compresses when the extruder pushes it into the hotend. After all, a really significant force is required to squeeze molten plastic through the tiny nozzle opening. When the printer suddenly slows down, the extruder gears may stop moving, but the filament is still compressed. The start pressure continues pushing material out of the nozzle, creating an overextruded column. When the printer accelerates again, the opposite happens. Some of the extruder movement initially goes into compressing the filament and rebuilding the pressure, so the material flow briefly falls behind. On older, slower printers, this was less noticeable because speed changes happened more gradually and the extrusion rates were lower. But on modern machines, the printer constantly
[00:02:00] accelerates, decelerates, and changes directions at very high speeds. A pressure advance compensates exactly for this delayed response. During acceleration, the firmware briefly commands additional extruder movement to build up pressure more quickly. During deceleration, it reduces the extrusion amount and may even briefly pull the filament back to release pressure before the motion stops. With the correct value, the actual flow follows the commanded extrusion much more closely. But the amount of compensation needs to be tuned. If the pressure advance value is too low, the corners remain overextruded. If it's too high, the corners become underextruded instead and your parts show holes. This compensation factor is usually called pressure advance PA or the K value. Traditionally, we calibrate it by printing a test pattern. One of the simplest version consists of several lines that transition from slow to fast and back to slow again. Every line uses a different K value. Once the test is
[00:03:01] finished, you inspect the lines, select the one with the most consistent width, and enter that value into your slicer or printer configuration. There are no more practical tests that use corners or a small tower, but they all follow the same basic principle. Print at several different pressure advance values and visually select the one that looks the best. The problem is that pressure advance is not simply a setting for the printer. It depends heavily on the filament. Different polymers have different stiffnesses and also melt flow behavior. Even two colors of the same filament can behave differently because the pigments and additives change the material properties. You can often get away with using a rough value for each material type, but especially on fast prints, a value that is too far off can become clearly visible. So, ideally, you should calibrate that value before every print. This is why Bambool automated the process. The original X1 printed a small pattern containing different extrusion conditions, scanned it using their laser
[00:04:00] line scanner, and automatically calculated the optimal K value. In principle, this is very similar to our manual test, except that the pattern is more compact and evaluation is also automated. Newer Bamboo Lab machines no longer need to print the calibration pattern onto the build plate. Instead, they perform an extrusion routine in the perch area and analyze the response using a sensor in the hotend. But despite the obvious benefits, almost no other manufacturer also offers automatic pressure advanced calibration. And this [clears throat] is strange because I'm confident that several printers already include much of the same hardware that should be required. All newer Pruscha printers equipped with an extruder, for example, contain a load cell in the print head. Its main purpose currently is nozzle-based bed probing, but it can also measure the force acting on the nozzle during extrusion. So my question was very simple. Can we use that force signal to also automatically determine pressure advance? Instead of printing a calibration object, could the printer simply extrude some filament into free
[00:05:01] air, measure the response, and calculate the K value directly? That is what I wanted to find out. But before we continue, this video is sponsored by Zefeld, and this might be one of the most fitting integrations I have ever had here on the channel. You might remember that I visited Cellofel in Hamburg and made a whole video documentary of how they 3D print shoes. So, this is not just some random company I've never heard of. I know the team. I have seen their custom machines and print form in person and they are currently looking for exactly the kind of person who watches a video like this and thinks could I make that calibration even better. They are looking for a software engineer who's committed to making their machines even better. This is not just a junior position, but this could be your opportunity to turn 3D printing from a serious hobby into your actual profession. They're not looking for a generic software developer who has printed just one benie. They want a proper 3D printing nerd. Someone who has built or heavily modified a Voron printer, a rhetoric rig or a custom
[00:06:01] corxy printer, understands clipper, pressure advance, input shaping, canvas, sensorless homing and macros, and also enjoys debugging the interaction between software, electronics, and mechanics. And this is a very hands-on job. You would help shape the control architecture of Zeopel's own production printers work on dynamic Zcalibration for their custom tool changing system, closed loop failure recovery and remote diagnostics for their entire print farms. Since the engineers, production team and the machines are all together on site in Hanbul. You would not just be writing abstract code. You would improve real production hardware and software, see the results firsthand, and help shape the future of footwear manufacturing. Zefeld has secured major funding, operates large print farms in Hamburg and also in Austin, and already works with major brands and designers. So, in my opinion, if you want to turn an unhealthy interest in printer firmware into a serious career, there are very few more exciting places to do it. This is an on-site position in
[00:07:01] Hamburg, Germany, and you can find the job link in the description. And now let's return to exactly the kind of automation and sensor challenges for which they would like to have someone to solve and implement it. The first printer I looked at was actually not the Pusche, but the Snapmaker U1. The U1 is basically what you might get if a Prusche XL and a Bamboo Lab X1 had a baby. And it also performs automatic pressure advanced calibration by purging filament using a repeated slow fast slow extrusion pattern. During this routine, the printer varies the K value and monitors the response using a sensor inside the tool head. The interesting part is that the U1 runs clipper based firmware and much of its code is publicly available. So in principle, this could provide some insight in how their automatic calibration works. The test commands themselves are visible. We can see the slow fast slow extrusion pattern, the tested K values, and the sensor data being collected. But part of the final evaluation appears to happen
[00:08:00] in a separate process that is not part of Clipper and therefore I also don't have any code for it. So we can observe what the printer does but we cannot exactly see how it converts the sensor signals into the data that is used to determine the K value. So let's simply try to look at the data ourself and see if we can figure it out. Unfortunately the U1 also does not provide convenient access to its life sensor data. But as I said before, newer Pruscha printers have a very similar load cell arrangement, and Pruscha provides an open metrics interface that lets us monitor the nozzle force signal remotely. You enable the metrics in the printer's network menu, choose which data you want to transmit, and send it to a monitoring application on your computer. After a little configuration, you can access a surprising amount of live information from the machine, including the nozzle load cell. I'm not trying to shill for puscha here, but for this kind of research, this is genuinely useful. So, I build a small web interface that connects to the printer and records the
[00:09:00] load cell data. When I tap the nozzle, a force spike immediately appears in the graph. And when I extrude filament, the sensor shows how much force is acting on the hotend assembly while the material is pushed through it. For the calibration test, the printer repeatedly switches between a low and a high extrusion rate. The commanded extrusion speed therefore looks like a square wave. I have a ton of measured data, but it's easier to explain the effect in this schematic animation. Now, let's look at the measured force response without any pressure advance. At the low extrusion rate, the force settles at a relatively constant level. When the printer suddenly switches to the higher rate, the force starts increasing, but it does not rise instantly. It gradually approaches the new steady state value. When the extrusion rate drops again, the force also takes a bit of time to fall back down. This delay is exactly the representation of the same behavior that causes under and over extrusion during a print. The commanded extrusion rate has already changed, but the mechanical pressure inside the extrusion system is
[00:10:00] still catching up. Now we gradually increase the pressure advance value. Pressure advance adds a short burst of extruder movement during the acceleration and removes extrusion during the deceleration. As the K value increases, the measured force response begins to follow the commanded square wave more closely. The rising and falling edges become steeper and the delay becomes smaller. At some point, the compensation is almost perfect. The force quickly reaches the new steady state value without a large delay or an overshoot. But if we increase K even further, the compensation becomes too aggressive. During the transition to the higher flow rate, the force briefly rises above the steady state level. And during the transition back to the slow rate, it drops below it. So we get three characteristic responses. With K too low, the force response is slow and rounded. With a good K value, it closely follows the commander change. And with K too high, the response overshoots and undersshoots. My assumption is that the automatic calibration system analyzes
[00:11:01] these differences and selects the K value that produces the best response. To test this idea, I created a web-based tool that automatically prepares and runs the calibration. You select the desired nozzle temperature and then start the test. The tool generates the G-code, sends it to the printer, and begins recording the load cell data. The printer heats up, moves to a safe position, and extrudes filament into free air using the slow fast slow pattern while stepby step increasing the K value. Once the sweep is complete, the tool separates the individual test sequences and calculates several metrics for each K value. These include the overshoot after acceleration, the undershoot after deceleration, the slope of the rising and the falling edge, the settling behavior, and the total area between the measured force response, and an ideal square wave. At first, I expected that the total error area, so how far we deviate from the ideal curve to be the best metric because this is what I think the U1 uses. But in
[00:12:01] practice, this did not give me the most reliable results. One major problem besides regularly some missing data could be timing. The Pusche metric interface gives me the load cell signal, but it does not provide the exact extrudal position, which means I don't know when exactly we start and stop extruding. So my tool needs to estimate when each extrusion transition begins and ends using the available data. Even a small timing offset can significantly change the calculated deviation area. This would be much easier if the analysis ran directly inside the printer firmware because the firmware knows exactly when each extrusion command is executed. So surprisingly the most useful metric in my test was much simpler and that was the undershoot after switching from fast extrusion back to the slow extrusion. With low K values, the force decreases towards the near steady state value but doesn't fall below it. As K increases, the response becomes faster. But once the compensation becomes too aggressive, the measured force briefly drops below the
[00:13:01] steady state level. That undershoot is a clear indication that the K value is now too high. So instead of trying to mathematically find the perfect square wave, I can look for the point where compensation first becomes too excessive. The selected value is the final K value before a clear undershoot appears. And that was a much more robust signal in my current setup. But a calibration graph can look convincing and still produce horrible results. The important question is if the automatically selected value agrees with the traditionally printed calibration. So I tested several different materials. For each one, I first printed a conventional pressure advance test and manually selected the value that looked the best. I then ran the automatic calibration and compared the results and those results were surprisingly close. The pattern test is here our ground truth or what I would have selected if I would have printed a manual test. Depending on the material, the automatically selected value was either exactly where I would have placed it
[00:14:00] manually or slightly higher. Only the hot printed ASA was a bit more off. That does not mean that the method is finished or universally reliable. At the moment, my sample size was still limited, and there definitely needs to be more work tuning the weights and the method. And who even says that a perfect square wave false response produces the best print results. Interestingly, the U1 also has fallback values if the test looks odd. I have even heard people put tape over their lighter scanners on the X1 and also still got good results. So good default values are definitely a reasonable starting point, but with the data that we get, we could further refine them and improve the overall result and we can do that without printing a calibration object. The test only needs to extrude a relatively small amount of filament into free air and the evaluation can happen automatically. My web tool is not yet a replacement for a properly integrated firmware implementation. And the biggest limitations come from retrieving and
[00:15:00] synchronizing the sensor data externally. But as a proof of concept, in my opinion, it still works remarkably well. And because this project is free and open source, you can try it out yourself and help improve the analysis and potentially implement it somewhere else or at least get yourself inspired. But pressure advanced calibration is also only one possible application of the sensor. The next obvious one is maximum volumetric flow. I have previously used a separate load cell test rig to study extruders, nozzles and different filaments. When the extrusion rate increases, the required force also rises. At some point, the hotend can no longer melt and move the material reliably. The force response becomes unstable, rises sharply, and begins deviating from the expected behavior. With a load cell already built into the print head, the printer could perform a flow rate sweep automatically. It begins at a low extrusion rate, gradually increases it, and then determine the maximum stable flow for the exact combination of material, temperature, nozzle, and hot end. That would be far more useful than relying on a generic
[00:16:01] maximum flow value for an entire material profile or constantly printing test parts. And if you want to try it out, this test is also already implemented in my web tool. Because the Puscha load cell arrangement is sensitive not only to vertical forces but also to lateral loads, the nozzle could potentially also probe geometric reference features on the print bed. In principle, this would allow the printer to measure whether its X and Y axis are truly perpendicular and for example detect skew automatically, for example, after the coaxy belts have been adjusted. Pusche already uses the lateral nozzle contact when calibrating the tool position on the XL. So the basic capability is already here. I do not claim that all of these ideas can be implemented reliably tomorrow, but they demonstrate how much information may be hidden inside a sensor that is currently used almost exclusively for bet probing. And this leads also to a much bigger topic, and that's process monitoring. 3D printers are increasingly being used for real production parts, but our quality
[00:17:02] control is still surprisingly primitive. Most of the time we look at the outside of a finished part and decide whether it appears acceptable. But an internal extrusion defect can cause a structural or even a functional failure even when the exterior looks completely fine. So imagine receiving a process report after every print. The machine could confirm that the nozzle and the bed temperatures remained inside their specified window. It could report whether the extrusion response remained stable and whether there were signs of a collision or a partial clog. A nozzle force sensor alone cannot guarantee the quality of a finished part, but combined with the data that the printer already has, it could provide far more insight than we currently get. This is why I think these sensors are still extremely underutilized. Puscha has included a nozzle load cell in its machine for more than 3 years, but its main job is still simply to touch probe the build plate. My relatively simple experiments have shown that the same hardware could
[00:18:00] potentially calibrate material and monitor the printing process. Fortunately, there are already some other projects moving in this direction. During my research, I came across BD pressure from Panda Pi3D. It combines a nozzle force sensor with a Clipper plugin that performs automatic pressure advanced calibration. Then there's also the Amplify hotend which is expected to come to market later this year. It uses Revo nozzles and also includes an integrated load cell. So it may be able to use a similar approach. And then of course we have the Snapmaker U1 which already performs a false-based automatic calibration even though part of the evaluation algorithm is not visible in the public available code. But still the concept clearly works. The remaining challenge is making it reliable across different printers, hotends, nozzles, temperatures and materials. But finally, there is the question why automatic material calibration is still not more common. Initially, I assumed that manufacturers simply had not invested enough time into developing a robust
[00:19:00] algorithm, but during my research, I came across several patents from Bamboo Lab in that regard. A quick disclaimer here, I'm not a patent lawyer and none of this is legal advice. But for the camera or patentbased calibration approach, Bamboo Lab appears to have active patent protection in China, the United States, and Europe. This means another manufacturer may not be able to simply recreate the X1 calibration system without considering those patterns. For the force-based calibration approach, it appears to be slightly different. The method is patented in China, but the related international application currently as of July 2026 appears not to have been pursued successfully in Europe. I don't know why, and the legal situation may be more complicated than simply searching for one patent family, but it leaves at least some hope that similar false-based calibration systems could appear in more machines or eventually become a standard feature in open-source firmware such as Clipper. Patents are always a controversial topic, but honestly, Bambool has a legitimate commercial
[00:20:01] interested in protecting the technology it developed. While the rest of the industry would obviously benefit from a wider access to automatic calibration routines, I'm not going to resolve that debate right here, but I will continue following the pattern situation on this specific topic and let you know if anything changes. For me, the most important takeaway from this experiment is that the necessary hardware may already be inside of our printers. The load cell that touches the bed can also observe what's happening during extrusion. With the right test, the right algorithm, it can estimate pressure advance, potentially determine maximum flow, and provide valuable information about the printing process. My current web-based tuner is not perfect, and this functionality would ultimately work much better inside the printer firmware, but it demonstrates that smarter software can unlock entirely new capabilities from sensors that we already have. You can find the complete project free and open source on my GitHub. And if you are already a Clipper and 3D printing expert looking
[00:21:01] for a new challenge in exactly this field, check out the Cellofel job offering linked below. Thanks for watching everyone. I hope you found this video interesting. If you want to support my work, head over to Patreon or become a YouTube member. Also, check out the other videos in my library. I hope to see you in the next one of and goodbye.