public static KWP2000Message SendRequestEraseFlashResultMessage(KWP2000Interface commInterface) { byte[] tempData = new byte[1]; tempData[0] = (byte)KWP2000VAGLocalIdentifierRoutine.EraseFlash; return(commInterface.SendMessage((byte)KWP2000ServiceID.RequestRoutineResultsByLocalIdentifier, tempData)); }
public ExtendedDataLoggingDefineReadVariables(KWP2000Interface commInterface, Mode mode, IEnumerable <VariableDefinition> variables) : base(commInterface) { mVariables = variables; mMode = mode; NumVariablesDefined = 0; MaxNumVariableReadsPerTick = 255; MaxNumBytesPerRead = 64; }
public KWP2000Interface_ViewModel() { CommInterface = new KWP2000Interface(); CommInterface.PropertyChanged += CommInterfacePropertyChanged; CopyDefaultTimings(); CommInterface.ConnectionStatusChangedEvent += ConnectionStatusChangedEvent; var defaultBaudRates = ECUFlasher.Properties.Settings.Default.SupportedKWP2000BaudRates; var savedAvailableRates = new List <uint>(); if (defaultBaudRates != null) { foreach (var rateObj in defaultBaudRates) { if (rateObj is uint) { var rate = (uint)rateObj; if (!savedAvailableRates.Contains(rate)) { savedAvailableRates.Add(rate); } } } } savedAvailableRates.Sort(); AvailableBaudRates = new ObservableCollection <uint>(savedAvailableRates); if (!AvailableBaudRates.Any()) { ResetAvailableBaudRatesToDefault(); SaveAvailableBaudRates(); } //get the last used baud rate var previousRate = ECUFlasher.Properties.Settings.Default.DesiredKWP2000BaudRate; //try to find the last used baud rate in the available rates list, if it isn't there, then use the last baud rate if (AvailableBaudRates.Contains(previousRate)) { DesiredBaudRate = previousRate; } else { DesiredBaudRate = AvailableBaudRates.Last(); } //get the last used connection method DesiredConnectionMethod = ECUFlasher.Properties.Settings.Default.DesiredKWP2000ConnectionMethod; }
public string GetDataString(KWP2000Interface commInterface) { byte[] dataBytes = GetMessageDataBytes(commInterface); string dataString = ""; for (int x = 0; x < dataBytes.Length; x++) { dataString += string.Format("{0:X2}", dataBytes[x]) + ", "; } return(dataString); }
public static KWP2000Message SendRequestUploadMessage(KWP2000Interface commInterface, uint address, uint size, byte format) { byte[] data = new byte[7]; data[0] = (byte)((address >> 16) & 0xFF); data[1] = (byte)((address >> 8) & 0xFF); data[2] = (byte)(address & 0xFF); data[3] = format; data[4] = (byte)((size >> 16) & 0xFF); data[5] = (byte)((size >> 8) & 0xFF); data[6] = (byte)(size & 0xFF); return(commInterface.SendMessage((byte)KWP2000ServiceID.RequestUpload, data)); }
public ExtendedDataLoggingOperation(KWP2000Interface commInterface, List <uint> baudRates) : base(commInterface, baudRates) { EnableAutoStartDiagnosticSession(KWP2000DiagnosticSessionType.DevelopmentSession, baudRates); EnableAutoNegotiateTiming(NegotiateTimingParameters.NegotiationTarget.Limits); ShouldRelocateMessageHandlingTable = false; mState = State.DefineVariables; mExtendedDataLoggingSetup = false; mLastReadStartTime = DateTime.Now; MaxReadsPerSecond = 20; MaxVariableReadsPerTick = 255; MaxNumBytesPerRead = 64; }
public SetupExtendedDataLoggingOperation(KWP2000Interface commInterface, List <uint> baudRates) : base(commInterface, baudRates) { mDefineFunctionData = new byte[0x7C]; Buffer.BlockCopy(Communication.Properties.Resources.KWP2000DataLoggingFunctions, 0, mDefineFunctionData, 0, mDefineFunctionData.Length); Debug.Assert(mDefineFunctionData[mDefineFunctionData.Length - 2] == 0xDB); Debug.Assert(mDefineFunctionData[mDefineFunctionData.Length - 1] == 0x00); mReadFunctionData = new byte[Communication.Properties.Resources.KWP2000DataLoggingFunctions.Length - mDefineFunctionData.Length]; Buffer.BlockCopy(Communication.Properties.Resources.KWP2000DataLoggingFunctions, mDefineFunctionData.Length, mReadFunctionData, 0, mReadFunctionData.Length); mVariableDefinitionsData = new byte[257];//257 is hardcoded into the assembly function for (int x = 0; x < mVariableDefinitionsData.Length; x++) { mVariableDefinitionsData[x] = 0; } }
public static KWP2000Message SendValidateFlashChecksumMessage(KWP2000Interface commInterface, uint startAddress, uint endAddress, ushort checksum) { Debug.Assert(startAddress % 2 == 0); Debug.Assert(endAddress % 2 == 1); byte[] tempData = new byte[9]; tempData[0] = (byte)KWP2000VAGLocalIdentifierRoutine.ValidateFlashChecksum; tempData[1] = (byte)((startAddress >> 16) & 0xFF); tempData[2] = (byte)((startAddress >> 8) & 0xFF); tempData[3] = (byte)((startAddress) & 0xFF); tempData[4] = (byte)((endAddress >> 16) & 0xFF); tempData[5] = (byte)((endAddress >> 8) & 0xFF); tempData[6] = (byte)((endAddress) & 0xFF); tempData[7] = (byte)((checksum >> 8) & 0xFF); tempData[8] = (byte)((checksum) & 0xFF); return(commInterface.SendMessage((byte)KWP2000ServiceID.StartRoutineByLocalIdentifier, tempData)); }
public static KWP2000Message SendRequestEraseFlashMessage(KWP2000Interface commInterface, uint startAddress, uint endAddress, string flashToolCode) { Debug.Assert(flashToolCode != null); Debug.Assert(flashToolCode.Length <= 6); char[] FTC = flashToolCode.ToCharArray(); byte[] tempData = new byte[13]; tempData[0] = (byte)KWP2000VAGLocalIdentifierRoutine.EraseFlash; tempData[1] = (byte)((startAddress >> 16) & 0xFF); tempData[2] = (byte)((startAddress >> 8) & 0xFF); tempData[3] = (byte)((startAddress) & 0xFF); tempData[4] = (byte)((endAddress >> 16) & 0xFF); tempData[5] = (byte)((endAddress >> 8) & 0xFF); tempData[6] = (byte)((endAddress) & 0xFF); tempData[7] = (byte)FTC[0]; tempData[8] = (byte)FTC[1]; tempData[9] = (byte)FTC[2]; tempData[10] = (byte)FTC[3]; tempData[11] = (byte)FTC[4]; tempData[12] = (byte)FTC[5]; return(commInterface.SendMessage((byte)KWP2000ServiceID.StartRoutineByLocalIdentifier, tempData)); }
public byte[] GetMessageDataBytes(KWP2000Interface commInterface) { bool useOneByteHeader = false; UInt32 numHeaderBytes = 3; var actualAddressMode = mAddressMode; if (commInterface.IsOneByteHeaderSupported()) { useOneByteHeader = true; numHeaderBytes = 1; actualAddressMode = KWP2000AddressMode.None; } else { //if one byte headers aren't supported, then use three byte headers. //if key bytes don't allow any address info, then just use three byte headers. useOneByteHeader = false; numHeaderBytes = 3; actualAddressMode = mAddressMode; } byte format = (byte)actualAddressMode; bool extraDataLengthByteNeeded = false; byte dataLength = 1; //one for the service ID if (mData != null) { Debug.Assert(dataLength + mData.Length <= 255); dataLength += (byte)mData.Length; } //if key bytes don't allow any length info, then just ignore them bool keyBytesDontSpecifyAnyLengthInfo = !commInterface.IsAdditionalLengthByteSupported() && !commInterface.IsLengthInfoInFormatByteSupported(); if ((dataLength <= KWP2000Interface.MAX_MESSAGE_DATA_SIZE_WITHOUT_LENGTH_BYTE) && (commInterface.IsLengthInfoInFormatByteSupported() || keyBytesDontSpecifyAnyLengthInfo)) { format |= dataLength; } else { extraDataLengthByteNeeded = true; } if (extraDataLengthByteNeeded) { numHeaderBytes += 1; } uint totalNumBytesInMessage = numHeaderBytes + dataLength + 1; //data bytes, format byte, target byte, source byte, checksum byte byte[] messageBuffer = new byte[totalNumBytesInMessage]; if (useOneByteHeader) { messageBuffer[0] = format; } else { messageBuffer[0] = format; messageBuffer[1] = mDestination; messageBuffer[2] = mSource; } if (extraDataLengthByteNeeded) { messageBuffer[numHeaderBytes - 1] = dataLength; } messageBuffer[numHeaderBytes] = (byte)mServiceID; if (mData != null) { Buffer.BlockCopy(mData, 0, messageBuffer, (int)numHeaderBytes + 1, mData.Length); } byte checksum = 0; for (int x = 0; x < (numHeaderBytes + dataLength); x++) { checksum += messageBuffer[x]; } messageBuffer[totalNumBytesInMessage - 1] = checksum; return(messageBuffer); }
protected override bool MessageHandler(KWP2000Interface commInterface, KWP2000Message message) { bool handled = base.MessageHandler(commInterface, message); if (!handled) { if (mMode == Mode.Define) { if (KWP2000Interface.IsPositiveResponseToRequest(DefineVariablesID, message)) { NumVariablesDefined = message.mData[0]; ActionCompleted(true); handled = true; } else { KWP2000Interface.IsNegativeResponseToRequest(DefineVariablesID, message, out DefineFailureResponseCode); } } else { if (KWP2000Interface.IsPositiveResponseToRequest(ReadVariablesID, message)) { int dataIndex = 0; byte readVariablesEndIndex = (byte)(mReadVariableIndexLastRead + mNumReadVariablesLastRead); for (var curVarIndex = mReadVariableIndexLastRead; curVarIndex < readVariablesEndIndex; ++curVarIndex) { var curVariable = mVariables.ElementAt(curVarIndex); var dataSize = (curVariable.VarType == VariableDefinition.VariableType.Byte) ? 1 : 2; if (dataIndex + dataSize > message.DataLength) { break; } var variableData = new byte[dataSize]; Buffer.BlockCopy(message.mData, dataIndex, variableData, 0, dataSize); mReadVariableData.Add(variableData); dataIndex += dataSize; } mReadVariableIndexLastRead = readVariablesEndIndex; if (mReadVariableIndexLastRead >= NumVariablesDefined) { ActionCompleted(true); } else { SendReadMessage(); } handled = true; } } if (!handled) { ActionCompleted(false); } } return(handled); }