Some ideas for SettleBuildPlate, ElephantFoot, csv layer data, saving encrypted.ctb, DynamicLiftHeight

[msspad]

Jan wrote again a very nice blog post [1]. Below is our script we use regularly. It's not the nicest code and it's an every changing script for us but it might give others some ideas how to handle things, for example:

• CriticalLayers: when NumPixels changes significantly between layers, waitTimeBeforeCure is increased for the following 6 layers
• SettleBuildPlate() greatly reduces the elephant foot but some pixels still ooze out. Erode those remaining pixels.
• Saves automatically the updated SlicerFile. This prevents users from handling Chitubox' encrypted file mess.
• Creates a csv file with relevant layer parameters

[1] https://blog.honzamrazek.cz/2022/02/a-step-by-step-guide-for-the-perfect-bed-adhesion-and-removing-elephant-foot-on-a-resin-3d-printer/

using System;
using System.Text;
using System.IO;
using System.Collections.Generic;
using UVtools.Core;
using UVtools.Core.Extensions;
using UVtools.Core.Scripting;
using UVtools.Core.Operations;
using UVtools.Core.FileFormats;

namespace UVtools.ScriptSample 
{
    public class ScriptDebandingZSample : ScriptGlobals 
    {      
        record PrintProfile {
            public string Name { get; init;}

            // ===== Printer =====
            public uint numPixelsInDisplay { get; init; }

            // ===== SettleBuildPlate() =====
            public float groundEffectHeightMM { get; init; } = 1;
            public float groundEffectWaitTimeBeforeCureS { get; init; }
            // I think the Chitubox firmware still enforces a min time between layerExposure of about 5s. 
            // So with exposureTime=2s and a quick lift/retract, there is no point in reducing minWaitTimeBeforeCureS further.
            public float minWaitTimeBeforeCureS { get; init; } = 3; 
            public float maxWaitTimeBeforeCureS { get; init; } = 12;
            public float percentPixelForMaxWaitTime { get; init; } = 0.12f;

            // ===== DynamicLiftHeight() =====
            public float lowestLiftHeightMM { get; init; } = 3f;
            public float highestLiftHeightMM { get; init; } = 6f;
            public float percentPixelsForHighestLiftHeight { get; init; } = 0.12f;

            // ===== ElephantFootErode() =====
            public float elephantFootNumErodeIterations { get; init; }
        }
        private PrintProfile PhrozenMini4k_PrusaToughOrange = new() {
            Name = "Phrozen Sonic Mini 4K, Prusa tough orange",
            numPixelsInDisplay = SlicerFile.ResolutionX * SlicerFile.ResolutionY,
            groundEffectWaitTimeBeforeCureS = 40,
            elephantFootNumErodeIterations = 4
        };
        private PrintProfile PhrozenMini8k_T = new() {
            Name = "Phrozen Sonic Mini 8K, T",
            numPixelsInDisplay = SlicerFile.ResolutionX * SlicerFile.ResolutionY,
            groundEffectWaitTimeBeforeCureS = 30,
            elephantFootNumErodeIterations = 8
        };
        private PrintProfile profile;

        private string logFilePath;
        private string csvFilePath;
        private StringBuilder log = new();
        private StringBuilder invalidDataUserMessage = new();
        
        private ScriptTextBoxInput CriticalLayerIndicesInput = new() {
            Label = "Critical layers",
            ToolTip = $"Maximize the waitTimeBeforeCure after those layer indices, e.g. '100,550' for layer index 100 and 500. For 100, layer indices 100, 101, ..., 105 get waitTimeBeforeCure=12s",
            Unit = "1-10000",
            Value = ""
        };

        private ScriptNumericalInput<ushort> NumErodeInput = new() {
            Label = "Num bottom erode",
            ToolTip = "number of erode iterations of bottom layers",
            Unit = "-",
            Minimum = 0,
            Maximum = 100,
            Increment = 1,
            Value = 0
        };

