/// <summary> /// This method is used to send a command to the embedded PTU target using the type of /// device specified in the argument. The difference between this method and the 3 parameter /// method of the same name is that this method is used when there is no payload with the command. /// </summary> /// <param name="commDevice">The comm device used to communicate with target</param> /// <param name="packetRequestType">The command sent to the target</param> /// <returns>CommunicationError.Success (0) if all is well; otherwise another enumeration which is less than 0</returns> public CommunicationError SendCommandToEmbedded(ICommDevice commDevice, ProtocolPTU.PacketType packetRequestType) { // Send the SOM and receive it CommunicationError commError = (CommunicationError)commDevice.SendReceiveSOM(); // Verify the sending and receiving of SOM is /RX OK if (commError != CommunicationError.Success) { return(commError); } // Create the message header for a command and command type; "null" as 1st argument indicates no payload ProtocolPTU.DataPacketProlog dpp = new ProtocolPTU.DataPacketProlog(); Byte[] txMessage = dpp.GetByteArray(null, packetRequestType, ProtocolPTU.ResponseType.COMMANDRESPONSE, commDevice.IsTargetBigEndian()); // Send the command to the target Int32 errorCode = commDevice.SendMessageToTarget(txMessage); // Verify the command was sent without errors if (errorCode < 0) { return(CommunicationError.BadRequest); } // Since no return data is expected, verify the embedded target responds with an Acknowledge (implicit // acknowledge with TCP, but 232 has no such entity errorCode = commDevice.ReceiveTargetAcknowledge(); if (errorCode < 0) { return(CommunicationError.BadResponse); } return(CommunicationError.Success); }
/// <summary> /// This method is used to send a data request to the embedded PTU target using the type of /// device specified in the argument. The difference between this method and the method of the same name /// is that this method is used when there is NO payload with the data request. /// </summary> /// <param name="commDevice">The comm device used to communicate with target</param> /// <param name="packetRequestType">The command sent to the target</param> /// <param name="rxMessage">Used to store the response from the embedded target</param> /// <returns>CommunicationError.Success (0) if all is well; otherwise another enumeration which is less than 0</returns> public CommunicationError SendDataRequestToEmbedded(ICommDevice commDevice, ProtocolPTU.PacketType packetRequestType, Byte[] rxMessage) { // Send the SOM and receive it CommunicationError commError = (CommunicationError)commDevice.SendReceiveSOM(); // Verify the sending and receiving of SOM is /RX OK if (commError != CommunicationError.Success) { return(commError); } // Create the message header for a command and command type; "null" as 1st argument indicates no payload ProtocolPTU.DataPacketProlog dpp = new ProtocolPTU.DataPacketProlog(); Byte[] txMessage = dpp.GetByteArray(null, packetRequestType, ProtocolPTU.ResponseType.DATARESPONSE, commDevice.IsTargetBigEndian()); // Send the command to the target Int32 errorCode = commDevice.SendMessageToTarget(txMessage); if (errorCode < 0) { return(CommunicationError.BadRequest); } // Verify the target responds with data errorCode = commDevice.ReceiveTargetDataPacket(rxMessage); if (errorCode < 0) { return(CommunicationError.BadResponse); } return(CommunicationError.Success); }
/// <summary> /// This method is used to send a command to the embedded PTU target using the type of /// device specified in the argument. The difference between this method and the 2 parameter /// method of the same name is that this method is used when there is a payload with the command. /// </summary> /// <param name="commDevice">The comm device used to communicate with target</param> /// <param name="requestObj">This object is a request that already has the all of the necessary payload /// parameters ready to be formed into a message to be sent to embedded target</param> /// <returns>CommunicationError.Success (0) if all is well; otherwise another enumeration which is less than 0</returns> public CommunicationError SendCommandToEmbedded(ICommDevice commDevice, ICommRequest requestObj) { // Send the SOM and receive it CommunicationError commError = (CommunicationError)commDevice.SendReceiveSOM(); // Verify the sending and receiving of SOM is /RX OK if (commError != CommunicationError.Success) { return(commError); } // Create the message header and payload for a command and command type Byte[] txMessage = requestObj.GetByteArray(commDevice.IsTargetBigEndian()); // Send the command and payload to the target Int32 errorCode = commDevice.SendMessageToTarget(txMessage); // Verify the command was sent without errors if (errorCode < 0) { return(CommunicationError.BadRequest); } // Since no return data is expected, verify the embedded target responds with an Acknowledge (implicit // acknowledge with TCP, but 232 has no such entity errorCode = commDevice.ReceiveTargetAcknowledge(); if (errorCode < 0) { return(CommunicationError.BadResponse); } return(CommunicationError.Success); }
/// <summary> /// This method is used to send a data request to the embedded PTU target using the type of /// device specified in the argument. The difference between this method and the method of the same name /// is that this method is used when there is a payload with the data request. /// </summary> /// <param name="commDevice">The comm device used to communicate with target</param> /// <param name="requestObj">This object is a request that already has the all of the necessary payload /// parameters ready to be formed into a message to be sent to embedded target</param> /// <param name="rxMessage">Used to store the response from the embedded target</param> /// <returns>CommunicationError.Success (0) if all is well; otherwise another enumeration which is less than 0</returns> public CommunicationError SendDataRequestToEmbedded(ICommDevice commDevice, ICommRequest requestObj, Byte[] rxMessage) { // Send the SOM and receive it CommunicationError commError = (CommunicationError)commDevice.SendReceiveSOM(); // Verify the sending and receiving of SOM is /RX OK if (commError != CommunicationError.Success) { return(commError); } // Create the message header and payload for a command and command type Byte[] txMessage = requestObj.GetByteArray(commDevice.IsTargetBigEndian()); // Send the command and payload to the target Int32 errorCode = commDevice.SendMessageToTarget(txMessage); if (errorCode < 0) { return(CommunicationError.BadRequest); } // Verify the target responds with data errorCode = commDevice.ReceiveTargetDataPacket(rxMessage); if (errorCode < 0) { return(CommunicationError.BadResponse); } return(CommunicationError.Success); }
/// <summary> /// Exit the self test task. /// </summary> /// <remarks>This request will end the self test process on the VCU.</remarks> /// <param name="result">The result of the call. A value of: (1) 1 represents success; (2) indicates that the error message defined by the /// <paramref name="reason"/> parameter applies and (3) represents an unknown error.</param> /// <param name="reason">A value of 1 represents success; otherwise, the value is mapped to the <c>ERRID</c> field of the /// <c>SELFTESTERRMESS</c> table /// of the data dictionary in order to determine the error message returned from the VCU.</param> /// <exception cref="CommunicationException">Thrown if the error code returned from the call to the m_SelfTestMarshal.ExitSelfestTask() method is not /// CommunicationError.Success.</exception> public void ExitSelfTestTask(out short result, out short reason) { Debug.Assert(m_MutexCommuncationInterface != null, "CommunicationSelfTest.ExitSelfTestTask() - [m_MutexCommuncationInterface != null]"); CommunicationError errorCode = CommunicationError.UnknownError; try { m_MutexCommuncationInterface.WaitOne(DefaultMutexWaitDurationMs, false); errorCode = m_SelfTestMarshal.ExitSelfTestTask(out result, out reason); } catch (Exception) { errorCode = CommunicationError.SystemException; throw new CommunicationException("CommunicationSelfTest.ExitSelfTestTask()", errorCode); } finally { m_MutexCommuncationInterface.ReleaseMutex(); } if (DebugMode.Enabled == true) { DebugMode.ExitSelfTestTask_t exitSelfTestTask = new DebugMode.ExitSelfTestTask_t(result, reason, errorCode); DebugMode.Write(exitSelfTestTask.ToXML()); } if (errorCode != CommunicationError.Success) { throw new CommunicationException("CommunicationSelfTest.ExitSelfestTask()", errorCode); } }
/// <summary> /// Run the predefined self tests associated with the specified test list identifier, these tests are defined in the data dictionary. /// </summary> /// <param name="testListIdentifier">The test list identifier of the predefined self tests that are to be executed.</param> /// <exception cref="CommunicationException">Thrown if the error code returned from the call to the m_SelfTestMarshal.RunPredefinedSTTests() method is /// not CommunicationError.Success.</exception> public void RunPredefinedSTTests(short testListIdentifier) { Debug.Assert(m_MutexCommuncationInterface != null, "CommunicationSelfTest.RunPredefinedSTTests() - [m_MutexCommuncationInterface != null]"); CommunicationError errorCode = CommunicationError.UnknownError; try { m_MutexCommuncationInterface.WaitOne(DefaultMutexWaitDurationMs, false); errorCode = m_SelfTestMarshal.RunPredefinedSTTests(testListIdentifier); } catch (Exception) { errorCode = CommunicationError.SystemException; throw new CommunicationException("CommunicationSelfTest.RunPredefinedSTTests()", errorCode); } finally { m_MutexCommuncationInterface.ReleaseMutex(); } if (DebugMode.Enabled == true) { DebugMode.RunPredefinedSTTests_t runPredefinedSTTests = new DebugMode.RunPredefinedSTTests_t(testListIdentifier, errorCode); DebugMode.Write(runPredefinedSTTests.ToXML()); } if (errorCode != CommunicationError.Success) { throw new CommunicationException("CommunicationSelfTest.RunPredefinedSTTests()", errorCode); } }
/// <summary> /// Update the self test mode. /// </summary> /// <remarks>This call is used to check whether communication with the VCU has been lost.</remarks> /// <param name="selfTestMode">The required self test mode.</param> /// <exception cref="CommunicationException">Thrown if the error code returned from the call to the m_SelfTestMarshal.UpdateSTMode() method is not /// CommunicationError.Success.</exception> public void UpdateSTMode(SelfTestMode selfTestMode) { Debug.Assert(m_MutexCommuncationInterface != null, "CommunicationSelfTest.UpdateSTMode() - [m_MutexCommuncationInterface != null]"); CommunicationError errorCode = CommunicationError.UnknownError; try { m_MutexCommuncationInterface.WaitOne(DefaultMutexWaitDurationMs, false); errorCode = m_SelfTestMarshal.UpdateSTMode((Int16)selfTestMode); } catch (Exception) { errorCode = CommunicationError.SystemException; throw new CommunicationException("CommunicationSelfTest.UpdateSTMode()", errorCode); } finally { m_MutexCommuncationInterface.ReleaseMutex(); } if (DebugMode.Enabled == true) { DebugMode.UpdateSTMode_t updateSTMode = new DebugMode.UpdateSTMode_t(selfTestMode, errorCode); DebugMode.Write(updateSTMode.ToXML()); } if (errorCode != CommunicationError.Success) { throw new CommunicationException("CommunicationSelfTest.UpdateSTMode()", errorCode); } }
public CommunicationException(string message, string serviceName, CommunicationError code) : base(message) { _serviceName = serviceName; _code = code; }
/// <summary> /// Send self test communication watchdog message to the VCU /// </summary> /// <remarks>This method will send a communication watchdog message to the VCU. A response is expected back from the VCU. No action /// is taken in the VCU side. </remarks> /// <exception cref="CommunicationException">Thrown if the error code returned from the call to m_SelfTestMarshal.CommunicationWatchdog() method is not /// CommunicationError.Success.</exception> /// <param name="InSelfTest">true if target hardware is in self test mode; false otherwise</param> public void CommunicationWatchdog(ref Boolean InSelfTest) { Debug.Assert(m_MutexCommuncationInterface != null, "CommunicationSelfTest.CommunicationWatchdog() - [m_MutexCommuncationInterface != null]"); CommunicationError errorCode = CommunicationError.UnknownError; try { m_MutexCommuncationInterface.WaitOne(DefaultMutexWaitDurationMs, false); errorCode = m_SelfTestMarshal.CommunicationWatchdog(ref InSelfTest); } catch (Exception) { errorCode = CommunicationError.SystemException; throw new CommunicationException("CommunicationSelfTest.CommunicationWatchdog()", errorCode); } finally { m_MutexCommuncationInterface.ReleaseMutex(); } if (DebugMode.Enabled == true) { //TODO DAS DebugMode.UpdateSTTestList_t updateSTTestList = new DebugMode.UpdateSTTestList_t(testCount, tests, errorCode); //TODO DAS DebugMode.Write(updateSTTestList.ToXML()); } if (errorCode != CommunicationError.Success) { throw new CommunicationException("CommunicationSelfTest.CommunicationWatchdog()", errorCode); } }
/// <summary> /// Execute the self tests that are defined in the current list. /// </summary> /// <param name="truckInformation">The truck to which the self tests apply. This does not apply on the CTA project as separate self-tests are /// set up for each truck.</param> /// <exception cref="CommunicationException">Thrown if the error code returned from the call to the m_SelfTestMarshal.ExecuteSTTestList() method is not /// CommunicationError.Success.</exception> public void ExecuteSTTestList(TruckInformation truckInformation) { Debug.Assert(m_MutexCommuncationInterface != null, "CommunicationSelfTest.ExecuteSTTestList() - [m_MutexCommuncationInterface != null]"); CommunicationError errorCode = CommunicationError.UnknownError; try { m_MutexCommuncationInterface.WaitOne(DefaultMutexWaitDurationMs, false); errorCode = m_SelfTestMarshal.ExecuteSTTestList((short)truckInformation); } catch (Exception) { errorCode = CommunicationError.SystemException; throw new CommunicationException("CommunicationSelfTest.ExecuteSTTestList()", errorCode); } finally { m_MutexCommuncationInterface.ReleaseMutex(); } if (DebugMode.Enabled == true) { DebugMode.ExecuteSTTestList_t executeSTTestList = new DebugMode.ExecuteSTTestList_t(truckInformation, errorCode); DebugMode.Write(executeSTTestList.ToXML()); } if (errorCode != CommunicationError.Success) { throw new CommunicationException("CommunicationSelfTest.ExecuteSTTestList()", errorCode); } }
/// <summary> /// Partial method that can optionally be defined to extract the error /// message, code, and details in a service specific manner. /// </summary> /// <param name="content">The error content.</param> /// <param name="responseHeaders">The response headers.</param> /// <param name="message">The error message.</param> /// <param name="errorCode">The error code.</param> /// <param name="additionalInfo">Additional error details.</param> protected override void ExtractFailureContent( string content, ResponseHeaders responseHeaders, ref string message, ref string errorCode, ref IDictionary <string, string> additionalInfo ) { if (string.IsNullOrEmpty(content)) { return; } try { using var document = JsonDocument.Parse(content); foreach (var property in document.RootElement.EnumerateObject()) { if (property.NameEquals("error")) { var communicationError = CommunicationError.DeserializeCommunicationError(property.Value); errorCode = communicationError.Code; message = communicationError.Message; additionalInfo = new Dictionary <string, string>() { ["target"] = communicationError.Target }; break; } } } catch { } }
/// <summary> /// Get the self test special message. /// </summary> /// <param name="result">The result of the call. A value of: (1) 1 represents success; (2) indicates that the error message defined by the /// <paramref name="reason"/> parameter applies and (3) represents an unknown error.</param> /// <param name="reason">A value of 1 represents success; otherwise, the value is mapped to the <c>ERRID</c> field of the /// <c>SELFTESTERRMESS</c> table /// of the data dictionary in order to determine the error message returned from the VCU.</param> /// <exception cref="CommunicationException">Thrown if the error code returned from the call to the m_SelfTestMarshal.GetSelfTestSpecialMessage() /// method is not CommunicationError.Success.</exception> public void GetSelfTestSpecialMessage(out short result, out short reason) { // Check that the function delegate has been initialized. Debug.Assert(m_MutexCommuncationInterface != null, "CommunicationSelfTest.GetSelfTestSpecialMessage() - [m_MutexCommuncationInterface != null]"); CommunicationError errorCode = CommunicationError.UnknownError; try { m_MutexCommuncationInterface.WaitOne(DefaultMutexWaitDurationMs, false); errorCode = m_SelfTestMarshal.GetSelfTestSpecialMessage(out result, out reason); } catch (Exception) { errorCode = CommunicationError.SystemException; throw new CommunicationException("CommunicationSelfTest.GetSelfTestSpecialMessage()", errorCode); } finally { m_MutexCommuncationInterface.ReleaseMutex(); } if (DebugMode.Enabled == true) { DebugMode.GetSelfTestSpecialMessage_t getSelfTestSpecialMessage = new DebugMode.GetSelfTestSpecialMessage_t(result, reason, errorCode); DebugMode.Write(getSelfTestSpecialMessage.ToXML()); } if (errorCode != CommunicationError.Success) { throw new CommunicationException("CommunicationSelfTest.GetSelfTestSpecialMessage()", errorCode); } }
/// <summary> /// Set the car identifier. /// </summary> /// <param name="carIdentifier">The car identfier.</param> public void SetCarID(string carIdentifier) { // Check that the function delegate has been initialized. Debug.Assert(m_SetCarID != null, "CommunicationApplication.SetCarID() - [m_SetCarID != null]"); Debug.Assert(m_MutexCommuncationInterface != null, "CommunicationApplication.SetCarID() - [m_MutexCommuncationInterface != null]"); CommunicationError errorCode = CommunicationError.UnknownError; try { m_MutexCommuncationInterface.WaitOne(DefaultMutexWaitDurationMs, false); errorCode = (CommunicationError)m_SetCarID(carIdentifier); } catch (Exception) { errorCode = CommunicationError.SystemException; throw new CommunicationException(Resources.EMCarIDSetFailed, errorCode); } finally { m_MutexCommuncationInterface.ReleaseMutex(); } if (errorCode != CommunicationError.Success) { throw new CommunicationException(Resources.EMCarIDSetFailed, errorCode); } }
/// <summary> /// Write the specified data to the watch variable specified by the <paramref name="dictionaryIndex"/> parameter. /// </summary> /// <param name="dictionaryIndex">The dictionary index.</param> /// <param name="dataType">The data type.</param> /// <param name="data">The data.</param> /// <exception cref="CommunicationException">Thrown if the error code returned from the call to the PTUDLL32.CloseCommunication() method is not /// CommunicationError.Success.</exception> public void SendVariable(short dictionaryIndex, short dataType, double data) { Debug.Assert(m_MutexCommuncationInterface != null, "CommunicationWatch.SendVariable() - [m_MutexCommuncationInterface != null]"); CommunicationError errorCode = CommunicationError.UnknownError; try { m_MutexCommuncationInterface.WaitOne(DefaultMutexWaitDurationMs, false); errorCode = (CommunicationError)m_WatchClockMarshal.SendVariable(dictionaryIndex, dataType, data); } catch (Exception) { errorCode = CommunicationError.SystemException; throw new CommunicationException(Resources.EMSendVariableFailed, errorCode); } finally { m_MutexCommuncationInterface.ReleaseMutex(); } if (errorCode != CommunicationError.Success) { throw new CommunicationException(Resources.EMSendVariableFailed, errorCode); } if (DebugMode.Enabled == true) { DebugMode.SendVariable_t sendVariable = new DebugMode.SendVariable_t(dictionaryIndex, dataType, data, errorCode); DebugMode.Write(sendVariable.ToXML()); } }
/// <summary> /// Set the time and date on the target hardware. /// </summary> /// <param name="use4DigitYearCode">A flag that specifies whether the Vehicle Control Unit uses a 2 or 4 digit year code. True, if it /// uses a 4 digit year code; otherwise, false.</param> /// <param name="dateTime">The time and date as a .NET <c>DateTime</c> object.</param> public void SetTimeDate(bool use4DigitYearCode, DateTime dateTime) { // Check that the function delegate has been initialized. Debug.Assert(m_SetTimeDate != null, "CommunicationApplication.SetTimeDate() - [m_SetTimeDate != null]"); Debug.Assert(m_MutexCommuncationInterface != null, "CommunicationApplication.SetTimeDate() - [m_MutexCommuncationInterface != null]"); // Set the parameters according to whether the VCU uses 2 or 4 digit year code. short use4DigitYearCodeAsShort = (use4DigitYearCode == true) ? Use4DigitYearCodeTrue : Use4DigitYearCodeFalse; short year = (use4DigitYearCode == true) ? (short)dateTime.Year : ConvertYearTo2DigitFormat((short)dateTime.Year); CommunicationError errorCode = CommunicationError.UnknownError; try { m_MutexCommuncationInterface.WaitOne(DefaultMutexWaitDurationMs, false); errorCode = (CommunicationError)m_SetTimeDate(use4DigitYearCodeAsShort, year, (short)dateTime.Month, (short)dateTime.Day, (short)dateTime.Hour, (short)dateTime.Minute, (short)dateTime.Second); } catch (Exception) { errorCode = CommunicationError.SystemException; throw new CommunicationException(Resources.EMTimeDateSetFailed, errorCode); } finally { m_MutexCommuncationInterface.ReleaseMutex(); } if (errorCode != CommunicationError.Success) { throw new CommunicationException(Resources.EMTimeDateSetFailed, errorCode); } }
/// <summary> /// Update the number of times that the selected tests are to be run. /// </summary> /// <param name="loopCount">The number of cycles/loops of the defined tests that are to be performed.</param> /// <exception cref="CommunicationException">Thrown if the error code returned from the call to the m_SelfTestMarshal.UpdateSTLoopCount() method is not /// CommunicationError.Success.</exception> public void UpdateSTLoopCount(short loopCount) { // Check that the function delegate has been initialized. Debug.Assert(m_MutexCommuncationInterface != null, "CommunicationSelfTest.UpdateSTLoopCount() - [m_MutexCommuncationInterface != null]"); CommunicationError errorCode = CommunicationError.UnknownError; try { m_MutexCommuncationInterface.WaitOne(DefaultMutexWaitDurationMs, false); errorCode = m_SelfTestMarshal.UpdateSTLoopCount(loopCount); } catch (Exception) { errorCode = CommunicationError.SystemException; throw new CommunicationException("CommunicationSelfTest.UpdateSTLoopCount()", errorCode); } finally { m_MutexCommuncationInterface.ReleaseMutex(); } if (DebugMode.Enabled == true) { DebugMode.UpdateSTLoopCount_t updateSTLoopCount = new DebugMode.UpdateSTLoopCount_t(loopCount, errorCode); DebugMode.Write(updateSTLoopCount.ToXML()); } if (errorCode != CommunicationError.Success) { throw new CommunicationException("CommunicationSelfTest.UpdateSTLoopCount()", errorCode); } }
/// <summary> /// Assign the specified watch variable to the specified chart recorder channel index. /// </summary> /// <param name="ChartIndex">The chart recorder channel index.</param> /// <param name="VariableIndex">The watch identifier of the watch variable that is to be assigned to the channel.</param> /// <returns>CommunicationError.Success (0) if all is well; otherwise another enumeration which is less than 0</returns> public CommunicationError SetChartIndex(Int16 ChartIndex, Int16 VariableIndex) { ProtocolPTU.SetChartIndexReq request = new ProtocolPTU.SetChartIndexReq(ChartIndex, VariableIndex); CommunicationError commError = m_PtuTargetCommunication.SendCommandToEmbedded(m_CommDevice, request); return(commError); }
/// <summary> /// Map the watch identifiers listed in <paramref name="WatchElements"/> to the watch element array monitored by the embedded target. /// </summary> /// <param name="WatchElements">TArray containing the watch identifiers that are to be mapped to each element of the watch element array. /// </param> /// <returns>CommunicationError.Success (0) if all is well; otherwise another enumeration which is less than 0</returns> public CommunicationError SetWatchElements(Int16[] WatchElements) { ProtocolPTU.SetWatchElementsReq request = new ProtocolPTU.SetWatchElementsReq(WatchElements); CommunicationError commError = m_PtuTargetCommunication.SendCommandToEmbedded(m_CommDevice, request); return(commError); }
/// <summary> /// Sets the chart mode of the chart recorder outputs /// </summary> /// <param name="TargetChartMode">the desired chart mode (data, ramp, full scale or zero)</param> /// <returns>CommunicationError.Success (0) if all is well; otherwise another enumeration which is less than 0</returns> public CommunicationError SetChartMode(Int16 TargetChartMode) { ProtocolPTU.SetChartModeReq request = new ProtocolPTU.SetChartModeReq((byte)TargetChartMode); CommunicationError commError = m_PtuTargetCommunication.SendCommandToEmbedded(m_CommDevice, request); return(commError); }
/// <summary> /// Run the predefined self tests associated with the specified test list identifier, these tests are defined in the data dictionary. /// </summary> /// <param name="TestID">The test list identifier of the predefined self tests that are to be executed.</param> /// <returns>Success, if the communication request was successful; otherwise, an error code.</returns> public CommunicationError RunPredefinedSTTests(Int16 TestID) { ProtocolPTU.SelfTestCommand request = new ProtocolPTU.SelfTestCommand(STC_CMD_SEL_LIST, 0, (UInt16)TestID); // Initiate transaction with embedded target CommunicationError commError = m_PtuTargetCommunication.SendCommandToEmbedded(m_CommDevice, request); return(commError); }
/// <summary> /// Update the self test mode. /// </summary> /// <remarks>This call is used to check whether communication with the VCU has been lost.</remarks> /// <param name="NewMode">The required self test mode.</param> /// <returns>Success, if the communication request was successful; otherwise, an error code.</returns> public CommunicationError UpdateSTMode(Int16 NewMode) { ProtocolPTU.SelfTestCommand request = new ProtocolPTU.SelfTestCommand(STC_CMD_UPDT_MODE, 0, (UInt16)NewMode); // Initiate transaction with embedded target CommunicationError commError = m_PtuTargetCommunication.SendCommandToEmbedded(m_CommDevice, request); return(commError); }
/// <summary> /// Update the list of individually selected self tests that are to be executed. /// </summary> /// <remarks>This method will define the list of self-tests that are to be executed once the tester selects the execute command. The self tests /// are defined using the self test identifiers defined in the data dictionary.</remarks> /// <param name="NumberOfTests">The number of tests in the list.</param> /// <param name="TestList">A list of the self test identifiers.</param> /// <returns>Success, if the communication request was successful; otherwise, an error code.</returns> public CommunicationError UpdateSTTestList(Int16 NumberOfTests, Int16[] TestList) { ProtocolPTU.SelfTestUpdateListReq request = new ProtocolPTU.SelfTestUpdateListReq(STC_CMD_UPDT_LIST, NumberOfTests, TestList); // Initiate transaction with embedded target CommunicationError commError = m_PtuTargetCommunication.SendCommandToEmbedded(m_CommDevice, request); return(commError); }
/// <summary> /// Send an operator acknowledge message. /// </summary> /// <remarks>This request allows the operator to move to the next step of an interactive test.</remarks> /// <returns>Success, if the communication request was successful; otherwise, an error code.</returns> public CommunicationError SendOperatorAcknowledge() { ProtocolPTU.SelfTestCommand request = new ProtocolPTU.SelfTestCommand(STC_CMD_OPRTR_ACK, 0, 0); // Initiate transaction with embedded target CommunicationError commError = m_PtuTargetCommunication.SendCommandToEmbedded(m_CommDevice, request); return(commError); }
/// <summary> /// Abort the self test sequence. /// </summary> /// <remarks>This request will stop the execution of the self-test process on the VCU and return control to the propulsion software.</remarks> /// <returns>Success, if the communication request was successful; otherwise, an error code.</returns> public CommunicationError AbortSTSequence() { ProtocolPTU.SelfTestCommand request = new ProtocolPTU.SelfTestCommand(STC_CMD_ABORT_SEQ, 0, 0); // Initiate transaction with embedded target CommunicationError commError = m_PtuTargetCommunication.SendCommandToEmbedded(m_CommDevice, request); return(commError); }
/// <summary> /// Update the number of times that the selected tests are to be run. /// </summary> /// <param name="LoopCount">The number of cycles/loops of the defined tests that are to be performed.</param> /// <returns>Success, if the communication request was successful; otherwise, an error code.</returns> public CommunicationError UpdateSTLoopCount(Int16 LoopCount) { ProtocolPTU.SelfTestCommand request = new ProtocolPTU.SelfTestCommand(STC_CMD_UPDT_LOOP_CNT, 0, (UInt16)LoopCount); // Initiate transaction with embedded target CommunicationError commError = m_PtuTargetCommunication.SendCommandToEmbedded(m_CommDevice, request); return(commError); }
/// <summary> /// Execute the self tests that are defined in the current list. /// </summary> /// <param name="TruckInformation">The truck to which the self tests apply. This does not apply on the CTA project, separate self-tests are set /// up for each truck.</param> /// <returns>Success, if the communication request was successful; otherwise, an error code.</returns> public CommunicationError ExecuteSTTestList(Int16 TruckInformation) { ProtocolPTU.SelfTestCommand request = new ProtocolPTU.SelfTestCommand(STC_CMD_EXECUTE_LIST, (Byte)TruckInformation, 0); // Initiate transaction with embedded target CommunicationError commError = m_PtuTargetCommunication.SendCommandToEmbedded(m_CommDevice, request); return(commError); }
/// <summary> /// Write the specified data to the watch variable specified by the <paramref name="DictionaryIndex"/> parameter. /// </summary> /// <param name="DictionaryIndex">The dictionary index.</param> /// <param name="DataType">The data type.</param> /// <param name="Data">The value of the data to be written.</param> /// <returns>CommunicationError.Success (0) if all is well; otherwise another enumeration which is less than 0</returns> public CommunicationError SendVariable(Int16 DictionaryIndex, Int16 DataType, Double Data) { UInt32 data = (UInt32)Data; ProtocolPTU.SendVariableReq request = new ProtocolPTU.SendVariableReq(DictionaryIndex, data); CommunicationError commError = m_PtuTargetCommunication.SendCommandToEmbedded(m_CommDevice, request); return(commError); }
/// <summary> /// This method updates the embedded target real time clock with the desired date and time. /// </summary> /// <param name="Use4DigitYearCode">true if the embedded target expects a 4 digit year code; false otherwise</param> /// <param name="Year">Year</param> /// <param name="Month">Month</param> /// <param name="Day">Day</param> /// <param name="Hour">Hour</param> /// <param name="Minute">Minute</param> /// <param name="Second">Second</param> /// <returns>CommunicationError.Success (0) if all is well; otherwise another enumeration which is less than 0</returns> public CommunicationError SetTimeDate(Boolean Use4DigitYearCode, Int16 Year, Int16 Month, Int16 Day, Int16 Hour, Int16 Minute, Int16 Second) { ProtocolPTU.SetTimeDateReq request = new ProtocolPTU.SetTimeDateReq(Use4DigitYearCode, (Byte)Hour, (Byte)Minute, (Byte)Second, (UInt16)Year, (Byte)Month, (Byte)Day); CommunicationError commError = m_PtuTargetCommunication.SendCommandToEmbedded(m_CommDevice, request); return(commError); }
/// <summary> /// Map the watch identifiers listed in <paramref name="watchElementList"/> to the watch element array monitored by the target hardware. /// </summary> /// <remarks> The number of watch identifiers in the list must not exceed <c>WatchSize</c>.</remarks> /// <param name="watchElementList">The list containing the watch identifiers that are to be mapped to each element of the watch element array. /// </param> /// <exception cref="CommunicationException">Thrown if the error code returned from the call to the PTUDLL32.SetWatchElements() method is not /// CommunicationError.Success.</exception> public void SetWatchElements(List <short> watchElementList) { Debug.Assert(m_SetWatchElements != null, "CommunicationWatch.SetWatchElements() - [m_SetWatchElementDelegates != null]"); Debug.Assert(m_MutexCommuncationInterface != null, "CommunicationWatch.SetWatchElements() - [m_MutexCommuncationInterface != null]"); // Skip, if the parameter isn't defined. if (watchElementList == null) { return; } Debug.Assert(watchElementList.Count <= Parameter.WatchSize, "CommunicationWatch.SetWatchElements - [watchElementList.Count <= Parameter.WatchSize]"); short[] watchElements = new short[Parameter.WatchSize]; Array.Copy(watchElementList.ToArray(), watchElements, watchElementList.Count); // Send the mapping to the target hardware. CommunicationError errorCode = CommunicationError.UnknownError; try { m_MutexCommuncationInterface.WaitOne(DefaultMutexWaitDurationMs, false); errorCode = (CommunicationError)m_SetWatchElements(watchElements); } catch (Exception) { errorCode = CommunicationError.SystemException; throw new CommunicationException(Resources.EMSetWatchElementsFailed, errorCode); } finally { m_MutexCommuncationInterface.ReleaseMutex(); } if (DebugMode.Enabled == true) { DebugMode.SetWatchElements_t setWatchElements = new DebugMode.SetWatchElements_t(watchElements, errorCode); DebugMode.Write(setWatchElements.ToXML()); } if (errorCode != CommunicationError.Success) { throw new CommunicationException(Resources.EMSetWatchElementsFailed, errorCode); } // Keep a record up the new mapping beween the each element index and the watch identifier. for (short elementIndex = 0; elementIndex < Parameter.WatchSize; elementIndex++) { m_WatchElements[elementIndex].WatchIdentifier = watchElements[elementIndex]; // Required to map between the watch identifier and the element index. m_WatchElements[elementIndex].ElementIndex = elementIndex; } }
/// <summary> /// Set the chart scaling for the specified watch variable. /// </summary> /// <param name="DictionaryIndex">The watch identifier of the watch variables that is to be scaled.</param> /// <param name="MaxScale">The watch variable engineering value associated with the maximum Y axis value.</param> /// <param name="MinScale">The watch variable engineering value associated with the minimum Y axis value.</param> /// <returns>CommunicationError.Success (0) if all is well; otherwise another enumeration which is less than 0</returns> public CommunicationError SetChartScale(Int16 DictionaryIndex, Double MaxScale, Double MinScale) { Int32 maxScale = (Int32)MaxScale; Int32 minScale = (Int32)MinScale; ProtocolPTU.SetChartScaleReq request = new ProtocolPTU.SetChartScaleReq(DictionaryIndex, maxScale, minScale); CommunicationError commError = m_PtuTargetCommunication.SendCommandToEmbedded(m_CommDevice, request); return(commError); }
/// <summary> /// Initializes a new instance of the communications exception class. This constructor is used when the exception is thrown as a result of receiving an error /// code other than CommunicationError.Success from a call to one of the methods included in PTUDLL32.dll. /// </summary> /// <remarks>The PTUDLL32.dll dynamic link library is a set of communication methods developed in C++ to support communication with the VCU.</remarks> /// <param name="auxMessage">A message to be passed to the exception handler.</param> /// <param name="communicationError">The error code returned from the call to the PTUDLL32 dynamic link library..</param> public CommunicationException(string auxMessage, CommunicationError communicationError) : base(String.Format("{0}", auxMessage)) { m_CommunicationError = communicationError; }
public CommunicationException(string message, CommunicationError code, Exception inner) : base(message, inner) { _code = code; }
public CommunicationException(string message, string serviceName, CommunicationError code) : base(message) { _serviceName = serviceName; _code = code; }