5 Model-Based Control of FFF 3D Printers
5.1 Introduction
I discussed in Chapter 1 how machine control is fundamentally a constrained optimization problem. We want machines to work quickly and precisely, but their operation is constrained by machine and material physics. In the state-of-the-art we must intuit these constraints and then estimate which process and control parameters will prevent the machine from violating them; see the CAM primer 1.2, these parameters are exposed in 3D printing within softwares called slicers that turn 3D models into machine instructions (GCodes). The proposal in this thesis is that we can instead articulate constraints using mathematical models of machine operation and then use those models either directly (making the optimization explicit) or indirectly (to better inform our intuition). In addition, we can make models using the machines themselves rather than going through longer metrology loops.
In the last chapter I explained how models for motion can be developed using a machine’s own actuators and then showed how to deploy those models directly in an optimization based motion controller; doing so makes for faster machines and provides feedback that we didn’t previously have access to. This improvement to motion control is valuable primarily to machine builders (who must tune their machines), but also to users who would like to run their hardware closer to its real physical limits. I also showed how exposing machine controllers’ hidden motion optimization (1.3.3) can provide more direct feedback to machine users about how their chosen CAM settings will affect real-world outcomes. Section 2.7.6 describes why this is valuable in a broader systems integration and modelling context and Section 6.4.4 makes its value clear in a user-facing context to help CNC machine operators understand what their hardware will do before they run a job.
However, motion control is only half of the story for digital fabrication machines. The other half is the reason we are here: fabrication, which requires process control. This side of the problem is often directly under the purview of machine users who must tune their machines across many materials and configurations, not to mention the infinity of objects they may be trying to create. In this chapter, I will show that we can apply smarter control to one of the most ubiquitous digital fabrication processes: Fused Filament Fabrication (FFF1) 3D printing where molten polymers are extruded line-by-line (in “tracks”) that sequentially build parts (see Section 5.2.1 for a more complete explanation of the process). Applying model based methods here can make our printers faster, more flexible across materials and nozzles, and re-frames the process tuning step against machine-sourced physical constraints directly rather than as a purely guess-and-check exercise.
5.1.1 Feedforward FFF Configuration and Operation is Lossy and Limits Machines and Operators
5.1.1.1 Separating Low- and High-Level Control Configurations
In printing and in CNC machining, low-level velocity planning and control is done within GCode interpreters but process planning is done entirely within CAM configurations. However, some process physics must also be handled online. In FFF this primarily means operation of the extruder motor to manage filament compressibility as I will explain in Sections 5.2.1.1 and 5.2.3.2. Although these dynamics vary greatly depending on material and melt flow temperatures, the parameters that control them are normally set on a per machine / per nozzle basis.
The velocity planners that are used in state-of-the-art FFF printers cannot solve for nonlinear or history-dependent dynamics, the likes of which we will see are present in FFF filament flow. Nor can they integrate directly with models: we write configurations for them, which can be extracted from models as I showed in Section 6.2.2, but in common practice are often guess-and-check.
This all represents a limit for systems configuration: rather than reflecting on physical models to control hardware, we must develop piecewise heuristics, parameters and lossy algorithms that enable control of those physics in simpler systems but then require subsequent tuning across multiple internal representations i.e. some factors are exposed in slicers, others are expressed as firmware-level configurations, and others (like variable nozzle temperatures and time-dependent melt flow dynamics) are simply not possible to express given the current limitations.
5.1.1.2 Limits to Offline Preset Development
To describe how machines should use a certain material 3D printing machine and material, companies carefully develop parameter presets for use with their products that can be used to configure slicers. However, these can take lots of time to develop and limit the adoption of new materials and machines. For example there are thermoplastics that are common in injection moulding that have not been adopted in FFF 3D printing; because learning which materials are suitable for 3D printing must be done using trial and error, filament manufacturers must carefully select the materials that they will introduce to the 3D printing market. Even when they do so, machine companies must then develop the preset that describes how that material can be used with their particular hardware and so there are many more filaments available in the market than there are presets; material development tends to lead adoption and even when excellent new materials emerge it can take time for them to arrive in users hands. For example Prusa (a 3D printing company) brought their PCBlend filament to market in October 2022 [1] but their PCBlend with carbon fiber fill to market in April 2023 [2], a six-month lag. We cannot know for sure if this lag was due to preset development or some other factors, but this many months between a material’s availability as a filament and the arrival of machine-specific presets is not uncommon. Add this to the fact that machine companies can go out of business, users may modify their machines making factory-developed presets irrelevant, and that people have varying uses for their printers. While some may primarily print i.e., small minifigures for their dungeons and dragons sessions, others may be printing engineering prototypes or even production-ready parts. Presets that suit small, detailed objects are not necessarily optimal for large parts (as we will see).
So, where presets are not available, not suited for the particular use-case, or a machine has been modified from its factory configuration, users must modify existing presets or develop a new one. Doing so requires that they intuit not only how the underlying physics works, but how their parameter selections are modified by the slicer and by the machine controller itself; both the slicer and machine controller contain some lossy representations that change those process values in non-intuitive ways.
5.1.1.3 Presets are Tuned Through Lossy Representations
In Section 5.2.2 I describe the tune-able parameters in a state-of-the-art slicer and in Section 5.2.3 I explain how these parameters relate to process physics. While updates to certain parameters can have massive effects on print physics, those relationships are not made clear to the users of 3D printers who are ultimately contending with those physics.
For example if we double the layer height but retain the same translational speeds we double the flowrate of the polymer melt: this has huge ramifications for the physics of the process, but that is not reflected anywhere else in the parameter set. Manually changing print speeds to reflect the new layer height (or otherwise slowing down polymer flows globally in the print job) would mean updating nine other parameters (excluding those that can be set by a percentage). Nor are those parameters related to longer-term outcomes like the resulting thermal history of the print’s interlayer joints, which are a main indicator of part strength [3]. Inversely, if we increase the nozzle temperature we often unlock more flowrate, but there is no way to update print speeds as a function of temperature, or increase layer cooling time. Instead of having any knowledge of print physics built into the slicer, users need to intuit how these many parameters will relate to the machine’s operation.
Part geometry can also change parameters: in Section 5.2.3.4 I explain how printer speeds change based on layer size ensure that parts do not slump (printing at high temperature but without any cooling time leads to molten parts). This means that print parameters developed by hand for small geometries may suddenly fail when we try to print larger parts: the translational speeds that were selected in the slicer were not actually being sent to the machine because this cooling-related slowdown was applied in the small part but not the large part. I mentioned similar effects that emerge from the hidden velocity planning optimization in Section 1.3.3, where GCode interpreters scale target velocities (which are set in slicers) according to acceleration limits (which are set in interpreter firmwares) — again, in some cases small parts may work well with large translational speed selections (even though those speeds are not ever actually reached) but large parts subsequently fail.
Parameter presets represent a wealth of tacit knowledge and hidden labour, but their use also constrains our operation of machine systems when we compare them to real underlying limits. For example in Section 5.8.4 I show that nozzle temperature can be selected based on flow and cooling models, and that this method often selects temperatures that are well above recommended values (and that lead to large increases in print time). This is because the model-based method can easily pick process parameters across a range of temperatures and large parts are not constrained by part cooling. Presets that are tuned by hand tend towards colder nozzle temperatures because they are normally developed to print a small test part (the 3DBenchy), which is dominated by part cooling; process tuners tend to select nozzle temperatures that work well for this part and then tune all the other parameters at that temperature.
So in the state-of-the-art, feedforward tuning of these parameters is basically guess-and-check: we tune parameters and print parts, watching to see if and where those parts fail. No data is produced during the print and operation is not based on physical models so we have limited recourse to understand why a failure occurred — i.e., which physical constraint our parameter selections cause the hardware to exceed.
5.1.2 Chapter Overview
In this chapter I try to re-frame this preset-based workflow into one that is informed by feedback from our machines. In this feedback-based workflow process tuning is done with respect to underlying constraints: rather than picking parameters directly that may exceed those constraints we can tune heuristics against those constraints, for example declaring that “for infill tracks (that are not visible in the final part) use as much flowrate as is physically possible and for perimeters (which are) use only \(40\%\) of the maximum.” This still exposes human-tuneable parameters so that the space of optimal print outcomes can be explored (trading off between speed, precision and strength) but the tuning exercise happens within physics-based bounds that are sourced from the real world.
This chapter first covers basic physics of the FFF process in Section 5.2.1 (for melt flow physics and layer cooling), and then how these physics are integrated into state-of-the-art 3D printing slicers and controllers in 5.2.3. Section 5.2.2 describes the state-of-the-art workflow most often used to produce parts, discussing how feed-forward parameters in those workflows are related (but not directly explained with regards to) process physics across motion, rheology and cooling. I then look at related research in FFF in Section 5.2.4, covering other efforts to model polymer flows (5.2.4.1), to control them (5.2.4.2) and to improve FFF workflows overall (5.2.4.4). As in other cases in this thesis, those efforts all make important contributions in parts of the system but struggle to combine models with model-based control or with higher-level optimizations and workflow formulations.
In the rest of the chapter I explain how we can use models for FFF throughout the printing process not only to more directly operating machines against their physical limits but also to pick higher level parameters using optimization and to apply model-mediated heuristics to the process. This means that the tuning steps that remain in the workflow are articulated also against real constraints.
Developing this system happens in a few steps. In Section 5.4 I build two instrumented machines that modify state-of-the-art FFF hardware, enabling them to build as well as use models. The first machine was a development mule, the second is a modified off-the-shelf machine that also demonstrates how the work in this thesis can be implemented without requiring that we rebuild our machines themselves. It also serves as a 1:1 comparison against state-of-the-art workflows because its underlying hardware is the same.
Models for FFF (and methods for fitting them without any external equipment) are outlined in three sections. Section 5.5 develops models that can be automatically fit to data from our hardware, as well as methods for generating that data that can probe boundaries of operation without breaking the system. These models advance the state-of-the-art in a few ways: they can fit flowrates at the nozzle tip using a measurement of the internal pressure state; this removes a difficult flow modelling step that requires observing printed tracks directly (Section 5.2.3.3). They also combine isothermal models with time-varying estimates of melt flow temperatures as they deviate from nozzle temperatures; a key limit to other modelling efforts is that they do not connect these two components of melt flow physics. These flow models couple to motor models (see 4.3.1) for the printer’s extruder in Section 5.6. Finally, FFF also requires the consideration of longer dynamics, namely part cooling. In Section 5.7, I explain a simple model that we can use for these purposes when combined with some machine-estimated material parameters.
Bringing these models to bear on printer control starts by extending the work from the last chapter. One of the claims that I made in Section 4.1.1 is that state-of-the-art velocity planners cannot be extended to simultaneously optimize over motion and process physics without major structural changes, but that the velocity planner formulated there (in Section 4.6) can do so by adding new simulations and extending the cost function. Section 5.9 realizes that by including models for FFF rheology, extruder dynamics, filament compression, and time-varying internal states like melt flow temperature in the optimization loop.
Doing so means that we can build a velocity planner for FFF that optimizes directly against models of process physics rather than direct parameters that are set by hand by machine developers (for motion) and machine users (for processes and materials). As in the earlier work on motion alone, this allows us to use more of the machine’s underyling dynamic range and more intimately connects machine operation with machine physics.
But it is not enough to make the process work well because even these more advanced models do not capture all the relevant physics: layer cooling happens on longer time-scales than the velocity planner can consider, our motion models are missing key frequency domain components (machine stiffness), and extrusion at exceptionally high pressures and cold melt flows (which our planner would tend towards if it were simply told to maximize speeds) can cause plastics to degrade and / or to exhibit die swell.2
To encode these higher-level heuristics and optima, Section 5.3 develops a new feedback-based FFF system that inverts the state-of-the-art; instead of feedforward configurations using presets, the machine itself develops models of flow and motion and those are combined with part geometry (and some heuristics) to produce parts in an end-to-end workflow. This can automatically generate parameters that respect long-term process constraints (Section 5.8) and selects nozzle temperatures that optimize total print time by trading off between hot nozzles (which allow for faster flows) and cold (which reduce layer cooling time), striking a geometry-dependent balance. These plans are then sent to the velocity planner so that dynamical constraints are also respected.
To evaluate all of this, I deploy it all to print seventeen different parts in nine different materials across three types of nozzle (Section 5.10.1). I characterize the reduction in the size of the human-tuneable parameter space and discuss other advantages (like printing in new and renewable materials) of the feedback-based workflow in Section 5.10.3. In Section 5.11.6 I show model-based printing’s resilience to human errors and in Section 5.10.4 I show the speed increases that arise from model-based printing’s ability to more fluidly move around in process parameter-space. Section 5.10.5 qualitatively compares print quality and shows that visual errors correlate well with model-fit errors.
At runtime, these machines generate more data than they consume (about one gigabyte per hour). I use these data to evaluate the quality of key mathematical models and fits by comparing the controller’s predictions vs. real world measurements (Section 5.10.6). I also discuss how these data and models could be used to inform machine designers and users in Sections 5.11.1 and 5.11.3.
Finally, a section on future work in FFF 5.12 discusses the frontier of new projects that are enabled via model-based control, the most exciting of which considers process tuning with pareto optimality (5.12.4).
5.2 Background in FFF 3D Printing
I describe Fused Filament Fabrication (FFF) physics in increasing detail as this section progresses: first I set us up with a good baseline in the fundamentals (below), and then Section 5.2.2 explains how these physics are articulated in state-of-the-art workflows using direct parameters. In Section 5.2.3 I expand on that to explain how those parameters interact in the real world, how they are interpreted by GCode-based controllers, and how some newer controllers have integrated online sensing to improve the state-of-the-art - comparing that strategy to an improvement that this work makes. Finally Section 5.2.4 covers other research on the topic: advanced modelling methods and physical insights, other examples of model-based control for FFF extrusion (but none that couple extrusion models into velocity planners), and work that lives in the outer loop which relates process parameter selection to printed component outcomes.
5.2.1 Fundamentals of FFF 3D printing
5.2.1.1 Rheology, Thermodynamics, and Motion
The FFF process is akin to the use of a hot glue gun: we drive a thermoplastic filament into a hot nozzle and extrude tracks of molten material. By translating the machine in 3D while we do this, we can additively construct parts.
Extrusion of these tracks must be tightly coupled with our motion controller: to extrude a target track width we need to carefully match the flowrate from the tip of the nozzle \((mm^3/s)\) with the machine’s translational rate \((mm/s).\) The quality of our machine’s motion obviously has a lot to do with the machine’s ability to produce precise parts, but so does its ability to control the filament flow.
The fundamental physics for flow are rheological — i.e., having to do with material flow and deformation under various loading and thermal conditions [4]. The key relationship is between pressure in the nozzle and the flowrate from the nozzle tip: this is why our most valuable tool for FFF model building is a load cell positioned in the printer such that we can measure extrusion forces alongside the nozzle temperature measurement (see hardware used in Section 5.4). This pressure-to-flow relationship depends on the material’s own properties, its temperature, and the nozzle geometry.
The filament also compresses before it leaves the nozzle, meaning that changes to flowrate at the tip must be anticipated by our motion controller, preloading the melt zone. These physics are coupled into the extruder motor’s own physics, as I explain in Section 5.6.
Thermodynamics are also important: the filament is cold when it enters the nozzle and approaches the nozzle temperature as it transits towards the exit. At high printing speeds, filament heating is the fundamental limit [5]. This phenomenology lead me to develop two models for flow: one characterizing steady-state system behaviour (5.5.2) where thermodynamics dominates and one for isothermal behaviour (5.5.3) where the material’s actual underlying viscosity dominates.
Depending on who you ask, the FFF process is either incredibly simple (heat, squish, and extrude material) or complex — involving nonlinear rheological models, history-dependent thermodynamics, and interlayer polymer diffusion and cooling models. One of the primary challenges faced in this chapter is to describe these physics using models that can be easily fit to data available from our own machines, and that can be useful across high- and low-level planning tasks. This requires that we strike a balance between model fidelity and simplicity.
5.2.1.2 Layer Cooling
The temperature of the melt flow affects its viscosity as we extrude and also affects the part geometry: if plastics are too molten as we print, our parts slump — previous layers not being solidified enough to fully support succeeding layers. This is why FFF printers all include part cooling fans (PCF); one of which is visible in Figure 5.13. They can accelerate layer cooling, but we need then to know when we should try to cool layers and when we should deactivate the PCF in order to promote better interlayer adhesion.
As I learned over the course of this project (and am able to show quantitatively in Section 5.11.1) cooling of printed parts is often the primary limit to overall print speed. I discuss how state-of-the-art systems articulate and choose cooling parameters and how this work improves upon those methods and combines them with other models to optimally select nozzle temperature against cooling models in Section 5.2.3.4.
5.2.2 Parameters in the State-of-the-Art FFF Workflow
So, we can begin to see what the key physical constraints to our FFF machines are. How then are machines configured in the state-of-the-art such that users can have success while printing parts? In this section I will explain how these physics are exposed to 3D printer users, and then describe how these parameters relate to physics and how those physics are then controlled (sometimes) in lower level planners.
In the CAM tools for 3D printing (known as slicers) users import 3D objects and set parameters to tune the process. Some parameters are geometric: layer height, track widths, external perimeter counts, and infill pattern and density. Other parameters set the machine’s speed (how fast the nozzle moves in cartesian space, also called translational rates) for different features: outside perimeters, interior perimeters, infill, etc. They select temperatures: for the nozzle, for the print bed, and (sometimes) for the print chamber. Finally, they adjust cooling parameters: slicers maintain a minimum layer time with the goal that when the next layer is printed, the previously deposited material has nearly solidified.
.stl mesh files, which are exported from design software), and slicers are set up with parameters to match the machine, material, and extruder configuration. The slicer writes a GCode, which is transferred to the machine controller to produce the part.
All told, there are about one hundred parameters to tune in a slicer. Historically, tuning these parameters was a major barrier to the adoption of 3D printing, but sets of parameters that are matched to a particular machine, material, and nozzle are commonly available for users now as slicer presets. These can be imported, modified, and exported from slicers and shared online in user communities [6]. Presets have been developed manually over the years by the 3D printing community, and are distributed by machine manufacturers (for example Prusa bundles presets for its machines and materials within PrusaSlicer [7]), by material manufacturers, and by user groups.
However, we need a new preset any time we change either the machine, the nozzle, or the material. It is becoming common also to develop a series of presets for each combination: one for “speed,” one for “quality,” and one for “strength”. This leads to a combinatorial explosion where the space of effective presets we would want explodes. For example with a small set of only four machines, five materials, four nozzles, and three (speed, quality or strength) options we quickly arrive at 240 individual presets to develop, each of which contains tens of parameters.
| Geometric Parameters | Typical Values | Units / Type | Physical Relation |
|---|---|---|---|
| Layer Height | \(0.1 - 0.4\) | \(mm\) | Geometry, Flow |
| Vertical Shells | \(2 - 6\) | count | Geometry |
| Horizontal Shells | \(3 - 6\) | count | Geometry |
| Infill | \(10 - 100\) | \(\%\) | Geometry |
| Infill Pattern | i.e ‘grid’, ‘gyroid’ | selection | Geometry |
| Shell Pattern | i.e. ‘rectilinear’ | selection | Geometry |
| Support Material | yes / no | selection | Geometry |
| Support Material Type | i.e. ‘grid’, ‘organic’ | selection | Geometry |
| Motion Parameters | Typical Values | Units / Type | Physical Relation |
|---|---|---|---|
| Speeds | — | — | — |
| Perimeters | \(25 - 250\) | \(mm/s\) | Motion, Flow |
| Small Perimeters | \(20 - 150\) | \(mm/s\) | Motion, Flow |
| External Perimeters | \(20 - 200\) | \(mm/s\) | Motion, Flow |
| Infill | \(50 - 350\) | \(mm/s\) | Motion, Flow |
| Solid Infill | \(20 - 250\) | \(mm/s\) | Motion, Flow |
| Gap Fill | \(20 - 100\) | \(mm/s\) | Motion, Flow |
| Bridges | \(10 - 50\) | \(mm/s\) | Motion, Flow |
| Support Material | \(10 - 100\) | \(mm/s\) | Motion, Flow |
| Support Interface | \(5 - 50\) | \(mm/s\) | Motion, Flow |
| First Layer | \(25 - 50\) (or as %) | \(mm/s\) | Motion, Flow |
| Travel | \(50 - 500\) | \(mm/s\) | Motion |
| Z-Travel | \(10 - 50\) | \(mm/s\) | Motion |
| Accelerations | — | — | — |
| Perimeters | \(1500 - 5000\) | \(mm^2/s\) | Motion, Flow |
| External Perimeters | \(1000 - 3000\) | \(mm^2/s\) | Motion, Flow |
| Infill | \(2000 - 10000\) | \(mm^2/s\) | Motion, Flow |
| Bridges | \(500 - 2000\) | \(mm^2/s\) | Motion, Flow |
| First Layer | \(100 - 1000\) | \(mm^2/s\) | Motion, Flow |
| Travel | \(2000 - 10000\) | \(mm^2/s\) | Motion |
| Travel (short) | \(100 - 1000\) | \(mm^2/s\) | Motion |
| Extrusion Parameters | Typical Values | Units / Type | Physical Relation |
|---|---|---|---|
| Extrusion Widthsa | — | — | — |
| Default | \(d_{nozzle} \cdot 1.25\) | \(mm\) | Geometry, Flow |
| First Layers | \(d_{nozzle} \cdot 1.25\) | \(mm\) | Geometry, Flow |
| Perimeters | \(d_{nozzle} \cdot 1.25\) | \(mm\) | Geometry, Flow |
| External Perimeters | \(d_{nozzle} \cdot 1.15\) | \(mm\) | Geometry, Flow |
| Infill | \(d_{nozzle} \cdot 1.1\) | \(mm\) | Geometry, Flow |
| Solid Infill | \(d_{nozzle} \cdot 1.0\) | \(mm\) | Geometry, Flow |
| Top Solid Infill | \(d_{nozzle} \cdot 0.9\) | \(mm\) | Geometry, Flow |
| Support Material | \(d_{nozzle} \cdot 0.8\) | \(mm\) | Geometry, Flow |
| Temperatures | — | — | — |
| Nozzle Temperature | \(160 - 300\) | \(^{\circ}\text{C}\) | Flow |
| Bed Temperature | \(40 - 120\) | \(^{\circ}\text{C}\) | Bed Adhesion |
| Chamber Temperature | \(40 - 80\) | \(^{\circ}\text{C}\) | Part Warping |
| Cooling Settings | — | — | — |
| Fan Enable Layer Time | \(5 - 50\) | \(s\) | Part Cooling |
| Minimum Layer Time | \(8 - 20\) | \(s\) | Part Cooling |
| Filament Settings | — | — | — |
| Maximum Flowrate | \(10 - 50\) | \(mm^3/s\) | Motion, Flow |
| Extruder Settingsb | — | — | — |
| Retraction Length | \(0 - 5.0\) | \(mm\) | Motion, Flow |
| Retraction Speed | \(10 - 100\) | \(mm/s\) | Motion, Flow |
| Deretraction Extra Length | \(0 - 1.0\) | \(mm\) | Motion, Flow |
| Deretraction Speed | \(5 - 50\) | \(mm/s\) | Motion, Flow |
a I’ve included extrusion widths here as a function of nozzle diameter \((d_{noz})\) but they are often also calculated with respect to layer height; if we try to extrude i.e. a 0.2mm track width at a 0.4mm layer height, the track does not connect to the previous layer. These are not a commonly re-tuned value, as defaults are easy to arrive at using those known variables.
b Settings for retracts can be tuned in two places: connected to the machine (which may have an amount of baseline extrusion slack) and as an “override” in the filament related settings, for i.e. very flexible filaments that may require extra retraction.
| Motion Parameters | Typical Values | Units / Type | Physical Relation |
|---|---|---|---|
| Fan Speed Maximum | \(60 - 100\) | \(\%\) | Fan Power, Matl. Heat Capacity |
| Fan Speed Minimum | \(0 - 40\) | \(\%\) | Fan Power, Matl. Heat Capacity |
| Enable Fan When < | \(30 - 60\) | Layer Time \(s\) | Print Temperature, Heat Capacity |
| Slow Part When < | \(10 - 30\) | Layer Time \(s\) | Print Temperature, Heat Capacity |
| Minimum Print Speed | \(10 - 30\) | \(mm/s\) | Maximum Slowdown |
The values we set in slicers all relate explicitly to the machine instructions (how fast to travel, how thick to make the layer, etc). They relate implicitly to the physics of 3D printing, which has mostly to do with flowrates and temperature of the polymer melt. To explain in more detail, I list the most important slicer parameters and how each relates to our control task in the tables here. These are separated into three subsets: parameters relating to path geometry (5.1), to the extrusion process (5.3), and to the printers’ motion system (5.2). While it is possible to separate these into three main categories, the physics that each parameter affects are coupled.
5.2.3 Physics Management in the State-of-the-Art FFF Workflow
5.2.3.1 Flowrate Limits Combine Translational Rates and Track Geometry
We can see that slicers allow users to tune printer motion physics via direct application of maximum acceleration and velocity. Chapter 4 showed that these alone do not completely describe motion control constraints: maximum acceleration is a function of speed not constant throughout speeds, and machines can decelerate much faster than they can accelerate because friction helps to stop the hardware.
In purely kinematic systems our top speed limit is based only on actuator power / voltage and friction. When we introduce melt flow physics, we add a velocity limit based on maximal flowrates: the tracks we extrude have a certain width and height and so to increase translational velocity we must also increase flowrate. If we change the nozzle temperature we increase this flowrate limit, and if we update the path geometry to print e.g., increasing layer thickness increases the flowrate required per unit of translational velocity by the same proportion. However, slicers expose tuning of flowrates in terms of translational rates alone; changes to either of these values are not reflected into those rate limits even though the physics are deeply coupled. They do allow that we set a global maxima for flowrate per nozzle, but that is itself not updated if we increase the nozzle temperature or even if we change the material definition. The flow models in this chapter show that these two factors change maximal flowrates significantly.
So, motion constraints can emerge from either motion or process constraints an in the state-of-the-art this coupling is not exposed. It is not either the case that we can simply pick one of these constraints to frame the problem because realtime operation is dynamic and includes both purely motion moves (jogging, where just motion is important) and extruding moves (where both factor). Track geometry also varies; if we print a track whose width goes from thin to thick suddenly, we need to decelerate the machine in the interval where the primary constraint changes from the motion system’s physics (for the thin component) to the flow system’s physics (in the thick portion).
5.2.3.2 Extrusion Dynamics via Linear Advance and Retraction
Machines are constantly accelerating and decelerating and do so in relation to motion system dynamics, but in FFF 3D printing we have an additional order in the dynamical system to consider which is present due to filament compressibility; filament is squishy (and is squishier when it is hotter). This makes cornering in 3D printers even more complicated than it is in purely kinematic systems: when we decelerate into the corner the extruder motor needs to rapidly unload pressure in the nozzle and when we accelerate it needs to rapidly load pressure in advance of the motion system’s own acceleration.
This means that the maximal overall printer velocity through a corner can be constrained by a number of factors. First, curvature defines how fast the motion system can traverse the corner. Flowrate limits and track width define how fast it enters the corner and what speed it will try to reach on corner exit. Then, as it decelerates it must unload the nozzle pressure accordingly and so the extruder motor’s own dynamic limits can constrain the system: if it cannot unload pressure as fast as the motion system can slow down to meet the curvature, the motion system must decelerate slower than it may otherwise, the same is true as the machine accelerates out of the corner. There is an asymmetry here as well because it is easier to release pressure in the extruder than it is to generate pressure — similar to the earlier notion from kinematic control alone that stopping with friction is easier than accelerating against friction.
Filament compressibility is managed approximately in state-of-the-art printer firmwares using an approach called linear advance [8] or pressure advance [9]. This is a firmware setting that adds velocity to the extruder motor for every unit of acceleration of the motion system in order to pre-load and un-load nozzle pressure. This is tuned as a single spring rate that is tuned per nozzle diameter, even though the flow models in this chapter show that filament spring rate can vary greatly across materials and melt flow temperatures.
Because pressure advance modifies extruder velocity based on machine acceleration and acceleration can change instantaneously in these controllers, this injects instantaneous changes to extruder velocities in the control of 3D printers. The motor models from Section 4.3.1 shows that even instantaneous changes to a motor’s acceleration violate important motor dynamics. In Section 5.2.4.2 I will discuss some research efforts that improve control of FFF extrusion dynamics using models; these make significant improvements on the simpler pressure advance scheme, but they too couple control to an existing velocity planner’s trajectories (using their outputs as a reference signal for a feedback-based extrusion controller) even though the extruder’s own dynamics should limit operation: neither pressure advance or these new methods completely couple motion control and process control, or can show us which constraint limited overall performance of our systems at any given point.
So, these methods manage cornering with respect to extruder dynamics, but we must also stop flow during purely motion moves, i.e. when we finish one track and begin another. Done properly, this step would also involve computing how the extruder system should be driven such that pressure in the nozzle goes to zero when we make a purely-motion move, based on flow and extruder physics. In the state-of-the-art, each filament can define simpler retraction parameters, these define the length of filament that should be pulled back from the nozzle tip in order to come to a full stop. As in other cases, the underlying physics depends on nozzle temperature and nozzle size as well, but here slicers expose just one set of parameters per material.
5.2.3.3 Direct Measurements of Output for Flow Calibrations
Understanding flow dynamics is challenging because it is difficult to measure how much filament is flowing from the tip of the nozzle at any moment, known as “outflow” or \(Q_{\text{out}}\) in the modelling in this chapter. Measuring the flow that goes into the nozzle is easier because it is basically equivalent to our extruder motor velocity (times some scalar), but between that value which we can control and the outflow are the compression dynamics and flow rheology.
To establish ground-truth measurements for these systems, state-of-the-art controllers make direct measurements of outflow by looking at extruded tracks of polymer. I implemented one example of this type of instrumentation in Figure 5.8: a camera points at extruded tracks and we use computer vision to measure track widths, then estimating flowrates using a known layer height and known translational velocity. Bambu Labs 3D printers make similar measurements using small line lasers, and the Rubedo system [10] developed in the open source does the same.
These methods are used to tune pressure advance parameters on a per-setup basis, but require that measurements be made under specific process parameters: measurements must be taken on extruded tracks on the build plate itself because differentiating layers can be difficult, instrumentation must be aligned with the tracks themselves (we can only make measurements of tracks that were extruded along the x-axis, for example), and the linear translation rate of the machine must be well known: normally these tests are done at a fixed translation rate so that machine acceleration does not couple into changes in track width.
In this work I use the idea of computational metrology to perform the same measurements: in developing a model that connects the internal pressure state to both outflow and inflow using rheology and compressibility, we can fit models against this internal state that extrapolate to predict outflow (Section 5.5.3). This advances the state-of-the-art because it removes measurement complexity (no cameras or line lasers required), enables higher frequency measurements (at hundreds of Hz, rather than camera frame rate limits), and means that we can measure flow dynamics all the time rather than only on the first layer and in certain directions.
5.2.3.4 Minimum Layer Times for Layer Cooling
OK, the aforementioned physics concern polymer behaviour during extrusion, but in Section 5.2.1.2 I explained the importance of polymer cooling after extrusion. In particular, we need to ensure that previous layers are solidified enough to accept subsequent layers without slumping before we print on top of them.
This is one of the more complicated phenomena to model properly in 3D printing because it depends on the material’s heat capacity, the selected nozzle temperature, the part cooling fan’s performance, and the part geometry because cooling is slower in i.e. dense parts than it is in sparse prints etc.
In state-of-the-art slicers, we tune a few values for minimum times per material, and for cooling fan utilization. Slicers will turn fans on if a layer takes less than a minimal time and will slow the layer down (changing translational rates) if it falls under a second minimal time.
In Section 5.7 I extend this method to calculate minimum cooling times based on volumetric heat capacity estimates made from the printer itself alongside estimates for part cooling fan performance and a simple thermodynamic model for diffusion of heat into previous layers an into air. Then, because we can select process parameters across a range of nozzle temperatures, we can pick nozzle temperature on a per-part basis for time optimality by trading off between hotter flows (which are faster) and layer cooling time (which increases with hotter flows). A clear optimum emerges where smaller parts should be printed close to minimal flow temperatures whereas larger parts can easily exploit high flowrates with larger nozzle temperatures because layer times are long anyway since the parts are big.
This leads to significant time improvements in large parts and suggests that printers have been mostly tuned by hand to produce small parts — not necessarily because most 3D printing users want to print only small parts, but because this is the faster way to tune parameters: a loop around parameter tuning for a large print being obviously slower (by hours) than the same loop around printing a small part.
5.2.4 Related Research in FFF
There is a lot of interest in FFF printing in the literature, and so the applied physics are quite thoroughly understood [11] [4]. In this section I will cover existing models for polymer flows, related work that applies those models to realtime control, and then research that takes place at higher levels to develop improved workflows overall.
As in the background section on related research for motion control with models (Section 4.2.8) the through line here is similar: there is excellent research at lower levels that model advanced machine physics and also research at the workflow level that shows how slicer and CAM parameters relate to print outcomes, but work that connects models directly to controllers is limited. For example most model-based controller for CNC machines integrate on top of existing velocity planners (Section 4.2.8.1), and where they do integrate directly they still use direct parameters (i.e. maximal jerk, acceleration, and velocity values) for planning (4.2.8.2).
In the examples here there is extensive modelling research on polymer flow physics both within the nozzle and outside the nozzle as tracks and parts cool. There is one example where researchers go to great length to make online model-based measurements of these physics, but they cannot connect those measurements back into a predictive controller, (they are also using an industrial robot arm with a proprietary controller, which may have been the limit). One group of researchers has applied some modelling to realtime control of FFF extrusion, but they too connect their controller below velocity planners, taking their outputs as a reference / target signal (their models only describe shorter scale compressibility dynamics).
In this chapter we try to connect these models more directly to velocity control, allowing constraints from the flow system to reflect back into the velocity plans. We do this by coupling the two systems in the same controller rather than splitting them hierarchically, and also include those time-varying dynamics. This is enabled both by developing simpler models (rather than e.g. complete CFD-based solutions) that can be fit to data from the machine and in leveraging the flexibility and computational power of the velocity planner that I developed in Chapter 4. Computing both of these systems together at the fine-grained resolution required for velocity planning is possible because the work from Chapter 2 allows us to relocate the velocity planner onto the GPU. This gives us many orders of magnitude more compute power than we would have in a controller deployed in firmware, while maintaining a connection between that GPU and the embedded devices that execute control plans and also generate data.
5.2.4.1 Related Work on Modelling of FFF Flows
I gave a brief overview of FFF rheology in Section 5.2.1.1; polymers are driven into a melt zone where thermodynamics, compressibility, and rheology all interact to deposit tracks of molten material that then subsequently cool and become printed components. There are many factors that come into play during this process and the underlying physics turns out to be quite involved. That is reflected in a very active group of researchers who are all trying to understand different components of the process.
Of primary relevance to this work is a line of research begun by TJ Coogan and David Kazmer, who developed an instrumented extruder similar to ours in [12] — it also adds a load cell between the extruder motor and the nozzle to estimate melt flow pressures and turns the hotend into a rheometer. But melt flow viscosity alone is not sufficient to describe the operation of a hotend, Kazmer continued this work to characterize the dynamic behaviour of filament during extrusion his paper on concurrent characterization of filament compressibility and flow in [13], [14] and [15], which helped me to develop the dynamics model I use in the current iteration of the FFF flow model that also model compressibility alongside rheology. These papers were also fundamental to my earlier work in [16] (see Figure 5.16), where we combined online model-building with parameter selection in a reduced space to print with unknown materials but did not integrate dynamical models for flow. For a closer look at melt flow rheology on its own, [17] analyzes some common 3D printer thermopolymers using capillary and parallel plate rheometers and shows that power law equations (which I use here) are a good basis for melt flow models.
These efforts cover compressibility and isothermal rheology, i.e. melt flows whose temperatures are not time-varying and can be assumed to be basically equivalent to the nozzle’s temperature. However, nozzle thermodynamics turn out to be a main limit to overall melt flow dynamics. Jamison Go’s [5] discusses absolute limits to print speeds based on nozzle thermodynamics (providing insight into how printers should be improved accordingly) and Mackay’s [18] models flowrates through a hotend as a function of nozzle temperature, mapping flowrate failures across nozzle temperatures.
Kazmer’s [13] notes that the connection between isothermal and thermodynamic aspects of a polymer melt flow are of key importance to understanding real printer operation; after only a few seconds of flow, the thermodynamic limits of the extruder begin to dominate the system’s phenomenology. In practice printers operate under non-isothermal conditions that are difficult to understand because it is nigh impossible to measure the internal temperature of the melt flow directly. The measurements that we can make are a few orders away from that internal state: thermocouples in most printers are located in the heater block which is much more thermally massive than the melt flow and are normally tens of millimeters away from it. In [19] the authors develop a hotend that locates a thermocouple and pressure transducer much closer to the melt flow, but still only at the melt zone’s wall rather than at it’s core, and located 6mm above the nozzle tip. They still report \(6.5\,^{\circ}\text{C}\) of temperature deviation during extrusion at only \(5.5mm^3/s\) (state-of-the-art printers can operate closer to \(50mm^3/s\)).
Zhang et al’s [20] uses a finite-element (FEA) multiphysics simulation of an FFF printer’s hotend to model melt flow thermodynamics within the nozzle and Nzebuka et al [21] uses a numerical model for a similar simulation, which they verify against real-world data. Pigeonneau’s work in [22] develops the complete mass, momentum and energy equations for non-isothermal flows in the melt zone of an FFF 3D printer and also uses FEA to solve the equations. They show that their model can provide the correct working conditions for the extruder in steady-state3 inlet flow conditions; based on nozzle temperature and some material parameters they can predict the maximum flowrate.
These efforts all represent more advanced modelling techniques that have been applied to the same system that I am modelling in this chapter, but there is a split between those who model isothermal flow and compressibility and those who model non-isothermal steady state flows. In control, we need to connect these to one another to simulate how the system evolves over time based on time-varying inputs from the past.
The authors of [23] explicitly set up their modelling workflow for the purposes of integration within a realtime controller. They use a thermal camera and thermocouple to model non-isothermal (steady-state) flows and build a “response map” for a range of steady-state flow conditions that is similar to the one that I develop in Section 5.5.4, which predicts melt flow temperature decrease as a function of nozzle temperature and inlet flowrate. While they develop their controller for realtime performance (focussing on high performance computer vision to process data), they do not ultimately connect this controller to a machine system and their model does not include shorter-order dynamics like compressibility.
5.2.4.2 Related Work on Real-Time FFF Control
I covered other work that combines process and motion control in Section 4.2.6.3 (in industrial systems) and in 4.2.8 (in other research). Many of those examples use feed override outputs from process-aware controllers to modify velocity planners rather than solving the problems together. This works well but requires that the velocity planners themselves are modelled so that their internal behaviour can be anticipated. There is one example there (in 4.2.8.2, for process control in CNC machining) that seems to completely combine the optimizations into one solver, although theirs is still formulated directly against direct parameters rather than models for motion control. I discuss in more detail how the planner used in this work is different from other motion control work in Section 4.2.9.
There is more research overall that connects process modelling to motion control in CNC milling (again see Sections 4.2.6.3 and 4.2.8), but here we are concerned with FFF extrusion. I mentioned [23]’s efforts to formulate steady-state polymer flow models such that the could be integrated with control, and each of the papers in Section 5.2.4.1 above mention integration of their modelling efforts with control as a primary motivation, but there are only a few efforts to actually do so.
Pinyi Wu’s work is one example, he develops a simple nonlinear model for filament flow that is based not on physical properties of the material but on the time-constant \(\tau\) of the delay between the extruder motor’s velocity and the flow velocity, which is a useful approximation that re-frames the problem in terms of delay. This is fit to data from a machine using the track-width measurement methods that I mentioned in 5.2.3.3. In [24] he applies this in two ways: the first is to modify that machine’s velocity planner so that the extruder controller (which is left as-is, i.e. it uses linear advance) is corrected according to the measured \(\tau.\) The second method modifies the velocity control only of the extruder motor to effectively improve the linear advance algorithm. In his PhD thesis [25] (and separately in [26]) he develops a hybrid extruder that acknowledges that FFF control has fundamentally two components: steady-state pressure generation and high-bandwidth pressure updates that must be applied while the system is cornering - he splits this into a slow extruder mounted via a bowden tube4 and a fast direct-drive extruder that provides higher bandwidth control.
These methods benefit the extruder system based on model insights, but they do not connect directly to process physics - instead using controls-oriented / delay-based compensations that are fit to physics and only apply on short time-scales (i.e. they miss the non-isothermal component). They also work in one of two ways: to shape velocity planner outputs to suit extrusion dynamics, or update extrusion dynamics to better respond to velocity planner outputs, using those as a reference signal. That is, neither approaches combines velocity control with extrusion control. To compare with work in this thesis, my approach combines physics-based models for extrusion with more advanced models of machine motion and kinematics, which should yield overall improvements to print speed - taking the machine system as a whole, whereas Wu et al’s work focuses mainly on the optimization of extruder commands. Ours also integrates the additional load cell sensor which allows us to bootstrap models on previously unseen filaments and develops an end-to-end workflow that extends the controls method up into higher level parameter selections by developing a model that captures both isothermal and non-isothermal flows.
In the background section on systems design, I also covered the integration of rheological control with motion control using “TCodes” (Section 2.2.4.8) where researchers work around interpreters entirely to produce control outputs that are synchronized against the expected time alignment of their machine’s GCodes to their custom control for gel extruders [27] [28]. This method allows those researchers to combine their own models for extrusion control with off-the-shelf motion systems but also misses conjoined optimization of the two problems: flow control is overlaid on motion plans already generated by off-the-shelf velocity controllers.
Finally I would like to cover Douglas Brion’s excellent work on FFF printer control using deep learning and machine vision [29] [30]. This takes a higher level approach, fitting cameras to a fleet of 3D printers and running them for weeks while collecting image data using GCodes that had segments with known good parameters (which were labelled as such) and segments that had known bad deviations from those parameters across lateral feed rate, z-offset, flowrate commanded and hotend temperature. That then generalizes into a framework where the vision model is used to estimate the current offset from “good” parameters, which can be used to update the relevant parameters on the fly (and subsequently modifies input GCodes to the machines). This is a completely different approach to the one we are taking here which seeks to model flows on a first-principles basis and can be bootstrapped without known good parameters or a large image dataset like the one used in Brion’s work. The work here also provides much higher bandwidth data and controls responses, again integrating with motion controllers themselves to find other parameter spaces that are viable rather than generalizing on a set that has been developed heuristically. However, their results are excellent and show the value of big data in 3D printing: while more generalizeable approaches with hidden internals can be difficult to interpret and don’t (for example) tell us anything new about our systems, they can perform well for complex tasks. In Section 7.7 I make a broader connection between the approaches that I take in this thesis and “AI-Powered” approaches like Brion’s contributions.
5.2.4.3 Related Research in FFF Cooling Physics
Most of my work in this chapter is concerned with the extrusion dynamics of polymer flows, but I have also mentioned that there are important physics on the other side of the nozzle tip — i.e. in how the part cools and solidifies after extrusion.
For example, we would like to be able to optimize prints to be maximally strong as well as precise and fast. Part strength also relates to nozzle temperature and part cooling because interlayer weld strength is a strong function of the layer interface’s thermal history [3] [31]; more time above the plastic’s glass transition temperature equates to more diffusion of polymer chains across the weld. The inter-layer pressure exerted by the melt flow during extrusion also factors. High shear rate extrusion also leads to increased die swell — which is shown in [32] — and die swell can leave unwanted stresses in finished parts that change geometry and further reduce strength.
These physics are complex because they involve thermodynamic models of polymers alongside models for e.g. how molten polymers crystalize or set5 as they cool. [33] uses multiphysics simulation to understand this behaviour, modelling both die swell and diffusion between recently extruded tracks and the rest of the part. Zhang et al’s [34] extends work from the group that I mentioned earlier on non-isothermal flows within the nozzle [20] to model non-isothermal cooling behaviour after the nozzle, now estimating the track’s internal thermodynamics using thermal image data of the track. In one of their tests, the exit surface temperature of the track was \(194\,^{\circ}\text{C}\) whereas the core temperature was only \(164\,^{\circ}\text{C},\) a significant delta.
These works also note that the short-term dynamics of extrusion also matter when considering longer-term cooling physics because the thermodynamics in the nozzle affect how much melt flows are reconstituted there (or not), i.e. flows that become more molten during extrusion also weld to one another more completely post extrusion. McIlroy’s earlier 2017 paper [35] reflects this: parts that are extruded at higher pressures do not weld as well because their polymers become “disentangled” at high pressures.
This is an important set of research for this workflow because these factors are missing from the models that I use to select print parameters. For example in Section 5.8 I pick nozzle temperatures based on a print speed optimization and some applied flowrate heuristics and in Section 5.9 my velocity planner selects maximal flowrates against those heuristics and dynamical models of the system. Maximal pressures in each of those cases are based on flow systems and extruder motors alone (and motion systems), but according to this research we may also want to avoid extremely high extrudate pressures to promote layer cooling and reduce die swell.
So, yet again everything is coupled. In Section 5.12.4 I discuss the possibility of eventually formulating the FFF workflow as a physics-based trade-off on three fronts: print speed, precision, and strength. Each of these relates in different ways to melt flow physics in the nozzle, part cooling physics outside of the nozzle, and motion dynamics of the machine.
5.2.4.4 Research on FFF Workflow Optimization
On the note of combinatorial optimization through the trade-offs between speed, strength and precision, I want to point out another selection studies on the relationship between slicer settings and print performance [36] [37] [38] [39] [40]. Rather than using physics-based analysis, these studies all operate in an outer loop around the state-of-the-art workflow - i.e. they optimize slicer parameters directly and observe the results in printed parts. As I’ve noted there is a great deal of loss between the parameters that slicers expose, the GCodes that machines consume and the control outputs that GCode interpreters ultimately use to operate machines, so the results from each of these studies is limited. However, they do show that optimizing print parameters alone and eschewing all of these complex physical models is possible, it is merely more difficult to trace and adapt across varying machines, materials, nozzles and geometries.
5.3 A Feedback-Based FFF Workflow
Combining the methods in this chapter, I developed a complete workflow for FFF that replaces feedforward machine configuration with feedback configurations using models. In overview, the workflow operates in two steps: machines make models using the materials and nozzles that they will use to print, and we then combine those with heuristics to operate the machine. Figure 5.9 below shows this process in more detail.
I do not take on the task of generating path geometry, instead focussing on the parts of the problem that combine motion and flow optimizations, i.e. speed and temperature selections.
Like the state-of-the-art workflow, this one takes in a part geometry as an .stl, and produces a fabricated part. It also uses an off-the-shelf slicer to generate path geometry from the part, i.e. to decompose the .stl into a series of tracks. In addition to the fabricated part, this workflow also produces a process data file, which contains time-series outputs from the machine’s sensors and the motion controller, alongside models that were used during the job, the input geometry and other metadata. This adds new value that I discuss later in the chapter, the most exciting of which is an ability to computationally identify errors and the opportunity to continuously improve models.
The parameters from the state-of-the-art workflow that control the motion and extrusion of the machine (i.e. from Table 5.2 and 5.3) are replaced with models of those aspects of the hardware. The extruder generates flow models, and those are used to select flowrates within the systems’ real physical boundaries. I do this with a preprocessor, where models are combined with heuristics (see Section 5.8) and with a cooling model, which allows for time-optimal nozzle temperature selection.
The machine itself is used to fit kinematic models to describe the motion system, the primary tool for which are the motors themselves — a process that I described in Section 4.5. These are combined with flow models to extend our motion planner, which then runs the machine in realtime such that speed is maximized while physical constraints and limits set in the preprocessor are respected.
Once models for flow and motion are fit (each takes tens of minutes to start, and can be re-used for subsequent prints using the same material, nozzle, and machine), the workflow to produce a new part follows these steps:
- The desired part file is turned into a path file, where we can select layer height, infill densities and patterns, and shell thicknesses. This is a static path encoding that contains a series of path segments and widths, each segment of which is binned into one of five categories: infill, perimeter, small, outer, and travel moves.
- The preprocessor (Section 5.8) is configured with material flow and cooling models, as well as user heuristics for motion, flow and cooling, and some estimates (see Table 5.5). It selects an optimal nozzle temperature for the combination and generates a run file, which is an annotated version of the path file whose data are described in Table 5.6.
- The run file is passed to the motion planner, (Section 5.9) along with motor, motion, and flow models. This controls the machine in realtime — maximizing speed while respecting constraints laid out in the models and in the run file. It is connected to the machine via OSAP (Section 2.3), PIPES (Section 2.4) and MAXL (Section 2.5).
- During the print, time series data are collected from the machine and it’s instruments and stored in a process data file. This data can be used to improve models, detect errors, or analyze machine performance.
| Manual Input | Units | Typ. Value | Mediating Models | Destination |
|---|---|---|---|---|
| Cooling Estimates | — | — | — | — |
| Chamber Temp | \(^{\circ}\text{C}\) | \(30.0\) | Cooling | Preprocessor |
| Cooling Target \(\Delta T\) | \(^{\circ}\text{C}\) | \(-20.0\) | Cooling | Preprocessor |
| \(h_{air}\) est. | \(5.0\) | Cooling | Preprocessor | |
| \(\kappa_{fil}\) est. | \(0.1\) | Cooling | Preprocessor | |
| Direct Heuristics | — | — | — | — |
| Minimum Flow | \(mm^3/s\) | \(15.0\) | Flow | Preprocessor |
| First Layer Rate | \(mm/s\) | \(50.0\) | Both | |
| Pressure Scalars | — | — | — | — |
| Infill | \(0-1.0\) | \(0.75\) | Flow | Both |
| Perimeters | \(0-1.0\) | \(0.65\) | Flow | Both |
| Details | \(0-1.0\) | \(0.45\) | Flow | Both |
| Current Scalars | — | — | — | — |
| XYZ (fast) | \(0-1.0\) | \(0.20\) | Motion | Planner |
| XYZ (fine) | \(0-1.0\) | \(0.25\) | Motion | Planner |
| E (fast) | \(0-1.0\) | \(0.75\) | Motion, Flow | Planner |
| E (fine) | \(0-1.0\) | \(0.60\) | Motion, Flow | Planner |
| Current Slew Rate Scalars | — | — | — | — |
| XYZ (fast) | \(0-1.0\) | \(0.125\) | Motion | Planner |
| XYZ (fine) | \(0-1.0\) | \(0.110\) | Motion | Planner |
| E (fast) | \(0-1.0\) | \(0.50\) | Motion, Flow | Planner |
| E (fine) | \(0-1.0\) | \(0.50\) | Motion, Flow | Planner |
| Extruder Heuristics | — | — | — | — |
| Pressure Offset | \(N\) | \(15.0\) | Planner | |
| Reset Balance | ratio | \(0.80\) | Planner | |
| E Rate Limit | \(mm^3/s\) | \(75.0\) | Planner | |
| E Acceleration Limit | \(mm^3/s^2\) | \(40000.0\) | Planner |
| Run File Content | Units | Notes |
|---|---|---|
| Per-Segment Variables | — | |
| Max Overall Rate | \(mm/s\) | Enforced for part cooling and flow heuristics. |
| Max XYZ Current Deployment | \(0-1.0\) | |
| Max E Current Deployment | \(0-1.0\) | |
| Max XYZ Current Slew Rate | \(0-1.0\) | |
| Max E Current Slew Rate | \(0-1.0\) | |
| Fixed Variables | ||
| Nozzle Temperature Setpoint | \(^{\circ}\text{C}\) | |
| Retract Target Pressure | \(N\) | |
| Retract Reset Asymmetry | \(0.0-1.0\) |
At first glance it might look like we replaced one set of parameters (Table 5.1, 5.3, 5.2) with another (Table 5.5), but in our workflow the heuristics are mediated by models: flowrates are set by targeting an allowable pressure that is scaled by the flow model, and motion (speed and acceleration together) is scaled via the motion model, by specifying how much current the machine should be allowed to deploy for different parts of the path. Whereas the state-of-the-art workflow requires us to re-tune parameters for any change to the machine, material, or nozzle, here we can instead modify the underlying models and cast the same set of heuristics through them: the preprocessor and planner work together to adjust real-time control outputs accordingly.
5.4 Hardware for Feedback-Based FFF
In order to develop and deploy this new workflow, we are going to need some hardware. In this section I will explain the two machines I developed for this chapter: the first was my development mule, the second is a minimally modified off-the-shelf machine.
5.4.1 The RheoPrinter
The RheoPrinter is a custom-built machine for the purposes of this project. The hardware is representative of most commercially available FFF 3D printers, except for the addition of instruments in the hotend, as detailed in the figure above.
I originally included a filament sensor on the machine to detect changes to filament width and slip between the extruder drive gears and filament, based on a design that was developed by Thomas Sanladerer [41]. Use of this instrument is not outlined in this thesis; it became mostly redundant once the extruder motor models were sufficiently well-developed.
5.4.2 The FrankenPrusa
While the hardware on the RheoPrinter has a similar mechanical architecture to state-of-the-art printers, the particular implementation is of course different than any off-the-shelf printers available. Motors are larger with more rotor inertia, axes are heavier, and of course the friction values are different. It also uses an extruder and hotend combination that (while commercially available) is not implemented in any particular off-the-shelf machine.
In the evaluation of this printing workflow we are interested in comparing just this control system with the state-of-the-art. To do this without having to dissect which differences arise from actual hardware limits, I retrofit a Prusa Core One [42] with my own control boards (Chapter 3).
This involved fitting motor and kinematic models of the printer using the workflow I described in Section 4.3.1 and Section 4.3.2, and then fitting flow models using techniques described in this section. The lynch-pin for me here is that the Prusa print head (dubbed the Nextruder [43]) implements a load cell into its design - primarily used by them for bed leveling - this is not available on all SOTA printers, but it is the most important flow modeling tool in our kit.
Besides the load cell, I also added a microbolometer to the Prusa, since time series spatial thermal data is invaluable in print analysis (but not required for the work described here). All other sensing is done either with thermistors or with motor controller current measurements. For more detail on the retrofit process itself, see Section 3.6.2.
In Table 5.7 I tally the values and data rates that are returned from this set of hardware as the machine operates.
| Device, Output | Units | Rate |
|---|---|---|
| Extruder Motor | ||
| Velocity Target | \(rads/s\) | \(500\text{Hz}\) |
| Velocity Measurement | \(rads/s\) | \(500\text{Hz}\) |
| Motor Current | \(Amps\) | \(500\text{Hz}\) |
| Loadcell | ||
| Calibrated Force | \(N\) | \(250\text{Hz}\) |
| H-Bridge Module | ||
| Nozzle Temperature | \(^{\circ}\text{C}\) | \(50\text{Hz}\) |
| Nozzle Power Output | \(W\) | \(50\text{Hz}\) |
| Microbolometer | ||
| Pixel Values \((\text{24x32})\) | \(^{\circ}\text{C}\) | \(16\text{Hz}\) |
5.5 Models for FFF Flow
In this section I develop a series of models and model fitting routines for FFF melt flow operation. This includes steady state models in Section 5.5.2 and isothermal / dynamic models in Section 5.5.3. In practice flow is neither steady-state or isothermal, and so I develop a strategy to interpolate between these two models in Section 5.5.4.
This is an important set of methods in our work; models must have enough fidelity to capture the important physics (some of which are time-varying and all of which are nonlinear) and should be simple enough to fit well on the available data and to run at real-time in the machine’s motion controller.
A key difference between these models and others from Section 5.2.4.1 is that these collapse material, nozzle, and machine physics into one set of models, i.e. they work to predict volumetric flow from the nozzle tip based on extruder motor inputs using the load cell’s pressure measurement. Some internal parameters reflect real physics (i.e. the filament spring rate is measured in \(N/mm^3\)) and the inputs and outputs are measured in real physical values (torques, forces, and volumetric flowrates), but the models are not focussed on understanding rheological properties directly (i.e. material viscosities and shear rates), rather they try to predict how the system can be operated.
The reason for doing so is twofold: firstly, if we build models of our machine with our machine, we can easily turn around and use those models in control. The second is that because our ultimate goal here is to control the system, it is actually easier to model the system as a whole rather than as constituent components. Although these models do break apart into a few pieces (motor models, isothermal flow models and steady-state flow models), overall we limit the number of free parameters to fit by collapsing (some) internal states.
Models are evaluated in Section 5.10.1 by reporting model errors for real world prints (comparing the planner’s pressure predictions to measured nozzle pressures), and in more detail in Section 5.10.6.
5.5.1 How Flows are Modelled in This Work
Modelling polymer flows for 3D printing was perhaps the most confounding task that I took on in this thesis, and the most surprising. Like with any good problem, each time I thought that I had understood it, another layer of complexity would reveal itself.
In building predictive flow models, we are trying to understand what flowrate will emerge from the tip of the nozzle at any given time (I will use \(Q_{\text{out}}\) for this value, in \(mm^3/s\)). The value depends on a handful of inputs, which I enumerate below.
- The polymer has a viscosity that is dependent on it’s temperature and shear rate (i.e. nozzle pressure) - polymers actually become less viscous when they are under pressure (this is called shear thinning).
- The filament between the extruder’s drive gears and the nozzle is compressible, and so we must build pressure before extrusion begins and measure the stiffness of the material (that stiffness also changes with temperature).
- The extruder motor has its own dynamics that must be coupled into the flow system.
- The thermal history of the filament in the melt zone needs be considered: the melt flow temperature \(T_{\text{melt}}\) takes time to come up to the nozzle’s temperature \(T_{noz}.\) At high extrusion speeds the melt flow does not reach this temperature before it is extruded, leading to colder flows where we need more pressures to achieve the same flowrate.
This means that there are a number of internal states between the inputs to the system that we can drive (the nozzle temperature \(T_{noz}\) and the extruder motor’s torque \(\tau_e\) ) and the outflow \(Q_{\text{out}}\) that we would like to predict and ultimately control. At an overview, the system has three core steps, that I try to diagram below.
- The motor model (which is coupled to filament dynamics) tells us what inflow (flowrate at the top of the melt zone \(Q_{in}\)) will be generated over time, given torques \(\tau_e.\)
- \(Q_{in}\) generates pressure in the nozzle \(F\) while \(Q_{\text{out}}\) relieves pressure in the nozzle.
- The nozzle pressure and the melt flow temperature can predict the actual outflow: \(Q_{\text{out}} = f_{\text{flow}}(F, T_{\text{melt}})\)
- The history of flow velocity in the melt zone is used to predict the actual melt flow temperature \(T_{\text{melt}}\)
Below is a simplified diagram of these components.
\[ \begin{aligned} \tau_e &\rightarrow f_1(Q_{in}, \dot{Q}_{in}, F) \rightarrow Q_{in} \rightarrow f_2(Q_{in}, Q_{\text{out}}, T_{\text{melt}}) \rightarrow F \rightarrow f_3(F, T_{\text{melt}}) \rightarrow Q_{\text{out}} \\ T_{noz} &\rightarrow f_4(Q_{\text{out}}) \rightarrow T_{\text{melt}} \end{aligned} \tag{5.1}\]
There are a number of interactions between these model components: nozzle pressure and inflow (and acceleration) affect the motor model, inflow, outflow and the melt temperature change the pressure (warmer flows are softer), and the melt temperature - the most difficult to predict - both predicts flow and is a function of flow history. Make the pressure measurement \(F\) directly is key, because it lies between the pressure generating half of these flow models, and the flow generating half.
The motor models were explained in Section 4.3.1; in 5.6 I show how those are connected to the extruder system.
Filament compressibility is modelled using a spring rate \(k_{sq},\) which is interpolated across temperatures. The ODE that describes this component is below: change in nozzle pressure is the change in the volume of filament between the drive gears and the nozzle times our spring rate; the spring rate has units \(N/mm^3\).
\[ \dot{F} = (Q_{in} - Q_{\text{out}})k_{sq} \tag{5.2}\]
To model flowrates as a function of nozzle pressure I use a generic power function, with a linear parameter and power parameter: those two are also interpolated across temperatures.
\[ Q = (F \cdot k_{lin} )^ {k_{pow}} \tag{5.3}\]
I fit two models for flow: behaviour in steady-state (\(Q_{ss},\) where behaviour is dominated by thermodynamics) and in isothermal conditions (\(Q_{iso},\) where it is dominated by the actual underlying rheology, see Section 5.5.2 and 5.5.3 for more details and fitting routines). Both take on the same shape as in the equation above, but with different parameters.
The most difficult step is in estimating \(T_{\text{melt}},\) for that I interpolate between the two flow models - see Section 5.5.4.
I use these models to make print-scale planning choices (for nozzle temperature) in Section 5.8 (in combination with cooling models, 5.7), and in realtime machine control in Section 5.9.
5.5.2 Fitting Steady-State Flow
Given that we start with little or no information about our system (besides the motor model), our first modelling challenge is to find the maximum flowrate that can be achieved at any given temperature. This sets an initial boundary for operation within which our tests for dynamic parameters can be performed without fear that we will operate the machine in a failure mode; we want our tests to be non-destructive, so that we can proceed without having to manually reload or reset filament, etc.
I developed a simple open-loop test for this that is quick, repeatable, and provides us with enough information to determine a few key parameters: (1) a linear fit for maximum flowrate across temperatures and (2) a nonlinear fit that gives us the steady-state flowrate at any nozzle pressure and temperature. The data from this test is also used in Section 5.7.1 to estimate the filament’s volumetric heat capacity, which can be used in conjunction with simple cooling models to generate minimum layer times (more on those later).
1. Heat the nozzle to its maximum temperature.
2. Set the extruder's velocity controller setpoint to our test rate.
3. Turn the nozzle heater off.
4. While the velocity controller's error is below some threshold:
- Collect time series data for:
- Loadcell Force
- Extruder Motion States
- Nozzle Temperature
- IR Frames
5. Restart the test at the next flowrate.The test heats the nozzle to its maximum temperature, turns the nozzle heater off, and then drives the extruder motor at a set of constant rates while measuring all of our system states. The nozzle temperature decays naturally, pressure rises, and the test stops when the extruder motor’s velocity controller fails to maintain the target rate, i.e. maximum torque cannot sustain flow. To avoid shearing brittle materials, the test can be configured to limit extruder torque.
After this test, I first fit a linear model for the minimum flow temperature across flowrates. The zero crossing of this linear fit is an initial estimate of the nozzle temperature where we might expect any flow to be possible \(T_{\text{min}}\) - which we will use to normalize temperature ranges in some of the next steps’ fits.
As I described above in 5.5.1, we can fit a power function to the relationship for flowrate, given nozzle pressure and temperature:
\[ Q_{ss} = f_{ss}(F, T_{noz}) = (F \cdot k_{lin} )^ {k_{pow}} \tag{5.4}\]
Where \(k_{lin}, k_{pow}\) vary across temperature, according to:
\[ \begin{aligned} T_{norm} &= \frac{T - T_{\text{min}}}{T_{\text{max}} - T_{\text{min}}} \\ k_{ss,lin} &= T_{norm} \cdot a + b \\ k_{ss,pow} &= T_{norm} \cdot c + d \end{aligned} \tag{5.5}\]
I fit these four parameters \(a, b, c, d\) alongside \(T_{\text{min}}\) (which is initialized using the estimate generated in Figure 5.15) with scipy’s minimize routine [44] using the L-BFGS-B solver [45]. Here, I can fit the entire state space at once (rather than in time-series) because there is no time dependence in the steady-state system. This function nets us the contour plot below, which maps the steady-state characteristics of a particular material and nozzle.
To re-iterate, this is not exactly a model of the material or nozzle - i.e. we cannot extract the material’s viscosity from the model - instead it models the system as a whole. I call it a map because it shows us where it is possible to operate our machine in the space of flows, temperatures, and pressures.
5.5.3 Fitting Isothermal Flow and Compression
The steadystate model helps us to set operating boundaries for our machine, but it does not properly model operation of the system during short time intervals. In practice, most FFF printing is dynamic: machines are constantly accelerating and decelerating and flow targets are correspondingly increasing and decreasing such that track widths remain consistent.
The isothermal pressure to flow relationship itself can be modelled with a similar power function to the one we saw in the section above, but to a different set of parameters, and now using the melt flow temperature \(T_{\text{melt}}\) rather than the nozzle temperature. In isothermal operation, we also have to consider the filament’s compression dynamics, which are modelled (as discussed) by the ODE in the second row of Equation 5.6 below.
\[ \begin{aligned} Q_{iso} &= f_{iso}(F, T_{\text{melt}}) = (F \cdot k_{lin} )^ {k_{pow}} \\ \dot{F} &= (Q_{in} - Q_{\text{out}})k_{sq} \end{aligned} \tag{5.6}\]
Again, \(k_{lin}, k_{pow}\) vary across temperature, as does the spring rate, according to another set of parameters:
\[ \begin{aligned} T_{norm} &= \frac{T - T_{\text{min}}}{T_{\text{max}} - T_{\text{min}}} \\ k_{sq} &= T_{norm} \cdot e + f \\ k_{iso,lin} &= T_{norm} \cdot g + h \\ k_{iso,pow} &= T_{norm} \cdot l + m \end{aligned} \tag{5.7}\]
To generate data for these fits, we have the problem that we cannot measure \(T_{\text{melt}}\) (which deviates from nozzle temperature after long periods of high flowrates) directly. To approximate isothermal operation, I run a quick chirp test (oscillating the extruder motor’s velocity) through the system, after allowing filament to dwell in the nozzle for thirty seconds. This mostly avoids generating data whose phenomenology is dependent on filament heating. The chirps are operated at a pre-determined set of temperatures (a simple range of \(20\,^{\circ}\text{C}\) intervals from \(T_{\text{min}} \rightarrow T_{\text{max}}\)). Chirp amplitudes are chosen as a proportion of the steady-state maximum flowrates possible at those temperatures, and their frequencies and duration are fixed via a test configuration.
Because the filament compression is time-dependent, I fit these six parameters \(e, f, g, h, l, m\) (now using the \(T_{\text{min}}\) fit on the steady-state test) against time-series data using a simulation of the system that is driven with the same inputs as were recorded in the test routine. A simulated system is rendered below against time-series data.
The cost function for the fit (again using scipy’s minimize utility with the L-BFGS-B solver) compares time-series of the simulated system’s internal pressure state against the measurements. This modelling step is a key differentiator between this work and other modelling efforts, where direct measurements of \(Q_{\text{out}}\) are required. Those are difficult to make, as I discussed in Section 5.2.3.3. Using the internal pressure state is possible if we can trust the surrounding models; a key insight in this case is that the pressure \(F\) is related both to \(Q_{in}\) (which increases pressure, and we can measure directly) and to \(Q_{\text{out}}\) (which decreases pressure, but we cannot measure) - for our model to be consistent, it needs to explain pressure generation and decay.
Finally, we can generate an isothermal map of the same operating space (pressure, flow, temperature). Again, we make one of these maps for any material and nozzle combination.
5.5.4 Interpolating Between Steady-State and Isothermal Operation
The tests developed here are designed to provide explicitly steady-state and isothermal data separately. In practice, the machine operates somewhere between these two ranges: long, fast sections of infill might get us close to steady-state operation, whereas slow, detailed sections of a print are close to isothermal.
Modelling this properly as a history dependent thermodynamic system would be difficult because it would add a few new internal parameters like filament conductivity, heat capacity, and might require that we accurately estimate the nozzle heater’s thermal mass, etc. I discuss the possibility of taking this on in Section 5.12.1, but in this cycle I take the approach of interpolating between steady-state and isothermal models using a measurement of the average flowrate of the filament in the melt zone.
First, let’s look at both models, Figure 5.20 shows steady-state and isothermal maps for PETG using a 0.6mm brass nozzle.
In the steady-state model, as pressure increases, steadystate flow increases but at a decaying rate - i.e. for every additional N of load, we get less return on flow (\(k_{pow} < 1.0\)). However, on shorter time-scales, this is reversed: flow increases at an increasing rate for every additional N of load (\(k_{pow} > 1.0\)).
The decaying power in steadystate can be understood as the melt flow’s temperature dropping at larger rates (thus increasing its viscosity, and increasing the force required to extrude). On short time scales, we see polymer shear thinning, a phenomenon observed in non-newtonian fluids where increases to pressure (… shear) drop the flow’s viscosity [17].
The steady-state and isothermal maps are both temperature contours in the (pressure, flowrate) space. If we pick any point here, we have two temperatures: one from the steady-state model, and one from the isothermal model.
While the two models mostly overlap near the origin, the steady state model predicts larger temperatures than the isothermal model as speeds and pressures increase. If we subtract the isothermal temperature from the steady-state temperature across the operating space, we get a third map that corresponds to temperature drop of the melt flow from the nozzle temperature. In that map (in the top right of Figure 5.21), the X axis is the average flowrate of the melt flow within the nozzle, the Y axis is the extrusion pressure, and the contour (color-mapped) is the drop between the nozzle temperature and the melt flow temperature.
By taking a slice of this model at the operating nozzle temperature, we can plot the expected temperature drop as a function of average flowrates at that temperature. That’s above in Figure 5.21, and is the information we will need later when we deliver these models to the machine controller, which uses this curve to estimate the actual melt flow temperature during operation.
5.6 Models for Extruder Motors
The models above are sufficient to understand the flow dynamics in nozzle. However, we need to drive those dynamics with our extruder motor. I already covered the relevant motor physics (and our modelling strategy for the same) in Section 4.3.1, but for a short reprisal: motor torque \(\tau\) is proportional to stator current \(I\). Current generation is limited by the motor’s construction, our driver’s power electronics, and by motor speed. In this section, I will describe how I couple motor models to flow models using a few additional parameters, and how those parameters are fit to data.
Motor dynamics are typically coupled into motion systems that have fixed mass and damping, and the extruder motor is similar: the filament sliding around between the spool and the motor (and on its way towards the melt zone) produces friction (damping), and it has some mass, as does the motor’s own rotor. In the case of the extruder motor, I fit these terms against the volumetric flowrate at the motor, \(Q_{in}\), which is proportional to the extruder motor velocity \((rads/s)\) via the extruder’s drive ratio (a scalar that describes the volume of filament that is extruded for each motor rotation). This scalar is measured and defined by hand, and used to calculate the motor rotor’s actual speed for the electrical half of the motor model.
For flow, we need to add new parameters that describe the amount of current required to generate pressure in the nozzle. For this I fit a current offset \(k_{off}\) and proportion \(k_f\). The total accounting for extruder current prediction is in Equation 5.8.
\[ \begin{aligned} I_{\text{extr}} &= Fk_f + k_{off} + Q_{in}k_d + \dot{Q}_{in}k_a \\ k_f &= \text{Linear Load Factor} \ (A/N) \\ k_{off} &= \text{Load Offset} \ (A) \\ k_{d} &= \text{Damping} \ (A/mm^3/s) \\ k_{a} &= \text{Inertial} \ (A/mm^3/s^2) \end{aligned} \tag{5.8}\]
We have in total three states that are combined to predict extruder current, along with one offset. In Figure 5.22, I plot data points from the isothermal flow chirp test in two spaces: load vs. current and flowrate vs. current, with data point colours mapped to additional states.
Finding the parameters for this model is simple with time series data, where I can simply fit parameters such that the measured states properly predict the measured extruder motor current.
Extruder current is typically dominated by the nozzle load, with a smaller damping parameter and even smaller acceleration parameter. Even though it looks small, the acceleration parameter often becomes the critical limit during dynamic moves where optimal inflow acceleration requests can exceed \(50000mm^3/s^2\). Parameters from an example fit are called out in Figure 5.23 below, where I compare time series measurements (in blue) to the model’s estimates (in orange).
5.7 Models for FFF Cooling
So! Our models so far explain how our extruder operates as it is printing a new track of filament, but it is also invaluable to be able to estimate how long it will take for that track to cool to a temperature where it is solid enough to print the next track on top of it, as I discussed in Section 5.2.1.2. For this task, I will show how the steady-state test data can be used to (approximately) measure our material’s volumetric heat capacity, and then develop a simple cooling model using that measurement and some other estimates.
5.7.1 Volumetric Heat Capacity
While it is difficult to develop a complete thermal model of our filament, we can at least estimate its volumetric heat capacity \((J/mm^3)\). We can make this estimate using data from our steady-state tests, where nozzle temperature decays due to losses into ambient environment and loss into the filament flow. For example in Figure 5.14, it is clear that nozzle temperature decays much faster at higher flowrates than at lower flowrates. To convert these losses into estimates that have real-world units, we use our knowledge of how much power is delivered to the nozzle at any given time, which we can measure with the nozzle’s thermal controller.
We begin with a model that estimates the change in nozzle temperature over time Equation 5.9.
\[ \begin{aligned} \frac{dT}{dt} = (T_{amb} - T) k_{loss} + {Q}(T_{amb} - T) k_{\text{flow}} \end{aligned} \tag{5.9}\]
| Symbol | Units | Value |
|---|---|---|
| \(T\) | \(^{\circ}\text{C}\) | Nozzle Temperature |
| \(T_{amb}\) | \(^{\circ}\text{C}\) | Ambient Temperature |
| \(Q\) | \(mm^3/s\) | Volumetric Flowrate |
| \(k_{loss}\) | \(({C/s}) \cdot {\Delta T}\) | Heat Loss to Ambient |
| \(k_{\text{flow}}\) | \(((C/s) / (mm^3/s)) \cdot {\Delta T}\) | Heat Loss per unit of Flow |
The \(\Delta T\) we use for each of these losses is from ambient temp \(T_{amb}\) to the nozzle temperature \(T\). This makes the assumption that filament heats from ambient up to the nozzle temperature before exiting the nozzle, which we know that is not always entirely true — especially at large flowrates — but it nets us an estimate that is sufficient. To fit, we first estimate the total loss across each flowrate, as in Figure 5.24.
We can then plot the total losses at each flowrate. This fits a simple linear relationship, where we estimate that the offset represents our loss to ambient, and the slope represents additional loss for every unit of filament flowrate.
These losses are not yet power measurements. To back out a heat capacity, we need to measure the wattage required to move the nozzle temperature. For this, we can fit an additional parameter that is active when the nozzle is warming up.
\[ \begin{aligned} \frac{dT}{dt} = k_{in}W_{in} + (T_{amb} - T) k_{loss} \end{aligned} \tag{5.10}\]
| Symbol | Units | Value |
|---|---|---|
| \(T\) | \(^{\circ}\text{C}\) | Temperature of Flow |
| \(T_{amb}\) | \(^{\circ}\text{C}\) | Ambient Temperature |
| \(k_{in}\) | \((C/s) / W\) | Change in Temperature per Watt |
| \(k_{loss}\) | \(({C/s})\cdot{\Delta T}\) | Heat Loss to Ambient |
We can measure the power into the nozzle \((W_{in})\) by measuring our heater’s resistance and the controller’s supply voltage.
We can now combine our measurements to produce an estimate for the filament’s heat capacity. If we do a bit of units analysis (see 5.11), we can see that the volumetric heat capacity \(C_v\) is equal to \(k_{\text{flow}} / k_{in}\).
\[ \begin{aligned} C_v &= k_{\text{flow}} / k_{in} \\ &= \left( \frac{C/s}{mm^3/s} \cdot {\Delta T} \right) / (\frac{C/s}{W}) \\ &= \frac{C/s}{mm^3/s} \cdot {\Delta T} \cdot \frac{J/s}{C/s} \\ &= \frac{J}{mm^3} \cdot \Delta T \end{aligned} \tag{5.11}\]
It is more common to measure specific heat capacity of materials (i.e. \(J/kg \cdot \Delta T\)), but in our case volumetric units are more useful since we extrude in terms of \(mm^3,\) not by weight, and we anyway don’t have an estimate for material density.
Our measurements are not incredibly precise, but do put us in a reasonable ballpark for the real physical value. Polymer heat capacity is anyway nonlinear in practice, with e.g. different phases of each polymer having different heat-carrying capabilities (not to mention density changes). For our purposes an estimate is good enough.
5.7.2 Layer Cooling Time
Whereas slicers use direct parameters to control part cooling (see Table 5.3 and 5.2.1.2), I replace those with a model that estimates minimum layer time (\(t_{\text{min}},\) the time that we need to wait after printing a track before we can print on top of it without risk of slumping) for any nozzle temperature.
The rate at which the fan cools the layer is dependent on many things: the polymer’s heat capacity, its temperature, the temperature of the surrounding layers, the print geometry, and the fluid dynamics of the cooling air, the chamber temperature, etc. We will build a simple model of this that excludes those fluid dynamics, and also ignores thermal history beyond the previous layer.
For material parameters, we have the filament’s volumetric heat capacity (estimated in the section above), but we need also the filament’s conductivity \(\kappa_{fil}, \ (W/m \cdot \Delta T)\). It seems possible to estimate this value (since it factors in the filament’s ability to absorb heat from the nozzle, see 5.5.4), but I resort to estimates for this value instead; the typical range for our common polymers is \(0.1, 0.25\).
We also need to estimate the effectiveness of our printer’s cooling system. This is encoded in \(h_{air}, \ (W/m^2 \cdot \Delta T)\) — energy flow out of the filament into the print chamber. An intuitive sense for this value is that it lies somewhere in the range \(10, 100\), and fan-driven cooling rates are relatively well tabulated in engineering references. Luckily this value is tied to the machine (not the material), so we can tune it over time.
We use the materials’ conductivity to estimate the cooling rate into the layer below \(h_{layer}, (\ W/m^2 \cdot \Delta T)\) - this is a function of the layer height, and is further shimmed by an estimate of the layer to layer contact \((l_{iface})\), giving us \(h_{layer} = (\kappa_{fil} / H) \cdot l_{iface}\).
Finally we need to pick a target cooling temperature \(T_{targ}\) - we want this to represent the temperature where our layer is going to be solidified enough to support subsequent layer geometry. This is a real decision variable: for intricate parts we want our previous layers to be relatively cold. With large, blocky prints we can get away with a bigger value here. I tune this relative to the material’s zero flow temperature (from Section 5.5.2). My reasoning is that, when the material is cold enough that it cannot be extruded, it will be relatively stiff. This is exposed as one of the preprocessor inputs as a \(\Delta T\) such that \(T_{targ} = T_{\text{min}} - T_{cool}\)
| Symbol | Value | Units | Source |
|---|---|---|---|
| \(H\) | Layer height | \(mm\) | Part Geo. |
| \(l_{iface}\) | Layer interface proportion | 0-1.0 | Part Geo. |
| \(\kappa_{fil}\) | Filament conductivity | \(W/m \cdot \Delta T\) | Estimated |
| \(C_{fil}\) | Filament heat capacity | \(J/m^3 \cdot \Delta T\) | Model Fit |
| \(T_{noz}\) | Nozzle temperature | \(^{\circ}\text{C}\) | Direct Measurement |
| \(T_{targ}\) | Cooling target temperature | \(^{\circ}\text{C}\) | From Flow Models |
| \(T_{amb}\) | Ambient temperature | \(^{\circ}\text{C}\) | Known |
| \(h_{air}\) | Heat transfer to air | \(W/m^2 \cdot \Delta T\) | Estimated |
| \(h_{layer}\) | Heat transfer to layer below | \(W/m^2 \cdot \Delta T\) | Via \(fil_k\) |
We can work out a cooling time constant \((\tau)\) using Equation 5.12, and an equilibrium temperature \((T_{eq})\) using Equation 5.13. Finally, we use these to calculate the layer cooling time \((t_{\text{min}})\) with Equation 5.15.
\[ \begin{aligned} \tau = (C_{fil}) / (h_{air} + h_{layer}) \end{aligned} \tag{5.12}\]
\[ \begin{aligned} T_{eq} = \frac{(h_{air} \cdot T_{amb} + h_{layer} \cdot T_{targ})}{(h_{air} + h_{layer})} \end{aligned} \tag{5.13}\]
\[ \begin{aligned} h_{layer} = (\kappa_{fil} / H) \cdot l_{iface} \end{aligned} \tag{5.14}\]
\[ \begin{aligned} t_{\text{min}} = -\tau \cdot log((T_{targ} - T_{eq})/(T_{noz} - T_{eq})) \end{aligned} \tag{5.15}\]
This model is approximate. For example our equilibrium temperature calculation assumes that the previous layer’s temperature is a boundary condition, when of course it actually continues cooling into the layer below it as time progresses. This means that we probably over-estimate layer cooling times, especially in large prints. Our model could be extended across each layer, but we would need to develop a much more complex (and probably geometric) solver for this — the approximation works well enough especially considering that we are already estimating \(h_{air}\) and the filament’s conductivity. In Section 5.12.3.3 I discuss the possibility of using the microbolometer that I have attached to the RheoPrinter and FrankenPrusa’s hotend to fit these cooling models (and other relevant melt flow physics).
5.8 High Level FFF Planning
OK. By now we understand the models that our machine can fit for flow (and its coupling into the extruder motor) and for layer cooling. The point of this exercise is not just about understanding our machine and materials, it is to enable better operation of our machine. So, we now return to the workflow itself (from Section 5.3), and look at the preprocessor step (see Figure 5.9). This is where we combine our part file (geometry) and models with heuristics to select high level operating parameters.
In this section I will show how I combine heuristics with flow models to generate processing parameters across any nozzle temperature, and then how nozzle temperature can be selected automatically for time optimality (i.e., printing as fast as possible). In Section 5.12.4, I discuss how this method could be extended to select parameters as a trade-off between a number of optimalities (speed, strength, and precision).
5.8.1 Selecting Flowrates using Models and Heuristics
I use the isothermal map (5.5.3, and shown below) to select flowrates for printer operation. These work well to encode the extruder system’s real physical constraints which are defined by two boundaries. First (small dashed line) is the nozzle’s maximum temperature, a pure hardware limit (hotter temperatures would soften some of the extruder’s own construction). Second we have (longer dashed lines) the steady-state flow boundary: this is extracted from the steady-state flow model and plots the maximum sustainable flowrate across nozzle temperatures (see Figure 5.16).
Models do well to describe these boundaries, but I found that actually printing with these models required that I mix in some heuristics to make selections within those boundaries. In Section 5.12.4 I discuss how the methods in this chapter could be extended to completely remove this heuristic selection step, but I also discussed in the introduction that turning our digital fabrication workflows into completely autonomous black boxes may not be so valuable: heuristics can be extremely valuable.
Rather than applying heuristics directly (picking flowrates outright as is done in the state-of-the-art), we can apply them through models, so that heuristic choices are updated to reflect changes in the underlying constraints. For example in this step I add a lower temperature boundary (solid black line), which is defined by selecting a minimum \(Q_{\text{max}}\); this is the temperature where the steady-state boundary crosses a selected flowrate that we know (heuristically) represents a reasonable lower bound for flowrates. For example in all of the printing that I did with this system, I used \(15 mm^3/s\) to select minimal operating nozzle temperatures, which is rendered in Figure 5.26.
These boundaries set us up with a space of nozzle temperatures and flowrates that we know will be viable. We still want to select actual flowrates for the part geometry. Here, we apply another set of heuristics. Recall from 5.3 that the path geometry components are binned into line segments for part infill, perimeters, and details. For each segment type, we pick a scalar in \(0-1.0\) where \(1.0\) represents the pressure required to generate the maximum flowrate at the selected temperature. The scalar selects for a flowrate between zero flow / zero pressure, and this maximum. Figure 5.27 demonstrates this process, using PLA and PETG models and applying the same temperature and flowrate heuristics to both.
| Input | Selection | Resulting Flowrate |
|---|---|---|
| Temperature | \(210\,^{\circ}\text{C}\) | — |
| Infill Scalar | \(0.90\) | \(18.6 mm^3/s\) |
| Perimeter Scalar | \(0.75\) | \(11.8 mm^3/s\) |
| Detail Scalar | \(0.60\) | \(6.8 mm^3/s\) |
| Input | Selection | Resulting Flowrate |
|---|---|---|
| Temperature | \(210\,^{\circ}\text{C}\) | — |
| Infill Scalar | \(0.90\) | \(16.8 mm^3/s\) |
| Perimeter Scalar | \(0.75\) | \(11.6 mm^3/s\) |
| Detail Scalar | \(0.60\) | \(7.4 mm^3/s\) |
This process nets us maximum flowrates per segment type, and maximum translational rate for each individual segment (dividing the segment’s width (which is effectively \(mm^3/mm\)) by the selected flowrate for that segment type). This encodes both flow heuristics (flow is tidier and more linear at lower pressures) and motion heuristics: we care more about the quality of our part’s perimeters and details than we do about its infill, and lower speeds will generate cleaner motion trajectories. By selecting larger pressure scalars for infill, we allow the machine to use more translational velocity there but that velocity is carefully calibrated with respect to flow. Accelerations are also model / heuristically tuned using current scalars, as I discuss under the next heading.
5.8.2 Applying Acceleration and Jerk Heuristics
As I mentioned above, we typically care more about the quality of our print’s outer tracks (perimeters) than its infill. We also know that when a motion system is operating near its limits, it will generally move with less grace. This is a relatively imprecise statement, but we are talking about heuristics here.
The state-of-the-art workflow lets us tune translational rates and accelerations (across segment types) directly. As I’ve discussed, this presents the issue of scaling flowrates alongside translational rates; making modifications to the motion system parameters changes flow parameters even though the change is not reflected anywhere. It also does not show us how close to the motion system’s actual limits those rate selections are, we must guess and check. Our strategy here uses flow models and normalized pressure targets for the same task, as I described above.
We also want to scale acceleration and jerk (its derivative). We have an excellent basis for this in the motion models of our machine, whose fundamental limits come from current saturations in the actuators (see Section 4.3). If we scale the maximum current that the machine is allowed to deploy, we scale its acceleration. Here I use the same strategy as in the flowrate selection: using a scalar to de-tune the system from the model-defined limits, rather than setting limits directly.
To tune jerk, I scale the actuators’ deployment of \(\dot{I},\) the rate of change of current. Reducing jerk further smooths motion and reduces the frequency of the disturbances that the actuators will send into the mechanical system. In Section 4.8.5 I discuss the missing component of these models, which would address resonant excitations of our systems directly.
In all, we have eight heuristics that we apply at this level, all listed in Table 5.5 under Current Scalars and Current Slew Rate Scalars. The preprocessor applies those on a per-segment basis to the geometry, which can be seen in Table 5.6.
5.8.3 First Layer Speed
Finally, we have this last pure heuristic to apply. FFF veterans know well that the quality of a print’s first layer is critical. In fact, there is an entire subreddit dedicated to images of high quality first layers6. The main difference between this layer and the rest is that it must adhere to the printer’s bed, rather than to itself. Depending on how readily our print material sticks to our bed material, we want to reduce the speed at this layer so that adhesion is sure to work. It is almost always the case that bed adhesion is much worse than layer-to-layer adhesion: bed are engineered to stick well (but not so well as to prevent us from retrieving our prints!). To ameliorate this, first layers are normally printed at ~ 20% of the “normal” speeds. Lowering the speed gives the polymer more time to bond to the bed, and reduces vibrations or other errors that arise from translating around too fast.
While it should be possible to build a model for bed (and inter-layer) adhesion, I have not tried to do so. So, we stick with heuristics: first layer speeds are capped at some direct value, which can be calculated as 10% of the maximum flowrate given by our extruder model, or set directly as a maximum traversal rate in \(mm/s.\)
5.8.4 Time-Optimal Nozzle Temperature Selection
OK - flow models show us where operation of our hardware is possible, and we just developed some methods to pick actual parameters for operation using heuristics \(\times\) models at any nozzle temperature. We still need a good way to actually select that temperature, which is probably the single most important parameter in FFF printing: changes to nozzle temperature change almost all other aspects of the system.
One of the surprising advantages of the model-based workflow is that it enables us to select good parameters across nozzle temperatures: everything else is updated automatically. In the state-of-the-art, it is most common for values to be tuned by hand around some temperature, i.e. the nozzle temperature is refined first, and then everything else is dialled in around it.
While I discuss how we might get smarter about multi-objective print optimizations in Section 5.12.4, for now I am framing this as a time-optimal selection with heuristics applied such that we also produce parts of reasonable quality. But! If we were to select based on flowrates alone, we would surely always pick the hottest nozzle temperature (since this is where flowrates are maximized with minimal pressures). Surely this is not really optimal, because (as discussed in Section 5.2.1.2) part cooling is also important: using excessively hot print temperatures leads to part slumping.
As it turns out, there is a very clear optimization to run here: hot nozzles give us large flowrates, but subsequently increase layer cooling times. Colder nozzles reduce flowrates, but also decrease layer cooling times. So the trade-off emerges around part geometry; large parts (with already long layer times) should tend towards hotter print temperatures, whereas smaller parts (where new layers appear faster) should tend towards colder nozzle temperatures.
I already explained how the minimum layer time is calculated for any material and nozzle temperature (5.7). This enables us to run the per-part optimization, but we first need to develop a tool that scales layer speeds such that minimum layer times are achieved. That is next in Section 5.8.4.1, and is a method that is common in state-of-the-art slicers (although they use heuristically tuned minimum layer times, whereas ours are estimated with the cooling model). I then describe and show some results from the nozzle temperature selection optimization in 5.8.4.2; this optimization is new work.
5.8.4.1 Adjusting Segment \(V_{\text{max}}\) for Minimum Layer Times
Given a nozzle temperature and the velocity selections described above, we can estimate the total layer time for any layer in the part at any temperature. To enforce minimum layer times, we skew velocities within each layer such that the layer’s total time increases. However, we prefer to skew velocities in segments that are less critical to our overall dimensions and appearances, i.e. the infill is modified first, if this does not suffice we move to the perimeters, and if this is still not enough we modify the external perimeters. This insight comes from Prusa Research’s note on the topic [46]: polymer tracks extruded at higher speeds / pressures have slightly different visual properties (more matte) than those printed at lower speeds (which tend to be glossier). They also have different rates of die swell. To reduce these effects, we try to avoid skewing external perimeters unless it is truly necessary for the target lap time. Finally, we have a global limit to the skew, such that no segments have a translational velocity of less than \(10mm/s\).
5.8.4.2 Optimal Nozzle Temperature for Minimum Print Times
So by now we can pick a viable temperature range from some minimum up to the nozzle’s maximum, and then at any temperature we can select flowrates for each segment type, and calculate and then enforce a minimum layer time. Having done all of that work, we can easily pick a nozzle temperature that will give us the minimum total print time.
This optimization turns out to be exceptionally simple: rather than optimizing over nozzle temperature, we simply evaluate the total expected print time at every nozzle temperature between the minimum and maximum, and pick the temperature with the smallest overall time - evaluating each is relatively cheap computationally (it takes about thirty seconds to do so on a modern laptop).
The outcome is also intuitive; in smaller parts, total print time tends to be dominated by the minimum layer time and so colder nozzle temperatures (less cooling) are preferred. As parts increase in size, print time is dominated more by the flowrate / time to actually deposit the layer - so we want to increase the temperature to increase these flowrates.
There is a crossover print size that depends on our cooling models, flow models, and selected flow heuristics. i.e. in the RheoPrinter with PETG (and a 0.6mm Nozzle) I found that prints about Benchy sized (60x30mm) clearly favour cold flows, whereas even slightly larger prints (90x70mm) clearly favour maximally hot flows. Parts in between exhibit a clear time-optimum temperature somewhere between our minimum and maximum temperatures. In these cases, flowrates and layer times increase together and balance such that the average layer time naturally meets the minimum layer time (Figure 5.30). If we increase our estimate of the printer’s cooling capability, the crossover size gets smaller (and vice versa). For polymers where temperature increases don’t lead to exceptional gains in flow, colder temperatures overall are preferred, etc.
I had always thought that printers were over-optimized for producing small, detailed parts. The 3DBenchy is the de-facto parameter tuning object partially because it encapsulates lots of different features but also because it prints relatively quickly which decreases the time for human-in-the-loop tuning iterations. However, the 3DBenchy does not necessarily represent users’ most common print jobs. In mechanical prototyping especially, we typically print larger beds with i.e. multiple small parts or larger single parts. This means that print parameters have been hand tuned tend to favour colder temperatures overall, even though there are huge speed gains to be had by increasing the nozzle temperature. For example we can select a very hot flow for the larger part in Figure 5.30 (second row) that decreases the total print time from 30 minutes to 20 minutes, a substantial speedup. In the case of this work, because we develop print parameters over the entire range of viable temperatures, we can more flexibly adjust that single parameter and let our models and “model mediated heuristics” dial out the rest of the knobs.
5.9 Real-Time FFF Planning
Finally! It is time to actually operate the printer.
I have mentioned constrained optimization in a number of places in this thesis. In the last few sections, I have shown how we can build 3D printing hardware (Section 5.4) that can be used to fit models (5.5, 5.7), and how those models can be used to select and adapt print parameters, mixing heuristics with feedback (5.8.1). I also showed that nozzle temperature selection can be framed explicitly as an offline optimization (5.8.4).
Using models for high-level tasks and optimizations like those is in itself productive; in an earlier paper I used similar methods to pick key slicer parameters for state-of-the-art printers automatically [16], but they were still operated with their existing GCode interpreters. As I’ve mentioned, these are responsible for low-level control of the hardware and managing our machine’s dynamical constraints, which is primarily done with a velocity planner. Those were the topic of Chapter 4, where I developed a new type of planner that can be configured directly with models for motion. In that chapter (and here, in Sections 5.2.3 and 5.2.4.2) I often discussed how machine control is really constrained by both motion and process physics even though these are managed independently in the state-of-the-art and in most other research.
So, I wanted to see if it were possible to extend the motion controller from Section 4.6 to also optimize over constraints that emerge from process control. Doing so would show that models of machine operation can be used across multiple levels of a digital fabrication workflow. This could simplify machine systems configuration by organizing it around a shared representation of constraints rather than via multiple different hand-tuned parameter sets that each encode different aspects of the same underlying physics. It could also unlock some performance; process constraints as articulated in CAM tools need to hold in steady-state, but we have different flow dynamics in short time scales than in steady-state (see Sections 5.5.4 and 5.11.5).
In this section, I explain how I extend my velocity planner to include flow control (Section 5.9.1, 5.9.1.2, 5.9.2) and how it is connected to printer hardware via PIPES / MAXL (5.9.3). I use this planner to operate the printer in 5.10. It helps to reduce the number of parameters we must tune in that workflow (5.10.3) and its outputs can be used to learn about our hardware (5.11.1) and to more clearly connect system tuning to system constraints (5.11.2). They can also be used to inspect modelling errors’ correlation to print job errors (5.10.5).
5.9.1 Optimization Formulation
I explained how the velocity planner is structure overall in Section 4.6.1. Here we are just extending that system to add models for flow, so this section will be difficult to understand if you have not read that one.
The planner is one part of a larger FFF workflow that I described in Section 5.3. It consumes a run file from that workflow’s preprocessor. The run file contains an unplanned target trajectory of line segments. The maximum velocity \(v_{\text{max}}(s)\) for each was set using flow models and flow heuristics in 5.8.1. Each segment also has actuator current deployment scalars \(I_{\text{prop}}(s), \ \dot{I}_{\text{prop}}(s),\) these will scale each actuator’s permitted current limit from their underlying model-based maximum (each scalar is within \([0,1]\)).
Here we also have FFF-specific values. First is a target flowrate for each segment \(Q_{\text{targ}}(s)\) which is defined spatially in \(mm^3/mm;\) this is the extrudate track width: when we divide it by layer height we get \(mm^2/mm\) i.e. just \(mm.\) We also have extruder motor current scalars \(I_{\text{prop,e}}(s), \ \dot{I}_{\text{prop,e}}(s).\)
The preprocessor also adds definitions of flow models for the part and four heuristics for the extruder system. These are two direct limits to the extruder motor’s motion \(e_{\text{vmax}}, \ e_{\text{amax}}\) and two values for retractions \(F_{\text{off}}, \ e_{\text{assym}}\). I found that these were required to run the printer successfully because there seems to be some loss in two parts of the controller.
The first loss is in the extruder dynamics and the bandwidth of the extruder motor’s velocity controller. Near the end of each track the extruder needs to retract filament very quickly. This causes the extruder motor’s velocity to spike and then fall quickly back to zero. The extruder motor coupling from Section 5.6 should impose the velocity limit here based on the motor and flow system’s underlying dynamics, but the velocity controller in the motor firmware needs to track the change accurately. However, it has limited bandwidth (see Section 4.4.0.2), hence the manually imposed limit.
The retraction heuristics are a negative pressure offset \(F_{\text{off}}\) that is applied to the nozzle pressure target during non-extruding moves and then a scalar \(e_{\text{assym}}\) that is applied to the extruder motor velocity during de-retraction. I found that these were required to avoid stringing and oozing for two reasons. The first is that even at low or zero measured pressure we see some extrusion because the filament in the melt zone expands as it heats up. This is especially problematic when we finish a track that was extruded at high speeds where the melt flow’s temperature can be quite a bit colder than the nozzle temperature. The second is that the flow models do not always predict nozzle pressure perfectly: where they under-predict pressure, the planner does not retract filament sufficiently to drive the real pressure to zero.
It should be possible to remove the retraction heuristics if the flow models can be improved across more dynamical states. I discuss that task in Section 5.12.1, which would allow us to update flow models from data generated by the machine during normal operation (5.12.2). The velocity controller in the extruder could certainly be improved or should actually track cumulative position of the filament so that negative velocity spikes are integrated properly over time. The best solution overall would be to close the pressure control loop in realtime: this could be done at all times if the models for flow are well-matched to reality, or it could be implemented just during non-extruding moves to drive the pressure back to zero regardless of modelling errors. I discuss this in some more detail in Section 5.12.3.1.
OK, back on topic: we take those new target values and limits and add them to the target trajectory. The planner otherwise works in the same basic manner as previously described (4.6.1): it selects \(v(s)\) for each segment, calculates required accelerations and time-steps between each, and then broadcasts those states through machine models to compute required internal states. These are compared in a cost function to their limits, and the \(v(s)\) are optimized such that speed is maximized while constraints are not exceeded.
The basic layout of this process is below, adding flow-related components: calculating output flowrates and the melt flow temperature (Section 5.9.1.1), calculating flow dynamics (5.9.1.2) and then extruder current requirements (5.9.1.3), finally adding those new values to the cost function (5.9.2).
\[ \overbrace{ \begin{bmatrix} Q_{\text{trg}} \\ \vdots \\ \vdots \\ \vdots \\ s \end{bmatrix} \begin{bmatrix} I_{\text{prop,e}} \\ \vdots \\ \vdots \\ \vdots \\ s \end{bmatrix} \begin{bmatrix} \dot{I}_{\text{prop,e}} \\ \vdots \\ \vdots \\ \vdots \\ s \end{bmatrix} }^{\text{Additions to Input Trajectory}} \rightarrow \overbrace{ \begin{bmatrix} v \\ \vdots \\ \vdots \\ \vdots \\ s \end{bmatrix} }^{\text{Select}} \rightarrow \overbrace{ \begin{bmatrix} \vec{a} \\ \vdots \\ \vdots \\ \vdots \\ s \end{bmatrix} \begin{bmatrix} \Delta t \\ \vdots \\ \vdots \\ \vdots \\ s \end{bmatrix} }^{f_a()} \rightarrow \overbrace{ \begin{bmatrix} Q_{\text{out}} \\ \vdots \\ \vdots \\ \vdots \\ s \end{bmatrix} }^{v(s) \cdot Q_{trg}} \ \overbrace{ \begin{bmatrix} T_{\text{melt}} \\ \vdots \\ \vdots \\ \vdots \\ s \end{bmatrix} }^{\text{~ NRG}} \rightarrow \text{Below} \tag{5.16}\]
\[ \text{Above} \rightarrow \overbrace{ \begin{bmatrix} F \\ \vdots \\ \vdots \\ \vdots \\ s \end{bmatrix} \begin{bmatrix} \Delta F \\ \vdots \\ \vdots \\ \vdots \\ s \end{bmatrix} \begin{bmatrix} Q_{\text{in}} \\ \vdots \\ \vdots \\ \vdots \\ n \end{bmatrix} \begin{bmatrix} \dot{Q}_{\text{in}} \\ \vdots \\ \vdots \\ \vdots \\ n \end{bmatrix} }^{\text{Flow Dynamics}} \rightarrow \overbrace{ \begin{bmatrix} I_{\text{req,e}} \\ \vdots \\ \vdots \\ \vdots \\ n \end{bmatrix} \begin{bmatrix} I_{\text{lim,e}} \\ \vdots \\ \vdots \\ \vdots \\ n \end{bmatrix} \begin{bmatrix} \dot{I}_{\text{req,e}} \\ \vdots \\ \vdots \\ \vdots \\ n \end{bmatrix} \begin{bmatrix} \dot{I}_{\text{lim,e}} \\ \vdots \\ \vdots \\ \vdots \\ n \end{bmatrix} }^{\text{New Intermediate Values}} \tag{5.17}\]
The planner’s internal structure is diagrammed above in Equation 5.16 and 5.17, and a screen capture of the planner’s realtime plotter is in Figure 5.31, showing the motion trajectory (left) and internal states (right).
5.9.1.1 Output Flowrate and Melt Flow Temperature Calculation
To work backwards from the chosen solution for \(v(s)\) towards the system’s constraints the planner first computes the cartesian acceleration and time step required in each segment \((\vec{a}_{\text{req}}, \ \Delta t).\) That was explained in Section 4.6.1.1 and the method for broadcasting those values back through motion models is in 4.6.1.2.
In this extension of the planner, we also compute flow dynamics so that they can be compared to their related constraints. This begins with finding the flowrate at the nozzle tip, which is a simple product of the target flowrate \(Q_{\text{targ}}, \ mm^3/mm\) and the selected velocity \(v(s), \ mm/s.\) The result is \(Q_{\text{out}}\) which is in \(mm^3/s\).
We then have the more substantial challenge of estimating the melt flow’s internal temperature \(T_{\text{melt}},\) which can deviate from the nozzle temperature significantly after periods of sustained outgoing flowrates, see Section 5.5.4.
I do this using an approximate energy model that cumulatively sums the “dwell time” for the filament in the melt zone, i.e. how long on average the filament in the melt zone has spent between the start of the heater block and the nozzle tip. Let’s call this \(t_{\text{dwell}},\) it is measured in seconds. This method uses a measurement of the total volume of the melt zone \(\mathcal{V}_{\text{melt}}, mm^3\) which is a simple diameter \(\times\) length of the melt zone. Special warning: \(\mathcal{V}\) here is volume, not velocity \(v\).
We cannot explicitly parallelize this calculation because it is history dependent. However, we can use an associative scan [47] which reduces time complexity from \(O(N)\) to \(O(log N)\) using a tree-reduction algorithm. This is implemented natively in JAX which also handles differentiation of the scan for us [48].
The associative scan requires that we formulate the computation with two prefixes, here I have one that describes a proportion of time that is added to the integral at each step and a proportion that is removed from the integral at each step:
\[ \begin{aligned} \text{out} &= 1.0 - Q_{\text{out}} \Delta t \\ \text{in} &= \mathcal{V}_{\text{melt}} \Delta t \end{aligned} \tag{5.18}\]
This is perhaps a bit non-intuitive, my best explanation is this: at each step we add an amount of time that is scaled by the melt zone’s volume, and we remove the proportion of that time that has flowed out of the nozzle tip. After running these operators to the scan, we get the melt flow’s dwell time for each step along the trajectory. We can use that to calculate the average flowrate within the melt zone:
\[ Q_{\text{avg}} = \mathcal{V}_{\text{melt}} / t_{\text{dwell}} = mm^3 / s \tag{5.19}\]
In Section 5.5.4 I showed that we can extract a curve at the nozzle’s temperature that plots the temperature difference between the steady-state and isothermal flow models for any \(Q_{\text{avg}}\) (Figure 5.21). Evaluating that curve returns an estimate of the actual melt flow temperature \(T_{\text{melt}}\).
5.9.1.2 Flow Dynamics Calculation
Given the melt flow’s temperatures, we can use the isothermal flow model from Section 5.5.3 to find the pressure \(F(s)\) required to generate the target flowrate. We also get the filament’s spring rate at that temperature \(k_{sq}\).
We can use these to calculate the total volume of filament that must be compressed at this point such that the target pressure is reached, \(\mathcal{V}_{\text{sq}} = F / k_{sq}.\) To maintain this pressure from step to step, the extruder must drive filament such that this balance is maintained:
\[ \Delta \mathcal{V}_{{\text{sq}}_{(s)}} = \mathcal{V}_{{\text{sq}}_{(s + 1)}} - \mathcal{V}_{{\text{sq}}_{(s)}} + Q_{{\text{out}}_{(s)}} \Delta t_{(s)} \tag{5.20}\]
That is, the change in volume is effectively the pressure delta plus the flow out from the nozzle, or is the dynamic step plus the steady-state step. That can be converted back to the extruder motor inflow:
\[ Q_{\text{in}} = \Delta \mathcal{V} / \Delta t \tag{5.21}\]
I want to make a quick note here about the key difference in the extruder vs. the motion system framing: the motion dynamics are carefully articulated in phase space, splitting the problem up into very many small segments that are each some distance apart. While this works well for motion, it makes for nonuniform \(\Delta t\) at each step and the extruder’s dynamics change more dramatically with varying time steps. This introduces some trouble when we actually solve this system; I discuss the trade-off and possible solutions in Section 4.8.2.
5.9.1.3 Extruder Current Calculation
I described how motor models are coupled to the extruder system in Section 5.6. At this point we have all of the states required to calculate the current that will be required by the extruder.
\[ I_{\text{req,e}} = f(Q_{\text{in}}, \dot{Q}_{\text{in}}, F) \]
We take a discrete derivative of extruder current to get \(\dot{I}_{\text{req,e}},\) and calculate the motor’s current limit as usual (see Section 4.3.3.2). The extruder motor’s velocity is scaled by the extruder’s effective gear ratio (converting from inflow to motor rotor velocity).
5.9.2 Extending the Cost Function, Update, and Output Steps
Extending the cost function is perhaps the most straightforward step, we simply add new terms. Those new states include:
- Extruder inflow and inflow acceleration \(Q_{\text{in}}(s), \dot{Q}_{\text{in}}(s)\)
- Extruder current requirements \(I_{\text{req,e}}(s)\)
- Extruder current slew requirements \(\dot{I}_{\text{req,e}}(s)\)
Each of those states also has associated limits. Exceedances of these values are calculated using the methods described in Section 4.6.1.3. The maximum extrusion force \(F\) limit is implicit via the extruder motor’s current requirement.
The planner generates new \(v(s)\) using gradient-descent over this cost, which now includes contributions from the motion system alongside those from the extruder system. That update step is described in Section 4.6.1.4 and no changes from this chapter are required.
Finally, we need to output the new control value: this is just the extruder motor’s velocity i.e. \(Q_{\text{in}}.\) For this step I simply add one more output to the method from Section 4.6.1.5.
5.9.3 Connecting the Planner to Hardware
This step is also the same as in Section 4.6.2; the planner is instantiated as a PIPES (Section 2.4) block via an interface class that relays data into- and out-of PIPES using sockets. It is connected as a MAXL (Section 2.5) component, and solution components emerge as spline control points, metered by a MAXL timer block. Those go to actuators, which each runs low-level closed-loop controls — PIDs for position control and PI for velocity control of the extruder motor, in which case the basis spline is used as a velocity reference instead of a position reference. Data from motors and sensors are piped back into data collector classes, which store timestamps and samples.
5.10 Evaluating Feedback-Based FFF
So, up to this point I have explained the feedback-based FFF workflow (5.3) and its constituent parts: the preprocessor (5.9), the motion controller (5.9), and the models used in both (5.5 and 5.7).
To evaluate these new tools, I used the FrankenPrusa, (5.4.2) to print an array of part geometries using a range of materials and nozzles. In Section 5.10.1 I show the resulting flow models and images of prints, alongside tables that render process saturations (i.e. which underlying machine constraint most limited printing time: see Section 5.11.1) and modelling errors. In Section 5.10.3, I explain how the feedback-based workflow compares to the state-of-the-art in reducing the number of parameters that must be tuned by hand and allows us to print in configurations that are not covered by off-the-shelf presets.
Because the FrankenPrusa’s underlying hardware is identical to one state-of-the-art machine (a Prusa Core One, [42]), I can also compare this workflow’s output to the state-of-the-art quantitatively on print speed (in Section 5.10.4) and on qualitative part precision (Section 5.10.5).
Finally, I examine model-fit quality in Section 5.10.6 by comparing the planner’s predictions of sensor readings real-world measurements made during operation.
I discuss all of these results, and some other ways in which feedback-based FFF differs from the state-of-the-art, in Section 5.11.
5.10.1 Printing with the Model-Based FFF Workflow
I printed parts using a set of materials and nozzles that I intended to be representative of state-of-the-art FFF operation. It includes the incredibly common “default materials” like PLA and PETG (which are useful to see because they are well understood), as well as fiber-filled versions of the same, (because it is often difficult to ascertain exactly what these blends are and our system can operate well even with that uncertainty). I also included some high performance materials that are classically difficult to print like Nylon and PolyCarbonate-ABS blends (and both with glass or carbon fill), since these are excellent engineering materials, and I was curious to see if our system could manage to learn how to print with them. Finally, I included natural materials that are interesting for their renewable properties and an Aluminum Fill material because I was interested to see a thermodynamic outlier; it’s conductivity and heat capacity should be much larger than other polymers.
I also printed parts using three different nozzles; a 0.6mm brass nozzle, and two “high flow” nozzles: these have a copper core, hardened steel tip, and more complex internal geometry that is designed to improve flowrates. They are also finished with a high hardness coating [49] in order to resist abrasion from filled filaments. Along this axis, I show how our flow models adapt not only to changes in material but also to changes in nozzles.
I’ve organized these prints by filament, roughly in order of most- to least-common. I present a flow model and at least one test part per filament, and (where they are available) compare those to prints on an unmodified Prusa Core One. In all cases, I use geometry generated by Prusa Slicer [7] (version 2.9.4) using the 0.2mm Speed preset, with 50% infill. Comparison prints use parameter presets for these settings, and our prints use the feedback-based workflow (diagrammed in Figure 5.9) to operate.
5.10.1.1 PLA, 0.6mm Brass Nozzle
PLA or Polylactic Acid is an extremely common 3D printing material that is derived from plant sugars. It is easy to print, has low warping, but is relatively brittle and is not resistant to chemical or UV exposure and softens at only \(60\,^{\circ}\text{C}\).
5.10.1.2 PETG, 0.6mm Brass Nozzle
PETG or Polyethylene Terephthalate Glycol is derived from the more common PET (which is what most single-use water bottles are made with), adding Glycol improves its printing performance and toughens it slightly. PETG has excellent inter-layer adhesion and provides a good balance between strength, flexibility and chemical resistance, and softens around \(80\,^{\circ}\text{C}\).
5.10.1.3 PETG (with Carbon Fiber Fill), 0.4mm High Flow Nozzle
Adding Carbon Fiber fill to PETG increases its stiffness and decreases warping, but increases cost and requires that we use hardened nozzles, as the carbon fibers can abrade soft brass. Due to PETG’s excellent layer adhesion, this material is a good basis for i.e. mechanical prototypes.
5.10.1.4 ASA (with Glass Fill), 0.4mm High Flow Nozzle
ASA or Acrylonitrile Styrene Acrylate is billed as an update to ABS (Acrylonitrile Butadiene Acrylate), it is UV stable and has similar (excellent) mechanical properties but warps less, which makes it more suitable for 3D printing.
5.10.1.5 Nylon (with Glass Fill), 0.6mm High Flow Nozzle
Nylon is an exceptional engineering polymer, used extensively in industry to produce i.e. power tool chassis, car parts, etc. It is normally combined with glass fill (as is this material) to improve stiffness and toughness. It has good wear resistance and fatigue life but is highly hygroscopic (it absorbs a lot of water from the air) so it must be dried before printing, which I did in order to process the material. It is difficult to print mostly because of the water absorption (the water boils as the material is heated, which causes obvious problems), but also requires a material-specific build plate - I used a phenolic composite bed. Its difficulty means that it is uncommon in 3D printing and so parameter presets are less developed for it than for other plastics, this was one of the materials for which there was no state-of-the-art preset available.
5.10.1.6 PCBlend (with Carbon Fiber), 0.6mm High Flow Nozzle
(Polycarbonate + ABS)
PCBlend is Polycarbonate with some unspecified additive [1] - although normally it is ABS. PC on its own is an excellent engineering material with high stiffness and toughness, but is also highly hygroscopic and warps a great deal; the blend is added to ameliorate both issues. It has excellent heat resistance, around \(113\,^{\circ}\text{C}\).
5.10.1.7 Timberfill, 0.4mm High Flow Nozzle
This is a material developed by Fillamentum [50] that is “similar to PLA” and includes natural fibers that have been “isolated from spruce” (i.e., sawdust). It is biodegradable and designed primarily for use in household objects.
5.10.1.8 AluFill (67% 6061 Aluminum + Binder), 0.6mm High Flow Nozzle
AluFill from The Virtual Foundry [51] is designed to be sintered post-printing to form a solid metal part. They claim \(67\%\) aluminum content but do not disclose the binder material and merely specify that it prints “similar to PLA.” Materials like this are challenging to print because they lack internal cohesion — they can act closer to tightly packed sand than to a polymer — and so extruder drive gears can easily shear them. In other printer configurations, articulating that the extruder should exert less force overall is difficult because we tune extruder motor velocity and acceleration parameters, but not force. In this case I de-rated the extruder motor’s current limit (from \(0.7 A \rightarrow 0.3 A\)) in both the flow model test and in printing. This prevents the extruder from exerting too much force across all dynamical states (while extruding, retracting, etc), and is easily captured in the model that relays this limit to the planner.
5.10.2 Tables of FFF Prints
5.10.2.1 Complete Table of Flow Models
Key parameters from each flow model that I generated are in Table 5.11. Here, a flow model’s Minimum Temperature \(T_{\text{min}}\) is the temperature at which Maximum Flowrate is \(15mm^3/s,\) the maximum flowrate \((Q_{\text{max}})\) is taken at \(290^{\circ}\text{C}\) (the nozzle’s maximum safe temperature), and the spring rate \((k_{sq})\) is shown at both \(220\,^{\circ}\text{C}\) and \(290\,^{\circ}\text{C}\) to show variance across temperatures
| Material | Noz. | \(T_{\text{min}}\) \((^{\circ}\text{C})\) | \(Q_{\text{max}}\) \((mm^3/s)\) | \(k_{sq} @ 220^{\circ}\text{C}\) \((N/mm^3)\) | \(k_{sq} @ 290^{\circ}\text{C}\) \((N/mm^3)\) |
|---|---|---|---|---|---|
| Timberfill | 0.4 HF | 151.2 | 80.3 | 16.21 | 3.24 |
| PLA | 0.6 | 181.1 | 54.0 | 25.83 | 9.19 |
| PLA | 0.6 HF | 175.0 | 69.3 | 26.66 | 7.89 |
| PETG | 0.6 | 193.4 | 53.9 | 24.20 | 10.91 |
| PETG | 0.6 HF | 200.5 | 57.7 | 32.82 | 12.41 |
| PETG CF | 0.4 HF | 197.7 | 73.1 | 56.91 | 21.33 |
| PETG CF | 0.6 HF | 188.0 | 77.5 | 42.44 | 16.92 |
| ASA | 0.6 HF | 193.8 | 58.4 | 28.19 | 7.32 |
| ASA GF | 0.4 HF | 188.9 | 71.1 | 34.24 | 7.67 |
| PCBlend CF | 0.6 HF | 235.4 | 53.5 | 53.61 | 20.83 |
| Nylon GF | 0.6 HF | 201.5 | 49.7 | 17.90 | 4.59 |
| AluFill | 0.6 HF | 209.9 | 146.4 | 19.88 | 13.33 |
5.10.2.2 Complete Table of Prints
Tables with key values from all the prints completed using the feedback-based workflow are in Table 5.12 (prints that were compared to the state-of-the-art workflow) and Table 5.13 (prints that were not compared). These show the nozzle temperature selection, average flowrate, total print time \(t,\) and saturation values that describe the percentage of print time in each part that was dominated by one of four physical constraints: \(s_{cool}\) (cooling limited), \(s_{\text{flow}}\) (flowrate / flow heuristics limited), \(s_{\text{extr}}\) (extruder dynamics limited), and \(s_{motn}\) (motion system dynamics limited). Section 5.11.1 describes how these saturations are produced using the planner’s outputs.
| Mat. | Noz. | Geometry | Sys. | \(T_{noz}\) | \(Q_{avg}\) | \(t\) | \(s_{cool}\) | \(s_{\text{flow}}\) | \(s_{\text{extr}}\) | \(s_{motn}\) |
|---|---|---|---|---|---|---|---|---|---|---|
| \(^{\circ}\text{C}\) | \(mm^3/s\) | \(min.\) | \(\%\) | \(\%\) | \(\%\) | \(\%\) | ||||
| PLA | 0.6 | 3DBenchy | Ours | 251 | 4.27 | 48.0 | 44.9 | 41.8 | 4.9 | 8.4 |
| SOTA | 230 | 4.02 | 53.0 | |||||||
| PLA | 0.6 | 3DBenchy 1.50x | Ours | 269 | 6.75 | 93.4 | 28.2 | 54.8 | 6.3 | 10.7 |
| SOTA | 230 | 6.37 | 104.0 | |||||||
| PETG | 0.6 | 3DBenchy | Ours | 277 | 5.80 | 35.3 | 43.3 | 29.0 | 12.2 | 15.6 |
| SOTA | 250 | 3.67 | 58.0 | |||||||
| PETG | 0.6 | Roadballs | Ours | 289 | 11.03 | 49.3 | 5.9 | 50.0 | 20.0 | 24.1 |
| SOTA | 250 | 8.50 | 68.0 | |||||||
| PCBlend CF | 0.6 HF | 3DBenchy | Ours | 289 | 5.36 | 38.3 | 49.4 | 33.4 | 5.8 | 11.5 |
| SOTA | 280 | 3.26 | 67.0 | |||||||
| PCBlend CF | 0.6 HF | Drone Cover | Ours | 289 | 6.34 | 15.4 | 40.4 | 32.3 | 9.6 | 17.8 |
| SOTA | 280 | 4.43 | 23.0 | |||||||
| PCBlend CF | 0.6 HF | Drone Arms | Ours | 289 | 9.25 | 60.4 | 3.11 | 45.5 | 19.8 | 31.6 |
| SOTA | 280 | 6.72 | 80.0 | |||||||
| PCBlend CF | 0.6 HF | Drone Fuselage | Ours | 289 | 10.24 | 65.1 | 2.9 | 54.5 | 12.6 | 30.0 |
| SOTA | 280 | 7.65 | 92.0 |
| Mat. | Noz. | Geometry | Sys. | \(T_{noz}\) | \(Q_{avg}\) | \(t\) | \(s_{cool}\) | \(s_{\text{flow}}\) | \(s_{\text{extr}}\) | \(s_{motn}\) |
|---|---|---|---|---|---|---|---|---|---|---|
| \(^{\circ}\text{C}\) | \(mm^3/s\) | \(min.\) | \(\%\) | \(\%\) | \(\%\) | \(\%\) | ||||
| PETG CF | 0.4 HF | 3DBenchya | Ours | 213 | 4.61 | 44.4 | 50.0 | 36.1 | 8.4 | 5.5 |
| PETG CF | 0.4 HF | Kleata | Ours | 279 | 10.82 | 25.4 | 11.7 | 36.8 | 45.6 | 5.8 |
| PETG CF | 0.4 HF | Circuit Mounta | Ours | 257 | 9.04 | 64.7 | 39.8 | 33.8 | 21.8 | 5.6 |
| ASA GFd | 0.4 HF | 3DBenchya | Ours | 219 | 4.57 | 44.8 | 46.3 | 41.6 | 6.5 | 5.7 |
| ASA GF | 0.4 HF | Brake Ductb | Ours | 279 | 11.74 | 142.3 | 22.8 | 59.1 | 10.6 | 7.5 |
| Nylon GFd | 0.6 HF | 3DBenchy | Ours | 230 | 5.03 | 40.8 | 47.6 | 27.0 | 18.1 | 7.3 |
| Nylon GF | 0.6 HF | Hood Latch | Ours | 268 | 9.13 | 14.5 | 33.3 | 20.3 | 32.5 | 13.9 |
| Nylon GF | 0.6 HF | Motor Mount | Ours | 238 | 6.40 | 38.7 | 39.0 | 38.7 | 11.7 | 10.6 |
| Timberfill | 0.4 HF | 3DBenchya | Ours | 166 | 4.67 | 43.9 | 42.4 | 41.4 | 10.3 | 5.9 |
| Timberfill | 0.4 HF | Moaia | Ours | 184 | 9.06 | 87.1 | 42.0 | 43.6 | 11.7 | 2.8 |
| Timberfill | 0.4 HF | Knife Holdera | Ours | 248 | 13.68 | 90.3 | 6.8 | 66.5 | 22.3 | 4.4 |
| AluFillc,d | 0.6 HF | 3DBenchy | Ours | 246 | 2.41 | 85.1 | 11.1 | 70.3 | 14.1 | 4.4 |
| AluFill | 0.6 HF | Circuit Heatsink | Ours | 238 | 2.29 | 59.4 | 2.9 | 77.9 | 16.5 | 2.7 |
| AluFill | 0.6 HF | Circuit Heatsink 1.18x | Ours | 246 | 2.88 | 83.8 | 2.2 | 76.7 | 18.2 | 2.9 |
a These prints were mislabelled: I mistakenly inserted a 0.4mm high flow nozzle, but thought I had a 0.6mm high-flow nozzle installed. This means that I printed them with geometry for a 0.6mm nozzle, rather than 0.4mm. However, the flow models were produced using the 0.4mm nozzle, so the parts still worked, but it means that I did not complete comparisons to the state-of-the-art for these parts. I discuss this error in Section 5.11.6.
b This part was printed with a 0.6mm nozzle re-installed, but the model used for flow was generated with the 0.4mm nozzle.
c As I noted in Section 5.10.1.8, this material was printed with a de-tuned extruder motor (limited current deployment), to avoid shearing the material.
d These materials were not compared to the state-of-the-art because no slicer presets were available for them at the time of writing.
5.10.3 Reducing Parameter Spaces
To quantitatively compare feedback-based operation to the state-of-the-art, we can compare the total number of human-tuneable values required in state-of-the-art presets to the values that this workflow exposes.
In the introduction of this section, I rendered tables of printing parameters taken from a state-of-the-art slicer (Prusa Slicer 2.9.4 [7]), (Tables 5.1, 5.2, 5.3, and 5.4). That set contains 47 parameters, of which:
- 16 are either geometric or easily calculated based on nozzle width,
- 12 are translational velocities
- 7 are accelerations
- 3 are temperatures (nozzle, bed, chamber)
- 1 is directly filament flow related (maximum flowrate)
- 4 are retraction related
Our workflow does not modify the geometry generation step of the state-of-the-art, and does not set bed or chamber temperatures, so we are left with 29 free parameters to replace with the feedback-based workflow. It still relies on some human-in-the-loop selections and I lay out a table of those parameters in Table 5.5. It contains 21 heuristics or “manually” estimated values:
- 4 related to cooling
- 1 first layer rate
- 1 minimum flowrate
- 3 pressure scalars
- 8 motion scalars (current, and current slew rates)
- 4 extruder heuristics
In all, we have a similar total count of parameters. However, parameters in the state-of-the-art workflow should be modified by hand for every new material, nozzle, or machine. Our workflow uses models to mediate between this subset of heuristics and actual control inputs to the machine. While I was printing the parts above in Section 5.10.1, I dialled these heuristics in once for the machine (using PLA, over the course of about one day) and then left them alone for each new material or nozzle. Those values are the third column of Table 5.5. To be explicit, that means that tuning each of the print systems in Section 5.10.1 (11 nozzle and material combinations in total) from scratch in the state-of-the-art workflow would have involved tuning up to 319 individual parameters. In our workflow, we can tune 21 parameters on one material and nozzle, and use models to extend that work automatically across new materials and nozzles.
5.10.4 Print Speed vs. SOTA
In the small set of prints that were compared to the state-of-the-art, the workflow developed here increased print speed over on average by \(141 \%\). In Table 5.14 I have sorted these within their respective materials from smallest to largest speed-up and included our nozzle temperature selections vs. the state-of-the-art.
I expected there to be a rough correlation between print size and speed increase because one of the main advantages over the state-of-the-art is that our workflow can select hotter nozzle temperatures for larger parts (as in Section 5.8), but in this small set there is no clear relation. Geometry also plays a role here so e.g., tall and skinny parts will not see as strong of a speed-up as wide and flat parts.
| Mat. | Noz. | Geometry | Total Vol. | Our Temp | SOTA Temp | \(\Delta\) Temp | Our Time | SOTA Time | \(\Delta\) Time |
|---|---|---|---|---|---|---|---|---|---|
| \(mm^3\) | \(^{\circ}\text{C}\) | \(^{\circ}\text{C}\) | \(\%\) | \(min.\) | \(min.\) | \(\%\) | |||
| PLA | |||||||||
| PLA | 0.6 | 3DBenchy | 12773 | 251 | 230 | 109.1 | 48.0 | 53.0 | 110.4 |
| PLA | 0.6 | 3DBenchy 1.50x | 39737 | 269 | 230 | 117.0 | 93.4 | 104.0 | 113.5 |
| PETG | |||||||||
| PETG | 0.6 | Roadballs | 34687 | 289 | 250 | 115.6 | 49.3 | 68.0 | 137.9 |
| PETG | 0.6 | 3DBenchy | 12773 | 277 | 250 | 110.8 | 35.3 | 58.0 | 164.3 |
| PCBlend CF | |||||||||
| PCBlend CF | 0.6 HF | Drone Arms | 32247 | 289 | 280 | 103.2 | 60.4 | 80.0 | 132.5 |
| PCBlend CF | 0.6 HF | Drone Halves | 42233 | 289 | 280 | 103.2 | 65.1 | 92.0 | 141.3 |
| PCBlend CF | 0.6 HF | Drone Cover | 6119 | 289 | 280 | 103.2 | 15.4 | 23.0 | 149.4 |
| PCBlend CF | 0.6 HF | 3DBenchy | 13125 | 289 | 280 | 103.2 | 38.3 | 67.0 | 175.0 |
5.10.5 Qualitative Print Quality vs. SOTA
I did not develop a workflow to rigorously evaluate print quality against the state-of-the-art, but photographs below (our prints on the left, SOTA on the right in Figures 5.60, 5.61, 5.62, 5.63 and 5.64) provide a simple basis for qualitative assessment. Overall, prints using our controller have many more visual artefacts than the state-of-the-art. I discuss the alignment between those artefacts and modelling errors in Section 5.10.5.1.
5.10.5.1 Flow Modelling Errors Correlate with Part Errors
One promising result is that areas of prints that are clearly imprecise correlate well with areas where the planner’s flow model predictions deviated from actual measured values. I show this in Figures 5.65 and 5.66: both include images of printed parts (at left) and plots (right) that map error between the planner’s predicted pressure measurement and the load cell’s real measurement. In Figure 5.65 patches of the part that have clear over-extrusion artefacts correlate to areas in the dataset where measured pressure was much higher (by about \(50N\)) than the planner predicted. Two slices of the time-series dataset from this part are in Figure 5.67, at left is an area where models did well to predict measurements, and at right is an area (corresponding to the lower-right corner of the part) where models did poorly. Figure 5.66 shows two over-extrusion artefacts on the printed drone arm, which correlate directly to two moments in the dataset where pressure was again much higher than the planner predicted.
This means that where measurements do correlate to predictions, the planner works well to operate the machine — if predictions deviated from measurements in areas where prints looked good, something would clearly be wrong with the method overall. If the planner is to be trusted, locations and process states where we see deviations from its predictions mean one of two things: either the models are wrong (which leads the planner to produce incorrect outputs and thus produces the observable errors) or that the process inputs changed unexpectedly. In the examples I show here it is almost certainly the former: the models are fit on a limited set of data from the tests performed in Section 5.5 which does not properly map through all the very many time-varying states that the printer operates within. For example all errors highlighted in Figure 5.65 take place where the machine is rapidly accelerating and decelerating at relatively high flowrates and nozzle temperatures and there are only about 30 seconds of total data in this regime that has been applied to the model fit (see the fitting method in Section 5.5.3).
In particular, I think that the time-varying dynamics are poorly fit because collecting data that spans all the underlying states is difficult and the approximation that I use to interpolate between the steady-state and isothermal models (in Section 5.5.4) is lossy. In the next Section 5.10.6 I will discuss this at more length.
5.10.6 Flow Model Fit Quality
In each print above, I rendered a small table that includes average errors for XY Current and Pressure Estimate. These are end-to-end evaluations of our modelling workflow, and they are made using time-series data collected from the printer’s hardware and from the planner simultaneously. I look more closely at the XY Current error evaluations in the motion control chapter at Section 4.7.2. A table of model errors from each of these prints is here in Table 5.15, both take the mean of the absolute errors between the planner’s predicted value and the measured values across all samples in the print time series.
| Mat. | Noz. | Geometry | \(T_{noz}\) | \(Q_{avg}\) | \(t\) | Err. XY Motion | Err. Pressure |
|---|---|---|---|---|---|---|---|
| \(^{\circ}\text{C}\) | \(mm^3/s\) | \(min.\) | \(A\) | \(N\) | |||
| PLA | 0.6 | 3DBenchy | 251 | 4.27 | 48.0 | 0.146 | 3.83 |
| PLA | 0.6 | 3DBenchy 1.50x | 269 | 6.75 | 93.4 | 0.210 | 4.55 |
| PETG | 0.6 | 3DBenchy | 277 | 5.80 | 35.3 | 0.169 | 5.90 |
| PETG | 0.6 | Roadballs | 289 | 11.03 | 49.3 | 0.176 | 6.02 |
| PETG CF | 0.4 HF | 3DBenchy | 213 | 4.61 | 44.4 | 0.141 | 24.45a |
| PETG CF | 0.4 HF | Kleat | 279 | 10.82 | 25.4 | 0.171 | 11.71 |
| PETG CF | 0.4 HF | Circuit Mount | 257 | 9.04 | 64.7 | 0.167 | 6.03 |
| ASA GF | 0.4 HF | 3DBenchy | 219 | 4.57 | 44.8 | 0.135 | 8.92 |
| ASA GF | 0.4 HF | Brake Duct | 279 | 11.74 | 142.3 | 0.310 | 14.52b |
| Nylon GF | 0.6 HF | 3DBenchy | 230 | 5.03 | 40.8 | 0.141 | 5.61 |
| Nylon GF | 0.6 HF | Hood Latch | 268 | 9.13 | 14.5 | 0.175 | 7.21 |
| Nylon GF | 0.6 HF | Motor Mount | 238 | 6.40 | 38.7 | 0.148 | 5.41 |
| PCBlend CF | 0.6 HF | 3DBenchy | 289 | 5.36 | 38.3 | 0.164 | 7.10 |
| PCBlend CF | 0.6 HF | Drone Cover | 289 | 6.34 | 15.4 | 0.179 | 6.41 |
| PCBlend CF | 0.6 HF | Drone Arms | 289 | 9.25 | 60.4 | 0.197 | 8.54 |
| PCBlend CF | 0.6 HF | Drone Fuselage | 289 | 10.24 | 65.1 | 0.175 | 11.39 |
| Timberfill | 0.4 HF | 3DBenchy | 166 | 4.67 | 43.9 | 0.141 | 13.40a |
| Timberfill | 0.4 HF | Moai | 184 | 9.06 | 87.1 | 0.162 | 8.83 |
| Timberfill | 0.4 HF | Knife Holder | 248 | 13.68 | 90.3 | 0.256 | 5.87 |
| AluFill | 0.6 HF | 3DBenchy | 246 | 2.41 | 85.1 | 0.153 | 8.75 |
| AluFill | 0.6 HF | Circuit Heatsink | 238 | 2.29 | 59.4 | 0.124 | 8.31 |
| AluFill | 0.6 HF | Circuit Heatsink 1.18x | 246 | 2.88 | 83.8 | 0.160 | 8.19 |
a For both the PETG-CF 3DBenchy and the Timberfill 3DBenchy, the workflow chose flowrates close to the minimum flow temperature, which I believe is why these two prints show outsized modelling errors; see Section 5.11.7 for discussion on this.
b This part was printed with a 0.6mm nozzle, but the model used for flow was generated with the 0.4mm nozzle, which is the likely source of error in this case.
a motor currents, b motor currents, outflow predictions, melt flow dwell time \(T_{melt},\) inflow, load cell readings, extruder current, and saturations from Section 5.11.1.
Flow models are typically accurate only to \(5\%\) or so and can be particularly bad over certain intervals in a part. In Figure 5.67 I show two time-series slices of data from the part in Figure 5.65; models fit well in certain state spaces but poorly in others. We can see divergence in values for the extruder pressure and even divergence in phenomenology: the plot at right shows sharp pressure peaks as each new track begins whereas the model predicts square-topped pressure values. As I discussed in Section 5.10.5.1 I think that this emerges because of the lossy method that I use to approximate time-varying melt flow behaviour; the right plot (where models fit poorly) is taken where the melt flow’s dwell time (\(T_{melt},\) measured in seconds and representing how much time the filament at the nozzle tip has spent in the melt zone) is on average much longer than it is in the left plot (where models fit well).
The datasets used to fit these models comprise only tens of seconds of dynamical operation at each temperature under pseudo-isothermal conditions and then effectively one data point at each point in each approximately steady-state condition. Real-world operation of the machine spans many more states: time-varying melt flow temperatures, an array of nozzle temperatures, and a full span of pressures and flows. The other confounding factor is that extruding a track on top of an existing surface requires slightly more pressure than extruding into free air, which is how the initial datasets are generated.
This means that the modelling required to make this method work really well needs to be done using time-series data collected from real operation. In Section 5.12.1 I discuss how we might properly merge the isothermal and steady-state models and use that development to enable “continuous improvement and deployment” (CI-CD, Section 5.12.2) of these models. That would allow us to bootstrap models with the simple tests that I have developed here (or perhaps even simpler versions of the same) and then update models as the printer is used.
One result of this lossiness was that I had to implement the retract heuristic, which properly would be handled by the flow model properly driving pressure to zero. In Section 5.12, I cover a range of topics that might lead to improved modelling and operation of the hardware.
Some other part errors emerge from the motion system, which does not model machine stiffness and vibration even though this turns out to be a major limit to overall precision. I discussed those limits in Section 4.8.5, other limits to this system are discussed in Section 5.11.7.
5.11 Discussion
In Section 5.1.1 I described how preset-based configuration of FFF 3D printers limits adoption of new materials because they must be developed for each new material, nozzle or printer configuration, and how state-of-the-art controller configuration separates low- and high-level process control parameters. Section 5.2.2 explains how state-of-the-art workflows manage printer parameters. I expanded on how motion and process physics are intimately coupled in Section 5.2.3, and why that prevents us from running machines near their real underlying limits.
In the state-of-the-art we tune machines through lossy representations that disconnect what we expect should happen when we change slicer parameters from what actually happens once piecewise configurations and optimizations are applied. To see how we can improve this, I tried to build an end-to-end workflow (Section 5.3) that uses motion, flow, and cooling models as a basis to configure and run a 3D printer. Other researchers have built models that describe these physics (Sections 5.2.4.1 and 5.2.4.3) and some have applied model-based control to parts of the process (Section 5.2.4.2), none have connected motion control directly to process control for FFF, or have connected model-based control to higher level planning. I extended the state-of-the-art in those regards in Sections 5.9 and 5.8 to develop a complete end-to-end workflow (Section 5.3). Most research on overall optimization of the printing workflow is done on top of existing systems (Section 5.2.4.4), i.e., using fuzzy logic and neural networks to try to estimate how slicer settings will impact part performance.
In Section 5.10.1 I tested this workflow end-to-end, showing in Section 5.10.3 that the total space of parameters to tune is reduced and in Section 5.10.4 that it improves time optimality of prints when measured against an equivalent state-of-the-art workflow. In Sections 5.10.5 and 5.10.5.1 we see that although parts printed with this workflow have more visually perceptible errors than the state-of-the-art, those errors correlate well with deviations from model predictions. This is promising because it means that if we can formulate models such that they can be re-fit on new data (which the machine produces copious amounts of), we will be able to sequentially improve models and prints over time (see Section 5.12).
To discuss all of this, I want to go back to the compiler analogy that I made with Figure 1.4. In this comparison, the state-of-the-art workflow amounts to writing assembly codes directly: parameters we set are implemented literally by the machine (subject only acceleration control). Our workflow is something like a compiler, combining high level and physically meaningful heuristics with models and optimization to produce the actual, low-level instructions; it is declarative rather than imperative machine programming. So, in Section 5.11.1 I explore how we can use outputs from this workflow to reflect on machine design and process design / limits, and Section 5.11.2 shows that heuristics that are exposed here are tuned against underlying limits: rather than throwing darts at the process map, we throw them within the process map. We also stand to learn from flow models alone (Section 5.11.3).
The methods that I developed enable some new capabilities. Declarative programming allows optimization-based tools to select parameters from a wider swathe of viable parameter space (Section 5.11.4) and the planner’s inclusion of time-varying melt flow dynamics can exploit performance (momentarily) that extends beyond steady state limits (Section 5.11.5). The workflow is also resilient to some human errors (Section 5.11.6), but is not without its limits. I discuss those in Section 5.11.7.
5.11.1 Learning from Printer Data Outputs
Whereas models on their own can tell us about how components of our system behave, the model based controller outputs can teach us about the system as a whole. During any print job, we collect numerous data streams from the machine and the planner that can all be used for analysis later. With sufficiently accurate models, we can even do this with the velocity planner alone, as it represents a kind of digital twin.
Probably the most interesting way to process this data is to analyze which aspect of the machine was limiting overall performance, these are constraint saturations and I show an example in Figure 5.68. That includes a distribution of saturations for the whole part (bottom) and those saturations projected onto the trajectory such that we see which physics limited the printer velocity for each segment.
To calculate constraint saturations I compare time series data of each component’s outputs state with the relevant limit, for example motor current utilization vs. the maximum current available at that time. Each segment has a maximum velocity set via flow models and related heuristics, when that velocity is saturated we know that nothing else is constraining speed. Where velocity has been scaled to meet a minimum layer cooling time, we know that the part cooling model has limited speed at that point. In the table below, I summed these saturations across all the prints that I evaluated using the FrankenPrusa.
These saturations are included in print Tables 5.12 and 5.13. I tally total limit saturation percentages across the complete set of prints in Table 5.16.
| \(s_{cool}\) | \(s_{\text{flow}}\) | \(s_{\text{extr}}\) | \(s_{motn}\) |
|---|---|---|---|
| \(28.0 \%\) | \(46.0 \%\) | \(15.4 \%\) | \(10.7 \%\) |
Generating these types of outputs is not possible in state-of-the-art workflows, first because low-level control states are not exposed computationally but also because other controllers are structurally different. Trapezoid planners use motion parameters rather than motion models and do very little in the way of considering process control, as discussed. Their outputs, if collected, could be used in conjunction with models to render similar traces (replaying motion states through machine models), but we would see that the trapezoidal planner’s own limitations would be the main performance limit, as I show in Section 4.7.1. Other model predictive controllers could probably be formulated to generate similar outputs but so far none have been instrumented in this manner, and none that combine extrusion and motion dynamics exist.
Because the control framework in this thesis allows us to run the planner on large compute hardware, there is bandwidth to spare to serialize and save intermediate controller outputs like each system components’ limits for each time-step in the solution (which are normally compressed in the cost function to a single value). That means that this is the first example of a digital fabrication workflow that allows us to analyze a machine system in this manner, and we can learn something new here.
The categories covered relate both to machine / motion models and flow models. The most dominant constraints overall (over the short set of parts) are the flow models themselves, which were combined with some heuristics (recall Section 5.8). In 5.12.4, I discuss how these heuristics could be supplanted with explicit descriptions of optimalities like precision and part strength, which would increase the fidelity of this “bin” of saturations. The second most dominant limit overall was cooling: tracks that have been slowed down to meet minimum layer time constraints. Then we have a series of machine related limits: inflow and inflow acceleration as well as extruder current limits are all related to the extruder motor’s performance and power budget. AB and Z motor current limits relate to our actuator’s performance, but also the machine’s motion system as a whole: reducing the occurrence of these limits could involve increasing actuator size or decreasing friction or mass in the motion system.
Machine design is a game of trade-offs: if we improve overall flowrates by increasing the extruder motor size, we add mass that the motion system must heft around through tight corners. If we decrease the size of the part cooling fan to reduce the same weight, we remove cooling performance and need to add more time in each layer to counter it. Actually determining which of these trade-offs is the best to make is difficult to ascertain on pen and paper alone (or with a good spreadsheet) because constraint saturations are an emergent property of the system as a whole. These limits are also geometry dependent: small, intricate parts we are more likely to be limited by the machine’s motion system and part cooling whereas large parts are more likely limited by overall flowrates.
Besides this more complex binning of output data to determine limiting components, we can also render individual traces to learn about our system. Figures 5.70 and 5.69 show nozzle pressure, filament dwell time and AB motor currents as extracted from the toolpath in Figure 5.68.
5.11.2 Model-Based Knobs
I want to talk briefly about connecting tacit knowledge to machine models. In the state-of-the-art, We have very many inputs (slicer parameters) and only a few easily measured outputs (total print time and quality, and observations of obvious errors). Those inputs relate directly to machine operation, but not to machine physics. This means that learning how and which parameters should be adjusted in order to combat different negative outcomes (or improve positive ones) requires that users develop an intuitive sense for machine physics and a tacit understanding of how parameters impact those physics through multiple layers of control.
For example, we might slow down linear traversal rates (Table 5.2) and see that part quality was improved. But this adjustment has three physical effects: it slows flowrates (reducing required extrusion pressure and extruder motor current), it calms the motion system (reducing actuator current requirements) and it causes layer time to increase, which changes the layer cooling system as a byproduct. It is difficult to tell which of these affects was responsible for the improvement.
This can happen across changes to geometry as well: big parts may print well using the same slicer parameters that work poorly for small parts, but we have little recourse to understand why. Using the new outputs generated by this workflow, we can see that smaller parts tend to saturate our motion and cooling models (left plots in Figure 5.71), whereas larger parts tend to saturate flow models (right plots).
In FFF, users often tune their machines by hand towards high speed printing. But hidden velocity optimizations can make this process confusing; in Figure 1.7 way back in the introduction I gave the example of two trajectories: one with a \(100mm/s\) speed setting and the other with a \(500mm/s\) setting. Both were run through the same velocity optimization with the same \(1000mm/s^2\) acceleration limit. Despite the \(5x\) speed setting increase, the realized time improvement was only \(14 \%\) because the machine spent most of its time accelerating and decelerating. This can lead to tuning loops where we increase speed settings aggressively while printing a small test part (thinking that we are improving performance), and then when we run a larger part (where the machine can actually accomplish the target speeds), our flow constraints are suddenly limited and extrusion fails. I discuss this also in Section 6.3.1 in the machining chapter because visualizing these deviations is valuable to CNC programmers before they run toolpaths.
| Layer Height | Infill Pres. | Perim Pres. | Detail Pres. | XYZ Cur. | E Cur. |
|---|---|---|---|---|---|
| 0.3 | 0.75 | 0.65 | 0.45 | 0.25 | 0.75 |
| Layer Height | Infill Pres. | Perim Pres. | Detail Pres. | XYZ Cur. | E Cur. |
|---|---|---|---|---|---|
| 0.3 | 1.75 | 0.65 | 0.45 | 0.45 | 0.95 |
In Figure 5.72, I show how I express the same tune using the workflow that I developed in this chapter: at left is a part that uses conservative flow and motion heuristics that I tuned for quality, and at right is a part that uses aggressive heuristics tuned for speed. Rather than writing a new parameter that we might expect would result in more speed, we say at a high level that we want the printer to use more of its available capacity — as mediated by the flow and motion models via the realtime controller, increasing the scalar that describes how much of the maximum steady-state pressure should be targeted in the nozzle during infill moves (from \(0.75 \rightarrow 1.75\)) and also increasing the proportion of the maximum available motor current that the system should use (from \(0.25 \rightarrow 0.45\) for XY motion and from \(0.75 \rightarrow 0.95\) for the extruder). I show parameters, resulting saturation maps and distributions, and histograms for the accelerations that result from the deployment of more or less actuator current.
Note that the saturation bars in Figures 5.72 and 5.74 all use the same time span across they y-axis. We can see that the total print time is decreased from 10.1 to 9.6 minutes and that the acceleration used changes: with more motor current deployed the distribution widens. The saturations change too; time against the motor current limits stays about the same (saturations are measured against the applied heuristics), but the cooling model starts to dominate more presumably because the speeds reached at the larger infill pressure are subsequently scaled back by the cooling model.
I want to offer one more example here, which I also called out in Section 5.2.2: if we change the layer height in our the state-of-the-art workflow, we effectively double the flowrates that our machine will try to operate with across all segment types. This is another result of writing direct parameters: geometric settings and flow settings are coupled in non-intuitive ways. In this workflow, geometry is decoupled from flow. In Figure 5.74 I show two of the same part, one printed at \(0.2mm\) layer height and the other at \(0.3mm,\) both at the same nozzle temperature. Flowrate selections remain the same but the velocity distribution shifts. The machine is doing less “total motion” for the same print volume, so flow and cooling models saturate more often in the thicker part (together they are limiting for \(71.8\%\) of the \(0.2mm\) print and \(74.5\%\) of the \(0.3mm\) print), and motion dynamics saturate more often in the thinner part (\(19.7\%\) of the \(0.2mm\) print and \(16.3\%\) of the \(0.3mm\) print).
| Layer Height | Infill Pres. | Perim Pres. | Detail Pres. | XYZ Cur. | E Cur. |
|---|---|---|---|---|---|
| 0.2 | 1.75 | 0.65 | 0.45 | 0.45 | 0.95 |
| Layer Height | Infill Pres. | Perim Pres. | Detail Pres. | XYZ Cur. | E Cur. |
|---|---|---|---|---|---|
| 0.3 | 1.75 | 0.65 | 0.45 | 0.45 | 0.95 |
I think that these examples show how machine operation can be re-framed using models. The methods that I developed in this chapter reduce the total number of parameters we need to tune in order to print with new materials; they also connect the parameters that we do tune more directly to the real underlying physical constraints in our system. Rather than setting parameters without knowing if they will drive our printer beyond its underlying constraints, we tune them with respect to those constraints. In doing so, we can express what we want our printer to do at a higher level, for example “use more of the available motive power” rather than “try to print at exactly this speed,” without any knowledge about whether that rate will actually be accomplished, or if it will cause the flow or motion systems to be over extended. In addition, we get new outputs that let us inspect the results of the realtime dynamics’ application to those parts, identifying in minute detail how machine physics relate to performance. Because the velocity planner still applies an optimization on top of this, the results of these tuning updates can still have indirect consequences especially in cases where the cooling adjustments are applied. But because that planner can run entirely in software using just a virtual model of the machine, we can experiment with these updates before running a part — and we can see which optimization or model has been applied and where.
I showed how model-based control can also help us understand errors from printed parts, in Section 5.10.5.1 we saw that visual artefacts tend to correlate to deviations between model predictions and measurements. That can happen when models are poorly fit or when unforeseen disturbances (or misconfigurations) occurred. In Section 5.12.4 I discuss how we might extend the workflow to express trade-offs that I currently manage using input heuristics as a weighted set of optimalities for speed, strength, and precision.
Finally, I want to stress that I do not see this as a replacement for our mental models of machines and processes. Instead, I think of these as a tool to help more of us develop those models in more detail, with less time, and in a manner that could be more easily shared with others.
5.11.3 Learning from Flow Models
5.11.3.1 Comparing Materials and Fills
I want to make the simple point that models encode information about our materials that could be used to develop intuitive understandings of those materials. In Figure 5.75 I show three materials, each developed on the same nozzle and printer.
We can also compare materials with different fillers, e.g., carbon or glass fibers. Before I started this project, I assumed that filaments with fiber fill were overall harder to print because the fills are stiffer than molten plastic and do not melt themselves. Looking at their flow models, I was surprised to see that filled materials actually tend to have favourable flow properties. Models for PETG (without, and with) carbon fill are shown in Figure 5.76, both using the same nozzle; we can see that the filled material moves the steady-state boundary away from the origin, and also substantially decreases the minimum flow temperature.
I think the phenomenology is that the fill — while increasing the viscosity of the material — also substantially increases its thermal conductivity. This leads to better flows overall because the melt flow’s internal temperature is maintained at high flowrates. It may also be the case that the base PETG used in either filament is actually from a different batch or slightly different formulation, and carbon fibers may already be aligned in the filament in which case it would make sense that their inclusion doesn’t decrease the base material’s viscosity substantially.
If you read the spring rate \((k_{sq})\) for each material, you will see that the fill has a higher spring rate \((16.9 \ \text{vs} \ 12.41 N/mm^3)\) at the same temperature \((290\,^{\circ}\text{C})\). We would expect this from the carbon fill, and it shows that it may be possible to extract some metric for material stiffness using this hardware, i.e., simply using the extruder and load cell and extruder as an in-situ Universal Testing Machine.7
5.11.3.2 Comparing Nozzles
Recently, new FFF nozzles have been developed that include some internal geometry that improves heat conduction into the filament. Models for flow can provide a basis for comparing these parts. Below, I show flow models for PLA and PETG, using a traditional 0.6mm diameter nozzle on the left and a 0.6mm High Flow nozzle on the right. We can see that these nozzles do increase overall flowrates (as claimed) and also expand the size of the viable parameter space, moving the steady-state boundary curve away from the origin.
In Section 7.2.1, I discuss how figures or models like these could be used by nozzle manufacturers and customers to better articulate performance improvements or characteristics. For example a standard datasheet for a motor includes a torque curve, but in the state-of-the-art nozzle manufacturers only include scalar values for “maximum flow” for their nozzles, which are not even normalized across materials.
5.11.4 Using a Full Range of Possible Nozzle Temperatures
It is difficult to tune state-of-the-art systems across temperatures because springrates, maximum flowrates and cooling times all change along with nozzle temperature. Because here we can extract all of these values from models, we can use temperature as a tuning value without having to update all of those other direct parameters. For example Figure 5.78 shows this applied to the Nylon-GF filament; using the same input parameters overall the time-optimal nozzle temperature selects a colder temperature for the 3DBenchy (which is tall and skinny) than for the hood latch (which is relatively flat, and wider), based on the layer cooling models.
It would be difficult to apply this optimization if we could not automatically update other parameters against that temperature, i.e., we need a way to know how much flow can be increased with increased temperatures, how much extra cooling is needed, and we would need to manually interpolate springrates across temperatures so that the filament compressibility value is updated. However, the benefit is clear: the second row of Figure 5.78 shows that increasing nozzle temperature from \(230 \rightarrow 272\,^{\circ}\text{C}\) drops the print time from \(11 \rightarrow 8.5 \text{min}\), a \(22 \%\) speed-up. Other examples of this e.g., the Kleat print in Figure 5.30 (from Section 5.8.4) is decreased from \(31 \rightarrow 20 \text{min}\). Minimum temperatures here are set using a minimum flowrate heuristic that I describe in Section 5.8.1.
5.11.5 Exploiting Time-Varying Printing Dynamics
In some examples above I set the pressure scalar for infill moves to be \(1.75\text{x}\) the maximum steady state pressure at that time. This is viable because the velocity planner still optimizes against the complete flow models; the dynamical limit to flow is much larger than the steady-state limit because over short time spans maximum flow is based on the underlying rheology, not the time-varying melt flow temperature / nozzle thermodynamics (see Section 5.5.4).
For example in Figure 5.79 the third row from the top is the motion planner’s estimate of the internal melt flow temperature; this is colder when the average velocity of the material in the melt zone is fast, but after slow parts of the print (e.g., detailed outer perimeters) the melt flow temperature gets close to the nozzle temperature. So, when we transition out of these regions there is an opportunity to print much faster than the steady-state limit alone encodes until the thermodynamic limit is reached.
5.79 shows how these dynamics evolve in the highlighted segment. When it starts the melt flow is close to the nozzle temperature (around \(240\,^{\circ}\text{C}\) in this case). As the machine accelerates the outflow briefly exceeds the steady-state limit, but as the melt flow temperature decreases (towards \(210\,^{\circ}\text{C}\)) the pressure required to extrude at this rate increases and the system reaches the extruder motor’s current limit (5th row from the bottom). To maintain track width, the machine slows down overall, which is visible in the velocity norm plot (fourth row from the bottom).
This is another good example of how motion and flow are coupled and how different physics limit operation under various conditions, as I discussed in Section 5.2.3. It is also a good example of how this planner enables us to optimize over time-varying dynamics; motors themselves have similar thermal limits and as I discussed in Section 4.9.2 applying this strategy for motion systems themselves may have real benefit.
5.11.6 Resilience to Human Errors
A number of prints in Section 5.10.1 have a note: geometry was mistakenly generated for a 0.6mm nozzle. In these cases, I made the human error of labelling a flow model with the nozzle that I thought I had put into the machine (a 0.6mm High Flow Obxidian nozzle), whereas I had actually installed a 0.4mm version of the same. The Obxidian nozzle is black, making it difficult to catch the nozzle diameter visually.
Some of these prints had more extrusion artefacts than usual, especially on top surfaces. I assumed that these were just modelling errors, until I realized that the nozzle was actually smaller than I had labelled it. However, they all worked and on later inspection the model errors are not very far out of the distribution when compared to the rest of the prints.
In these cases, the models used to process the files was still consistent with the nozzle that was used to print the parts: I swapped it before making models, not between model-making and printing (except for in one case). This means that the only thing amiss is that the track widths were configured for a 0.6mm nozzle, while the nozzle was actually 0.4mm. The system is resilient to this error since track widths are not dependent on nozzle diameter, only on total flowrate per unit of spatial displacement \((mm^3/mm),\) which can be forced out of a nozzle of any size.
It does mean that a key heuristic was missing, which is that track widths should not be printed that are substantially larger than the nozzle diameter. In Section 5.2.2 I briefly explained this: track widths are normally calculated over nozzle diameter, e.g., up to \(1.25 \cdot d_{noz}\) In these cases, track widths are about \(1.7 \cdot d_{noz}\).
As an experiment, I tried printing using the state-of-the-art workflow, now intentionally making the error: I used a preset for each material in the two figures below for a 0.6mm nozzle, but installed a 0.4mm nozzle in the machine. Surprisingly these prints also worked without significant errors, as we can see in Figures 5.81 and 5.80. That also indicates that presets and state-of-the-art printer controllers do not drive machines very close to their real underlying limits; if they were close, shrinking the nozzle size by \(50\%\) would surely cause failures. This is likely because operating close to physical limits during normal operation would lead to more visual artefacts and problems, and because the state-of-the-art tuning workflow does not allow preset developers to directly see those limits and tune against them.
5.11.7 Key Limits
I’ve shown that we can fit and then use models for FFF flow dynamics in-situ, and then how we can organize a feedback-based workflow around these models that simplifies much of the direct parameter tuning from the state-of-the-art workflow. But there are a few notable limitations to what I have done, which I will discuss here.
5.11.7.1 Missing Piecewise Evaluations
This connected a long list of components: isothermal and steady-state models, an optimization-based planner, a new set of tools for systems integration and motion control (from Chapter 2), a time-optimal nozzle temperature selection using models for cooling, and a new method to apply heuristics alongside models to e.g. scale relative pressure and current deployment during operation.
Each of these components could be unpacked and tested in more detail: for example understanding if the method that I developed in Section 5.5.3 to model outflow from inlet flow and the internal pressure measurement is only implicitly evaluated here in the end-to-end workflow; although the prints that I showed are not visually exceptional they do not have obvious under- or over-extrusion errors in corners as would be the case if the flow models were egregiously under-fit. Evaluating this method on its own would be possible using the methods developed in [24] and in the Rubedo system [10]. I had even previously developed a workflow for these direct measurements (see Figure 5.8 in Section 5.2.3.3), but didn’t apply that measurement to verify the new method. The interpolation between steady-state and isothermal models from Section 5.5.4 could be verified against FEA models like those developed in [20], [21] [22] (although those primarily cover only steady-state operation, see Section 5.2.4.1), or against measurements taken using a thermal camera using the methods developed by [34] (see Section 5.2.4.3), and the layer cooling models could be verified using thermal imaging.
Not having done these evaluations makes it more difficult to tell which of these contributions is most productive and which may add errors rather than help to improve prints overall. There is already excellent research on most of these topics in isolation; but they have not been combined with control nor in end-to-end workflows, which is primarily where this work advances the state-of-the-art (although the flow measurement using the internal pressure state and the combination of steady-state and isothermal dynamics are both novel, as is the particular set of model fitting routines). I wanted to focus on exploring how models can be integrated across many aspects of machine control, organizing previously disparate representations using physics directly. In “Wait, it’s all Models?” (Section 7.2) I explore this in more detail.
5.11.7.2 The Isothermal to Steady-State Interpolation is Lossy and Prevents Refitting
In Sections 5.10.5.1 and 5.10.6 I began discussing why I believe the steady-state to isothermal interpolation (5.5.4) is a main source of loss in this work; the printer covers a much broader state-space during real-world operation than it does in the small test routine that I run to fit these models. In particular, the tests are designed to approximate either steady-state or isothermal operation. Neither condition is actually reached even in the test routine, which is obvious when we see how the models overlap in Figure 5.82: according to my interpretation of these models, all points in the steady-state contour should be above the same point in the isothermal contour because the nozzle thermodynamics is such that for the same flowrate and pressure, we should need a larger nozzle temperature for continuous flow than we would need for instantaneous flow. However, as formulated the models overlap near the origin.
I made the connection between these two models only late in the development of this system; earlier versions of the velocity planner used the isothermal model alone but that led to obviously wrong model fits in places where average flowrates were high. Besides limiting the quality of the velocity planner’s pressure predictions (which has ramifications also for retraction), describing this system as two separate models that are interpolated limits my ability to update the models on new data. That would be an invaluable capability because real-world operation obviously spans the state spaces that are most relevant to fit models within. In Section 5.12.1 I discuss how these could be properly connected from the start by developing a coherent energy model for the system and fitting some additional free parameters for heat flux, heat capacity, etc.
5.11.7.3 Bridging, Ringing, and Other Missing Models
In Section 4.8.5 I mentioned that the models I use for motion control do not include machine stiffness and vibration, which turns out to be a major limit to overall performance. I apply the motion system heuristics (limiting deployable actuator current) partially to counter these effects; using less motive force naturally shrinks the amplitudes at which machine structures and transmissions are excited. Vibrations appear in 3D printing as “ringing;” vertical artefacts that occur near corners — sharp deceleration into the corner loads up the machine structure, which then oscillates as it relaxes while the machine prints the subsequent line.
I show one example of ringing here in Figure 5.83. In Figure 4.24 from Section 4.8.5 another example of ringing is shown, where we can also see ringing in the dataset generated by the machine (as servo positioning errors).
Bridges in a 3D print are unsupported spans between two supported sections. These can be drastically improved by printing them slowly with maximum cooling while also slightly under-extruding, so that tracks stretch across the gap and are rapidly solidified. In the state-of-the-art these heuristics are applied to bridges that the slicer identifies geometrically.
There are many other heuristics that are applied by slicers, for example support materials are generated according to overhang angles, infill tracks overlap slightly with perimeters to improve bonding between the two, etc. These types of heuristic are related both to part geometry and to flow, but the workflow that I developed here misses many of them.
5.11.7.4 The Planner’s Phase Space Representation is Poorly Suited for Flow Models
In Section 4.8.2 I discussed why solving the velocity planning problem for motion systems alone works well in phase space, where the problem is represented in discrete spatial steps that have varying time steps based on the chosen velocities.
However, in the current version of the 3D printer velocity planner, calculations that involve the (varying) \(\Delta t\) appear in multiple locations. In particular the melt flow temperature calculation is history dependent and the dynamics that describe filament compressibility and flow are based on time steps, not spatial steps. This means that the extruder system has the same difficulty that the motion system would have if it were formulated using fixed time intervals; its targets are effectively moving around after each update to \(v(s).\) As a result, the allowable gradient descent step size is much lower in the printer system, which limits overall performance and can lead to “shaky” outputs when the planner fails to converge on a good solution in time.
It may be possible to reformulate parts of the extruder system to avoid this conflict — after all the amount of filament extruded in each spatial step should ultimately be the same even as the time scaling over those steps change. The thermal history is another story; although the energy lost in each step is equivalent to the volume of the filament extruded times the temperature of that filament, the energy added to the melt flow is certainly time-dependent. It may also be that properly articulating the whole thing as a classical direct transcription solver is best, as I discussed in Section 4.8.5.
5.11.7.5 Low-Level PID / PI Errors
Finally, I suspect that the motor controllers’ low-level controllers (from Section 4.4.0.2, which are tuned by hand) contribute to the visual artefacts that can be seen in the prints from this chapter. It is obvious why a poorly tuned low-level position tracking controller would lead to some artefacts, and I discussed in Section 5.9.1 how the motor’s velocity controller bandwidth limit requires that we impose additional constraints on the extruder motor’s velocity and acceleration.
5.12 Future Work in FFF
5.12.1 Properly Combining Flow and Thermodynamic Models
In Section 5.5.4, I showed how I interpolate between steady-state and isothermal flow models. This step aids greatly in pressure prediction because FFF melt flows are, in practice, constantly changing temperature.
However, the modelling strategy that I use is somewhat lossy (see Section 5.11.7.2) and the models that I use on either end can’t be fit on “generic” machine data; e.g. because the motion models that I use are not time-varying they can be fit against data from any set of time-series data that the machine produces, which means that they can be improved over time as the machine operates (see Section 4.7.3). For the flow models, we need to isolate data that approximates either steady-state or isothermal behaviour; the tests from Section 5.5 are designed to do so.
After building the velocity planner’s flow temperature calculation step in Section 5.9.1.1, I can now see that modelling the system directly as a thermodynamic system plus a temperature varying model for isothermal flow is viable. Effectively we should develop a model that describes the melt flow temperature as a function of flow history and then use that internal estimate to fit the isothermal flow model. This is similar in practice to what I do already, but there I use the steady-state flow model (which is abstract) to approximate an estimate for temperature drop at any given average flowrate. Now I am proposing that instead of the interpolation, we fit a few additional free parameters to estimate the temperature drop: the filament’s volumetric heat capacity (which I have already showed we can estimate, in Section 5.7.1), conductivity between the melt zone wall and the filament, and heat capacity and delay in the heater block itself.
I described models built by other researchers that are similar to what I am imagining in Section 5.2.4.1. [20] and [21] use FEA for this, but Pigeonneau’s work [22] is probably the best place to start from because resolves into a more concise analytical description of the system whose parameters would be simpler to fit against data.
Modelling the thermodynamic system directly may have knock-on benefits. Its free parameters are values that we are interested in finding anyway; real thermal measurements for the heat block are an excellent basis for tuning the controllers that regulate them and both the filament’s heat capacity and conductivity are important in the layer cooling model.
Because this introduces many new internal states, adding additional data sources may be valuable; that could involve modifying extruder designs to add a second thermocouple closer to the nozzle to better estimate the heater block properties, as is done by [19] to more accurately model flows. [23] does the same and also adds thermal imaging. I implemented a small microbolometer on the FrankenPrusa’s hotend but didn’t use it in any capacity beyond just looking at the videos it produced, [23] and [34] both use thermal imaging to estimate internal flow temperatures.
Improved modelling of heaters themselves is also critical for the development of feed-forward terms in thermal controllers that would enable predictive control of hotend thermodynamics. In the state-of-the-art we rely on the large heat capacity of the heater block to make flows temperatures more predictable, but there is ongoing work in developing inductive nozzles for FFF. These have much less thermal mass, and so can change temperature much faster. I expect that they will become the new state-of-the-art over the next few years and will require better thermal control.
Given that cooling is a major driver of overall print time and that nozzle temperature has the largest overall effect on flow dynamics, the reduced thermal mass of an inductive nozzle (and their higher power and more even heating) also presents a major opportunity. Fast thermal slew rates could be used to optimize nozzle temperatures over the course of a print; larger layers printed at warmer temperatures, smaller layers with colder temperatures. If thermal slew-rates are fast enough, we could even ramp nozzle temperature along with acceleration to produce prints with roughly equal extrusion pressure throughout or e.g. use hot and fast tracks during infill and more precise extrusion on perimeters, etc. In Section 5.11.5 I showed that we can connect these types of time-varying dynamics to motion control, so connecting these two systems seems immanently possible and would be invaluable if we are to move towards “Pareto frontier printing” (Section 5.12.4).
5.12.2 Continuous Improvement and Deployment
One of the things that makes this system unique is that the measurement equipment and the process equipment are the same. In most materials modeling paradigms, we use offline hardware to characterize samples, develop process parameters for feed-forward controllers, and then deploy them. In this case, we use much lower fidelity instrumentation but can use it continuously to generate “an embarrassment” of data [52], about one gigabyte per hour.
Section 4.7.3 shows that we can successfully re-fit motion models from data generated during machine operation. This is particularly valuable for machines whose damping and inertial terms may change over time as e.g., grease dries out, belts are tightened or loosen, or (in a milling machine) when masses change even over short time spans. We should be able to do the same for our process models, continually refining flow, cooling, and extruder models as we amass more data. This is limited mostly by the flow models themselves as I just described in Section 5.12.1, but there are a few more things to consider.
The first is that much of the data generated will be redundant; if we print the same part tens of times, we need methods to apply updates to models without endlessly filling hard drives. Models are made for this (they are effectively compressed representations of observable phenomenology…), but when we re-fit we would want to keep some older samples to avoid over-fitting only in the states represented by new data. This is basically a normalization problem, for which there is well established practice.
The other consideration is about how to separate measurements that represent model updates from data that represents errors in the system; both are cases where new data fit poorly to old models, but mis-fits here could either represent unknown behaviour or external disturbances like part failures, material changes, or machine changes. This could be done by separating deltas over various time scales: changes that happen over hours and days may indicate machine maintenance issues, whereas changes that happen in milliseconds or seconds may indicate disturbances. Changes that happen when we load a new batch of material could indicate that something in the material supply chain has been modified (even if that has not been made clear).
5.12.3 Smaller Improvements to the System
5.12.3.1 Real-Time Closed-Loop Pressure
I mentioned in Section 5.9.1 that (with good enough flow models) a good avenue to control new FFF machines would involve closing the loop over the melt flow pressure. In this case we would eschew driving the extruder motor directly and instead send the extruder system a target pressure, building a lower level controller to update extruder motor torques such that the target pressure is reached. Pinyi Wu made good progress in servo control for an extruder motor in [26], but he doesn’t connect the extruder dynamics back into the velocity planner or use pressure-based control (his extruder tracks a velocity signal from an existing planner and modifies it according to filament compression dynamics alone).
Doing this properly would still require predictive control such that the pressure reference signal does not exceed the system’s physical bandwidth, and would require that the complete pressure-to-flow system is accurately modelled. As we have seen that is highly dependent on hidden internal states like the melt flow temperature; if our models estimate the flow temperature to be \(200\,^{\circ}\text{C}\) but it is really \(240\,^{\circ}\text{C}\) the same pressure target will generate much more flow.
So, this leaves us with a real question: how do we combine control modes or e.g. use open-loop control as our models are developed and then transition towards closed-loop control. Another exciting approach would involve measuring track width in real-time to control extrusion against that signal directly, etc. Pressure-based control may be particularly well suited for screw-type extruders that are used in larger extrusion systems [53] which are more difficult to tune in open-loop because they are not direct displacement pumps, i.e. a single turn of the screw does not correlate linearly to a single unit of flow from the nozzle.
5.12.3.2 The Filament Sensor
I added a filament sensor to the RheoPrinter that measure inlet flowrate alongside the filament’s real width using a passive idler wheel (connected to an encoder) with a preloading wheel whose displacement can be measured precisely; see Figure 5.11. The design is based on Thomas Sanladerer’s [41]. I originally used this for steady-state flow tests in [16] where the extruder motor was run entirely open-loop and its teeth would shear material when flow stopped. With the closed-loop motor I can instead limit motor torque to values that won’t shear materials.
But this sensor provides an opportunity to control flow based on the measured width of the incoming material rather than relying on upstream manufacturing to produce high precision filaments, which increases costs. In the state-of-the-art filament manufacturing must be done very consistently, e.g. each roll of Prusa filament is inspected with a laser width sensor at the factory [1].
5.12.3.3 Die Swell and Cooling Models
In Section 5.2.4.3 I mentioned some ongoing research efforts to model filament behaviour after it leaves the nozzle and in Sections 5.2.1.2 and 5.2.3.4 I described the importance of layer cooling overall and how it is managed in the state-of-the-art. In this work, time-optimal nozzle temperature selection which is based on cooling models (Section 5.8.4) provides some of the biggest benefits (Section 5.11.4).
So, connecting these two sides of the problem (dynamics in the nozzle to part formation outside the nozzle) is an obviously interesting area for future work, and there is a deep connection between how melt flows are “disentangled” within the nozzle and their adhesion to one another outside of the nozzle, as noted by [35]. In [32] we see that extrusion pressure / shear rate is also correlated with die swell, which is a widening of extruded tracks that occurs mostly when we extrude polymers when they’re not completely molten or are extruded at extremely high pressures.
These aspects of extrusion may indicate that there is a second upper limit to flowrates and melt flow temperatures, besides those that we can already see that are based on pressure generation and heating of the filament. Some materials also degrade when they are heated past certain temperatures, representing another important boundary.
Here again the microbolometer is likely a valuable instrument, e.g. [32] [34] and [23] all use thermal imaging to improve both heating and cooling of individual tracks of filament.
Thermal data has an obvious utility in estimating how layers cool; the methods that I develop in Section 5.7.2 use estimates for heat transfer to air and into the layer below. Those could be supplanted with data fit from the microbolometer. In fact because its frames are time-synchronized to the motion system, we should be able to use them to recreate a 3D thermal history of the printed part. It may also be easier to develop simpler strategies like measuring the average temperature of a part surface under variable fan parameters and geometries.
5.12.4 Pareto Frontier Printing
Finally, and the most exciting way to improve the process overall, is the prospect of formulating the FFF workflow on the basis of Pareto optimality across underlying trade-offs between precision, strength, and speed.
For example the key tuning knob in the optimum nozzle temperature step here is picking our target layer temperature \(T_{targ}\) — if we favor “hot and fast” prints that may be somewhat slumped (but stronger due to improved layer adhesion), we can dial this up: the minimum-time optimization will be penalized less for warmer flows (as minimum layer times will be shorter). If we want precision above all, we can turn this down and we will see the opposite result. This makes up one axis in a theoretical Pareto frontier, which trades strength (at the cost of precision) for speed. If we want strength and precision, we would print layers hot but also slow them down to avoid slumping. Similar trade-offs extend into the motion system; using more motive force there increases acceleration and cornering velocities but excites mechanical vibrations in the machine and requires that motors track higher bandwidth signals.
This is a classic “pick two” scenario: we can have precision and strength but not with speed, or speed and strength but not precision. By “Pareto optimality” we mean that, given two or more objectives, we must decrease the optimal outcome of one in order to improve the outcome of the other. In between these trade-offs there is still a “Pareto frontier” that is the most optimal outcome overall, given the constraints of the underlying problem. Originally developed in economics [54] it often appears in engineering and mathematics [55] to describe these types of trade-offs.
In FFF printing we could formalize trade-offs for precision, speed and layer strength by defining optimal results for each. Optimal speed is obvious: we measure total time. Overall precision is a strong function of our cooling target temperature, motion system and also flow system. Layer adhesion / part strength is a function of the layer interfaces’ thermal history [3]. What is missing from the current work is a characterization of how much layer strength is gained from a given increase in interface temperature / time, and how much precision is gained from slowing down and over-cooling parts. These are all dependent on physical models that change from machine to machine and across materials.
What is perhaps more difficult than modelling how these trade-offs interact physically is choosing how to articulate them to machine operators. For one example, rendering systems in CGI sometimes let users say e.g. “I have five hours maximum to wait for this render to complete, render at as high of a resolution is possible in that timeframe;” we can imagine the utility of making the same formulation for FFF 3D printing. For precision users could articulate how much deviation they would allow between the printed part and their CAD model, but interlayer adhesion may be the most difficult to express and to model. Rather than specifying target values directly, a simpler interface may simply allow users to pick weights within \(0 \rightarrow 1\) for each trade-off.
Overall, I think the future of FFF printing is bright. I know that there are many others working in this domain, and (luckily for the public good) many of the critical patents have expired8. Despite the onslaught of new strategies being developed for additive (laser bed fusion, binder jetting, etc.), FFF remains extremely useful, relatively easy, cheap, and capable of producing excellent parts. In my research group at the Center for Bits and Atoms we have access to a long list of advanced equipment, some of which are worth hundreds of thousands of dollars each. We also have a wall of twelve FFF 3D printers, each worth around one thousand dollars. Measured in total output of new ideas tested, they are the most productive pieces of equipment in the lab.
References
FFF: Fused Filament Fabrication is the nomenclature preferred by academics for the 3D printing process of extruding plastic filaments through a hot nozzle which typically goes by another three-letter acronym. The other acronym is actually trademarked by a 3D printing firm who shall not be named.↩︎
Die swell is a phenomenon where plastics extruded at high pressure will return to their pre-extrusion geometries - in FFF 3D printing this means that tracks extruded at, say, 0.6mm width and 0.3mm height will tend back towards the shape of the filament - a 1.75mm cylinder - as they cool. This happens because the filament has not completely melted during extrusion, and retains some memory of its original shape.↩︎
Technically in rheology “steady-state” flow means that a flow is “fully developed,” and so temperature in the flow is unchanging. In the modelling here I call “steady state” the flow conditions that we reach after extruding at the same nozzle temperature and inlet flow i.e. this is steady state of the flow dynamics even though the flow’s internal temperature changes significantly from one end (the inlet) and the other (the nozzle tip).↩︎
A bowden tube is a design used in many FFF printers where a drive motor pushes filament into a (normally PTFE / Teflon) tube that is only marginally larger than the filament, which is connected to the hotend. This moves the extruder mass off of the moving gantry, but introduces more delay between the extruder motor and extrusion.↩︎
Some polymers are amorphous whereas others are crystalline, so behaviour at this stage (and during extrusion) can vary based on this property as well.↩︎
The subreddit in question is reddit.com/r/FirstLayerPorn.↩︎
A Universal Testing Machine (UTM) — often known by the brand name Instron — is a machine used to generate stress-strain curves for material samples. They stretch or compress materials (normally until they break) while measuring elongation or squish and recording load cell measurements.↩︎
For example Stratasys held a patent on enclosed build chambers and so for about 15 years most FFF companies couldn’t put their machine in a box (which greatly improves part warping, and makes the printer less susceptible to i.e. a drafty room). Some readers may be wondering why I keep calling it FFF - well, the other acronym is trademarked by the same company. This is all fair game in today’s patent law ecosystem, but a clear case where our old laws (developed in an era where technological advancement was more costly and took place in longer cycles) have become outdated. Not to mention a changing global order, especially in manufacturing, where some of the main participants are developing equipment within completely different legal frameworks - given the difference in the two worlds’ approaches to IP law it is no surprise to me that they are able to innovate at such an outstanding pace. Notes should be taken…↩︎