        private List<int> ReadCriticalLayerIndices() {
            List<int> levels = new();
            var layerIndexStrings = CriticalLayerIndicesInput.Value.Split(',', StringSplitOptions.TrimEntries);
            foreach (var layerIndexStr in layerIndexStrings) {
                if (! string.IsNullOrEmpty(layerIndexStr)) {
                    if(int.TryParse(layerIndexStr, out var layerIndex)) {
                        if ((0 <= layerIndex) & (layerIndex <= SlicerFile.LastLayer.Index)) {
                            levels.Add(layerIndex);
                        } else {
                            invalidDataUserMessage.AppendLine($"Invalid layerIndex value {layerIndex}");
                        }
                    } else {
                        invalidDataUserMessage.AppendLine($"Invalid layerIndex format {layerIndexStr}");
                    }
                }
            }
            return levels;
        }

        public void ScriptInit() {
            Script.Name = "ABC script for customer parts and engineering parts";
            Script.Author = "ABC";
            Script.Version = new Version(1, 0);
            Script.UserInputs.Add(CriticalLayerIndicesInput);
            Script.UserInputs.Add(NumErodeInput);

            string downloadPath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile)+ @"\Downloads";
            logFilePath = Path.Combine(downloadPath,"UVToolsScriptLog.txt");
            csvFilePath = Path.Combine(downloadPath, $"UVTools_{SlicerFile.FilenameNoExt}.csv");

            StringBuilder description = new();
            if ((SlicerFile.MachineName != null) && (SlicerFile.MaterialName != null)) {
                if (SlicerFile.MachineName.ContainsAll("Phrozen", "4k") && SlicerFile.MaterialName.ContainsAll("Prusa", "Tough")) {
                    profile = PhrozenMini4k_PrusaToughOrange;
                    description.AppendLine($"- Profile: {profile.Name}");
                } else if (SlicerFile.MachineName.ContainsAll("Phrozen", "8k") && SlicerFile.MaterialName.ContainsAll("T")) {
                    profile = PhrozenMini8k_T;
                    description.AppendLine($"- Profile: {profile.Name}");
                } else {
                    description.AppendLine($"ERRORRRRRRRRRRRRRRRRR: Could not find valid MachineName for {SlicerFile.MachineName}");
                }
            } else {
                description.AppendLine($"ERRORRRRRRRRRRRRRRRRR: Could not find MachineName={SlicerFile.MachineName} and MaterialName={SlicerFile.MaterialName} combination (e.g. CTB files do not have MaterialName but SL1 have.)");
            }

            description.AppendLine($"- script overwrites {SlicerFile.FileFullPath}");
            description.AppendLine($"- log {logFilePath}");
            description.AppendLine($"- csv {csvFilePath}");
            Script.Description = description.ToString();
        }

        public string ScriptValidate() {
            StringBuilder userMessage = new();

            if (Operation.LayerIndexStart != SlicerFile.FirstLayer.Index) {
                userMessage.AppendLine("Note that this script applies to all layers. The range selector is ignored");
            }
            if (Operation.LayerIndexEnd != SlicerFile.LastLayer.Index) {
                userMessage.AppendLine("Note that this script applies to all layers. The range selector is ignored");
            }

            if (SlicerFile.MaterialName == null) {
                userMessage.AppendLine("no MaterialName definied, e.g. CTB files do not have MaterialName but SL1 have.");
            }
            if (!(SlicerFile.CanUseAnyLightOffDelay & SlicerFile.CanUseAnyWaitTimeBeforeCure)) {
                userMessage.AppendLine("Your printer/file format is not supported.");
            }

            if (profile == null) {
                userMessage.AppendLine("Combination of printer/resin material is unknown.");
            }

            // check for LiftHeight2==0, RetractHeight2==0
            for (uint layerIndex = SlicerFile.FirstLayer.Index; layerIndex <= SlicerFile.LastLayer.Index; layerIndex++) {
                var layer = SlicerFile[layerIndex];
                if (0 < layer.LiftHeight2) {
                    userMessage.AppendLine($"WARNING {layer.Index}: LiftHeight2=={layer.LiftHeight2}, not 0! why?");
                }
                if (layer.RetractHeight2 != 0) {
                    userMessage.AppendLine($"WARNING {layer.Index}: RetractHeight2=={layer.RetractHeight2}, not 0! why?");
                }             
            }

            // invalidDataUserMessage
            ReadCriticalLayerIndices();
            if (0 < invalidDataUserMessage.Length) {
                userMessage.Append(invalidDataUserMessage);
            }
            invalidDataUserMessage.Clear();

            return userMessage.ToString();
        }

