public override bool ProcessUnsignedIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, uint value)
{
bool result = false;
if (valueType.Type == TAGDataType.t4bitUInt && value <= 3) // Check only the two least significant bits are set
{
valueSink.SetInAvoidZoneState((byte)value);
result = true;
}
return(result);
}
public override bool ProcessUnsignedIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, uint value)
{
if (valueType.Type == TAGDataType.t8bitUInt &&
(value == (byte)ElevationMappingMode.LatestElevation ||
value == (byte)ElevationMappingMode.MinimumElevation))
{
valueSink.SetElevationMappingModeState((ElevationMappingMode)value);
return(true);
}
return(false);
}
public override bool ProcessUnsignedIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, uint value)
{
bool result = false;
if (valueType.Type == TAGDataType.t4bitUInt && value <= 2) // Sonic state currently only defines three states
{
valueSink.ICSonic3D = (byte)value;
result = true;;
}
return(result);
}
public override bool ProcessUnsignedIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, uint value)
{
bool result = false;
if (valueType.Type == TAGDataType.t8bitUInt)
{
valueSink.SetICCCALeftRearValue((byte)value);
result = true;
}
return(result);
}
public override bool ProcessIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, int value)
{
// Position value is integer number of millimeters offset from the current position
bool result = false;
if (state.HaveSeenAnAbsoluteRearPosition)
{
if (valueType.Name == TAGValueNames.kTagFileEastingRearTag)
{
if (state.RearSide == TAGValueSide.Left)
{
valueSink.DataRearLeft.X += (double)value / 1000;
}
else
{
valueSink.DataRearRight.X += (double)value / 1000;
}
result = true;
}
else if (valueType.Name == TAGValueNames.kTagFileNorthingRearTag)
{
if (state.RearSide == TAGValueSide.Left)
{
valueSink.DataRearLeft.Y += (double)value / 1000;
}
else
{
valueSink.DataRearRight.Y += (double)value / 1000;
}
result = true;
}
else if (valueType.Name == TAGValueNames.kTagFileElevationRearTag)
{
if (state.RearSide == TAGValueSide.Left)
{
valueSink.DataRearLeft.Z += (double)value / 1000;
}
else
{
valueSink.DataRearRight.Z += (double)value / 1000;
}
result = true;
}
}
return(result);
}
public override bool ProcessUnsignedIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, uint value)
{
bool result = false;
// Value is the absolute CCV value
if (valueType.Type == TAGDataType.t16bitUInt)
{
valueSink.ICTargetLiftThickness = (float)value / 1000;
result = true;
}
return(result);
}
public override bool ProcessUnsignedIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, uint value)
{
bool result = false;
// Value is a minimum temperature warning level value...
if (valueType.Type == TAGDataType.t12bitUInt)
{
valueSink.ICTempWarningLevelMinValue = (ushort)(value * CellPassConsts.MaterialTempValueRatio);
result = true;
}
return(result);
}
public override bool ProcessUnsignedIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, uint value)
{
bool result = false;
// Value is the absolute MDP value
if (valueType.Type == TAGDataType.t12bitUInt)
{
valueSink.ICMDPTargetValue = (short)value;
result = true;
}
return(result);
}
public override bool ProcessEmptyValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType)
{
if (!state.ProofingRunProcessed)
{
state.ProofingRunProcessed = valueSink.ProcessEpochContext();
}
valueSink.StartProofing = "";
SetProofingRunStartTime(state, valueSink);
return(true);
}
public override bool ProcessUnsignedIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, uint value)
{
bool result = false;
if (valueType.Type == TAGDataType.t4bitUInt &&
(value >= MachineGearConsts.MACHINE_GEAR_MIN_VALUE && value <= MachineGearConsts.MACHINE_GEAR_MAX_VALUE))
{
valueSink.ICGear = (MachineGear)value;
result = true;
}
return(result);
}
public override bool ProcessUnsignedIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, uint value)
{
bool result = false;
if (valueType.Type == TAGDataType.t4bitUInt &&
(value >= OnGroundStateConsts.ON_GROUND_STATE_MIN_VALUE && value <= OnGroundStateConsts.ON_GROUND_STATE_MAX_VALUE))
{
valueSink.SetOnGround((OnGroundState)value);
result = true;
}
return(result);
}
public void Test_TAGFile_Read_File()
{
// Create the TAG file and reader classes
TAGFile file = new TAGFile();
// Create the state and sink
TAGProcessorStateBase stateBase = new TAGProcessorStateBase(); // Derivatives to construct later
TAGValueSink sink = new TAGValueSink(stateBase);
//Read the TAG file
TAGReadResult result = file.Read(Path.Combine("TestData", "TAGFiles", "TestTAGFile-TAGFile-Read-File.tag"), sink);
Assert.Equal(TAGReadResult.NoError, result);
}
public override bool ProcessUnsignedIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, uint value)
{
bool result = false;
if (valueType.Type == TAGDataType.t12bitUInt)
{
valueSink.SetVolkelMeasUtilRange((int)value);
state.HaveSeenAnAbsoluteVolkelMeasUtilRange = true;
result = true;
}
return(result);
}
public override bool ProcessDoubleValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, double value)
{
state.HaveSeenAnAbsoluteTrackPosition = true;
if (valueType.Name == TAGValueNames.kTagFileEastingTrackTag)
{
if (state.TrackSide == TAGValueSide.Left)
{
valueSink.DataTrackLeft.X = value;
}
else
{
valueSink.DataTrackRight.X = value;
}
return(true);
}
if (valueType.Name == TAGValueNames.kTagFileNorthingTrackTag)
{
if (state.TrackSide == TAGValueSide.Left)
{
valueSink.DataTrackLeft.Y = value;
}
else
{
valueSink.DataTrackRight.Y = value;
}
return(true);
}
if (valueType.Name == TAGValueNames.kTagFileElevationTrackTag)
{
if (state.TrackSide == TAGValueSide.Left)
{
valueSink.DataTrackLeft.Z = value;
}
else
{
valueSink.DataTrackRight.Z = value;
}
return(true);
}
return(false);
}
public override bool ProcessDoubleValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, double value)
{
// Value is absolute wheel width expressed in
bool result = false;
if (valueType.Type == TAGDataType.tIEEEDouble)
{
valueSink.MachineWheelWidth = value;
result = true;
}
return(result);
}
public void Test_TAGProcessorStateBase_SetAndGetMachineDirection()
{
var state = new TAGProcessorStateBase();
// Note: Machine direction cannot be set after a gear value is selected
Assert.Equal(MachineDirection.Unknown, state.MachineDirection);
state.SetMachineDirection(MachineDirection.Forward);
Assert.Equal(MachineDirection.Forward, state.MachineDirection);
state.ICGear = MachineGear.Forward;
state.SetMachineDirection(MachineDirection.Reverse);
Assert.NotEqual(MachineDirection.Reverse, state.MachineDirection);
}
public override bool ProcessUnsignedIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, uint value)
{
state.HaveSeenAnAbsoluteAmplitude = true;
bool result = false;
if (valueType.Type == TAGDataType.t12bitUInt)
{
valueSink.SetICAmplitude((ushort)value);
result = true;
}
return(result);
}
public override bool ProcessDoubleValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, double value)
{
state.HaveSeenAnAbsoluteRearPosition = true;
bool result = false;
if (valueType.Name == TAGValueNames.kTagFileEastingRearTag)
{
if (state.RearSide == TAGValueSide.Left)
{
valueSink.DataRearLeft.X = value;
}
else
{
valueSink.DataRearRight.X = value;
}
result = true;
}
else if (valueType.Name == TAGValueNames.kTagFileNorthingRearTag)
{
if (state.RearSide == TAGValueSide.Left)
{
valueSink.DataRearLeft.Y = value;
}
else
{
valueSink.DataRearRight.Y = value;
}
result = true;
}
else if (valueType.Name == TAGValueNames.kTagFileElevationRearTag)
{
if (state.RearSide == TAGValueSide.Left)
{
valueSink.DataRearLeft.Z = value;
}
else
{
valueSink.DataRearRight.Z = value;
}
result = true;
}
return(result);
}
public override bool ProcessUnsignedIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, uint value)
{
bool result = false;
var testValue = value - 1; // Direction value in tag file is 1-based
if (valueType.Type == TAGDataType.t4bitUInt &&
(testValue >= MachineDirectionConsts.MACHINE_DIRECTION_MIN_VALUE && testValue <= MachineDirectionConsts.MACHINE_DIRECTION_MAX_VALUE))
{
valueSink.MachineDirection = (MachineDirection)testValue;
result = true;
}
return(result);
}
public override bool ProcessDoubleValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, double value)
{
if (state.GPSBasePositionReportingHaveStarted)
{
valueSink.GPSBaseLon = value;
state.GPSBasePositionReportingHaveStarted = !valueSink.GPSBaseLLHReceived;
}
else
{
valueSink.LLHLon = value;
state.HaveSeenAnLLHPosition = valueSink.LLHReceived;
}
return(true);
}
public override bool ProcessEmptyValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType)
{
state.HaveSeenAnAbsoluteTrackPosition = false;
if (state.TrackSide == TAGValueSide.Left)
{
valueSink.DataTrackLeft = XYZ.Null;
}
else
{
valueSink.DataTrackRight = XYZ.Null;
}
return(true);
}
public void Test_TAGProcessorStateBase_HaveReceivedValidRearPositions()
{
var state = new TAGProcessorStateBase();
Assert.False(state.HaveReceivedValidRearPositions, "Initial value incorrect");
state.DataRearLeft = new XYZ(10.0, 10.0, 10.0);
state.DataRearRight.X = 10.0;
state.DataRearRight.Y = 10.0;
Assert.False(state.HaveReceivedValidRearPositions, "Value incorrect after setting");
state.DataRearRight.Z = 10.0;
Assert.True(state.HaveReceivedValidRearPositions, "Value incorrect after setting");
}
public override bool ProcessIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, int value)
{
bool result = false;
if (state.HaveSeenAnAbsoluteAmplitude &&
(valueType.Type == TAGDataType.t4bitInt || valueType.Type == TAGDataType.t8bitInt))
{
if (((ushort)(valueSink.ICAmplitudes.GetLatest()) + value) >= 0)
{
valueSink.SetICAmplitude((ushort)((ushort)(valueSink.ICAmplitudes.GetLatest()) + value));
result = true;
}
}
return(result);
}
public override bool ProcessIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, int value)
{
bool result = false;
if (state.HaveSeenAnAbsoluteVolkelMeasUtilRange &&
(valueType.Type == TAGDataType.t4bitInt || valueType.Type == TAGDataType.t8bitInt))
{
if (((int)valueSink.VolkelMeasureUtilRanges.GetLatest() + value) >= 0)
{
valueSink.SetVolkelMeasUtilRange((int)valueSink.VolkelMeasureUtilRanges.GetLatest() + value);
result = true;
}
}
return(result);
}
public override bool ProcessEmptyValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType)
{
bool result = false;
if (valueType.Name == TAGValueNames.kTagFileLeftRearTag)
{
state.RearSide = TAGValueSide.Left;
result = true;
}
else if (valueType.Name == TAGValueNames.kTagFileRightRearTag)
{
state.RearSide = TAGValueSide.Right;
result = true;
}
return(result);
}
public void Test_TAGFile_Read_Stream()
{
// Create the TAG file and reader classes
TAGFile file = new TAGFile();
using (var reader = new TAGReader(new FileStream(
Path.Combine("TestData", "TAGFiles", "TestTAGFile-TAGFile-Read-Stream.tag"), FileMode.Open,
FileAccess.Read)))
{
// Create the state and sink
TAGProcessorStateBase stateBase = new TAGProcessorStateBase(); // Derivatives to construct later
TAGValueSink sink = new TAGValueSink(stateBase);
//Read the TAG file
TAGReadResult result = file.Read(reader, sink);
Assert.Equal(TAGReadResult.NoError, result);
}
}
public override bool ProcessUnsignedIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, uint value)
{
bool result = false;
if (valueType.Type == TAGDataType.t4bitUInt &&
(value >= CoordinateSystemTypeConsts.COORDINATE_SYSTEM_MIN_VALUE && value <= CoordinateSystemTypeConsts.COORDINATE_SYSTEM_MAX_VALUE))
{
valueSink.CSType = (CoordinateSystemType)value;
if (valueSink.CSType == CoordinateSystemType.ACS)
{
valueSink.IsCSIBCoordSystemTypeOnly = false;
}
result = true;
}
return(result);
}
public override bool ProcessUnsignedIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, uint value)
{
bool result = false;
if (valueType.Name == TAGValueNames.kTagFileStartProofingTimeTag)
{
// Every time record marks the end of the collected data for an epoch
// Thus, we instruct the value sink to process its context whenever we receive a time value.
if (state.HaveSeenAProofingRunTimeValue && !valueSink.ProcessEpochContext())
{
return(false);
}
if (valueType.Type == TAGDataType.t32bitUInt)
{
valueSink.StartProofingTime = value; // Time value is GPS milliseconds since start of week
state.HaveSeenAProofingRunTimeValue = true;
result = true;
}
}
if (valueType.Name == TAGValueNames.kTagFileStartProofingWeekTag)
{
if (valueType.Type == TAGDataType.t16bitUInt)
{
valueSink.StartProofingWeek = (short)value;
state.HaveSeenAProofingRunWeekValue = true;
result = true;
}
}
// if we have seen both a GPS week and time then we can compute the DataTime
// value for the value sink
if (result && state.HaveSeenAProofingRunTimeValue && state.HaveSeenAProofingRunWeekValue)
{
valueSink.StartProofingDataTime = GPS.GPSOriginTimeToDateTime(valueSink.StartProofingWeek, valueSink.StartProofingTime);
}
return(result);
}
public override bool ProcessUnsignedIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, uint value)
{
bool result = false;
if (valueType.Type == TAGDataType.t8bitUInt)
{
valueSink.UTMZone = (byte)value;
if (!state.HaveSeenAUTMZone)
{
valueSink.UTMZoneAtFirstPosition = (byte)value;
state.HaveSeenAUTMZone = true;
}
result = true;
}
return(result);
}
public override bool ProcessUnsignedIntegerValue(TAGValueMatcherState state, TAGProcessorStateBase valueSink,
TAGDictionaryItem valueType, uint value)
{
bool result = valueType.Type == TAGDataType.t16bitUInt;
if (result)
{
GPSAccuracy Accuracy;
// Shift bits right so that we can check the top 2 bits
ushort WordToCheck = (ushort)(value >> 14); //16-bit UINT
switch (WordToCheck)
{
case 0:
Accuracy = GPSAccuracy.Fine;
break;
case 1:
Accuracy = GPSAccuracy.Medium;
break;
case 2:
Accuracy = GPSAccuracy.Coarse;
break;
default:
Accuracy = GPSAccuracy.Unknown;
break;
}
// Lose the top 2 bits; what remains is the error limit in mm
ushort ErrorLimit = (ushort)(value & 0x3fff);
valueSink.SetGPSAccuracyState(Accuracy, ErrorLimit);
}
return(result);
}