public override void EstablishSync()
{
int i;
for (i = 0; i < MaxSyncRetries; i++)
{
Send(new GetSyncRequest());
var result = Receive <GetSyncResponse>();
if (result == null)
{
continue;
}
if (result.IsInSync)
{
break;
}
}
if (i == MaxSyncRetries)
{
UploaderLogger.LogAndThrowError <IOException>(
string.Format(
"Unable to establish sync after {0} retries.", MaxSyncRetries));
}
var nextByte = ReceiveNext();
if (nextByte != Constants.RESP_STK_OK)
{
UploaderLogger.LogAndThrowError <IOException>(
"Unable to establish sync.");
}
}
private uint GetParameterValue(byte param)
{
logger.Trace("Retrieving parameter '{0}'...", param);
SendWithSyncRetry(new GetParameterRequest(param));
var nextByte = ReceiveNext();
var paramValue = (uint)nextByte;
nextByte = ReceiveNext();
if (nextByte == Constants.RESP_STK_Failed)
{
UploaderLogger.LogAndThrowError <IOException>(
string.Format("Retrieving parameter '{0}' failed!", param));
}
if (nextByte != Constants.RESP_STK_OK)
{
UploaderLogger.LogAndThrowError <IOException>(
string.Format(
"General protocol error while retrieving parameter '{0}'.",
param));
}
return(paramValue);
}
public override void EstablishSync()
{
int i;
for (i = 0; i < MaxSyncRetries; i++)
{
Send(new GetSyncRequest());
var result = Receive <GetSyncResponse>();
if (result == null)
{
continue;
}
if (!result.IsInSync)
{
continue;
}
deviceSignature = result.Signature;
break;
}
if (i == MaxSyncRetries)
{
UploaderLogger.LogAndThrowError <IOException>(
string.Format(
"Unable to establish sync after {0} retries.", MaxSyncRetries));
}
}
public override void CheckDeviceSignature()
{
logger.Debug("Expecting to find '{0}'...", EXPECTED_DEVICE_SIGNATURE);
if (!deviceSignature.Equals(EXPECTED_DEVICE_SIGNATURE))
{
UploaderLogger.LogAndThrowError <IOException>(
string.Format("Unexpected device signature - found '{0}'- expected '{1}'.",
deviceSignature, EXPECTED_DEVICE_SIGNATURE));
}
}
public override void LeaveProgrammingMode()
{
Send(new LeaveProgrammingModeRequest());
var response = Receive <LeaveProgrammingModeResponse>();
if (response == null)
{
UploaderLogger.LogAndThrowError <IOException>(
"Unable to leave programming mode on the device!");
}
}
public virtual void ProgramDevice(MemoryBlock memoryBlock)
{
var sizeToWrite = memoryBlock.HighestModifiedOffset + 1;
var flashMem = MCU.Flash;
var pageSize = flashMem.PageSize;
logger.Info("Preparing to write {0} bytes...", sizeToWrite);
logger.Info("Flash page size: {0}.", pageSize);
int offset;
for (offset = 0; offset < sizeToWrite; offset += pageSize)
{
var needsWrite = false;
for (var i = offset; i < offset + pageSize; i++)
{
if (!memoryBlock.Cells[i].Modified)
{
continue;
}
needsWrite = true;
break;
}
if (needsWrite)
{
logger.Debug("Executing paged write @ address {0} (page size {1})...", offset, pageSize);
var bytesToCopy = memoryBlock.Cells.Skip(offset).Take(pageSize).Select(x => x.Value).ToArray();
logger.Trace("Checking if bytes at offset {0} need to be overwritten...", offset);
var bytesAlreadyPresent = ExecuteReadPage(flashMem, offset);
if (bytesAlreadyPresent.SequenceEqual(bytesToCopy))
{
logger.Trace("Bytes to be written are identical to bytes already present - skipping actual write!");
continue;
}
logger.Trace("Writing page at offset {0}.", offset);
ExecuteWritePage(flashMem, offset, bytesToCopy);
logger.Trace("Page written, now verifying...");
var verify = ExecuteReadPage(flashMem, offset);
var succeeded = verify.SequenceEqual(bytesToCopy);
if (!succeeded)
{
UploaderLogger.LogAndThrowError <IOException>(
"Difference encountered during verification, write failed!");
}
}
else
{
logger.Trace("Skip writing page...");
}
}
logger.Info("{0} bytes written to flash memory!", sizeToWrite);
}
private void LoadAddress(int addr)
{
logger.Trace("Sending load address request: {0}.", addr);
addr = addr >> 1;
SendWithSyncRetry(new LoadAddressRequest(addr));
var result = ReceiveNext();
if (result == Constants.RESP_STK_OK)
{
return;
}
UploaderLogger.LogAndThrowError <IOException>(string.Format("LoadAddress failed with result {0}!", result));
}
public override void ExecuteWritePage(IMemory memory, int offset, byte[] bytes)
{
LoadAddress(offset);
SendWithSyncRetry(new ExecuteProgramPageRequest(memory, bytes));
var nextByte = ReceiveNext();
if (nextByte == Constants.RESP_STK_OK)
{
return;
}
UploaderLogger.LogAndThrowError <IOException>(
string.Format("Write at offset {0} failed!", offset));
}
private uint GetParameterValue(byte param)
{
logger.Trace("Retrieving parameter '{0}'...", param);
Send(new GetParameterRequest(param));
var response = Receive <GetParameterResponse>();
if (response == null || !response.IsSuccess)
{
UploaderLogger.LogAndThrowError <IOException>(
string.Format("Retrieving parameter '{0}' failed!", param));
}
return(response.ParameterValue);
}
private void LoadAddress(IMemory memory, int addr)
{
logger.Trace("Sending load address request: {0}.", addr);
addr = addr >> 1;
Send(new LoadAddressRequest(memory, addr));
var response = Receive <LoadAddressResponse>();
if (response == null || !response.Succeeded)
{
UploaderLogger.LogAndThrowError <IOException>(
"Unable to execute load address!");
}
}
public override void LeaveProgrammingMode()
{
SendWithSyncRetry(new LeaveProgrammingModeRequest());
var nextByte = ReceiveNext();
if (nextByte == Constants.RESP_STK_OK)
{
return;
}
if (nextByte == Constants.RESP_STK_NODEVICE || nextByte == Constants.RESP_STK_Failed)
{
UploaderLogger.LogAndThrowError <IOException>(
"Unable to leave programming mode on the device!");
}
}
public override void InitializeDevice()
{
var majorVersion = GetParameterValue(Constants.PARM_STK_SW_MAJOR);
var minorVersion = GetParameterValue(Constants.PARM_STK_SW_MINOR);
logger.Info("Retrieved software version: {0}.",
string.Format("{0}.{1}", majorVersion, minorVersion));
logger.Info("Setting device programming parameters...");
SendWithSyncRetry(new SetDeviceProgrammingParametersRequest((MCU)MCU));
var nextByte = ReceiveNext();
if (nextByte != Constants.RESP_STK_OK)
{
UploaderLogger.LogAndThrowError <IOException>(
"Unable to set device programming parameters!");
}
}
public override void ExecuteWritePage(IMemory memory, int offset, byte[] bytes)
{
LoadAddress(memory, offset);
logger.Trace(
"Sending execute write page request for offset {0} ({1} bytes)...",
offset, bytes.Length);
var writeCmd = writeCommands[memory.Type];
Send(new ExecuteProgramPageRequest(writeCmd, memory, bytes));
var response = Receive <ExecuteProgramPageResponse>();
if (response == null || response.AnswerID != writeCmd ||
response.Status != Constants.STATUS_CMD_OK)
{
UploaderLogger.LogAndThrowError <IOException>(
string.Format(
"Executing write page request at offset {0} failed!", offset));
}
}
public override byte[] ExecuteReadPage(IMemory memory, int offset)
{
LoadAddress(memory, offset);
logger.Trace("Sending execute read page request (offset {0})...", offset);
var readCmd = readCommands[memory.Type];
Send(new ExecuteReadPageRequest(readCmd, memory));
var response = Receive <ExecuteReadPageResponse>();
if (response == null || response.AnswerID != readCmd ||
response.Status != Constants.STATUS_CMD_OK)
{
UploaderLogger.LogAndThrowError <IOException>(
string.Format(
"Executing read page request at offset {0} failed!", offset));
}
var responseBytes = new byte[memory.PageSize];
Buffer.BlockCopy(response.Bytes, 2, responseBytes, 0, responseBytes.Length);
return(responseBytes);
}
protected void SendWithSyncRetry(IRequest request)
{
byte nextByte;
while (true)
{
Send(request);
nextByte = (byte)ReceiveNext();
if (nextByte == Constants.RESP_STK_NOSYNC)
{
EstablishSync();
continue;
}
break;
}
if (nextByte != Constants.RESP_STK_INSYNC)
{
UploaderLogger.LogAndThrowError <IOException>(
string.Format(
"Unable to aqcuire sync in SendWithSyncRetry for request of type {0}!",
request.GetType()));
}
}
public override void CheckDeviceSignature()
{
logger.Debug("Expecting to find '{0}'...", EXPECTED_DEVICE_SIGNATURE);
SendWithSyncRetry(new ReadSignatureRequest());
var response = Receive <ReadSignatureResponse>(4);
if (response == null || !response.IsCorrectResponse)
{
UploaderLogger.LogAndThrowError <IOException>(
"Unable to check device signature!");
}
var signature = response.Signature;
if (signature[0] != 0x1e || signature[1] != 0x95 || signature[2] != 0x0f)
{
UploaderLogger.LogAndThrowError <IOException>(
string.Format(
"Unexpected device signature - found '{0}'- expected '{1}'.",
BitConverter.ToString(signature),
EXPECTED_DEVICE_SIGNATURE));
}
}
public override byte[] ExecuteReadPage(IMemory memory, int offset)
{
var pageSize = memory.PageSize;
LoadAddress(offset);
SendWithSyncRetry(new ExecuteReadPageRequest(memory.Type, pageSize));
var bytes = ReceiveNext(pageSize);
if (bytes == null)
{
UploaderLogger.LogAndThrowError <IOException>(
string.Format("Read at offset {0} failed!", offset));
}
var nextByte = ReceiveNext();
if (nextByte == Constants.RESP_STK_OK)
{
return(bytes);
}
UploaderLogger.LogAndThrowError <IOException>(
string.Format("Read at offset {0} failed!", offset));
return(null);
}
