/// <summary>
/// Takes manual input parameters for a set of valve printhead command and outputs the command to the serial port.
/// </summary>
/// <param name="printheadName"></param>
public void ProcessManualSetValvePrintheadCommand(string printheadName)
{
try
{
List <string> outgoingMessagesList = new List <string>();
PrintheadModel printheadModel = _printerModel.FindPrinthead(printheadName);
ValvePrintheadTypeModel valvePrintheadTypeModel = (ValvePrintheadTypeModel)printheadModel.PrintheadTypeModel;
string setPrintheadString = _writeSetPrintheadModel.WriteSetValvePrinthead(valvePrintheadTypeModel.AttachedValveGPIOPinModel.PinID);
outgoingMessagesList.Add(setPrintheadString);
//Send GCode for the Z Axis attached to the Printhead.
AxisModel axisModel = printheadModel.AttachedZAxisModel;
int zAxisLimitPinID = (axisModel.AttachedLimitSwitchGPIOPinModel == null) ? GlobalValues.PinIDNull : axisModel.AttachedLimitSwitchGPIOPinModel.PinID;
string setAxisString = _writeSetAxisModel.WriteSetAxis(axisModel.AxisID, axisModel.AttachedMotorStepGPIOPinModel.PinID, axisModel.AttachedMotorDirectionGPIOPinModel.PinID,
axisModel.StepPulseTime, zAxisLimitPinID, axisModel.MaxSpeed, axisModel.MaxAcceleration, axisModel.MmPerStep);
outgoingMessagesList.Add(SerialMessageCharacters.SerialCommandSetCharacter + "RetractZ");
outgoingMessagesList.Add(setAxisString);
_serialCommunicationOutgoingMessagesModel.QueueNextProspectiveOutgoingMessage(outgoingMessagesList);
}
catch (NullReferenceException e)
{
_errorListViewModel.AddError("", "Printhead or z actuator needs to be set in Printer Settings before setting printhead in Control Menu.");
}
catch
{
_errorListViewModel.AddError("", "Unknown error while setting valve printhead.");
}
}
/// <summary>
/// Calls the OnPropertyChanged event and updates properties related to the Set Axis command.
/// </summary>
private void UpdateRecordSetAxis(string axisName)
{
char axisID = '0';
AxisModel axisModel = _realTimeStatusDataModel.PrinterModel.FindAxis(axisName);
if (axisModel != null)
{
axisID = axisModel.AxisID;
}
switch (axisID)
{
case 'X':
_xRealTimeStatusAxisViewModel = new RealTimeStatusAxisViewModel(_realTimeStatusDataModel.XRealTimeStatusAxisModel);
OnPropertyChanged("XRealTimeStatusAxisViewModel");
break;
case 'Y':
_yRealTimeStatusAxisViewModel = new RealTimeStatusAxisViewModel(_realTimeStatusDataModel.YRealTimeStatusAxisModel);
OnPropertyChanged("YRealTimeStatusAxisViewModel");
break;
case 'Z':
_zRealTimeStatusAxisViewModel = new RealTimeStatusAxisViewModel(_realTimeStatusDataModel.ZRealTimeStatusAxisModel);
OnPropertyChanged("ZRealTimeStatusAxisViewModel");
break;
default:
//Should never reach this point.
break;
}
}
/// <summary>
/// Takes manual input parameters for a set of commands for motorized printhead droplet printing and outputs the commands to the serial port.
/// </summary>
/// <param name="xDistance"></param>
/// <param name="yDistance"></param>
/// <param name="zDistance"></param>
/// <param name="interpolateDistance"></param>
/// <param name="eDispensePerDroplet"></param>
public void ProcessManualMotorDropletPrintCommand(double xDistance, double yDistance, double zDistance, double interpolateDistance, double eDispensePerDroplet)
{
PrintheadModel printheadModel = _printerModel.FindPrinthead(_realTimeStatusDataModel.ActivePrintheadModel.Name);
MotorizedPrintheadTypeModel motorizedPrintheadTypeModel = (MotorizedPrintheadTypeModel)printheadModel.PrintheadTypeModel;
double emmPerStep = motorizedPrintheadTypeModel.MmPerStep;
RealTimeStatusMotorizedPrintheadModel realTimeStatusMotorizedPrintheadModel = (RealTimeStatusMotorizedPrintheadModel)_realTimeStatusDataModel.ActivePrintheadModel;
double eMaxSpeed = realTimeStatusMotorizedPrintheadModel.MaxSpeed;
double eAcceleration = realTimeStatusMotorizedPrintheadModel.Acceleration;
double xmmPerStep = (xDistance != 0) ? _printerModel.AxisModelList[0].MmPerStep : double.MaxValue;
double ymmPerStep = (yDistance != 0) ? _printerModel.AxisModelList[1].MmPerStep : double.MaxValue;
AxisModel zAxisModel = _printerModel.FindAxis(_realTimeStatusDataModel.ZRealTimeStatusAxisModel.Name);
double zmmPerStep = (zDistance != 0) ? _printerModel.FindAxis(zAxisModel.Name).MmPerStep : double.MaxValue;
bool zDirectionInverted = (zAxisModel != null) ? zAxisModel.IsDirectionInverted : false;
double unused = 0;
string printString = GCodeLinesConverter.GCodeLinesListToString(
WriteG00.WriteMotorizedDropletPrint(
emmPerStep, xmmPerStep, ymmPerStep, zmmPerStep,
eDispensePerDroplet, 0, xDistance, 0, yDistance, 0, zDistance,
_printerModel.AxisModelList[0].IsDirectionInverted, _printerModel.AxisModelList[1].IsDirectionInverted, zDirectionInverted, motorizedPrintheadTypeModel.IsDirectionInverted,
ref unused, ref unused, ref unused, ref unused,
null, new DropletModel(interpolateDistance)));
_serialCommunicationOutgoingMessagesModel.QueueNextProspectiveOutgoingMessage(printString);
}
internal static NumericalAxisOhlcPlotInfo Create(AxisModel axis, double plotOffset, double high, double low, double open, double close, double origin)
{
NumericalAxisOhlcPlotInfo info = new NumericalAxisOhlcPlotInfo();
info.Axis = axis;
info.PlotOriginOffset = plotOffset;
info.NormalizedHigh = high;
info.NormalizedLow = low;
info.NormalizedOpen = open;
info.NormalizedClose = close;
info.NormalizedOrigin = origin;
if (high == low)
{
info.RelativeOpen = 0;
info.RelativeClose = 0;
}
else
{
info.RelativeOpen = (open - low) / (high - low);
info.RelativeClose = (close - low) / (high - low);
}
return(info);
}
/// <summary>
/// Takes manual input parameters for a set axis command and outputs the command to the serial port.
/// </summary>
/// <param name="axisName"></param>
/// <param name="maxSpeed"></param>
/// <param name="acceleration"></param>
public void ProcessManualSetAxisCommand(string axisName, double maxSpeed, double acceleration)
{
try
{
List <string> outgoingMessagesList = new List <string>();
AxisModel axisModel = _printerModel.FindAxis(axisName);
int limitPinID = (axisModel.AttachedLimitSwitchGPIOPinModel == null) ? GlobalValues.PinIDNull : axisModel.AttachedLimitSwitchGPIOPinModel.PinID;
string setAxisString = _writeSetAxisModel.WriteSetAxis(axisModel.AxisID, axisModel.AttachedMotorStepGPIOPinModel.PinID, axisModel.AttachedMotorDirectionGPIOPinModel.PinID,
axisModel.StepPulseTime, limitPinID, maxSpeed, acceleration, axisModel.MmPerStep);
//If switching Z Axes, then retract the current Z Axis first.
if (axisModel.AxisID == 'Z')
{
outgoingMessagesList.Add(SerialMessageCharacters.SerialCommandSetCharacter + "RetractZ");
}
outgoingMessagesList.Add(setAxisString);
_serialCommunicationOutgoingMessagesModel.QueueNextProspectiveOutgoingMessage(outgoingMessagesList);
}
catch (NullReferenceException e)
{
_errorListViewModel.AddError("", "Actuator needs to be set in Printer Settings before setting the actuator in Control Menu.");
}
catch
{
_errorListViewModel.AddError("", "Unknown error while setting valve printhead.");
}
}
/// <summary>
/// Adds one Z Axis to the Printer.
/// </summary>
public void AddZAxis()
{
AxisModel newZAxis = new AxisModel("Z Actuator " + ++_zAxesCreatedCount, 'Z');
_axisModelList.Add(newZAxis);
_zAxisModelList.Add(newZAxis);
}
public void SetAxis(AxisModel axis)
{
Config = new CanvasConfiguration();
Config.BuildConfiguration(axis, AttachedCanvas.ActualWidth, AttachedCanvas.ActualHeight);
DrawGrid();
AdjustLocationsAfterResize();
}
/// <summary>
/// Record the parameters from a Move Axes command.
/// Parameters represent relative positions.
/// </summary>
/// <param name="xPosition"></param>
/// <param name="yPosition"></param>
/// <param name="zPosition"></param>
public void RecordMoveAxes(int xStepsTaken, int yStepsTaken, int zStepsTaken)
{
//mm Per Step.
double xmmPerStep = _printerModel.AxisModelList[0].MmPerStep;
double ymmPerStep = _printerModel.AxisModelList[1].MmPerStep;
double zmmPerStep = 0;
AxisModel zAxisModel = _printerModel.FindAxis(_zRealTimeStatusAxisModel.Name);
if (zAxisModel != null)
{
zmmPerStep = zAxisModel.MmPerStep;
}
//Record positions.
if (xStepsTaken != 0)
{
_xRealTimeStatusAxisModel.Position += (_printerModel.AxisModelList[0].IsDirectionInverted == false) ? (double)(xStepsTaken * xmmPerStep) : (double)(xStepsTaken * -1 * xmmPerStep);
_xRealTimeStatusAxisModel.LimitSwitchStatus = LimitSwitchStatus.NoLimit;
}
if (yStepsTaken != 0)
{
_yRealTimeStatusAxisModel.Position += (_printerModel.AxisModelList[1].IsDirectionInverted == false) ? (double)(yStepsTaken * ymmPerStep) : (double)(yStepsTaken * -1 * ymmPerStep);
_yRealTimeStatusAxisModel.LimitSwitchStatus = LimitSwitchStatus.NoLimit;
}
if (zStepsTaken != 0)
{
_zRealTimeStatusAxisModel.Position += (_printerModel.FindAxis(_zRealTimeStatusAxisModel.Name).IsDirectionInverted == false) ? (double)(zStepsTaken * zmmPerStep) : (double)(zStepsTaken * -1 * zmmPerStep);
_zRealTimeStatusAxisModel.LimitSwitchStatus = LimitSwitchStatus.NoLimit;
}
//Notify other classes.
OnRecordMoveAxesExecuted();
}
/// <summary>
/// Adds one Z Axis with a Name to the Printer.
/// </summary>
/// <param name="name"></param>
public void AddZAxis(string name)
{
AxisModel newZAxis = new AxisModel(name, 'Z');
_axisModelList.Add(newZAxis);
_zAxisModelList.Add(newZAxis);
}
internal static double GetSlotLength(CategoricalStrokedSeriesModel stepLineSeriesModel, AxisPlotDirection plotDirection, Size chartScale)
{
double slotLength;
int slotsCount;
AxisModel axisModel = plotDirection == AxisPlotDirection.Vertical ? stepLineSeriesModel.firstAxis : stepLineSeriesModel.secondAxis;
double axisLength = plotDirection == AxisPlotDirection.Vertical ? axisModel.layoutSlot.Width : axisModel.layoutSlot.Height;
double zoomScale = plotDirection == AxisPlotDirection.Vertical ? chartScale.Width : chartScale.Height;
axisLength = axisLength * zoomScale;
DateTimeContinuousAxisModel dateTimeContinuousAxisModel = axisModel as DateTimeContinuousAxisModel;
if (dateTimeContinuousAxisModel != null)
{
return(0);
}
CategoricalAxisModel categoricalAxisModel = (CategoricalAxisModel)axisModel;
slotsCount = categoricalAxisModel.ActualPlotMode == AxisPlotMode.OnTicks ? categoricalAxisModel.categories.Count - 1 : categoricalAxisModel.categories.Count;
slotsCount = slotsCount * categoricalAxisModel.GetMajorTickInterval();
slotsCount = Math.Max(1, slotsCount);
slotLength = axisLength / slotsCount;
return(slotLength);
}
/// <summary>
/// Record the parameters from a Set Axis command.
/// </summary>
/// <param name="axisName"></param>
/// <param name="maxSpeed"></param>
/// <param name="acceleration"></param>
public void RecordSetAxis(char axisID, string axisName, double maxSpeed, double acceleration)
{
AxisModel axisModel = _printerModel.FindAxis(axisName);
double mmPerStep = axisModel.MmPerStep;
//Max speed is read as steps / s and acceleration is read as steps / s2.
//These parameters are converted to this program's convention of mm / s and mm / s2.
double convertedMaxSpeed = maxSpeed * mmPerStep;
double convertedAcceleration = acceleration * mmPerStep;
//Record new data.
switch (axisID)
{
case 'X':
_xRealTimeStatusAxisModel = new RealTimeStatusAxisModel(axisName, _xRealTimeStatusAxisModel.Position, convertedMaxSpeed, convertedAcceleration);
break;
case 'Y':
_yRealTimeStatusAxisModel = new RealTimeStatusAxisModel(axisName, _yRealTimeStatusAxisModel.Position, convertedMaxSpeed, convertedAcceleration);
break;
case 'Z':
//If the Z Axis does not need to be changed, then keep the same position. Otherwise, create new positions assuming the Z actuator was retracted before becoming active.
double zPosition = (axisName == _zRealTimeStatusAxisModel.Name) ? _zRealTimeStatusAxisModel.Position : _printerModel.FindAxis(axisName).MaxPosition - GlobalValues.LimitBuffer - _printerModel.FindAxis(axisName).MinPosition;
_zRealTimeStatusAxisModel = new RealTimeStatusAxisModel(axisName, zPosition, convertedMaxSpeed, convertedAcceleration);
break;
default:
//Should never reach this point.
break;
}
//Notify other classes.
OnRecordSetAxisExecuted(axisName);
}
/// <summary>
/// Set the new center as the origin (position 0) and adjust the max and min range around such.
/// </summary>
/// <param name="commandSet"></param>
/// <returns></returns>
private List <string> InterpretSetOrigin(string commandSet)
{
//Remove "*Origin" from the beginning of the string.
commandSet = commandSet.Substring(6);
if (commandSet.Contains("E"))
{
if (_realTimeStatusDataModel.ActivePrintheadType == PrintheadType.Motorized)
{
RealTimeStatusMotorizedPrintheadModel realTimeStatusMotorizedPrintheadModel = (RealTimeStatusMotorizedPrintheadModel)_realTimeStatusDataModel.ActivePrintheadModel;
MotorizedPrintheadTypeModel motorizedPrintheadTypeModel = (MotorizedPrintheadTypeModel)_printerModel.FindPrinthead(realTimeStatusMotorizedPrintheadModel.Name).PrintheadTypeModel;
double previousEPosition = realTimeStatusMotorizedPrintheadModel.Position;
motorizedPrintheadTypeModel.MaxPosition -= previousEPosition;
motorizedPrintheadTypeModel.MinPosition -= previousEPosition;
realTimeStatusMotorizedPrintheadModel.Position = 0;
}
}
if (commandSet.Contains("X"))
{
AxisModel xAxisModel = _printerModel.AxisModelList[0];
double previousXPosition = _realTimeStatusDataModel.XRealTimeStatusAxisModel.Position;
xAxisModel.MaxPosition -= previousXPosition;
xAxisModel.MinPosition -= previousXPosition;
_realTimeStatusDataModel.XRealTimeStatusAxisModel.Position = 0;
}
if (commandSet.Contains("Y"))
{
AxisModel yAxisModel = _printerModel.AxisModelList[1];
double previousYPosition = _realTimeStatusDataModel.YRealTimeStatusAxisModel.Position;
yAxisModel.MaxPosition -= previousYPosition;
yAxisModel.MinPosition -= previousYPosition;
_realTimeStatusDataModel.YRealTimeStatusAxisModel.Position = 0;
}
if (commandSet.Contains("Z"))
{
AxisModel zAxisModel = _printerModel.FindAxis(_realTimeStatusDataModel.ZRealTimeStatusAxisModel.Name);
double previousZPosition = _realTimeStatusDataModel.ZRealTimeStatusAxisModel.Position;
zAxisModel.MaxPosition -= previousZPosition;
zAxisModel.MinPosition -= previousZPosition;
_realTimeStatusDataModel.ZRealTimeStatusAxisModel.Position = 0;
}
OnCommandSetMinMaxPositionChanged();
OnCommandSetMinMaxPositionChanged();
//No commands to return.
return(null);
}
public void InitSscanModel()
{
AxisModel xAxis = new AxisModel(-10, 100, 1000);
AxisModel yAxis = new AxisModel(1e-3, 100, 1000);
sscanModel = new SscanModel(xAxis, yAxis);
plottingData = new double[xAxis.Number, yAxis.Number];
}
protected Axis()
{
this.model = this.CreateModel();
this.titlePresenter.Content = null;
this.SetBinding(Axis.VisibilityWatcherProperty, new Binding()
{
Path = new PropertyPath("Visibility"), Source = this
});
}
internal static NumericalAxisRangePlotInfo Create(AxisModel axis, double plotOriginOffset, double normalizedHigh, double normalizedLow, double normalizedOrigin)
{
NumericalAxisRangePlotInfo info = new NumericalAxisRangePlotInfo();
info.Axis = axis;
info.PlotOriginOffset = plotOriginOffset;
info.NormalizedHigh = normalizedHigh;
info.NormalizedLow = normalizedLow;
info.NormalizedOrigin = normalizedOrigin;
return(info);
}
/// <summary>
/// Retracts the Z Axis up to a short distance away from the Limit Switch (does not hit the Limit Switch).
/// </summary>
/// <param name="commandSet"></param>
/// <returns></returns>
private List <string> InterpretRetractZ(string commandSet)
{
//Command set to be returned.
List <string> returnCommands = new List <string>();
//Find the retracting Z Axis.
AxisModel zAxisModel = _printerModel.FindAxis(_realTimeStatusDataModel.ZRealTimeStatusAxisModel.Name);
//Generate commands for retracting the Z Axis.
returnCommands = RetractZ(commandSet, zAxisModel);
//Return null if failed to find Z Axis.
return(returnCommands);
}
/// <summary>
/// Returns a set of commands for Axis movement that compensates for a new Printhead's offsets.
/// Print speeds will be maximized before moving to offset.
/// </summary>
/// <param name="newPrinthead"></param>
/// <param name="currentPrinthead"></param>
/// <param name="zPosition">Relative position of the Z Axis before and after switching.</param>
/// <param name="pauseBeforeActivating">Pauses the print sequence before lowering the Z actuator.</param>
/// <returns></returns>
private List <string> WriteMoveToOffset(PrintheadModel newPrinthead, PrintheadModel currentPrinthead, double zPosition, bool pauseBeforeActivating)
{
List <string> returnCommands = new List <string>();
AxisModel xAxisModel = _printerModel.AxisModelList[0];
AxisModel yAxisModel = _printerModel.AxisModelList[1];
AxisModel zAxisModel = newPrinthead.AttachedZAxisModel;
double xMove = newPrinthead.XOffset - currentPrinthead.XOffset;
double yMove = newPrinthead.YOffset - currentPrinthead.YOffset;
double zMove = 0;
if (newPrinthead.AttachedZAxisModel.Name != _realTimeStatusDataModel.ZRealTimeStatusAxisModel.Name)
{
//If a new Z actuator is requried.
zMove = -1 * (newPrinthead.AttachedZAxisModel.MaxPosition - GlobalValues.LimitBuffer) + zPosition;
}
//Move to the X and Y offsets first to prevent bumping of print container walls.
double unused = 0;
if ((xMove != 0) || (yMove != 0))
{
//Maximize movement speeds before moving to offset.
returnCommands.Add(_writeSetAxisModel.WriteSetAxis(_printerModel.AxisModelList[0]));
returnCommands.Add(_writeSetAxisModel.WriteSetAxis(_printerModel.AxisModelList[1]));
returnCommands.Add(GCodeLinesConverter.GCodeLinesListToString(
WriteG00.WriteAxesMovement(xAxisModel.MmPerStep, yAxisModel.MmPerStep, 0,
xMove, yMove, 0, xAxisModel.IsDirectionInverted, yAxisModel.IsDirectionInverted, false,
ref unused, ref unused, ref unused)));
}
//Pause before activating.
if (pauseBeforeActivating == true)
{
returnCommands.Add(SerialMessageCharacters.SerialPrintPauseCharacter.ToString());
}
//Move the Z offset after the X and Y positions are set.
if (zMove != 0)
{
returnCommands.Add(_writeSetAxisModel.WriteSetAxis(newPrinthead.AttachedZAxisModel));
returnCommands.Add(GCodeLinesConverter.GCodeLinesListToString(
WriteG00.WriteAxesMovement(0, 0, zAxisModel.MmPerStep,
0, 0, zMove, false, false, zAxisModel.IsDirectionInverted,
ref unused, ref unused, ref unused)));
}
return(returnCommands);
}
/// <summary>
/// Reads the coordinate values in a movement or print command.
/// </summary>
/// <param name="convertedGCodeLine"></param>
/// <param name="gCodeIndex"></param>
/// <param name="materialModel"></param>
/// <returns></returns>
private MovementModel ReadCoord(string convertedGCodeLine, int gCodeIndex, MaterialModel materialModel)
{
//G Commands from Converted GCode are in relative positions.
string[] gCodePhrases = GCodeStringParsing.GCodeTo2DArr(convertedGCodeLine)[0];
double xDistance = 0;
double yDistance = 0;
double zDistance = 0;
double eDistance = 0;
//Read the coordinates from the GCode.
for (int phrase = 1; phrase < gCodePhrases.Length; phrase++)
{
switch (gCodePhrases[phrase][0])
{
case 'X':
int xSteps = (int)GCodeStringParsing.ParseDouble(gCodePhrases[phrase]);
AxisModel xAxisModel = _printerModel.AxisModelList[0];
xDistance = G00Calculator.StepsToDistance(xSteps, xAxisModel.MmPerStep, xAxisModel.IsDirectionInverted);
break;
case 'Y':
int ySteps = (int)GCodeStringParsing.ParseDouble(gCodePhrases[phrase]);
AxisModel yAxisModel = _printerModel.AxisModelList[1];
yDistance = G00Calculator.StepsToDistance(ySteps, yAxisModel.MmPerStep, yAxisModel.IsDirectionInverted);
break;
case 'Z':
int zSteps = (int)GCodeStringParsing.ParseDouble(gCodePhrases[phrase]);
AxisModel zAxisModel = _printerModel.FindAxis(materialModel.PrintheadModel.AttachedZAxisModel.Name);
zDistance = G00Calculator.StepsToDistance(zSteps, zAxisModel.MmPerStep, zAxisModel.IsDirectionInverted);
break;
case 'E':
int eSteps = (int)GCodeStringParsing.ParseDouble(gCodePhrases[phrase]);
MotorizedPrintheadTypeModel motorizedPrintheadTypeModel = (MotorizedPrintheadTypeModel)materialModel.PrintheadModel.PrintheadTypeModel;
eDistance = G00Calculator.StepsToDistance(eSteps, motorizedPrintheadTypeModel.MmPerStep, motorizedPrintheadTypeModel.IsDirectionInverted);
break;
default:
//Do nothing.
break;
}
}
MovementModel movementModel = new MovementModel(xDistance, yDistance, zDistance, eDistance, gCodeIndex, materialModel, _printerModel);
return(movementModel);
}
/// <summary>
/// Generate commands for retracting a Z Axis.
/// </summary>
/// <param name="zAxisModel"></param>
/// <returns></returns>
private List <string> RetractZ(string commandSet, AxisModel zAxisModel)
{
List <string> returnCommands = new List <string>();
if (zAxisModel != null)
{
//Retract Z Axis.\
double unused = 0;
bool zDirectionInverted = (zAxisModel != null) ? zAxisModel.IsDirectionInverted : false;
if (commandSet.Contains("Limit")) //If CommandSet is "RetractZLimit", then hit the Limit Switch before returning to default position.
{
//Hit the Limti Switch.
double retractDistance = 5000;
string zRetract = GCodeLinesConverter.GCodeLinesListToString(
WriteG00.WriteAxesMovement(
1, 1, zAxisModel.MmPerStep,
0, 0, retractDistance,
false, false, zDirectionInverted,
ref unused, ref unused, ref unused));
returnCommands.Add(zRetract);
//Move away from the Limit Switch to default position.
string zMoveAwayFromLimit = GCodeLinesConverter.GCodeLinesListToString(
WriteG00.WriteAxesMovement(
0, 0, zAxisModel.MmPerStep,
0, 0, -1 * GlobalValues.LimitBuffer,
false, false, zAxisModel.IsDirectionInverted,
ref unused, ref unused, ref unused));
returnCommands.Add(zMoveAwayFromLimit);
}
else //If the CommandSet is "RetractZ", then move to default position without hitting the Limit Switch.
{
//Move to default position.
double retractDistance = zAxisModel.MaxPosition - _realTimeStatusDataModel.ZRealTimeStatusAxisModel.Position - GlobalValues.LimitBuffer;
string zRetract = GCodeLinesConverter.GCodeLinesListToString(
WriteG00.WriteAxesMovement(
1, 1, zAxisModel.MmPerStep,
0, 0, retractDistance,
false, false, zDirectionInverted,
ref unused, ref unused, ref unused));
returnCommands.Add(zRetract);
}
return(returnCommands);
}
return(null);
}
/// <summary>
/// Returns converted GCode for the setting of an Axis. Sets the highest Max Speed and Acceleration values.
/// </summary>
/// <param name="axisModel"></param>
/// <returns></returns>
public string WriteSetAxis(AxisModel axisModel)
{
string convertedGCode = "";
try
{
int limitPinID = (axisModel.AttachedLimitSwitchGPIOPinModel == null) ? GlobalValues.PinIDNull : axisModel.AttachedLimitSwitchGPIOPinModel.PinID;
convertedGCode = WriteSetAxis(axisModel.AxisID, axisModel.AttachedMotorStepGPIOPinModel.PinID, axisModel.AttachedMotorDirectionGPIOPinModel.PinID,
axisModel.StepPulseTime, limitPinID, axisModel.MaxSpeed, axisModel.MaxAcceleration, axisModel.MmPerStep);
}
catch when(axisModel == null) //Axis unset.
{
//Catching and error handling should have happened earlier.
convertedGCode = "";
}
/// <summary>
/// Takes manual input parameters for a movement command and outputs the command to the serial port.
/// </summary>
/// <param name="xDistance"></param>
/// <param name="yDistance"></param>
/// <param name="zDistance"></param>
public void ProcessManualMovementCommand(double xDistance, double yDistance, double zDistance)
{
double xmmPerStep = (xDistance != 0) ? _printerModel.AxisModelList[0].MmPerStep : double.MaxValue;
double ymmPerStep = (yDistance != 0) ? _printerModel.AxisModelList[1].MmPerStep : double.MaxValue;
AxisModel zAxisModel = _printerModel.FindAxis(_realTimeStatusDataModel.ZRealTimeStatusAxisModel.Name);
double zmmPerStep = (zDistance != 0) ? _printerModel.FindAxis(zAxisModel.Name).MmPerStep : double.MaxValue;
bool zDirectionInverted = (zAxisModel != null) ? zAxisModel.IsDirectionInverted : false;
double unused = 0;
string axesMovementString = GCodeLinesConverter.GCodeLinesListToString(
WriteG00.WriteAxesMovement(xmmPerStep, ymmPerStep, zmmPerStep,
xDistance, yDistance, zDistance,
_printerModel.AxisModelList[0].IsDirectionInverted, _printerModel.AxisModelList[1].IsDirectionInverted, zDirectionInverted,
ref unused, ref unused, ref unused));
_serialCommunicationOutgoingMessagesModel.QueueNextProspectiveOutgoingMessage(axesMovementString);
}
internal static IEnumerable <Point> GetPoints(DataPointSegment segment, StepSeriesModel seriesModel, IList <DataPoint> renderPoints, ReferenceDictionary <string, Delegate> valueExtractor)
{
AxisPlotDirection plotDirection = seriesModel.GetTypedValue <AxisPlotDirection>(AxisModel.PlotDirectionPropertyKey, AxisPlotDirection.Vertical);
AxisModel axisModel = plotDirection == AxisPlotDirection.Vertical ? seriesModel.firstAxis : seriesModel.secondAxis;
var risersActualPosition = StepSeriesHelper.GetActualRisersPosition(seriesModel.RisersPosition, axisModel.ActualPlotMode);
var isRisersPositionEqualToPlotMode = StepSeriesHelper.IsRisersPositionEqualToPlotMode(axisModel.ActualPlotMode, risersActualPosition);
var view = seriesModel.GetChartArea().view;
Size chartScale = new Size(view.ZoomWidth, view.ZoomHeight);
double slotLength = StepSeriesHelper.GetSlotLength(seriesModel, plotDirection, chartScale);
double halfSlotLength = slotLength / 2;
Func <Point, Point, Point> riserPointGetter = (Func <Point, Point, Point>)valueExtractor[RiserPointGetter];
Func <Point, Point, double, Point> firstRiserPointGetter = (Func <Point, Point, double, Point>)valueExtractor[FirstRiserPointGetter];
Func <Point, Point, double, Point> secondRiserPointGetter = (Func <Point, Point, double, Point>)valueExtractor[SecondRiserPointGetter];
int pointIndex = segment.StartIndex;
while (pointIndex <= segment.EndIndex)
{
var currentPoint = renderPoints[pointIndex].Center();
yield return(currentPoint);
if (pointIndex == segment.EndIndex)
{
yield break;
}
var nextPoint = renderPoints[pointIndex + 1].Center();
if (isRisersPositionEqualToPlotMode || axisModel is DateTimeContinuousAxisModel)
{
yield return(riserPointGetter(currentPoint, nextPoint));
}
else
{
yield return(firstRiserPointGetter(currentPoint, nextPoint, halfSlotLength));
yield return(secondRiserPointGetter(currentPoint, nextPoint, halfSlotLength));
}
pointIndex++;
}
}
/// <summary>
/// Takes manual input parameters for a motor print with movement command and outputs the command to the serial port.
/// </summary>
/// <param name="xDistance"></param>
/// <param name="yDistance"></param>
/// <param name="zDistance"></param>
/// <param name="eDispensePerDistance"></param>
public void ProcessManualMotorPrintWithMovementCommand(double xDistance, double yDistance, double zDistance, double eDispensePerDistance)
{
MotorizedPrintheadTypeModel motorizedPrintheadTypeModel = (MotorizedPrintheadTypeModel)_printerModel.FindPrinthead(_realTimeStatusDataModel.ActivePrintheadModel.Name).PrintheadTypeModel;
double emmPerStep = motorizedPrintheadTypeModel.MmPerStep;
double xmmPerStep = (xDistance != 0) ? _printerModel.AxisModelList[0].MmPerStep : double.MaxValue;
double ymmPerStep = (yDistance != 0) ? _printerModel.AxisModelList[1].MmPerStep : double.MaxValue;
AxisModel zAxisModel = _printerModel.FindAxis(_realTimeStatusDataModel.ZRealTimeStatusAxisModel.Name);
double zmmPerStep = (zDistance != 0) ? _printerModel.FindAxis(zAxisModel.Name).MmPerStep : double.MaxValue;
bool zDirectionInverted = (zAxisModel != null) ? zAxisModel.IsDirectionInverted : false;
double unused = 0;
string printString = GCodeLinesConverter.GCodeLinesListToString(
WriteG00.WriteMotorizedContinuousPrint(emmPerStep, xmmPerStep, ymmPerStep, zmmPerStep,
eDispensePerDistance, xDistance, yDistance, zDistance,
_printerModel.AxisModelList[0].IsDirectionInverted, _printerModel.AxisModelList[1].IsDirectionInverted, zDirectionInverted, motorizedPrintheadTypeModel.IsDirectionInverted,
ref unused, ref unused, ref unused, ref unused,
null));
_serialCommunicationOutgoingMessagesModel.QueueNextProspectiveOutgoingMessage(printString);
}
public AxisViewModel(AxisModel AxisModel, GPIOPinListsViewModel GPIOPinListsViewModel)
{
_axisModel = AxisModel;
_gPIOPinListsViewModel = GPIOPinListsViewModel;
}
/// <summary>
/// Interpret a switch material command set and return an array of commands.
/// </summary>
/// <param name="commandSet"></param>
/// <returns></returns>
private List <string> InterpretSwitchMaterial(string commandSet)
{
//Remove "*SwitchMaterial" from the beginning of the command set.
commandSet = commandSet.Substring(14);
//Potentially pause before deactivating the current printhead.
bool pauseBeforeDeactivating = false;
if (commandSet.Contains('D'))
{
pauseBeforeDeactivating = true;
}
//Potentially pause after activating the next printhead.
bool pauseBeforeActivating = false;
if (commandSet.Contains('A'))
{
pauseBeforeActivating = true;
}
//Set of commands to be returned at the end of this method.
List <string> returnCommands = new List <string>();
//The name of the Material which will be switched to will be between quote characters.
int firstNameIndex = commandSet.IndexOf('"');
int nameLength = commandSet.Substring(firstNameIndex + 1).IndexOf('"');
string materialName = commandSet.Substring(firstNameIndex + 1, nameLength);
MaterialModel materialModel = _printModel.FindMaterialByName(materialName);
if (materialModel == null)
{
_errorListViewModel.AddError("Command Set Invalid", materialName + " Not Set");
return(null);
}
//References to the current and new Printheads.
PrintheadModel currentPrintheadModel = _printerModel.FindPrinthead(_realTimeStatusDataModel.ActivePrintheadModel.Name);
PrintheadModel newPrintheadModel = materialModel.PrintheadModel;
//References to the Z Axis on the current Printhead.
AxisModel currentZAxisModel = _printerModel.FindAxis(currentPrintheadModel.AttachedZAxisModel.Name);
int currentZLimitPinID = (currentZAxisModel.AttachedLimitSwitchGPIOPinModel != null) ? currentZAxisModel.AttachedLimitSwitchGPIOPinModel.PinID : GlobalValues.PinIDNull;
//References to the XY Axes and new Z Axis.
AxisModel xAxisModel = _printerModel.AxisModelList[0];
int xLimitPinID = (xAxisModel.AttachedLimitSwitchGPIOPinModel != null) ? xAxisModel.AttachedLimitSwitchGPIOPinModel.PinID : GlobalValues.PinIDNull;
AxisModel yAxisModel = _printerModel.AxisModelList[1];
int yLimitPinID = (yAxisModel.AttachedLimitSwitchGPIOPinModel != null) ? yAxisModel.AttachedLimitSwitchGPIOPinModel.PinID : GlobalValues.PinIDNull;
AxisModel zAxisModel = _printerModel.FindAxis(newPrintheadModel.AttachedZAxisModel.Name);
int zLimitPinID = (zAxisModel.AttachedLimitSwitchGPIOPinModel != null) ? zAxisModel.AttachedLimitSwitchGPIOPinModel.PinID : GlobalValues.PinIDNull;
//If a new Printhead is required...
if (newPrintheadModel.Name != currentPrintheadModel.Name)
{
//1. Set previous Z Axis at max speeds.
//2. Retract the previous Printhead / Z Axis.
returnCommands.Add(_writeSetAxisModel.WriteSetAxis('Z', currentZAxisModel.AttachedMotorStepGPIOPinModel.PinID, currentZAxisModel.AttachedMotorDirectionGPIOPinModel.PinID,
currentZAxisModel.StepPulseTime, currentZLimitPinID, currentZAxisModel.MaxSpeed, currentZAxisModel.MaxAcceleration, currentZAxisModel.MmPerStep));
List <string> retractZ = RetractZ("", currentPrintheadModel.AttachedZAxisModel);
foreach (string command in retractZ)
{
if (!String.IsNullOrWhiteSpace(command))
{
returnCommands.Add(command);
}
}
//Pause before deactivating.
if (pauseBeforeDeactivating == true)
{
returnCommands.Add(SerialMessageCharacters.SerialPrintPauseCharacter.ToString());
}
//3. Set new XYZ to max speeds and move to the new Offset.
//Set associated X Axis at max speeds.
returnCommands.Add(_writeSetAxisModel.WriteSetAxis('X', xAxisModel.AttachedMotorStepGPIOPinModel.PinID, xAxisModel.AttachedMotorDirectionGPIOPinModel.PinID,
xAxisModel.StepPulseTime, xLimitPinID, xAxisModel.MaxSpeed, xAxisModel.MaxAcceleration, xAxisModel.MmPerStep));
//Set associated Y Axis at max speeds.
returnCommands.Add(_writeSetAxisModel.WriteSetAxis('Y', yAxisModel.AttachedMotorStepGPIOPinModel.PinID, yAxisModel.AttachedMotorDirectionGPIOPinModel.PinID,
yAxisModel.StepPulseTime, yLimitPinID, yAxisModel.MaxSpeed, yAxisModel.MaxAcceleration, yAxisModel.MmPerStep));
//Set associated Z Axis at max speeds.
returnCommands.Add(_writeSetAxisModel.WriteSetAxis('Z', zAxisModel.AttachedMotorStepGPIOPinModel.PinID, zAxisModel.AttachedMotorDirectionGPIOPinModel.PinID,
zAxisModel.StepPulseTime, zLimitPinID, zAxisModel.MaxSpeed, zAxisModel.MaxAcceleration, zAxisModel.MmPerStep));
//4.Move to the new Offset at max speeds.
double zPosition = _realTimeStatusDataModel.ZRealTimeStatusAxisModel.Position;
List <string> moveToOffset = WriteMoveToOffset(newPrintheadModel, currentPrintheadModel, zPosition, pauseBeforeActivating);
foreach (string command in moveToOffset)
{
if (!String.IsNullOrWhiteSpace(command))
{
returnCommands.Add(command);
}
}
}
//5.Set the print speed parameters for the new Material.
//Set associated X Axis at print speeds.
returnCommands.Add(_writeSetAxisModel.WriteSetAxis('X', xAxisModel.AttachedMotorStepGPIOPinModel.PinID, xAxisModel.AttachedMotorDirectionGPIOPinModel.PinID,
xAxisModel.StepPulseTime, xLimitPinID, materialModel.XYPrintSpeed, materialModel.XYPrintAcceleration, xAxisModel.MmPerStep));
//Set associated Y Axis at print speeds.
returnCommands.Add(_writeSetAxisModel.WriteSetAxis('Y', yAxisModel.AttachedMotorStepGPIOPinModel.PinID, yAxisModel.AttachedMotorDirectionGPIOPinModel.PinID,
yAxisModel.StepPulseTime, yLimitPinID, materialModel.XYPrintSpeed, materialModel.XYPrintAcceleration, yAxisModel.MmPerStep));
//Set associated Z Axis at print speeds.
returnCommands.Add(_writeSetAxisModel.WriteSetAxis('Z', zAxisModel.AttachedMotorStepGPIOPinModel.PinID, zAxisModel.AttachedMotorDirectionGPIOPinModel.PinID,
zAxisModel.StepPulseTime, zLimitPinID, materialModel.ZPrintSpeed, materialModel.ZPrintAcceleration, zAxisModel.MmPerStep));
//6. Set the new Printhead at print speeds.
string setNewPrinthead = _setWritePrintheadModel.SetWritePrinthead(newPrintheadModel);
returnCommands.Add(setNewPrinthead);
return(returnCommands);
}
/// <summary>
/// Sets the minimum and/or maximum position of actuator-based equipment as its current position.
/// </summary>
/// <param name="commandSet"></param>
/// <returns></returns>
private List <string> InterpretSetMinMaxPosition(string commandSet)
{
//Remove "*SetMinMaxPos" from the beginning of the command set.
commandSet = commandSet.Substring(12);
for (int index = 0; index < commandSet.Length; index++)
{
switch (commandSet[index])
{
case 'E':
if (_realTimeStatusDataModel.ActivePrintheadType == PrintheadType.Motorized)
{
//Set the current position as the parameter value.
RealTimeStatusMotorizedPrintheadModel realTimeStatusMotorizedPrintheadModel = (RealTimeStatusMotorizedPrintheadModel)_realTimeStatusDataModel.ActivePrintheadModel;
MotorizedPrintheadTypeModel motorizedPrintheadTypeModel = (MotorizedPrintheadTypeModel)_printerModel.FindPrinthead(_realTimeStatusDataModel.ActivePrintheadModel.Name).PrintheadTypeModel;
double ePreviousPosition = realTimeStatusMotorizedPrintheadModel.Position;
realTimeStatusMotorizedPrintheadModel.Position = ParseDouble(commandSet.Substring(index));
double ePositionDifference = realTimeStatusMotorizedPrintheadModel.Position - ePreviousPosition;
//Set the Min or Max Position property as the parameter value.
//Adjust the Min and Max positions such that the distance between Max and Min Position remains the same.
switch (commandSet[index + 1])
{
case 'N':
motorizedPrintheadTypeModel.MinPosition = realTimeStatusMotorizedPrintheadModel.Position;
motorizedPrintheadTypeModel.MaxPosition += ePositionDifference;
break;
case 'M':
motorizedPrintheadTypeModel.MaxPosition = realTimeStatusMotorizedPrintheadModel.Position;
motorizedPrintheadTypeModel.MinPosition += ePositionDifference;
break;
default:
//Set position value only.
//Do nothing here.
break;
}
}
break;
case 'X':
//Set the current position as the parameter value.
RealTimeStatusAxisModel xRealTimeStatusAxisModel = _realTimeStatusDataModel.XRealTimeStatusAxisModel;
AxisModel xAxisModel = _printerModel.AxisModelList[0];
double xPreviousPosition = xRealTimeStatusAxisModel.Position;
xRealTimeStatusAxisModel.Position = ParseDouble(commandSet.Substring(index));
double xPositionDifference = xRealTimeStatusAxisModel.Position - xPreviousPosition;
//Set the Min or Max Position property as the parameter value.
//Adjust the Min and Max positions such that the distance between Max and Min Position remains the same.
switch (commandSet[index + 1])
{
case 'N':
xAxisModel.MinPosition = xRealTimeStatusAxisModel.Position;
xAxisModel.MaxPosition += xPositionDifference;
break;
case 'M':
xAxisModel.MaxPosition = xRealTimeStatusAxisModel.Position;
xAxisModel.MinPosition += xPositionDifference;
break;
default:
//Set position value only.
//Do nothing here.
break;
}
break;
case 'Y':
//Set the current position as the parameter value.
RealTimeStatusAxisModel yRealTimeStatusAxisModel = _realTimeStatusDataModel.YRealTimeStatusAxisModel;
AxisModel yAxisModel = _printerModel.AxisModelList[1];
double yPreviousPosition = yRealTimeStatusAxisModel.Position;
yRealTimeStatusAxisModel.Position = ParseDouble(commandSet.Substring(index));
double yPositionDifference = yRealTimeStatusAxisModel.Position - yPreviousPosition;
//Set the Min or Max Position property as the parameter value.
//Adjust the Min and Max positions such that the distance between Max and Min Position remains the same.
switch (commandSet[index + 1])
{
case 'N':
yAxisModel.MinPosition = yRealTimeStatusAxisModel.Position;
yAxisModel.MaxPosition += yPositionDifference;
break;
case 'M':
yAxisModel.MaxPosition = yRealTimeStatusAxisModel.Position;
yAxisModel.MinPosition += yPositionDifference;
break;
default:
//Set position value only.
//Do nothing here.
break;
}
break;
case 'Z':
//Set the current position as the parameter value.
RealTimeStatusAxisModel zRealTimeStatusAxisModel = _realTimeStatusDataModel.ZRealTimeStatusAxisModel;
AxisModel zAxisModel = _printerModel.FindAxis(zRealTimeStatusAxisModel.Name);
double zPreviousPosition = zRealTimeStatusAxisModel.Position;
zRealTimeStatusAxisModel.Position = ParseDouble(commandSet.Substring(index));
double zPositionDifference = zRealTimeStatusAxisModel.Position - zPreviousPosition;
//Set the Min or Max Position property as the parameter value.
//Adjust the Min and Max positions such that the distance between Max and Min Position remains the same.
switch (commandSet[index + 1])
{
case 'N':
zAxisModel.MinPosition = zRealTimeStatusAxisModel.Position;
zAxisModel.MaxPosition += zPositionDifference;
break;
case 'M':
zAxisModel.MaxPosition = zRealTimeStatusAxisModel.Position;
zAxisModel.MinPosition += zPositionDifference;
break;
default:
//Set position value only.
//Do nothing here.
break;
}
break;
}
}
OnCommandSetPositionChanged();
OnCommandSetMinMaxPositionChanged();
//No commands to return.
return(null);
}
/// <summary>
/// Interpret a center axes command set and return an array of commands.
/// </summary>
/// <param name="commandSet"></param>
/// <returns></returns>
private List <string> InterpretCenterAxes(string commandSet)
{
//Command set to be returned.
List <string> returnCommands = new List <string>();
AxisModel xAxisModel = _printerModel.AxisModelList[0];
AxisModel yAxisModel = _printerModel.AxisModelList[1];
RealTimeStatusAxisModel xRealTimeStatusAxisModel = _realTimeStatusDataModel.XRealTimeStatusAxisModel;
RealTimeStatusAxisModel yRealTimeStatusAxisModel = _realTimeStatusDataModel.YRealTimeStatusAxisModel;
double xNewPosition = xRealTimeStatusAxisModel.Position;
double yNewPosition = yRealTimeStatusAxisModel.Position;
//mmPerStep for each actuator.
double xmmPerStep = 0;
double ymmPerStep = 0;
//InvertDirection for each actuator.
bool xInvertDirection = (xAxisModel.IsDirectionInverted == false) ? false : true;
bool yInvertDirection = (yAxisModel.IsDirectionInverted == false) ? false : true;
//Distances from the center.
double xDistanceFromCenter = 0;
double yDistanceFromCenter = 0;
string[] gCodePhrases = GCodeStringParsing.GCodeTo2DArr(commandSet)[0];
foreach (string phrase in gCodePhrases)
{
switch (phrase[0])
{
case 'X':
xDistanceFromCenter = GCodeStringParsing.ParseDouble(phrase);
break;
case 'Y':
yDistanceFromCenter = GCodeStringParsing.ParseDouble(phrase);
break;
default:
//Do nothing.
break;
}
}
//Centering the actuator involves:
// 1. Finding the median position directly in the center of the max and min position.
// 2. Finding the distance between median position and the current position.
// 3. Executing that difference worth of movement.
if (commandSet.Contains("X"))
{
xNewPosition = (xAxisModel.MaxPosition - xAxisModel.MinPosition) / 2 + xAxisModel.MinPosition + xDistanceFromCenter;
xmmPerStep = xAxisModel.MmPerStep;
}
if (commandSet.Contains("Y"))
{
yNewPosition = (yAxisModel.MaxPosition - yAxisModel.MinPosition) / 2 + yAxisModel.MinPosition + yDistanceFromCenter;
ymmPerStep = yAxisModel.MmPerStep;
}
double unused = 0;
returnCommands.Add(GCodeLinesConverter.GCodeLinesListToString(
WriteG00.WriteAxesMovement(
xmmPerStep, ymmPerStep, 0,
xNewPosition - xRealTimeStatusAxisModel.Position, yNewPosition - yRealTimeStatusAxisModel.Position, 0,
xInvertDirection, yInvertDirection, false,
ref unused, ref unused, ref unused)));
return(returnCommands);
}
public void BuildConfiguration(AxisModel axis, double canvasWidth, double canvasHeight)
{
BuildConfiguration(axis.XMin, axis.XMax, axis.YMin, axis.YMax,
canvasWidth, canvasHeight,
axis.XCount, axis.YCount, axis.XStart, axis.YStart);
}
/// <summary>
/// Record the parameters from a Limit Switch status message.
/// </summary>
/// <param name="xLimit"></param>
/// <param name="yLimit"></param>
/// <param name="zLimit"></param>
/// <param name="eLimit"></param>
/// <param name="xStepsTaken"></param>
/// <param name="yStepsTaken"></param>
/// <param name="zStepsTaken"></param>
/// <param name="eStepsTaken"></param>
public void RecordLimit(bool xLimit, bool yLimit, bool zLimit, bool eLimit, int xStepsTaken, int yStepsTaken, int zStepsTaken, int eStepsTaken)
{
//E
if (_activePrintheadType == PrintheadType.Motorized)
{
//mm Per Step.
MotorizedPrintheadTypeModel motorizedPrintheadTypeModel = (MotorizedPrintheadTypeModel)_printerModel.FindPrinthead(_activePrintheadModel.Name).PrintheadTypeModel;
eStepsTaken = (motorizedPrintheadTypeModel.IsDirectionInverted == false) ? eStepsTaken : (-1 * eStepsTaken);
double emmPerStep = motorizedPrintheadTypeModel.MmPerStep;
//Update Position.
RealTimeStatusMotorizedPrintheadModel realTimeStatusMotorizedPrintheadTypeModel = (RealTimeStatusMotorizedPrintheadModel)_activePrintheadModel;
realTimeStatusMotorizedPrintheadTypeModel.Position += (double)(eStepsTaken * -1 * emmPerStep);
//Update Max/Min Position and Limit.
if (eLimit == true)
{
if (eStepsTaken > 0)
{
motorizedPrintheadTypeModel.MaxPosition = realTimeStatusMotorizedPrintheadTypeModel.Position;
realTimeStatusMotorizedPrintheadTypeModel.LimitSwitchStatus = LimitSwitchStatus.UpperLimit;
}
else if (eStepsTaken < 0)
{
motorizedPrintheadTypeModel.MinPosition = realTimeStatusMotorizedPrintheadTypeModel.Position;
realTimeStatusMotorizedPrintheadTypeModel.LimitSwitchStatus = LimitSwitchStatus.LowerLimit;
}
}
}
AxisModel xAxisModel = _printerModel.AxisModelList[0];
AxisModel yAxisModel = _printerModel.AxisModelList[1];
AxisModel zAxisModel = _printerModel.FindAxis(_zRealTimeStatusAxisModel.Name);
//mm Per Step.
double xmmPerStep = xAxisModel.MmPerStep;
double ymmPerStep = yAxisModel.MmPerStep;
double zmmPerStep = (zAxisModel != null) ? _printerModel.FindAxis(_zRealTimeStatusAxisModel.Name).MmPerStep : 0;
//Record positions.
if (xStepsTaken != 0)
{
xStepsTaken = (_printerModel.AxisModelList[0].IsDirectionInverted == false) ? xStepsTaken : (-1 * xStepsTaken);
_xRealTimeStatusAxisModel.Position += (double)(xStepsTaken * xmmPerStep);
}
if (yStepsTaken != 0)
{
yStepsTaken = (_printerModel.AxisModelList[1].IsDirectionInverted == false) ? yStepsTaken : (-1 * yStepsTaken);
_yRealTimeStatusAxisModel.Position += (double)(yStepsTaken * ymmPerStep);
}
if (zStepsTaken != 0)
{
zStepsTaken = (_printerModel.FindAxis(_zRealTimeStatusAxisModel.Name).IsDirectionInverted == false) ? zStepsTaken : (-1 * zStepsTaken);
_zRealTimeStatusAxisModel.Position += (double)(zStepsTaken * zmmPerStep);
}
//Set Max Positions and Limits.
if (xLimit == true)
{
if (xStepsTaken > 0)
{
xAxisModel.MaxPosition = _xRealTimeStatusAxisModel.Position;
_xRealTimeStatusAxisModel.LimitSwitchStatus = LimitSwitchStatus.UpperLimit;
}
else if (xStepsTaken < 0)
{
xAxisModel.MinPosition = _xRealTimeStatusAxisModel.Position;
_xRealTimeStatusAxisModel.LimitSwitchStatus = LimitSwitchStatus.LowerLimit;
}
}
if (yLimit == true)
{
if (yStepsTaken > 0)
{
yAxisModel.MaxPosition = _yRealTimeStatusAxisModel.Position;
_yRealTimeStatusAxisModel.LimitSwitchStatus = LimitSwitchStatus.UpperLimit;
}
else if (yStepsTaken < 0)
{
yAxisModel.MinPosition = _yRealTimeStatusAxisModel.Position;
_yRealTimeStatusAxisModel.LimitSwitchStatus = LimitSwitchStatus.LowerLimit;
}
}
if (zLimit == true)
{
if (zStepsTaken > 0)
{
if (_shouldZCalibrate == true)
{
zAxisModel.MaxPosition = _zRealTimeStatusAxisModel.Position;
_shouldZCalibrate = false;
}
_zRealTimeStatusAxisModel.LimitSwitchStatus = LimitSwitchStatus.UpperLimit;
}
else if (zStepsTaken < 0)
{
//The minimum Position of Z Axes are always zero.
//If the lower limit of a Z Axis is hit, then adjust the Max Position such that the range remains the same.
if (_shouldZCalibrate == true)
{
zAxisModel.MaxPosition = zAxisModel.MaxPosition + _zRealTimeStatusAxisModel.Position;
zAxisModel.MinPosition = 0;
_shouldZCalibrate = false;
}
_zRealTimeStatusAxisModel.LimitSwitchStatus = LimitSwitchStatus.LowerLimit;
}
}
//Notify other classes.
OnRecordLimitExecuted();
}
/// <summary>
/// Exposed for testing purposes.
/// </summary>
internal void SetTestModel(AxisModel testModel)
{
this.model = testModel;
}
