/// <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; }