/// <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 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 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) { messageMode = MessageMode.Brief; testCase = 0; testResult = ResultPassed; truckInformation = TruckInformation.None; resultAvailable = ResultAvailable; if ((m_UserAbort == false) && (m_LoopsExecuted < m_STLoopCount) && (m_QueuedTestList.Count > 0)) { testIdentifier = (short)m_QueuedTestList[m_CurrentTestIndex]; m_CurrentTestIndex += 1; if (m_CurrentTestIndex >= m_QueuedTestList.Count) { m_CurrentTestIndex = 0; m_LoopsExecuted += 1; } } else { if (m_UserAbort == true) { testIdentifier = (short)SpecialMessageIdentifier.TestAborted; m_UserAbort = false; } else { testIdentifier = (short)SpecialMessageIdentifier.TestComplete; } messageMode = MessageMode.Special; variableCount = 0; results = new InteractiveResults_t[0]; m_LoopsExecuted = 0; m_CurrentTestIndex = 0; return; } try { List <SelfTestVariable> variableList = Lookup.SelfTestTableBySelfTestNumber.Items[testIdentifier].SelfTestVariableList; variableCount = (short)variableList.Count; throw new Exception(); } catch { variableCount = 0; } results = new InteractiveResults_t[variableCount]; for (int index = 0; index < variableCount; index++) { results[index].Value = 0.0; results[index].Tag = 0; } }
/// <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); } }