        public bool ScriptExecute() {
            Progress.Reset("Changing all layers", Operation.LayerRangeCount);
            ReduceBottomLayers();
            DynamicLiftHeight();
            SettleBuildPlate();
            ElephantFootErode();
            AddEmptyFirstLayer();

            OverwriteSlicerFile();
            OverwriteLogAndCsv();
            return !Progress.Token.IsCancellationRequested;
        }

        // PrusaSlicer min BottomLayerCount is 3 but 2 is enough.
        private void ReduceBottomLayers() {
            SlicerFile.BottomLayerCount = 2;
        }

        // with significant changes of NumPixels in layer, allow the build plate to settle at the correct position. 
        // Otherwise slight misalignment of the layers might be visible or internal layer separation can happen.
        private string LayerIndicesWithNumPixelDropOrLeap() {
            var prevLayerPixelCount = SlicerFile.FirstLayer.NonZeroPixelCount;
            StringBuilder layerIndices = new();
            for (uint layerIndex = SlicerFile.FirstLayer.Index; layerIndex <= SlicerFile.LastLayer.Index; layerIndex++) {
                var layer = SlicerFile[layerIndex];
                if (profile.groundEffectHeightMM < layer.PositionZ) {
                    // increase waitTimeBeforeCure for the next 6 layers if pixel drop or pixel leap occurs
                    bool hasNumPixelDrop = (2 * layer.NonZeroPixelCount) < prevLayerPixelCount;
                    bool hasNumPixelLeap = (2 * prevLayerPixelCount) < layer.NonZeroPixelCount;

                    if (hasNumPixelDrop | hasNumPixelLeap) {
                        if (0 < layerIndices.Length) {
                            layerIndices.Append(",");
                        }
                        layerIndices.Append(layer.Index);
                    }
                }
                prevLayerPixelCount = layer.NonZeroPixelCount;
            }
            return layerIndices.ToString();
        }

