427 lines
12 KiB
C#
427 lines
12 KiB
C#
/*
|
|
Copyright (c) 2019, Lars Brubaker, John Lewin
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright notice, this
|
|
list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright notice,
|
|
this list of conditions and the following disclaimer in the documentation
|
|
and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
|
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
The views and conclusions contained in the software and documentation are those
|
|
of the authors and should not be interpreted as representing official policies,
|
|
either expressed or implied, of the FreeBSD Project.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text.RegularExpressions;
|
|
using MatterHackers.VectorMath;
|
|
using Newtonsoft.Json;
|
|
|
|
namespace MatterHackers.MatterControl.SlicerConfiguration
|
|
{
|
|
public class SettingsHelpers
|
|
{
|
|
private readonly PrinterSettings printerSettings;
|
|
private PrintLevelingData _printLevelingData = null;
|
|
|
|
public SettingsHelpers(PrinterSettings printerSettings)
|
|
{
|
|
this.printerSettings = printerSettings;
|
|
}
|
|
|
|
public double ExtruderTargetTemperature(int extruderIndex)
|
|
{
|
|
if (extruderIndex == 0)
|
|
{
|
|
return printerSettings.GetValue<double>(SettingsKey.temperature);
|
|
}
|
|
else
|
|
{
|
|
// Check if there is a material override for this extruder
|
|
// Otherwise, use the SettingsLayers that is bound to this extruder
|
|
if (extruderIndex < printerSettings.GetValue<int>(SettingsKey.extruder_count))
|
|
{
|
|
return printerSettings.GetValue<double>($"{SettingsKey.temperature}{extruderIndex}");
|
|
}
|
|
|
|
// else return the normal settings cascade
|
|
return printerSettings.GetValue<double>(SettingsKey.temperature);
|
|
}
|
|
}
|
|
|
|
public int[] LayerToPauseOn()
|
|
{
|
|
string[] userValues = printerSettings.GetValue("layer_to_pause").Split(';');
|
|
|
|
return userValues.Where(v => int.TryParse(v, out int temp)).Select(v =>
|
|
{
|
|
// Convert from 0 based index to 1 based index
|
|
int val = int.Parse(v);
|
|
|
|
// Special case for user entered zero that pushes 0 to 1, otherwise val = val - 1 for 1 based index
|
|
return val == 0 ? 1 : val - 1;
|
|
}).ToArray();
|
|
}
|
|
|
|
public void SetBaudRate(string baudRate)
|
|
{
|
|
printerSettings.SetValue(SettingsKey.baud_rate, baudRate);
|
|
}
|
|
|
|
public string ComPort()
|
|
{
|
|
return printerSettings.GetValue($"{Environment.MachineName}_com_port");
|
|
}
|
|
|
|
public void SetComPort(string port)
|
|
{
|
|
printerSettings.SetValue($"{Environment.MachineName}_com_port", port);
|
|
}
|
|
|
|
public void SetComPort(string port, PrinterSettingsLayer layer)
|
|
{
|
|
printerSettings.SetValue($"{Environment.MachineName}_com_port", port, layer);
|
|
}
|
|
|
|
public void SetDriverType(string driver)
|
|
{
|
|
printerSettings.SetValue(SettingsKey.driver_type, driver);
|
|
}
|
|
|
|
public void SetDeviceToken(string token)
|
|
{
|
|
if (printerSettings.GetValue(SettingsKey.device_token) != token)
|
|
{
|
|
printerSettings.SetValue(SettingsKey.device_token, token);
|
|
}
|
|
}
|
|
|
|
public void SetName(string name)
|
|
{
|
|
printerSettings.SetValue(SettingsKey.printer_name, name);
|
|
}
|
|
|
|
public PrintLevelingData PrintLevelingData
|
|
{
|
|
get
|
|
{
|
|
if (_printLevelingData == null)
|
|
{
|
|
// Load from settings if missing
|
|
var jsonData = printerSettings.GetValue(SettingsKey.print_leveling_data);
|
|
if (!string.IsNullOrEmpty(jsonData))
|
|
{
|
|
_printLevelingData = JsonConvert.DeserializeObject<PrintLevelingData>(jsonData);
|
|
}
|
|
|
|
// TODO: When this case is hit, it's certain to produce impossible to troubleshoot behavior where leveled printers suddenly act erratically.
|
|
// Investigate a better solution - ideally we'd mark that leveling is invalid and have a validation error preventing printing/export/general use
|
|
if (_printLevelingData == null)
|
|
{
|
|
_printLevelingData = new PrintLevelingData();
|
|
}
|
|
}
|
|
|
|
return _printLevelingData;
|
|
}
|
|
|
|
set
|
|
{
|
|
// Store new reference
|
|
_printLevelingData = value;
|
|
|
|
// Persist to settings
|
|
printerSettings.SetValue(SettingsKey.print_leveling_data, JsonConvert.SerializeObject(value));
|
|
}
|
|
}
|
|
|
|
private readonly List<(Regex Regex, string Replacement)> _writeLineReplacements = new List<(Regex Regex, string Replacement)>();
|
|
|
|
private string writeRegexString = "";
|
|
|
|
private static readonly Regex GetQuotedParts = new Regex(@"([""'])(\\?.)*?\1", RegexOptions.Compiled);
|
|
|
|
public List<(Regex Regex, string Replacement)> WriteLineReplacements
|
|
{
|
|
get
|
|
{
|
|
lock (_writeLineReplacements)
|
|
{
|
|
if (writeRegexString != printerSettings.GetValue(SettingsKey.write_regex))
|
|
{
|
|
_writeLineReplacements.Clear();
|
|
writeRegexString = printerSettings.GetValue(SettingsKey.write_regex);
|
|
|
|
foreach (string regExLine in writeRegexString.Split(new string[] { "\\n" }, StringSplitOptions.RemoveEmptyEntries))
|
|
{
|
|
var matches = GetQuotedParts.Matches(regExLine);
|
|
if (matches.Count == 2)
|
|
{
|
|
var search = matches[0].Value.Substring(1, matches[0].Value.Length - 2);
|
|
var replace = matches[1].Value.Substring(1, matches[1].Value.Length - 2);
|
|
_writeLineReplacements.Add((new Regex(search, RegexOptions.Compiled), replace));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return _writeLineReplacements;
|
|
}
|
|
}
|
|
|
|
public bool ProbeBeingUsed
|
|
{
|
|
get
|
|
{
|
|
return printerSettings.GetValue<bool>(SettingsKey.has_z_probe)
|
|
&& printerSettings.GetValue<bool>(SettingsKey.use_z_probe);
|
|
}
|
|
}
|
|
|
|
public bool ValidateLevelingWithProbe
|
|
{
|
|
get
|
|
{
|
|
return ProbeBeingUsed
|
|
&& printerSettings.GetValue<bool>(SettingsKey.validate_leveling);
|
|
}
|
|
}
|
|
|
|
public bool ActiveMaterialHasAnyBedTemperatures
|
|
{
|
|
get
|
|
{
|
|
void IncrementIfSet(string settingKey, ref int count)
|
|
{
|
|
var materialBedTemp = printerSettings.GetValue<double>(settingKey, printerSettings.MaterialLayerCascade);
|
|
if (materialBedTemp > 0)
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
|
|
var bedTemperatureCount = 0;
|
|
IncrementIfSet(SettingsKey.bed_temperature_blue_tape, ref bedTemperatureCount);
|
|
IncrementIfSet(SettingsKey.bed_temperature_buildtak, ref bedTemperatureCount);
|
|
IncrementIfSet(SettingsKey.bed_temperature_garolite, ref bedTemperatureCount);
|
|
IncrementIfSet(SettingsKey.bed_temperature_glass, ref bedTemperatureCount);
|
|
IncrementIfSet(SettingsKey.bed_temperature_kapton, ref bedTemperatureCount);
|
|
IncrementIfSet(SettingsKey.bed_temperature_pei, ref bedTemperatureCount);
|
|
IncrementIfSet(SettingsKey.bed_temperature_pp, ref bedTemperatureCount);
|
|
|
|
return bedTemperatureCount > 0;
|
|
}
|
|
}
|
|
|
|
public double ActiveBedTemperature
|
|
{
|
|
get
|
|
{
|
|
return printerSettings.GetValue<double>(ActiveBedTemperatureSetting);
|
|
}
|
|
}
|
|
|
|
public string ActiveBedTemperatureSetting
|
|
{
|
|
get
|
|
{
|
|
if (!printerSettings.GetValue<bool>(SettingsKey.has_swappable_bed)
|
|
|| !ActiveMaterialHasAnyBedTemperatures)
|
|
{
|
|
return SettingsKey.bed_temperature;
|
|
}
|
|
|
|
switch (printerSettings.GetValue(SettingsKey.bed_surface))
|
|
{
|
|
case "Blue Tape":
|
|
return SettingsKey.bed_temperature_blue_tape;
|
|
|
|
case "BuildTak":
|
|
return SettingsKey.bed_temperature_buildtak;
|
|
|
|
case "Garolite":
|
|
return SettingsKey.bed_temperature_garolite;
|
|
|
|
case "Glass":
|
|
return SettingsKey.bed_temperature_glass;
|
|
|
|
case "Kapton":
|
|
return SettingsKey.bed_temperature_kapton;
|
|
|
|
case "PEI":
|
|
return SettingsKey.bed_temperature_pei;
|
|
|
|
case "Polypropylene":
|
|
return SettingsKey.bed_temperature_pp;
|
|
|
|
default:
|
|
return SettingsKey.bed_temperature;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void DoPrintLeveling(bool doLeveling)
|
|
{
|
|
// Early exit if already set
|
|
if (doLeveling == printerSettings.GetValue<bool>(SettingsKey.print_leveling_enabled))
|
|
{
|
|
return;
|
|
}
|
|
|
|
printerSettings.SetValue(SettingsKey.print_leveling_enabled, doLeveling ? "1" : "0");
|
|
|
|
printerSettings.OnPrintLevelingEnabledChanged(this, null);
|
|
}
|
|
|
|
public void SetExtruderZOffset(int extruderIndex, double newZOffset)
|
|
{
|
|
// Get the existing offset, update Z, persist
|
|
var offset = this.ExtruderOffset(extruderIndex);
|
|
offset.Z = newZOffset;
|
|
this.SetExtruderOffset(extruderIndex, offset);
|
|
}
|
|
|
|
public void SetExtruderOffset(int extruderIndex, Vector3 newOffset)
|
|
{
|
|
var offsetsVector3 = new List<Vector3>();
|
|
string currentOffsets = printerSettings.GetValue(SettingsKey.extruder_offset);
|
|
string[] offsets = currentOffsets.Split(',');
|
|
|
|
foreach (string offset in offsets)
|
|
{
|
|
string[] xyz = offset.Split('x');
|
|
if (xyz.Length == 2)
|
|
{
|
|
var zOffset = printerSettings.GetValue<double>(SettingsKey.z_offset);
|
|
offsetsVector3.Add(new Vector3(double.Parse(xyz[0]), double.Parse(xyz[1]), -zOffset));
|
|
}
|
|
else
|
|
{
|
|
offsetsVector3.Add(new Vector3(double.Parse(xyz[0]), double.Parse(xyz[1]), double.Parse(xyz[2])));
|
|
}
|
|
}
|
|
|
|
while (offsetsVector3.Count <= extruderIndex)
|
|
{
|
|
offsetsVector3.Add(Vector3.Zero);
|
|
}
|
|
|
|
offsetsVector3[extruderIndex] = newOffset;
|
|
|
|
// now save it
|
|
var first = true;
|
|
var newValue = "";
|
|
foreach (var offset in offsetsVector3)
|
|
{
|
|
if (!first)
|
|
{
|
|
newValue += ",";
|
|
}
|
|
|
|
newValue += $"{offset.X:0.###}x{offset.Y:0.###}x{offset.Z:0.###}";
|
|
first = false;
|
|
}
|
|
|
|
printerSettings.SetValue(SettingsKey.extruder_offset, newValue);
|
|
}
|
|
|
|
public Vector3 ExtruderOffset(int extruderIndex)
|
|
{
|
|
string currentOffsets = printerSettings.GetValue(SettingsKey.extruder_offset);
|
|
string[] offsets = currentOffsets.Split(',');
|
|
int count = 0;
|
|
|
|
foreach (string offset in offsets)
|
|
{
|
|
if (count == extruderIndex)
|
|
{
|
|
string[] xyz = offset.Split('x');
|
|
|
|
if (xyz.Length == 2)
|
|
{
|
|
// Import deprecated z_offset data if missing
|
|
var zOffset = printerSettings.GetValue<double>(SettingsKey.z_offset);
|
|
return new Vector3(double.Parse(xyz[0]), double.Parse(xyz[1]), -zOffset);
|
|
}
|
|
else
|
|
{
|
|
return new Vector3(double.Parse(xyz[0]), double.Parse(xyz[1]), double.Parse(xyz[2]));
|
|
}
|
|
}
|
|
|
|
count++;
|
|
}
|
|
|
|
return Vector3.Zero;
|
|
}
|
|
|
|
public Vector3 ManualMovementSpeeds()
|
|
{
|
|
var feedRate = new Vector3(3000, 3000, 315);
|
|
|
|
string savedSettings = printerSettings.GetValue(SettingsKey.manual_movement_speeds);
|
|
if (!string.IsNullOrEmpty(savedSettings))
|
|
{
|
|
var segments = savedSettings.Split(',');
|
|
feedRate.X = double.Parse(segments[1]);
|
|
feedRate.Y = double.Parse(segments[3]);
|
|
feedRate.Z = double.Parse(segments[5]);
|
|
}
|
|
|
|
return feedRate;
|
|
}
|
|
|
|
public Dictionary<string, double> GetMovementSpeeds()
|
|
{
|
|
var speeds = new Dictionary<string, double>();
|
|
string movementSpeedsString = GetMovementSpeedsString();
|
|
string[] allSpeeds = movementSpeedsString.Split(',');
|
|
for (int i = 0; i < allSpeeds.Length / 2; i++)
|
|
{
|
|
speeds.Add(allSpeeds[i * 2 + 0], double.Parse(allSpeeds[i * 2 + 1]));
|
|
}
|
|
|
|
return speeds;
|
|
}
|
|
|
|
public string GetMovementSpeedsString()
|
|
{
|
|
string presets = "x,3000,y,3000,z,315,e0,150"; // stored x,value,y,value,z,value,e1,value,e2,value,e3,value,...
|
|
|
|
string savedSettings = printerSettings.GetValue(SettingsKey.manual_movement_speeds);
|
|
if (!string.IsNullOrEmpty(savedSettings))
|
|
{
|
|
presets = savedSettings;
|
|
}
|
|
|
|
return presets;
|
|
}
|
|
|
|
public int HotendCount()
|
|
{
|
|
if (printerSettings.GetValue<bool>(SettingsKey.extruders_share_temperature))
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
return printerSettings.GetValue<int>(SettingsKey.extruder_count);
|
|
}
|
|
}
|
|
}
|