public override string Convert(string value, PrinterSettings settings)
{
double finalValue = 0;
if (value.Contains("%"))
{
string withoutPercent = value.Replace("%", "");
double ratio = ParseDouble(withoutPercent) / 100.0;
string originalReferenceString = settings.GetValue(this.ReferencedSetting);
double valueToModify = ParseDouble(originalReferenceString);
finalValue = valueToModify * ratio;
}
else
{
finalValue = ParseDouble(value);
}
if (change0ToReference &&
finalValue == 0)
{
finalValue = ParseDouble(settings.GetValue(ReferencedSetting));
}
finalValue *= scale;
return(finalValue.ToString());
}
public void CheckImportPrinterSettingsToPrinter()
{
AggContext.StaticData = new FileSystemStaticData(TestContext.CurrentContext.ResolveProjectPath(4, "StaticData"));
MatterControlUtilities.OverrideAppDataLocation(TestContext.CurrentContext.ResolveProjectPath(4));
var printerSettings = new PrinterSettings();
printerSettings.SetValue(SettingsKey.cancel_gcode, "cancel gcode");
printerSettings.SetValue(SettingsKey.start_gcode, "start gcode");
string newValue = "----- cancel gcode ----";
string notAnExistingKey = "NotAnExistingKey";
var toImport = new PrinterSettings();
toImport.SetValue(SettingsKey.cancel_gcode, newValue);
toImport.SetValue(notAnExistingKey, "------------------");
var sourceFilter = new List <PrinterSettingsLayer>()
{
toImport.UserLayer
};
printerSettings.Merge(printerSettings.UserLayer, toImport, sourceFilter, false);
Assert.AreEqual(printerSettings.GetValue(SettingsKey.cancel_gcode), newValue, "Imported setting applied");
Assert.IsEmpty(printerSettings.GetValue(notAnExistingKey), "Invalid settings keys should be skipped");
}
public override string Convert(string value, PrinterSettings settings)
{
double lengthToExtrudeMm = ParseDouble(value);
// we need to convert mm of filament to mm of extrusion path
double amountOfFilamentCubicMms = settings.GetValue <double>(SettingsKey.filament_diameter) * MathHelper.Tau * lengthToExtrudeMm;
double extrusionSquareSize = settings.GetValue <double>(SettingsKey.first_layer_height) * settings.GetValue <double>(SettingsKey.nozzle_diameter);
double lineLength = amountOfFilamentCubicMms / extrusionSquareSize;
return(lineLength.ToString());
}
public ZTuningWidget(PrinterSettings printerSettings, ThemeConfig theme, int extruderIndex)
{
this.extruderIndex = extruderIndex;
this.theme = theme;
this.printerSettings = printerSettings;
this.HAnchor = HAnchor.Fit;
this.VAnchor = VAnchor.Fit | VAnchor.Center;
zOffsetStreamContainer = new FlowLayoutWidget(FlowDirection.LeftToRight)
{
Margin = new BorderDouble(3, 0),
Padding = new BorderDouble(3),
HAnchor = HAnchor.Fit,
VAnchor = VAnchor.Center,
BackgroundColor = theme.MinimalShade,
Height = 20
};
this.AddChild(zOffsetStreamContainer);
double zoffset = printerSettings.GetValue <double>(SettingsKey.baby_step_z_offset);
if (extruderIndex == 1)
{
zoffset = printerSettings.GetValue <double>(SettingsKey.baby_step_z_offset_1);
}
zOffsetStreamDisplay = new TextWidget(zoffset.ToString("0.##"), pointSize: theme.DefaultFontSize)
{
AutoExpandBoundsToText = true,
TextColor = theme.TextColor,
Margin = new BorderDouble(5, 0, 8, 0),
VAnchor = VAnchor.Center
};
zOffsetStreamContainer.AddChild(zOffsetStreamDisplay);
clearZOffsetButton = theme.CreateSmallResetButton();
clearZOffsetButton.Name = "Clear ZOffset button";
clearZOffsetButton.ToolTipText = extruderIndex == 0 ? "Clear ZOffset".Localize() : "Clear ZOffset 2".Localize();
clearZOffsetButton.Visible = zoffset != 0;
clearZOffsetButton.Click += (sender, e) =>
{
if (extruderIndex == 0)
{
printerSettings.SetValue(SettingsKey.baby_step_z_offset, "0");
}
else
{
printerSettings.SetValue(SettingsKey.baby_step_z_offset_1, "0");
}
};
zOffsetStreamContainer.AddChild(clearZOffsetButton);
// Register listeners
printerSettings.SettingChanged += Printer_SettingChanged;
}
public void firstLayerExtrusionWidthAcceptableValue(PrinterSettings printerSettings, PrinterSettingsLayer layer, string sourceFile)
{
string firstLayerExtrusionWidth;
if (!layer.TryGetValue(SettingsKey.first_layer_extrusion_width, out firstLayerExtrusionWidth))
{
return;
}
float convertedFirstLayerExtrusionWidth;
string nozzleDiameter = printerSettings.GetValue(SettingsKey.nozzle_diameter);
float acceptableValue = float.Parse(nozzleDiameter) * 4;
if (firstLayerExtrusionWidth.Contains("%"))
{
string reformatFirstLayerExtrusionWidth = firstLayerExtrusionWidth.Replace("%", " ");
convertedFirstLayerExtrusionWidth = float.Parse(reformatFirstLayerExtrusionWidth) / 100;
}
else
{
convertedFirstLayerExtrusionWidth = float.Parse(firstLayerExtrusionWidth);
}
Assert.LessOrEqual(convertedFirstLayerExtrusionWidth, acceptableValue, "Unexpected firstLayerExtrusionWidthAcceptableValue value: " + sourceFile);
}
public void firstLayerSpeedEqualsAcceptableValue(PrinterSettings settings, PrinterSettingsLayer layer, string sourceFile)
{
string firstLayerSpeedString;
if (!layer.TryGetValue(SettingsKey.first_layer_speed, out firstLayerSpeedString))
{
return;
}
double firstLayerSpeed;
if (firstLayerSpeedString.Contains("%"))
{
string infillSpeedString = settings.GetValue(SettingsKey.infill_speed);
double infillSpeed = double.Parse(infillSpeedString);
firstLayerSpeedString = firstLayerSpeedString.Replace("%", "");
double FirstLayerSpeedPercent = double.Parse(firstLayerSpeedString);
firstLayerSpeed = FirstLayerSpeedPercent * infillSpeed / 100.0;
}
else
{
firstLayerSpeed = double.Parse(firstLayerSpeedString);
}
Assert.Greater(firstLayerSpeed, 5, "Unexpected firstLayerSpeedEqualsAcceptableValue value: " + sourceFile);
}
public TcpipSerialPort(PrinterSettings settings)
{
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
if (int.TryParse(settings.GetValue("ip_port"), out port) &&
IPAddress.TryParse(settings.GetValue("ip_address"), out ipAddress))
{
ipEndPoint = new IPEndPoint(ipAddress, port);
readBuffer = new byte[1024];
bufferIndex = 0;
}
else
{
this.IsValid = false;
}
}
public void firstLayerHeightLessThanNozzleDiameter(PrinterSettings printerSettings, PrinterSettingsLayer layer, string sourceFile)
{
string firstLayerHeight;
if (!layer.TryGetValue(SettingsKey.first_layer_height, out firstLayerHeight))
{
return;
}
float convertedFirstLayerHeightValue;
if (firstLayerHeight.Contains("%"))
{
string reFormatLayerHeight = firstLayerHeight.Replace("%", " ");
convertedFirstLayerHeightValue = float.Parse(reFormatLayerHeight) / 100;
}
else
{
convertedFirstLayerHeightValue = float.Parse(firstLayerHeight);
}
string nozzleDiameter = printerSettings.GetValue(SettingsKey.nozzle_diameter);
Assert.LessOrEqual(convertedFirstLayerHeightValue, float.Parse(nozzleDiameter), "Unexpected firstLayerHeightLessThanNozzleDiameter value: " + sourceFile);
}
public string WelcomeText(int numberOfSteps, int numberOfMinutes)
{
if (printerSettings.GetValue <bool>(SettingsKey.has_heated_bed))
{
return("{0}\n\n\t• {1}\n\t• {2}\n\t• {3}\n\t• {4}\n\t• {5}\n\n{6}\n\n{7}".FormatWith(
this.welcomeLine1,
this.selectMaterial,
"Home the printer".Localize(),
this.heatTheBed,
this.WelcomeLine5(numberOfSteps),
this.turnOnLeveling,
this.WelcomeLine7(numberOfMinutes),
this.ClickNext));
}
else
{
return("{0}\n\n\t• {1}\n\t• {2}\n\t• {3}\n\n{4}\n\n{5}".FormatWith(
this.welcomeLine1,
"Home the printer".Localize(),
this.WelcomeLine5(numberOfSteps),
this.turnOnLeveling,
this.WelcomeLine7(numberOfMinutes),
this.ClickNext));
}
}
public LevelingFunctions(PrinterSettings printerSettings, PrintLevelingData levelingData)
{
this.printerSettings = printerSettings;
this.SampledPositions = new List <Vector3>(levelingData.SampledPositions);
bedSize = printerSettings.GetValue <Vector2>(SettingsKey.bed_size);
// get the delaunay triangulation
var zDictionary = new Dictionary <(double, double), double>();
var vertices = new List <DefaultVertex>();
foreach (var sample in SampledPositions)
{
vertices.Add(new DefaultVertex()
{
Position = new double[] { sample.X, sample.Y } //, sample.Z }
});
var key = (sample.X, sample.Y);
if (!zDictionary.ContainsKey(key))
{
zDictionary.Add(key, sample.Z);
}
}
;
int extraXPosition = -50000;
vertices.Add(new DefaultVertex()
{
Position = new double[] { extraXPosition, SampledPositions[0].Y }
});
var triangles = DelaunayTriangulation <DefaultVertex, DefaultTriangulationCell <DefaultVertex> > .Create(vertices, .001);
var probeOffset = new Vector3(0, 0, printerSettings.GetValue <double>(SettingsKey.z_probe_z_offset));
// make all the triangle planes for these triangles
foreach (var triangle in triangles.Cells)
{
var p0 = triangle.Vertices[0].Position;
var p1 = triangle.Vertices[1].Position;
var p2 = triangle.Vertices[2].Position;
if (p0[0] != extraXPosition && p1[0] != extraXPosition && p2[0] != extraXPosition)
{
var v0 = new Vector3(p0[0], p0[1], zDictionary[(p0[0], p0[1])]);
public override string Convert(string value, PrinterSettings settings)
{
if (settings.GetValue <bool>(enableOnKey))
{
return(sourceField.Convert(value, settings));
}
return(defaultValue);
}
private void Printer_SettingChanged(object s, StringEventArgs e)
{
if ((e?.Data == SettingsKey.baby_step_z_offset && extruderIndex == 0) ||
(e?.Data == SettingsKey.baby_step_z_offset_1 && extruderIndex == 1))
{
double zoffset = printerSettings.GetValue <double>(SettingsKey.baby_step_z_offset);
if (extruderIndex == 1)
{
zoffset = printerSettings.GetValue <double>(SettingsKey.baby_step_z_offset_1);
}
bool hasOverriddenZOffset = (zoffset != 0);
zOffsetStreamContainer.BackgroundColor = hasOverriddenZOffset ? theme.PresetColors.UserOverride : theme.MinimalShade;
clearZOffsetButton.Visible = hasOverriddenZOffset;
zOffsetStreamDisplay.Text = zoffset.ToString("0.##");
}
}
public override string Convert(string value, PrinterSettings settings)
{
Vector2 printCenter = settings.GetValue <Vector2>(SettingsKey.print_center);
Vector2 bedSize = settings.GetValue <Vector2>(SettingsKey.bed_size);
switch (settings.GetValue <BedShape>(SettingsKey.bed_shape))
{
case BedShape.Circular:
{
int numPoints = 10;
double angle = MathHelper.Tau / numPoints;
string bedString = "";
bool first = true;
for (int i = 0; i < numPoints; i++)
{
if (!first)
{
bedString += ",";
}
double x = Math.Cos(angle * i);
double y = Math.Sin(angle * i);
bedString += $"{printCenter.X + x * bedSize.X / 2:0.####}x{printCenter.Y + y * bedSize.Y / 2:0.####}";
first = false;
}
return(bedString);
}
// bed_shape = 99.4522x10.4528,97.8148x20.7912,95.1057x30.9017,91.3545x40.6737,86.6025x50,80.9017x58.7785,74.3145x66.9131,66.9131x74.3145,58.7785x80.9017,50x86.6025,40.6737x91.3545,30.9017x95.1057,20.7912x97.8148,10.4528x99.4522,0x100,-10.4528x99.4522,-20.7912x97.8148,-30.9017x95.1057,-40.6737x91.3545,-50x86.6025,-58.7785x80.9017,-66.9131x74.3145,-74.3145x66.9131,-80.9017x58.7785,-86.6025x50,-91.3545x40.6737,-95.1057x30.9017,-97.8148x20.7912,-99.4522x10.4528,-100x0,-99.4522x - 10.4528,-97.8148x - 20.7912,-95.1057x - 30.9017,-91.3545x - 40.6737,-86.6025x - 50,-80.9017x - 58.7785,-74.3145x - 66.9131,-66.9131x - 74.3145,-58.7785x - 80.9017,-50x - 86.6025,-40.6737x - 91.3545,-30.9017x - 95.1057,-20.7912x - 97.8148,-10.4528x - 99.4522,0x - 100,10.4528x - 99.4522,20.7912x - 97.8148,30.9017x - 95.1057,40.6737x - 91.3545,50x - 86.6025,58.7785x - 80.9017,66.9131x - 74.3145,74.3145x - 66.9131,80.9017x - 58.7785,86.6025x - 50,91.3545x - 40.6737,95.1057x - 30.9017,97.8148x - 20.7912,99.4522x - 10.4528,100x0
case BedShape.Rectangular:
default:
{
// bed_shape = 0x0,200x0,200x200,0x200
string bedString = $"{printCenter.X - bedSize.X / 2}x{printCenter.Y - bedSize.Y / 2}";
bedString += $",{printCenter.X + bedSize.X / 2}x{printCenter.Y - bedSize.Y / 2}";
bedString += $",{printCenter.X + bedSize.X / 2}x{printCenter.Y + bedSize.Y / 2}";
bedString += $",{printCenter.X - bedSize.X / 2}x{printCenter.Y + bedSize.Y / 2}";
return(bedString);
}
}
}
internal void OffsetStreamChanged(object sender, EventArgs e)
{
double zoffset = printerSettings.GetValue <double>(SettingsKey.baby_step_z_offset);
bool hasOverriddenZOffset = (zoffset != 0);
zOffsetStreamContainer.BackgroundColor = (allowRemoveButton && hasOverriddenZOffset) ? theme.PresetColors.UserOverride : theme.MinimalShade;
clearZOffsetButton.Visible = allowRemoveButton && hasOverriddenZOffset;
zOffsetStreamDisplay.Text = zoffset.ToString("0.##");
}
public override string Convert(string value, PrinterSettings settings)
{
if (settings.GetValue <bool>(SettingsKey.sla_printer))
{
// return the speed based on the layer height
var speedAt025 = settings.GetValue <double>(SettingsKey.laser_speed_025);
var speedAt100 = settings.GetValue <double>(SettingsKey.laser_speed_100);
var deltaSpeed = speedAt100 - speedAt025;
var layerHeight = settings.GetValue <double>(SettingsKey.layer_height);
var deltaHeight = .1 - .025;
var heightRatio = (layerHeight - .025) / deltaHeight;
var ajustedSpeed = speedAt025 + deltaSpeed * heightRatio;
return(ajustedSpeed.ToString());
}
else
{
return(base.Convert(value, settings));
}
}
private string GetLeveledPosition(string lineBeingSent, PrinterMove currentDestination)
{
PrintLevelingData levelingData = printerSettings.Helpers.GetPrintLevelingData();
if (levelingData != null &&
printerSettings?.GetValue <bool>(SettingsKey.print_leveling_enabled) == true &&
(lineBeingSent.StartsWith("G0 ") || lineBeingSent.StartsWith("G1 ")))
{
if (currentLevelingFunctions == null ||
currentProbeOffset != printerSettings.GetValue <double>(SettingsKey.z_probe_z_offset) ||
!levelingData.SamplesAreSame(currentLevelingFunctions.SampledPositions))
{
currentProbeOffset = printerSettings.GetValue <double>(SettingsKey.z_probe_z_offset);
currentLevelingFunctions = new LevelingFunctions(printerSettings, levelingData);
}
lineBeingSent = currentLevelingFunctions.DoApplyLeveling(lineBeingSent, currentDestination.position);
}
return(lineBeingSent);
}
public override string Convert(string value, PrinterSettings settings)
{
double infillRatio0To1 = ParseDouble(value);
// 400 = solid (extruder width)
double nozzle_diameter = settings.GetValue <double>(SettingsKey.nozzle_diameter);
double linespacing = 1000;
if (infillRatio0To1 > .01)
{
linespacing = nozzle_diameter / infillRatio0To1;
}
return(((int)(linespacing * 1000)).ToString());
}
public override string Convert(string value, PrinterSettings settings)
{
// When the state is store in mm, determine and use the value in (counted) units i.e. round distance up to layer count
if (value.Contains("mm"))
{
string withoutMm = value.Replace("mm", "");
string distanceString = settings.GetValue(keyToUseAsDenominatorForCount);
double denominator = ParseDouble(distanceString, 1);
int layers = (int)(ParseDouble(withoutMm) / denominator + .5);
return(layers.ToString());
}
return(value);
}
public void MergeDropsFieldsIfValueAlreadySet()
{
// Validates that field are dropped during import if they are already set in a base layer
//
AggContext.StaticData = new FileSystemStaticData(TestContext.CurrentContext.ResolveProjectPath(4, "StaticData"));
MatterControlUtilities.OverrideAppDataLocation(TestContext.CurrentContext.ResolveProjectPath(4));
var printerSettings = new PrinterSettings();
printerSettings.SetValue(SettingsKey.cancel_gcode, "cancel gcode");
printerSettings.SetValue(SettingsKey.start_gcode, "start gcode");
// Ensure layer_height of a given value
printerSettings.BaseLayer[SettingsKey.layer_height] = "0.25";
string newValue = "----- cancel gcode ----";
string notAnExistingKey = "NotAnExistingKey";
var toImport = new PrinterSettings();
toImport.SetValue(SettingsKey.cancel_gcode, newValue);
toImport.SetValue(SettingsKey.layer_height, "0.25");
toImport.SetValue(notAnExistingKey, "------------------");
var sourceFilter = new List <PrinterSettingsLayer>()
{
toImport.UserLayer
};
printerSettings.Merge(printerSettings.UserLayer, toImport, sourceFilter, false);
Assert.AreEqual(printerSettings.GetValue(SettingsKey.cancel_gcode), newValue, "Imported setting applied");
Assert.IsEmpty(printerSettings.GetValue(notAnExistingKey), "Invalid settings keys should be skipped");
Assert.IsFalse(printerSettings.UserLayer.ContainsKey(SettingsKey.layer_height), "User layer should not contain layer_height after merge");
Assert.AreEqual(2, printerSettings.UserLayer.Count, "User layer should contain two items after import (start_gcode, cancel_gcode)");
}
public ZTuningWidget(PrinterSettings printerSettings, ThemeConfig theme, bool allowRemoveButton = true)
{
this.theme = theme;
this.printerSettings = printerSettings;
this.allowRemoveButton = allowRemoveButton;
this.HAnchor = HAnchor.Fit;
this.VAnchor = VAnchor.Fit | VAnchor.Center;
PrinterSettings.SettingChanged.RegisterEvent((s, e) =>
{
if ((e as StringEventArgs)?.Data == SettingsKey.baby_step_z_offset)
{
OffsetStreamChanged(null, null);
}
}, ref unregisterEvents);
zOffsetStreamContainer = new FlowLayoutWidget(FlowDirection.LeftToRight)
{
Margin = new BorderDouble(3, 0),
Padding = new BorderDouble(3),
HAnchor = HAnchor.Fit,
VAnchor = VAnchor.Center,
BackgroundColor = theme.MinimalShade,
Height = 20
};
this.AddChild(zOffsetStreamContainer);
double zoffset = printerSettings.GetValue <double>(SettingsKey.baby_step_z_offset);
zOffsetStreamDisplay = new TextWidget(zoffset.ToString("0.##"), pointSize: theme.DefaultFontSize)
{
AutoExpandBoundsToText = true,
TextColor = ActiveTheme.Instance.PrimaryTextColor,
Margin = new BorderDouble(5, 0, 8, 0),
VAnchor = VAnchor.Center
};
zOffsetStreamContainer.AddChild(zOffsetStreamDisplay);
clearZOffsetButton = theme.CreateSmallResetButton();
clearZOffsetButton.Name = "Clear ZOffset button";
clearZOffsetButton.ToolTipText = "Clear ZOffset".Localize();
clearZOffsetButton.Visible = allowRemoveButton && zoffset != 0;
clearZOffsetButton.Click += (sender, e) =>
{
printerSettings.SetValue(SettingsKey.baby_step_z_offset, "0");
};
zOffsetStreamContainer.AddChild(clearZOffsetButton);
}
public void layerHeightLessThanNozzleDiameter(PrinterSettings printerSettings, PrinterSettingsLayer layer, string sourceFile)
{
string layerHeight;
if (!layer.TryGetValue(SettingsKey.layer_height, out layerHeight))
{
return;
}
float convertedLayerHeight = float.Parse(layerHeight);
string nozzleDiameter = printerSettings.GetValue(SettingsKey.nozzle_diameter);
float convertedNozzleDiameterValue = float.Parse(nozzleDiameter);
Assert.LessOrEqual(convertedLayerHeight, convertedNozzleDiameterValue, "Unexpected layerHeightLessThanNozzleDiameter value: " + sourceFile);
}
public async Task <bool> Slice(IEnumerable <IObject3D> printableItems, PrinterSettings printerSettings, string filePath, IProgress <ProgressStatus> progressReporter, CancellationToken cancellationToken)
{
using (var outputStream = File.OpenWrite(filePath))
{
var sourceMeshes = new List <DMesh3>();
foreach (var item in printableItems.Where(d => d.MeshPath != null))
{
string sourceFilePath = await item.ResolveFilePath(null, cancellationToken);
// Load Mesh
if (File.Exists(sourceFilePath))
{
var mesh = StandardMeshReader.ReadMesh(sourceFilePath);
if (mesh != null)
{
sourceMeshes.Add(mesh);
}
var printCenter = printerSettings.GetValue <Vector2>(SettingsKey.print_center);
ApplyTransform(mesh, item.WorldMatrix(), printCenter);
}
}
PrintSettings settings = LoadSettingsForPrinter(printerSettings);
// Construct slicer
var slicer = new GeometrySlicer();
slicer.SliceMeshes(sourceMeshes, settings);
bool valid = slicer.ExtractResultsIfValid(out PrintMeshAssembly meshes, out PlanarSliceStack slices);
// Construct GCode generator
var pathGenerator = new ToolpathGenerator();
pathGenerator.CreateToolPaths(meshes, slices, settings);
// Write GCode file
var gcodeWriter = new StandardGCodeWriter();
var streamWriter = new StreamWriter(outputStream);
gcodeWriter.WriteFile(pathGenerator.CurrentGCode, streamWriter);
return(true);
}
}
public static void WaitForLayer(this Emulator emulator, PrinterSettings printerSettings, int layerNumber, double secondsToWait = 30)
{
var resetEvent = new AutoResetEvent(false);
var heightAtTargetLayer = printerSettings.GetValue <double>(SettingsKey.layer_height) * layerNumber;
// Wait for emulator to hit target layer
emulator.ZPositionChanged += (s, e) =>
{
// Wait for print to start, then slow down the emulator and continue. Failing to slow down frequently causes a timing issue where the print
// finishes before we make it down to 'CloseMatterControlViaUi' and thus no prompt to close appears and the test fails when clicking 'Yes Button'
if (emulator.ZPosition >= heightAtTargetLayer)
{
resetEvent.Set();
}
};
resetEvent.WaitOne((int)(secondsToWait * 1000));
}
public void firstLayerExtrusionWidthAcceptableValue(PrinterSettings printerSettings, PrinterSettingsLayer layer, string sourceFile)
{
string firstLayerExtrusionWidth;
if (!layer.TryGetValue(SettingsKey.first_layer_extrusion_width, out firstLayerExtrusionWidth))
{
return;
}
float convertedFirstLayerExtrusionWidth;
string nozzleDiameter = printerSettings.GetValue(SettingsKey.nozzle_diameter);
float acceptableValue = float.Parse(nozzleDiameter) * 4;
if (firstLayerExtrusionWidth.Contains("%"))
{
string reformatFirstLayerExtrusionWidth = firstLayerExtrusionWidth.Replace("%", " ");
convertedFirstLayerExtrusionWidth = float.Parse(reformatFirstLayerExtrusionWidth) / 100;
}
else
{
convertedFirstLayerExtrusionWidth = float.Parse(firstLayerExtrusionWidth);
}
Assert.LessOrEqual(convertedFirstLayerExtrusionWidth, acceptableValue, "Unexpected firstLayerExtrusionWidthAcceptableValue value: " + sourceFile);
}
private string analyzePayload(int payloadLength, out bool commandOK)
{
commandOK = false;
StringBuilder payloadStrBuilder = new StringBuilder();
switch (response[2])
{
case 0x81:
payloadStrBuilder.Append("ok");
commandOK = true;
break;
case 0x80:
payloadStrBuilder.Append("Generic Packet Error, packet discarded");
break;
case 0x83:
payloadStrBuilder.Append("CRC mismatch, packet discarded\n");
payloadStrBuilder.Append("RS:" + X3GWriter.lineNumber + "\n");
payloadStrBuilder.Append("ok");
break;
case 0x88:
payloadStrBuilder.Append("Tool lock Timeout");
break;
case 0x89:
payloadStrBuilder.Append("Cancel Build");
break;
case 0x8C:
payloadStrBuilder.Append("Packet timeout error, packet discarded");
payloadStrBuilder.Append("RS:" + X3GWriter.lineNumber + "\n");
payloadStrBuilder.Append("ok");
break;
case 0x82: //Action Buffer overflow, Packet Discarded (currently will request resend of line, later should be avoided by checking buffer size before send)
payloadStrBuilder.Append("Action Buffer overflow, Packet Discarded\n");
payloadStrBuilder.Append("RS:" + X3GWriter.lineNumber + "\n");
payloadStrBuilder.Append("ok");
break;
case 0x84:
payloadStrBuilder.Append("Query Packet too big, packet discarded");
break;
case 0x85:
payloadStrBuilder.Append("Command not supported/recognized");
break;
case 0x87:
payloadStrBuilder.Append("Downstream timeout");
break;
case 0x8A:
payloadStrBuilder.Append("Bot is Building from SD");
break;
case 0x8B:
payloadStrBuilder.Append("Bot is Shutdown due to Overheat");
break;
default:
payloadStrBuilder.Append("Command Failed: " + response[2]);
break;
}
switch (payloadLength)
{
case 23: //22 is the length of the get position response + 1 for response code
if (printerDetails.currentPosition.Length != 0) //if we are not connecting just now to the printer we will report back the target move position
{
Vector3 printerPos = printerDetails.targetMovePosition;
payloadStrBuilder.Append(String.Format(" C: X:{0} Y:{1} Z:{2} E:{3}", printerPos.X, printerPos.Y, printerPos.Z, 0));
}
else //if we have not told the printer to move yet we get the location the printer actually thinks it is at
{
Vector3 posFromPrinter = new Vector3();
posFromPrinter.X = translateInt32(3);
posFromPrinter.Y = translateInt32(7);
posFromPrinter.Z = translateInt32(11);
posFromPrinter.X = posFromPrinter.X / printerDetails.stepsPerMm.X;
posFromPrinter.Y = posFromPrinter.Y / printerDetails.stepsPerMm.Y;
posFromPrinter.Z = posFromPrinter.Z / printerDetails.stepsPerMm.Z;
payloadStrBuilder.Append(String.Format(" C: X:{0} Y:{1} Z:{2} E:{3}", posFromPrinter.X, posFromPrinter.Y, posFromPrinter.Z, 0));
}
break;
case 3: //Length of temperature response, temperature is requested individually for each extruder and bed separately. This collects the information and condenses it into one response to be sent to the printer
if (!gCommandForResponse.Contains("M115"))
{
int temperature = translateInt16(3);
printerDetails.teperatureResponseCount++;
if (printerDetails.teperatureResponseCount == 1)
{
if (settings.GetValue <int>(SettingsKey.extruder_count) > 1)
{
temperatureResponseStrBuilder.Append(String.Format(" T0:{0}", temperature));
}
else
{
temperatureResponseStrBuilder.Append(String.Format(" T:{0}", temperature));
}
}
else if (printerDetails.teperatureResponseCount == 2 && settings.GetValue <bool>(SettingsKey.has_heated_bed))
{
temperatureResponseStrBuilder.Append(String.Format(" B:{0}", temperature));
}
else
{
temperatureResponseStrBuilder.Append(String.Format(" T1:{0}", temperature));
}
if (printerDetails.teperatureResponseCount == printerDetails.requiredTemperatureResponseCount)
{
payloadStrBuilder.Append(temperatureResponseStrBuilder.ToString());
temperatureResponseStrBuilder.Clear();
printerDetails.teperatureResponseCount = 0;
}
}
break;
}
for (int i = 2; i < payloadLength + 2; i++)
{
crc.update(response[i]);
}
return(payloadStrBuilder.ToString());
}
public MatterHackersPrinter(PrinterSettings settings)
{
string make = settings.GetValue <string>(SettingsKey.make);
string model = settings.GetValue <string>(SettingsKey.model);
var printCenter = settings.GetValue <Vector2>(SettingsKey.print_center);
var bedSize = settings.GetValue <Vector2>(SettingsKey.bed_size);
machineInfo = new FFFMachineInfo()
{
ManufacturerName = make,
ManufacturerUUID = agg_basics.GetLongHashCode(make).ToString(),
ModelIdentifier = model,
ModelUUID = agg_basics.GetLongHashCode(model).ToString(),
Class = MachineClass.PlasticFFFPrinter,
BedSizeXMM = (int)settings.BedBounds.Width,
BedSizeYMM = (int)settings.BedBounds.Height,
// BedSizeZMM = settings.GetValue<int>(SettingsKey.build_height),
MaxHeightMM = settings.GetValue <int>(SettingsKey.build_height),
NozzleDiamMM = settings.GetValue <double>(SettingsKey.nozzle_diameter),
FilamentDiamMM = settings.GetValue <double>(SettingsKey.filament_diameter),
// Set bed origin factors based on printer center/bedsize
BedOriginFactorX = printCenter.X / bedSize.X,
BedOriginFactorY = printCenter.Y / bedSize.Y,
HasHeatedBed = settings.GetValue <bool>(SettingsKey.has_heated_bed),
HasAutoBedLeveling = settings.GetValue <bool>(SettingsKey.has_hardware_leveling),
EnableAutoBedLeveling = false,
// TODO: Consider how to adapt and/or update for MatterControl printers
MaxExtruderTempC = 250,
MaxBedTempC = 80,
MaxExtrudeSpeedMMM = 80 * 60,
MaxTravelSpeedMMM = 120 * 60,
MaxZTravelSpeedMMM = 100 * 60,
MaxRetractSpeedMMM = 45 * 60,
MinLayerHeightMM = 0.05,
MaxLayerHeightMM = 0.3,
};
LayerHeightMM = settings.GetValue <double>(SettingsKey.layer_height);
ExtruderTempC = (int)settings.GetValue <double>(SettingsKey.temperature1);
HeatedBedTempC = (int)settings.GetValue <double>(SettingsKey.bed_temperature);
RoofLayers = settings.GetValue <int>(SettingsKey.top_solid_layers);
FloorLayers = settings.GetValue <int>(SettingsKey.bottom_solid_layers);
SolidFillNozzleDiamStepX = 1.0;
RetractDistanceMM = settings.GetValue <double>(SettingsKey.retract_length);
RetractSpeed = settings.GetValue <double>(SettingsKey.retract_speed) * 60;
ZTravelSpeed = settings.Helpers.GetMovementSpeeds()["z"] * 60;
RapidTravelSpeed = settings.GetValue <double>(SettingsKey.travel_speed) * 60;
CarefulExtrudeSpeed = settings.GetValue <double>(SettingsKey.first_layer_speed) * 60;
RapidExtrudeSpeed = Machine.MaxExtrudeSpeedMMM;
// Looks like fractional of perimeter speed
var outerSpeed = settings.GetValue <double>(SettingsKey.external_perimeter_speed);
var innerSpeed = settings.GetValue <double>(SettingsKey.external_perimeter_speed);
OuterPerimeterSpeedX = outerSpeed / innerSpeed;
}
public override bool SerialPortIsAvailable(string serialPortName, PrinterSettings settings)
{
return(int.TryParse(settings.GetValue(SettingsKey.ip_port), out _) &&
IPAddress.TryParse(settings.GetValue(SettingsKey.ip_address), out _));
}
public static bool ParseShowString(string unsplitSettings, PrinterSettings printerSettings, List<PrinterSettingsLayer> layerCascade)
{
if (!string.IsNullOrEmpty(unsplitSettings))
{
string[] splitSettings = unsplitSettings.Split('&');
foreach (var inLookupSettings in splitSettings)
{
var lookupSettings = inLookupSettings;
if (!string.IsNullOrEmpty(lookupSettings))
{
string showValue = "0";
if (lookupSettings.StartsWith("!"))
{
showValue = "1";
lookupSettings = lookupSettings.Substring(1);
}
string sliceSettingValue = printerSettings.GetValue(lookupSettings, layerCascade);
if (sliceSettingValue == showValue)
{
return false;
}
}
}
}
return true;
}
private void OffsetChanged()
{
offsetStream.Offset = new Vector3(0, 0, printerSettings.GetValue <double>(SettingsKey.baby_step_z_offset));
}
public BabyStepsStream(PrinterSettings printerSettings, GCodeStream internalStream, double startingMaxLength = 1)
: base(null)
{
this.printerSettings = printerSettings;
ActiveSliceSettings.SettingChanged.RegisterEvent((s, e) =>
{
if ((e as StringEventArgs)?.Data == SettingsKey.baby_step_z_offset)
{
OffsetChanged();
}
}, ref unregisterEvents);
maxLengthStream = new MaxLengthStream(internalStream, startingMaxLength);
offsetStream = new OffsetStream(maxLengthStream, new Vector3(0, 0, printerSettings.GetValue <double>(SettingsKey.baby_step_z_offset)));
base.internalStream = offsetStream;
}
internal static bool ImportFromExisting(string settingsFilePath)
{
if (string.IsNullOrEmpty(settingsFilePath) || !File.Exists(settingsFilePath))
{
return false;
}
string fileName = Path.GetFileNameWithoutExtension(settingsFilePath);
var existingPrinterNames = Instance.ActiveProfiles.Select(p => p.Name);
var printerInfo = new PrinterInfo
{
Name = agg_basics.GetNonCollidingName(existingPrinterNames, fileName),
ID = Guid.NewGuid().ToString(),
Make = "Other",
Model = "Other",
};
bool importSuccessful = false;
string importType = Path.GetExtension(settingsFilePath).ToLower();
switch (importType)
{
case ProfileManager.ProfileExtension:
// Add the Settings as a profile before performing any actions on it to ensure file paths resolve
{
Instance.Profiles.Add(printerInfo);
var printerSettings = PrinterSettings.LoadFile(settingsFilePath);
printerSettings.ID = printerInfo.ID;
printerSettings.ClearValue(SettingsKey.device_token);
printerInfo.DeviceToken = "";
// TODO: Resolve name conflicts
printerSettings.Helpers.SetName(printerInfo.Name);
if (printerSettings.OemLayer.ContainsKey(SettingsKey.make))
{
printerInfo.Make = printerSettings.OemLayer[SettingsKey.make];
}
if (printerSettings.OemLayer.ContainsKey(SettingsKey.model))
{
printerInfo.Model = printerSettings.OemLayer[SettingsKey.model] ?? "Other";
}
printerSettings.Save();
importSuccessful = true;
}
break;
case ".ini":
//Scope variables
{
var settingsToImport = PrinterSettingsLayer.LoadFromIni(settingsFilePath);
var printerSettings = new PrinterSettings()
{
ID = printerInfo.ID,
};
bool containsValidSetting = false;
printerSettings.OemLayer = new PrinterSettingsLayer();
printerSettings.OemLayer[SettingsKey.make] = "Other";
printerSettings.OemLayer[SettingsKey.model] = "Other";
foreach (var item in settingsToImport)
{
if (printerSettings.Contains(item.Key))
{
containsValidSetting = true;
string currentValue = printerSettings.GetValue(item.Key).Trim();
// Compare the value to import to the layer cascade value and only set if different
if (currentValue != item.Value)
{
printerSettings.OemLayer[item.Key] = item.Value;
}
}
}
if(containsValidSetting)
{
printerSettings.UserLayer[SettingsKey.printer_name] = printerInfo.Name;
printerSettings.ClearValue(SettingsKey.device_token);
printerInfo.DeviceToken = "";
printerInfo.Make = printerSettings.OemLayer[SettingsKey.make] ?? "Other";
printerInfo.Model = printerSettings.OemLayer[SettingsKey.model] ?? "Other";
Instance.Profiles.Add(printerInfo);
printerSettings.Helpers.SetName(printerInfo.Name);
printerSettings.Save();
importSuccessful = true;
}
}
break;
}
return importSuccessful;
}
private void AddDisplay(PrinterSettings printerSettings,
ThemeConfig theme,
bool showClearButton,
string setting,
int toolIndex,
TextWidget widget)
{
GuiWidget clearZOffsetButton = null;
void Printer_SettingChanged(object s, StringEventArgs e)
{
if (e?.Data == setting)
{
double zOffset = printerSettings.GetValue <double>(setting);
bool hasOverriddenZOffset = zOffset != 0;
if (clearZOffsetButton != null)
{
clearZOffsetButton.Visible = hasOverriddenZOffset;
}
widget.Text = zOffset.ToString("0.##");
DescribeExtruder(widget, toolIndex);
}
}
var zOffsetStreamContainer = new FlowLayoutWidget(FlowDirection.LeftToRight)
{
Margin = new BorderDouble(3, 0),
Padding = new BorderDouble(3),
HAnchor = HAnchor.Fit | HAnchor.Right,
VAnchor = VAnchor.Absolute,
Height = 20 * GuiWidget.DeviceScale
};
this.AddChild(zOffsetStreamContainer);
var zoffset = printerSettings.GetValue <double>(setting);
zOffsetStreamContainer.AddChild(widget);
if (showClearButton)
{
clearZOffsetButton = theme.CreateSmallResetButton();
clearZOffsetButton.Name = "Clear ZOffset button";
clearZOffsetButton.ToolTipText = "Clear ZOffset".Localize();
clearZOffsetButton.Visible = zoffset != 0;
clearZOffsetButton.Click += (sender, e) =>
{
printerSettings.SetValue(setting, "0");
};
zOffsetStreamContainer.AddChild(clearZOffsetButton);
}
printerSettings.SettingChanged += Printer_SettingChanged;
this.Closed += (s, e) =>
{
printerSettings.SettingChanged -= Printer_SettingChanged;
};
}
public void firstLayerHeightLessThanNozzleDiameter(PrinterSettings printerSettings, PrinterSettingsLayer layer, string sourceFile)
{
string firstLayerHeight;
if (!layer.TryGetValue(SettingsKey.first_layer_height, out firstLayerHeight))
{
return;
}
float convertedFirstLayerHeightValue;
if (firstLayerHeight.Contains("%"))
{
string reFormatLayerHeight = firstLayerHeight.Replace("%", " ");
convertedFirstLayerHeightValue = float.Parse(reFormatLayerHeight) / 100;
}
else
{
convertedFirstLayerHeightValue = float.Parse(firstLayerHeight);
}
string nozzleDiameter = printerSettings.GetValue(SettingsKey.nozzle_diameter);
Assert.LessOrEqual(convertedFirstLayerHeightValue, float.Parse(nozzleDiameter), "Unexpected firstLayerHeightLessThanNozzleDiameter value: " + sourceFile);
}
public void firstLayerSpeedEqualsAcceptableValue(PrinterSettings settings, PrinterSettingsLayer layer, string sourceFile)
{
string firstLayerSpeedString;
if (!layer.TryGetValue(SettingsKey.first_layer_speed, out firstLayerSpeedString))
{
return;
}
double firstLayerSpeed;
if (firstLayerSpeedString.Contains("%"))
{
string infillSpeedString = settings.GetValue("infill_speed");
double infillSpeed = double.Parse(infillSpeedString);
firstLayerSpeedString = firstLayerSpeedString.Replace("%", "");
double FirstLayerSpeedPercent = double.Parse(firstLayerSpeedString);
firstLayerSpeed = FirstLayerSpeedPercent * infillSpeed / 100.0;
}
else
{
firstLayerSpeed = double.Parse(firstLayerSpeedString);
}
Assert.Greater(firstLayerSpeed, 5, "Unexpected firstLayerSpeedEqualsAcceptableValue value: " + sourceFile);
}
public static void RefreshActiveInstance(PrinterSettings updatedProfile)
{
bool themeChanged = activeInstance.GetValue(SettingsKey.active_theme_name) != updatedProfile.GetValue(SettingsKey.active_theme_name);
activeInstance = updatedProfile;
SliceSettingsWidget.SettingChanged.CallEvents(null, new StringEventArgs(SettingsKey.printer_name));
if (themeChanged)
{
UiThread.RunOnIdle(() => SwitchToPrinterTheme(true));
}
else
{
UiThread.RunOnIdle(ApplicationController.Instance.ReloadAdvancedControlsPanel);
}
}
public void layerHeightLessThanNozzleDiameter(PrinterSettings printerSettings, PrinterSettingsLayer layer, string sourceFile)
{
string layerHeight;
if (!layer.TryGetValue(SettingsKey.layer_height, out layerHeight))
{
return;
}
float convertedLayerHeight = float.Parse(layerHeight);
string nozzleDiameter = printerSettings.GetValue(SettingsKey.nozzle_diameter);
float convertedNozzleDiameterValue = float.Parse(nozzleDiameter);
Assert.LessOrEqual(convertedLayerHeight, convertedNozzleDiameterValue, "Unexpected layerHeightLessThanNozzleDiameter value: " + sourceFile);
}
