/// <summary>
/// Constructor for T7Flasher.
/// </summary>
/// <param name="a_kwpHandler">The KWPHandler to be used for the communication.</param>
public T7Flasher()
{
m_command = FlashCommand.NoCommand;
m_flashStatus = FlashStatus.DoinNuthin;
m_thread = new Thread(run);
m_thread.Start();
}
//-------------------------------------------------------------------------
/**
* Interrupts ongoing read or write session.
*/
public virtual void stopFlasher()
{
lock (this.m_synchObject)
{
this.m_command = FlashCommand.StopCommand;
this.m_flashStatus = FlashStatus.DoinNuthin;
}
}
private FlashStatus GetFlashStatus(byte[] receivedBytes)
{
FlashStatus flashStatus = new FlashStatus();
if ((receivedBytes[0] == (byte)'R') || (receivedBytes[0] == (byte)'I'))
{
flashStatus.FlashRunStop = FlashStatusRunStop.Run;
}
else
{
flashStatus.FlashRunStop = FlashStatusRunStop.Stop;
}
flashStatus.eFlashStatus = (eFlashStatus)receivedBytes[1];
flashStatus.MemoryStatus = (MemoryStatus)receivedBytes[2];
flashStatus.CompilerStatus = (CompilerStatus)receivedBytes[3];
flashStatus.CurrentAddress = BitConverter.ToInt32(receivedBytes, 4);
flashStatus.SectorNumber = receivedBytes[8];
flashStatus.DownloadEnded = (receivedBytes[9] != 0);
flashStatus.SectorSize = BitConverter.ToInt32(receivedBytes, 10);
if ((int)flashStatus.CompilerStatus >= 3)
{
flashStatus.CompilerError = (CompilerError)flashStatus.CompilerStatus;
flashStatus.CompilerStatus = CompilerStatus.Error;
}
else
{
flashStatus.CompilerError = CompilerError.NoError;
}
flashStatus.ValidBitmap = new byte[4];
Array.Copy(receivedBytes, 90, flashStatus.ValidBitmap, 0, 4);
flashStatus.AllFlashValid = (receivedBytes[28] == 3);
return(flashStatus);
}
private bool m_EnableCanLog = false; ///< CAN logging flag
//-------------------------------------------------------------------------
/**
* Default constructor.
*/
public IFlasher()
{
// clear state
this.m_flashStatus = FlashStatus.DoinNuthin;
this.m_command = FlashCommand.NoCommand;
}
private void SetFlashStatus(FlashStatus status)
{
m_flashStatus = status;
}
/// <summary>
/// The run method handles writing and reading. It waits for a command to start read
/// or write and handles this command until it's completed, stopped or until there is
/// a failure.
/// </summary>
void run()
{
bool gotSequrityAccess = false;
while (true)
{
m_nrOfRetries = 0;
m_nrOfBytesRead = 0;
m_resetEvent.WaitOne(-1, true);
gotSequrityAccess = false;
lock (m_synchObject)
{
if (m_endThread)
return;
}
m_kwpHandler.startSession();
if (!gotSequrityAccess)
{
for (int nrOfSequrityTries = 0; nrOfSequrityTries < 5; nrOfSequrityTries++)
{
if (!m_kwpHandler.requestSequrityAccess(false))
m_flashStatus = FlashStatus.NoSequrityAccess;
else
{
gotSequrityAccess = true;
break;
}
}
}
//Here it would make sense to stop if we didn't ge security acces but
//let's try anyway. It could be that we don't get a possitive reply from the
//ECU if we alredy have security access (from a previous, interrupted, session).
if (m_command == FlashCommand.ReadCommand)
{
int nrOfBytes = 512; // TODO: Maybe increase value for faster reading?
byte[] data;
if (File.Exists(m_fileName))
File.Delete(m_fileName);
FileStream fileStream = File.Create(m_fileName, 1024);
for (int i = 0; i < 512 * 1024 / nrOfBytes; i++)
{
lock (m_synchObject)
{
if (m_command == FlashCommand.StopCommand)
continue;
if (m_endThread)
return;
}
m_flashStatus = FlashStatus.Reading;
while (!m_kwpHandler.sendReadRequest((uint)(nrOfBytes * i), (uint)nrOfBytes))
{
m_nrOfRetries++;
}
while (!m_kwpHandler.sendRequestDataByOffset(out data))
{
m_nrOfRetries++;
}
fileStream.Write(data, 0, nrOfBytes);
m_nrOfBytesRead += nrOfBytes;
}
fileStream.Close();
m_kwpHandler.sendDataTransferExitRequest();
}
else if (m_command == FlashCommand.ReadMemoryCommand)
{
int nrOfBytes = 512;//64;
byte[] data;
if (File.Exists(m_fileName))
File.Delete(m_fileName);
FileStream fileStream = File.Create(m_fileName, 1024);
int nrOfReads = (int)m_length / nrOfBytes;
for (int i = 0; i < nrOfReads; i++)
{
lock (m_synchObject)
{
if (m_command == FlashCommand.StopCommand)
continue;
if (m_endThread)
return;
}
m_flashStatus = FlashStatus.Reading;
if (i == nrOfReads - 1)
nrOfBytes = (int)m_length - nrOfBytes * i;
while (!m_kwpHandler.sendReadRequest((uint)m_offset + (uint)(nrOfBytes * i), (uint)nrOfBytes))
{
m_nrOfRetries++;
}
while (!m_kwpHandler.sendRequestDataByOffset(out data))
{
m_nrOfRetries++;
}
fileStream.Write(data, 0, nrOfBytes);
m_nrOfBytesRead += nrOfBytes;
}
fileStream.Close();
m_kwpHandler.sendDataTransferExitRequest();
}
else if (m_command == FlashCommand.ReadSymbolMapCommand)
{
byte[] data;
string swVersion = "";
m_nrOfBytesRead = 0;
if (File.Exists(m_fileName))
File.Delete(m_fileName);
FileStream fileStream = File.Create(m_fileName, 1024);
if (m_kwpHandler.sendUnknownRequest() != KWPResult.OK)
{
m_flashStatus = FlashStatus.ReadError;
continue;
}
m_flashStatus = FlashStatus.Reading;
m_kwpHandler.getSwVersionFromDR51(out swVersion);
if (m_kwpHandler.sendReadSymbolMapRequest() != KWPResult.OK)
{
m_flashStatus = FlashStatus.ReadError;
continue;
}
m_kwpHandler.sendDataTransferRequest(out data);
while (data.Length > 0x10)
{
fileStream.Write(data, 1, data.Length - 3);
m_nrOfBytesRead += data.Length - 3;
lock (m_synchObject)
{
if (m_command == FlashCommand.StopCommand)
continue;
if (m_endThread)
return;
}
m_kwpHandler.sendDataTransferRequest(out data);
}
fileStream.Flush();
fileStream.Close();
}
else if (m_command == FlashCommand.WriteCommand)
{
int nrOfBytes = 128;
int i = 0;
byte[] data = new byte[nrOfBytes];
if (!File.Exists(m_fileName))
{
m_flashStatus = FlashStatus.NoSuchFile;
continue;
}
m_flashStatus = FlashStatus.Eraseing;
if (m_kwpHandler.sendEraseRequest() != KWPResult.OK)
{
m_flashStatus = FlashStatus.EraseError;
// break;
}
FileStream fs = new FileStream(m_fileName, FileMode.Open, FileAccess.Read);
m_flashStatus = FlashStatus.Writing;
//Write 0x0-0x7B000
if (m_kwpHandler.sendWriteRequest(0x0, 0x7B000) != KWPResult.OK)
{
m_flashStatus = FlashStatus.WriteError;
continue;
}
for (i = 0; i < 0x7B000 / nrOfBytes; i++)
{
fs.Read(data, 0, nrOfBytes);
m_nrOfBytesRead = i * nrOfBytes;
if (m_kwpHandler.sendWriteDataRequest(data) != KWPResult.OK)
{
m_flashStatus = FlashStatus.WriteError;
continue;
}
lock (m_synchObject)
{
if (m_command == FlashCommand.StopCommand)
continue;
if (m_endThread)
return;
}
}
//Write 0x7FE00-0x7FFFF
if (m_kwpHandler.sendWriteRequest(0x7FE00, 0x200) != KWPResult.OK)
{
m_flashStatus = FlashStatus.WriteError;
continue;
}
fs.Seek(0x7FE00, System.IO.SeekOrigin.Begin);
for (i = 0x7FE00 / nrOfBytes; i < 0x80000 / nrOfBytes; i++)
{
fs.Read(data, 0, nrOfBytes);
m_nrOfBytesRead = i * nrOfBytes;
if (m_kwpHandler.sendWriteDataRequest(data) != KWPResult.OK)
{
m_flashStatus = FlashStatus.WriteError;
continue;
}
lock (m_synchObject)
{
if (m_command == FlashCommand.StopCommand)
continue;
if (m_endThread)
return;
}
}
}
m_flashStatus = FlashStatus.Completed;
}
}
private void SetFlashStatus(FlashStatus status)
{
m_flashStatus = status;
}
private bool m_EnableCanLog = false; ///< CAN logging flag
#endregion Fields
#region Constructors
//-------------------------------------------------------------------------
/**
Default constructor.
*/
public IFlasher()
{
// clear state
this.m_flashStatus = FlashStatus.DoinNuthin;
this.m_command = FlashCommand.NoCommand;
}
//-------------------------------------------------------------------------
/**
Interrupts ongoing read or write session.
*/
public virtual void stopFlasher()
{
lock (this.m_synchObject)
{
this.m_command = FlashCommand.StopCommand;
this.m_flashStatus = FlashStatus.DoinNuthin;
}
}
private async void Load()
{
await Task.Delay(TimeSpan.FromSeconds(1.5d));
FlashStatus.Begin();
}
