/// <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 initial values for all data.
/// </summary>
private void InitializeRealTimeStatusDataModel()
{
_xRealTimeStatusAxisModel = new RealTimeStatusAxisModel("Unset", 0, 0, 0);
_yRealTimeStatusAxisModel = new RealTimeStatusAxisModel("Unset", 0, 0, 0);
_zRealTimeStatusAxisModel = new RealTimeStatusAxisModel("Unset", 0, 0, 0);
_activePrintheadType = PrintheadType.Unset;
_activePrintheadModel = new RealTimeStatusUnsetPrintheadModel("Unset");
}
/// <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 RealTimeStatusAxisViewModel(RealTimeStatusAxisModel RealTimeStatusAxisModel)
{
_realTimeStatusAxisModel = RealTimeStatusAxisModel;
UpdateProperties();
}