        /* PositionZ of the build plate is an open-loop control system, so the effective PositionZ also depends on external forces:
        (1) "Ground effect" force: For the first layers, the resin of the entire area of the build plate needs to be displaced.
        (2) "crowded layer" force: Many pixels on the previous layer
        The force of 1) is likely much higher than 2). The forces result mainly in a deformation of the printer case.
        full descpription at https://github.com/sn4k3/UVtools/discussions/402#discussioncomment-1971512 */
        private void SettleBuildPlate() {
            var criticalLayerIndices = ReadCriticalLayerIndices();
            SlicerFile.BottomLightOffDelay = 0;
            SlicerFile.LightOffDelay = 0;
            SlicerFile.BottomWaitTimeBeforeCure = profile.groundEffectWaitTimeBeforeCureS;
            SlicerFile.WaitTimeBeforeCure = profile.maxWaitTimeBeforeCureS;

            var waitTimeBeforeCure = profile.maxWaitTimeBeforeCureS;
            var prevLayerPixelCount = SlicerFile.FirstLayer.NonZeroPixelCount;
            var firstLayerPositionZ = SlicerFile.FirstLayer.PositionZ;
            int numLayerForDropOrLeap = -1;
            for (uint layerIndex = SlicerFile.FirstLayer.Index; layerIndex <= SlicerFile.LastLayer.Index; layerIndex++) {
                var layer = SlicerFile[layerIndex];
                if ((float)layer.PositionZ <= profile.groundEffectHeightMM) {
                    var ratio = (layer.PositionZ - firstLayerPositionZ) / profile.groundEffectHeightMM;
                    waitTimeBeforeCure = profile.maxWaitTimeBeforeCureS + (1 - ratio) * (profile.groundEffectWaitTimeBeforeCureS - profile.maxWaitTimeBeforeCureS);
                } else {
                    if (criticalLayerIndices.Contains((int) layer.Index)) {
                        numLayerForDropOrLeap = 6;
                        waitTimeBeforeCure = profile.maxWaitTimeBeforeCureS;
                    }
                }
                layer.SetWaitTimeBeforeCureOrLightOffDelay(waitTimeBeforeCure);

                // calculate waitTimeBeforeCure for the next layer 
                if (0 < numLayerForDropOrLeap) {
                    waitTimeBeforeCure = profile.maxWaitTimeBeforeCureS;
                } else {
                    var cappedPixelPercent = Math.Min(profile.percentPixelForMaxWaitTime, ((float) layer.NonZeroPixelCount) / profile.numPixelsInDisplay);
                    var pixelRatio = Math.Clamp(cappedPixelPercent / profile.percentPixelForMaxWaitTime, 0f, 1f);
                    waitTimeBeforeCure = profile.minWaitTimeBeforeCureS + pixelRatio * (profile.maxWaitTimeBeforeCureS - profile.minWaitTimeBeforeCureS);
                }
                numLayerForDropOrLeap--;
                prevLayerPixelCount = layer.NonZeroPixelCount;
            }
        }

        // Running all layers with printer.highestLiftHeightMM gives great results. However, printing time can be reduced with dynamic lift heights without sacrificing quality.
        private void DynamicLiftHeight() {
            float liftHeightMM = profile.highestLiftHeightMM;

            for (uint layerIndex = SlicerFile.FirstLayer.Index; layerIndex <= SlicerFile.LastLayer.Index; layerIndex++) {
                var layer = SlicerFile[layerIndex];
                if (layer.IsBottomLayer) {       
                    liftHeightMM = profile.highestLiftHeightMM;        
                } else {
                    var cappedPixelPercent = Math.Min(profile.percentPixelsForHighestLiftHeight, ((float) layer.NonZeroPixelCount) / profile.numPixelsInDisplay);
                    var pixelRatio = Math.Clamp(cappedPixelPercent / profile.percentPixelsForHighestLiftHeight, 0f, 1f);
                    liftHeightMM = profile.lowestLiftHeightMM + pixelRatio * (profile.highestLiftHeightMM - profile.lowestLiftHeightMM);
                }

                layer.RetractHeight2 = 0;
                layer.LiftHeightTotal = (float) Math.Round(liftHeightMM, 1);
            }
        }

        // SettleBuildPlate() greatly reduces the elephant foot but some pixels still ooze out. Erode those remaining pixels.
        private void ElephantFootErode() {
            // TODO there is a nicer erode function in UVTools?
            if (0 < NumErodeInput.Value) {
                // log.AppendLine($"NumErodeInput={NumErodeInput.Value}");
                OperationMorph morph = new(SlicerFile) {
                    MorphOperation = OperationMorph.MorphOperations.Erode,
                    Iterations = NumErodeInput.Value,
                };
                morph.SelectBottomLayers();

                Progress.Token.ThrowIfCancellationRequested(); // Abort operation, user requested cancellation
                morph.ROI = Operation.ROI; // Copy user selected ROI to my operation
                morph.MaskPoints = Operation.MaskPoints; // Copy user selected Masks to my operation
                if (morph.CanValidate()) {
                    morph.Execute(Progress);
                }
            }
        }

