/// <summary>
/// Get the self test results.
/// </summary>
/// <param name="resultAvailable">A flag to indicate whether a valid result is available. A value of 1 indicates that a valid result is
/// available; otherwise, 0.</param>
/// <param name="messageMode">The type of message returned from the VCU.</param>
/// <param name="testIdentifier">The test result identifier; the interpretation of this value is dependent upon the message mode. For detailed
/// messages, this value represents the self test identifier.</param>
/// <param name="testCase">The test case number associated with the message.</param>
/// <param name="testResult">Used with the passive and logic self tests to define whether the test passed or failed. A value of 1 indicates
/// that the test passed; otherwise, the test failed.</param>
/// <param name="truckInformation">An enumerator to define the truck information associated with the message.</param>
/// <param name="variableCount">The number of variables associated with the message.</param>
/// <param name="results">An array of <see cref="InteractiveResults_t"/> structures containing the value of each self test variable associated
/// with the current interactive test.</param>
/// <exception cref="CommunicationException">Thrown if the error code returned from the call to the m_SelfTestMarshal.GetSelfTestResult() method is not
/// CommunicationError.Success.</exception>
/// <remarks>In C# the sizeof the InteractiveResults_t structure is 16 bytes as the size is rounded up to the nearest quad word. This is
/// inconsistent with the size of the InteractiveResults_t structure - 12 bytes. To ensure that the results are
/// interpreted correctly the results are passed as a byte array which is then mapped to an array of InteractiveResults structures.</remarks>
public void GetSelfTestResult(out short resultAvailable, out MessageMode messageMode, out short testIdentifier, out short testCase,
out short testResult, out TruckInformation truckInformation, out short variableCount,
out InteractiveResults_t[] results)
{
Debug.Assert(m_MutexCommuncationInterface != null,
"CommunicationSelfTest.GetSelfTestResult() - [m_MutexCommuncationInterface != null]");
results = new InteractiveResults_t[Parameter.WatchSizeInteractiveTest];
CommunicationError errorCode = CommunicationError.UnknownError;
try
{
m_MutexCommuncationInterface.WaitOne(DefaultMutexWaitDurationMs, false);
errorCode = m_SelfTestMarshal.GetSelfTestResult(out resultAvailable, out messageMode, out testIdentifier, out testCase, out testResult,
out truckInformation, out variableCount, results);
}
catch (Exception)
{
errorCode = CommunicationError.SystemException;
throw new CommunicationException("CommunicationSelfTest.GetSelfTestResult()", errorCode);
}
finally
{
m_MutexCommuncationInterface.ReleaseMutex();
}
if (DebugMode.Enabled == true)
{
DebugMode.GetSelfTestResult_t getSelfTestResult = new DebugMode.GetSelfTestResult_t(resultAvailable, messageMode, testIdentifier,
testCase, testResult, truckInformation,
variableCount, results, errorCode);
DebugMode.Write(getSelfTestResult.ToXML());
}
if (errorCode != CommunicationError.Success)
{
throw new CommunicationException("CommunicationSelfTest.GetSelfTestResult()", errorCode);
}
}
/// <summary>
/// Get the self test results.
/// </summary>
/// <param name="resultAvailable">A flag to indicate whether a valid result is available. A value of 1 indicates that a valid result is
/// available; otherwise, 0.</param>
/// <param name="messageMode">The type of message returned from the VCU.</param>
/// <param name="testIdentifier">The test result identifier; the interpretation of this value is dependent upon the message mode. For detailed
/// messages, this value represents the self test identifier.</param>
/// <param name="testCase">The test case number associated with the message.</param>
/// <param name="testResult">Used with the passive and logic self tests to define whether the test passed or failed. A value of 1 indicates
/// that the test passed; otherwise, the test failed.</param>
/// <param name="truckInformation">An enumerator to define the truck information associated with the message.</param>
/// <param name="variableCount">The number of variables associated with the message.</param>
/// <param name="results">An array of <see cref="InteractiveResults_t"/> structures containing the value of each self test variable associated
/// with the current interactive test.</param>
/// <exception cref="CommunicationException">Thrown if the error code returned from the call to the PTUDLL32.GetSelfTestResult() method is not
/// CommunicationError.Success.</exception>
/// <remarks>In C# the sizeof the InteractiveResults_t structure is 16 bytes as the size is rounded up to the nearest quad word. This is
/// inconsistent with the size of the InteractiveResults_t structure used in PTUDLL32.dll - 12 bytes. To ensure that the results are
/// interpreted correctly the results are passed as a byte array which is then mapped to an array of InteractiveResults structures.</remarks>
public void GetSelfTestResult(out short resultAvailable, out MessageMode messageMode, out short testIdentifier, out short testCase,
out short testResult, out TruckInformation truckInformation, out short variableCount,
out InteractiveResults_t[] results)
{
Debug.Assert(m_MutexCommuncationInterface != null,
"CommunicationSelfTest.GetSelfTestResult() - [m_MutexCommuncationInterface != null]");
results = new InteractiveResults_t[Parameter.WatchSizeInteractiveTest];
CommunicationError errorCode = CommunicationError.UnknownError;
try
{
m_MutexCommuncationInterface.WaitOne(DefaultMutexWaitDurationMs, false);
errorCode = m_SelfTestMarshal.GetSelfTestResult(out resultAvailable, out messageMode, out testIdentifier, out testCase, out testResult,
out truckInformation, out variableCount, results);
}
catch (Exception)
{
errorCode = CommunicationError.SystemException;
throw new CommunicationException("CommunicationSelfTest.GetSelfTestResult()", errorCode);
}
finally
{
m_MutexCommuncationInterface.ReleaseMutex();
}
if (DebugMode.Enabled == true)
{
DebugMode.GetSelfTestResult_t getSelfTestResult = new DebugMode.GetSelfTestResult_t(resultAvailable, messageMode, testIdentifier,
testCase, testResult, truckInformation,
variableCount, results, errorCode);
DebugMode.Write(getSelfTestResult.ToXML());
}
if (errorCode != CommunicationError.Success)
{
throw new CommunicationException("CommunicationSelfTest.GetSelfTestResult()", errorCode);
}
}
/// <summary>
/// Get the self test results.
/// </summary>
/// <param name="resultAvailable">A flag to indicate whether a valid result is available. A value of 1 indicates that a valid result is
/// available; otherwise, 0.</param>
/// <param name="messageMode">The type of message returned from the VCU.</param>
/// <param name="testIdentifier">The test result identifier; the interpretation of this value is dependent upon the message mode. For detailed
/// messages, this value represents the self test identifier.</param>
/// <param name="testCase">The test case number associated with the message.</param>
/// <param name="testResult">Used with the passive and logic self tests to define whether the test passed or failed. A value of 1 indicates
/// that the test passed; otherwise, the test failed.</param>
/// <param name="truckInformation">An enumerator to define the truck information associated with the message.</param>
/// <param name="variableCount">The number of variables associated with the message.</param>
/// <param name="results">An array of <see cref="InteractiveResults_t"/> structures containing the value of each self test variable associated
/// with the current interactive test.</param>
/// <exception cref="CommunicationException">Thrown if the error code returned from the call to the PTUDLL32.GetSelfTestResult() method is not
/// CommunicationError.Success.</exception>
/// <remarks>In C# the sizeof the InteractiveResults_t structure is 16 bytes as the size is rounded up to the nearest quad word. This is
/// inconsistent with the size of the InteractiveResults_t structure used in PTUDLL32.dll - 12 bytes. To ensure that the results are
/// interpreted correctly the results are passed as a byte array which is then mapped to an array of InteractiveResults structures.</remarks>
public unsafe void GetSelfTestResult(out short resultAvailable, out MessageMode messageMode, out short testIdentifier, out short testCase,
out short testResult, out TruckInformation truckInformation, out short variableCount,
out InteractiveResults_t[] results)
{
// Check that the function delegate has been initialized.
Debug.Assert(m_GetSelfTestResult != null,
"CommunicationSelfTest.GetSelfTestResult() - [m_GetSelfTestResult != null]");
Debug.Assert(m_MutexCommuncationInterface != null,
"CommunicationSelfTest.GetSelfTestResult() - [m_MutexCommuncationInterface != null]");
results = new InteractiveResults_t[Parameter.WatchSizeInteractiveTest];
int sizeOfInteractiveResultInPTUDLL32 = sizeof(double) + sizeof(int);
byte[] interactiveResultsAsByteArray = new byte[Parameter.WatchSizeInteractiveTest * sizeOfInteractiveResultInPTUDLL32];
CommunicationError errorCode = CommunicationError.UnknownError;
try
{
m_MutexCommuncationInterface.WaitOne(DefaultMutexWaitDurationMs, false);
unsafe
{
fixed(byte *interactiveResults = &interactiveResultsAsByteArray[0])
{
errorCode = (CommunicationError)m_GetSelfTestResult(out resultAvailable, out messageMode,
out testIdentifier, out testCase, out testResult,
out truckInformation, out variableCount,
interactiveResults);
}
}
}
catch (Exception)
{
errorCode = CommunicationError.SystemException;
throw new CommunicationException("CommunicationSelfTest.GetSelfTestResult()", errorCode);
}
finally
{
m_MutexCommuncationInterface.ReleaseMutex();
}
// Convert the byte array returned from the call to an array of InteractiveResults_t structures.
int offset = 0;
for (int index = 0; index < variableCount; index++)
{
offset = index * sizeOfInteractiveResultInPTUDLL32;
results[index].Value = BitConverter.ToDouble(interactiveResultsAsByteArray, offset);
results[index].Tag = BitConverter.ToInt32(interactiveResultsAsByteArray, offset + sizeof(double));
}
if (DebugMode.Enabled == true)
{
DebugMode.GetSelfTestResult_t getSelfTestResult = new DebugMode.GetSelfTestResult_t(resultAvailable, messageMode, testIdentifier,
testCase, testResult, truckInformation,
variableCount, results, errorCode);
DebugMode.Write(getSelfTestResult.ToXML());
}
if (errorCode != CommunicationError.Success)
{
throw new CommunicationException("CommunicationSelfTest.GetSelfTestResult()", errorCode);
}
}
/// <summary>
/// Get the self test results.
/// </summary>
/// <param name="resultAvailable">A flag to indicate whether a valid result is available. A value of 1 indicates that a valid result is
/// available; otherwise, 0.</param>
/// <param name="messageMode">The type of message returned from the VCU.</param>
/// <param name="testIdentifier">The test result identifier; the interpretation of this value is dependent upon the message mode. For detailed
/// messages, this value represents the self test identifier.</param>
/// <param name="testCase">The test case number associated with the message.</param>
/// <param name="testResult">Used with the passive and logic self tests to define whether the test passed or failed. A value of 1 indicates
/// that the test passed; otherwise, the test failed.</param>
/// <param name="truckInformation">An enumerator to define the truck information associated with the message.</param>
/// <param name="variableCount">The number of variables associated with the message.</param>
/// <param name="results">An array of <see cref="InteractiveResults_t"/> structures containing the value of each self test variable associated
/// with the current interactive test.</param>
/// <exception cref="CommunicationException">Thrown if the error code returned from the call to the PTUDLL32.GetSelfTestResult() method is not
/// CommunicationError.Success.</exception>
/// <remarks>In C# the sizeof the InteractiveResults_t structure is 16 bytes as the size is rounded up to the nearest quad word. This is
/// inconsistent with the size of the InteractiveResults_t structure used in PTUDLL32.dll - 12 bytes. To ensure that the results are
/// interpreted correctly the results are passed as a byte array which is then mapped to an array of InteractiveResults structures.</remarks>
public unsafe void GetSelfTestResult(out short resultAvailable, out MessageMode messageMode, out short testIdentifier, out short testCase,
out short testResult, out TruckInformation truckInformation, out short variableCount,
out InteractiveResults_t[] results)
{
// Check that the function delegate has been initialized.
Debug.Assert(m_GetSelfTestResult != null,
"CommunicationSelfTest.GetSelfTestResult() - [m_GetSelfTestResult != null]");
Debug.Assert(m_MutexCommuncationInterface != null,
"CommunicationSelfTest.GetSelfTestResult() - [m_MutexCommuncationInterface != null]");
results = new InteractiveResults_t[Parameter.WatchSizeInteractiveTest];
int sizeOfInteractiveResultInPTUDLL32 = sizeof(double) + sizeof(int);
byte[] interactiveResultsAsByteArray = new byte[Parameter.WatchSizeInteractiveTest * sizeOfInteractiveResultInPTUDLL32];
CommunicationError errorCode = CommunicationError.UnknownError;
try
{
m_MutexCommuncationInterface.WaitOne(DefaultMutexWaitDurationMs, false);
unsafe
{
fixed (byte* interactiveResults = &interactiveResultsAsByteArray[0])
{
errorCode = (CommunicationError)m_GetSelfTestResult(out resultAvailable, out messageMode,
out testIdentifier, out testCase, out testResult,
out truckInformation, out variableCount,
interactiveResults);
}
}
}
catch (Exception)
{
errorCode = CommunicationError.SystemException;
throw new CommunicationException("CommunicationSelfTest.GetSelfTestResult()", errorCode);
}
finally
{
m_MutexCommuncationInterface.ReleaseMutex();
}
// Convert the byte array returned from the call to an array of InteractiveResults_t structures.
int offset = 0;
for (int index = 0; index < variableCount; index++)
{
offset = index * sizeOfInteractiveResultInPTUDLL32;
results[index].Value = BitConverter.ToDouble(interactiveResultsAsByteArray, offset);
results[index].Tag = BitConverter.ToInt32(interactiveResultsAsByteArray, offset + sizeof(double));
}
if (DebugMode.Enabled == true)
{
DebugMode.GetSelfTestResult_t getSelfTestResult = new DebugMode.GetSelfTestResult_t(resultAvailable, messageMode, testIdentifier,
testCase, testResult, truckInformation,
variableCount, results, errorCode);
DebugMode.Write(getSelfTestResult.ToXML());
}
if (errorCode != CommunicationError.Success)
{
throw new CommunicationException("CommunicationSelfTest.GetSelfTestResult()", errorCode);
}
}