        // Only necessary because WaitBeforeCure is ignored for the first layer.
        private void AddEmptyFirstLayer() {
            var firstLayer = SlicerFile.FirstLayer;
            if (1 < firstLayer.NonZeroPixelCount) { // First layer is not blank as it seems, lets create one
                firstLayer = firstLayer.Clone();
                using var mat = EmguExtensions.InitMat(SlicerFile.Resolution);
                var pixelPos = firstLayer.BoundingRectangle.Center();
                mat.SetByte(pixelPos.X, pixelPos.Y, 1); // Print a very fade pixel to ignore empty layer detection
                firstLayer.LayerMat = mat;
                firstLayer.ExposureTime = SlicerFile.SupportsGCode ? 0 : 0.1f;
                firstLayer.SetWaitTimeBeforeCureOrLightOffDelay(0);
                SlicerFile.SuppressRebuildPropertiesWork(() => { SlicerFile.LayerManager.Prepend(firstLayer); });
            }
        }

        // Saves the modified file automatically.
        private void OverwriteSlicerFile() {
            if (SlicerFile.GetType() == typeof(CTBEncryptedFile)) {
                SlicerFile.Convert(typeof(CTBEncryptedFile), SlicerFile.FileFullPath);
            } else {
                SlicerFile.Save();
            }
        }

        private void OverwriteLogAndCsv() {
            if (File.Exists(logFilePath) | (0 < log.Length)) {
                File.WriteAllText(logFilePath, log.ToString());
                log.Clear();
            }

            using (StreamWriter csv = File.CreateText(csvFilePath)) {
                csv.WriteLine("Index,PositionZ [mm],LightOffDelay [s],LiftSpeed [mm/min],RetractSpeed [mm/min],LiftHeightTotal [mm],WaitTimeBeforeCure [s],WaitTimeAfterCure [s]");

                for (uint layerIndex = SlicerFile.FirstLayer.Index; layerIndex <= SlicerFile.LastLayer.Index; layerIndex++) {
                    var layer = SlicerFile[layerIndex];
                    if (layer.IsBottomLayer) {
                        csv.WriteLine($"{layer.Index},{layer.PositionZ},{SlicerFile.BottomLightOffDelay},{SlicerFile.BottomLiftSpeed},{SlicerFile.BottomRetractSpeed},{SlicerFile.BottomLiftHeight},{SlicerFile.BottomWaitTimeBeforeCure},{SlicerFile.BottomWaitTimeAfterCure}");
                    } else {
                        csv.WriteLine($"{layer.Index},{layer.PositionZ},{layer.LightOffDelay},{layer.LiftSpeed},{layer.RetractSpeed},{layer.LiftHeightTotal},{layer.WaitTimeBeforeCure},{layer.WaitTimeAfterCure}");
                    }             
                }
            }
        }

        public static bool ContainsAll(this string stringToSearch, params string[] findMes) {
            foreach (string findMe in findMes) {
                if (!stringToSearch.Contains(findMe, StringComparison.OrdinalIgnoreCase))
                    return false;
            }
            return true;
        }
    }
}

[sn4k3]

You wrote a nice script and put some work in it 👍
Here my code suggestions:

• Where you contrains to known machine names and resin, you could have a else to generic handle it based on other parameters like the display size or other(s)
• SlicerFile.MachineName can be null - Rare but carefull
• SlicerFile.GetType().GetProperty("MaterialName") can be SlicerFile.MaterialName you have public and direct access, use SlicerFile.MaterialName != null or SlicerFile.MaterialName is not null
• SlicerFile.FirstLayer.Index should be 0, first index is always 0, there's no need to extra calls
• SlicerFile.LastLayer.Index shoud be SlicerFile.LastLayerIndex it handles errors and nulls
• On OverwriteLogAndCsv function, instead of having a StringBuilder csv, you can have a TextWriter csv, that way you dont cache all that text and write at once, not if that matter anyway for a few Megabytes, but is always good pratice to buffer to file directly when you can.
• if (0 < numLayerForDropOrLeap) and similars, looks like you come from Powershell schemantic? It mess up my brain comparing something you dont have with what you have, also you use the otherway too if (layerIndices.Length > 0) which reads and looks better. Although this is a personal preference.

Overall good job and keep improving it 👍

[msspad]

very useful feedback, thank you! I updated the code in the original post:

• I put all parameters in a print profile now and define machine+resin combo at the beginning. Detection is still string based but might change it to display resolution later.
• SlicerFile.FirstLayer.Index is certainly slower at runtime. However, my bottleneck is the performance at understanding/writing code and for that, SlicerFile.FirstLayer.Index/SlicerFile.LastLayer.Index helps a lot (it prevents me from having to know it's 0-based, I also learn how to access the first, last layer etc)
• if (0 < variable) is certainly a personal preference thing :-) I always put <, so I never have the mental load of reading < or >. I don't know Powershell or C#, got experience mainly in Python and Java.

[yaqwsx]

Just to add my 2 cents; this is my proposal for estimating the rest times for individual layers: https://gist.github.com/yaqwsx/82618d9f37e1e09bece4f6eaa27d02d6

Happy to hear your feedback.

[msspad]

very interesting thoughts about optimal WaitTimeBeforeCure. Here is my current, ever-changing view:

goal
the build plate rests at the exact PositionZ while exposure happens

issue
due to different forces, the build plate slowly approaches the target PositionZ. The time it takes to reach PositionZ depends on the magnitude of the forces, which depend on:

1. number of pixels in previous layers
2. distribution of pixels in previous layers
3. the mechanical stiffness of the printer
4. viscosity of the resin (which depends on temperature, etc)
5. amount of resin in tank
6. etc, etc

solution 1 with UVTools
We cover 1)-6) with a constant time of e.g. WaitTimeBeforeCure=40s for all layers. The results are great but printing time goes through the roof.

solution 2 with UVTools
we cover 2)-6) with a constant time and estimate 1) with the number of pixels in the previous layer. We linearly increase WaitTimeBeforeCure from a minimal value (3s in the script) to a maximum value (12s in the script) and cap WaitTimeBeforeCure when more than 12% of pixels are exposed. The results are great, much faster than solution 1.

solution 3 with UVTools
we cover 3)-6) with a constant time and estimate 1) and 2). That's the solution you propose and I think it could work. The main benefit of solution 3 compared to solution 2 is lower printing time. So solution 3 must be much faster than linearly approximating 1) and cover 2) with a constant time. From my limited experience, that won't save you that much printing time. But I really hope you can prove me wrong :-)

solution 4 with hardware
We admit that it's impossible to simulate the optimal WaitTimeBeforeCure and achieve our original goal with adding a linear position sensor between the build plate and FEP. This closed loop system certainly achieves the goal but sensors with a precision below +-0.01mm and a length of 180mm are very expensive. So that won't happen with consumer 3D printers

solution 5 with hardware
Your measurements (they are super great, btw!) show that the build plate settles within a few seconds into the target PositionZ. It's very likely that this settlement could be detected with consumer-grade IMUs when attached to the arm of the build plate. IMUs are cheap, only cabling and assembly are somewhat costly for industrial production.
That's a fairly easy measurement and what I will do next (though too busy in the coming weeks). It should give a useful insight into how we can reach our goal: it features optimal printing time and is doable for 3D printer manufacturers (hat may take years though...). So let's hope someone comes up with an open source firmware for current printers.

What do you think?

[msspad]

I came around testing solution 5 mentioned above:

(removed chart, see post below)

• there is too much noise in the measurement to recognize when the build plate has settled, thus solution 5 is not a solution :-)

Measurement setup:

• Nano RP2040 Connect with ST LSM6DSOX at ODR 104 Hz, scale 2g
• IMU attached at the nose of the arm
• measured with a modified build plate that is about 100 g lighter than the standard build plate

[sn4k3]

could the noise be improved? You were taking raw values or use any smoothing like average/multisampling?

[msspad]

ok, so I rerun the measurement with a proper setup. Conclusion is still the same: the build plate either settles within the noise margin of the IMU or there is a very settlement duration with the Phrozen Mini 8k (or a combination of both).
Edit: I should add that gyro_x shows a settlement duration of about 1s at the first exposure and about 0.5s at the last exposure. It's possible that the build plate of the Phrozen Mini 8k settles that quick with this ctb. If it did settle that quick, IMU would be useful to measure the settlement duration.

That's 1 exposure cycle. "Reconstructed" is filtered with db2 wavelets. Didn't bother to tune more precisely, so there are some artefacts:

When zooming in, no settlement of the build plate is noticeable:

Measurement setup

• Nano RP2040 Connect with ST LSM6DSOX at ODR 104 Hz, scale 2g and 250dps
• IMU attached at the nose of the arm, PCB and cable are firmly attached to the arm, no vibration possible
• measured with a modified build plate that is about 100 g lighter than the standard build plate
• no calibration of IMU

Acceleration noise calculation

• ODR 104 Hz
• register 0x17 = 0x09 -> LPF2 = ODR/4
• LPF2 at 104Hz/4 = 26Hz
• I assume 26Hz is the -3dB cutoff frequency of a 1st order filter, bandwidth scaling factor = 1.57
• Acceleration noise density = 70 ug/sqrt(bandwidth)
• acc_noise_RMS = 70 ug/sqrt(bandwidth) * sqrt(1.57*26Hz) = 447ug

Gyro noise calculation

• ODR 104 Hz
• register 0x11: LPF2 = ODR/4
• LPF2 at 104Hz/4 = 26Hz
• I assume 26Hz is the -3dB cutoff frequency of a 1st order filter, bandwidth scaling factor = 1.57
• Gyro noise density = 3.8 mdps/sqrt(bandwidth)
• gyro_noise_RMS = 3.8 mdps/sqrt(bandwidth) * sqrt(1.57*26Hz) = 155mdps

Attached imu.zip is the ctb file and the raw IMU data for those who want to play around.

[JaPhi]

Why not use simple strain gauges on the arm? Way easier to handle and less noise.

[msspad]

IMUs are cheap, easy to attach to the build plate, suitable because the settlement happens within seconds and I have a few laying around and can start logging within minutes. The measurement reported above shows a very short settlement duration of about 1s. This means either the Phrozen 8k settles that fast or the noise of the IMU hides the rest of the settlement.

Probably the main reason why I haven't tried strain gauges is the expected stiffness of the Phrozen 8k: There is probably minor deformation in the build arm or the pole behind the spindle (have you seen the FEM simulation of Jan?). But those 2 elements are the easiest to attach a strain gauge, right?
Minor reasons are that the attachement of strain gauges is a bit more complicated, I don't have them laying around and I would have to interface the sensor with an MCU or somehow. It's certainly a good idea to try it out and I hope you (or somebody else) will report soon some result :-)

Our layers have a WaitTimeBeforeCureS between 2-6s and we haven't had any issues with printing for months. It's certainly possible to reduce that time and speed up the printing time somewhat but many other things have higher priority...

[yaqwsx]

The strain gauge needs a replacement of arm with a built-in strain gauge if you want to get reasonable measurements. You can attach ones to the existing arms, but that has two problems: the arm is too stiff, so you will get poor resolution, and it is pretty hard to attach them properly to the metal. Having a string gauge is probably the best option, but I am afraid it is not something a BFU can install without a premade-kit.

[msspad]

I forgot to add that we use a custom build plate/build arm. The interface between the plate and the arm are 3 screws that can be height-adjusted. Once I got a suitable pressure sensor, I will take some measurements and report back, but I have no idea when that day will come...

[msspad]

Just for historical reference: According to AmeraLabs, Asiga Max printers have a load cell integrated and they log out the data for each layer, https://ameralabs.com/blog/are-fep-alternatives-worth-it-acf-vs-nfep-vs-fep-films/