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.LogErrorAndThrow(
string.Format(
"Unable to establish sync after {0} retries.", MaxSyncRetries));
}
var nextByte = ReceiveNext();
if (nextByte != Constants.RESP_STK_OK)
{
UploaderLogger.LogErrorAndThrow(
"Unable to establish sync.");
}
}
public virtual void ProgramDevice(MemoryBlock memoryBlock, IProgress <double> progress = null)
{
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)
{
progress?.Report((double)offset / sizeToWrite);
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);
LoadAddress(flashMem, offset);
var bytesAlreadyPresent = ExecuteReadPage(flashMem);
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);
LoadAddress(flashMem, offset);
ExecuteWritePage(flashMem, offset, bytesToCopy);
logger.Trace("Page written, now verifying...");
Thread.Sleep(10);
LoadAddress(flashMem, offset);
var verify = ExecuteReadPage(flashMem);
var succeeded = verify.SequenceEqual(bytesToCopy);
if (!succeeded)
{
UploaderLogger.LogErrorAndThrow(
"Difference encountered during verification, write failed!");
}
}
else
{
logger.Trace("Skip writing page...");
}
}
logger.Info("{0} bytes written to flash memory!", sizeToWrite);
}
public override void Open()
{
var portName = serialPortConfig.PortName;
var baudRate = serialPortConfig.BaudRate;
logger.Info("Opening serial port {0} - baudrate {1}", serialPortConfig.PortName, serialPortConfig.BaudRate);
SerialPort = new SerialPortStream(portName, baudRate)
{
ReadTimeout = serialPortConfig.ReadTimeOut,
WriteTimeout = serialPortConfig.WriteTimeOut,
DtrEnable = true // This means the Arduino will reset the moment we open the serial connection.
};
try
{
SerialPort.Open();
}
catch (ObjectDisposedException ex)
{
UploaderLogger.LogErrorAndQuit(
string.Format("Unable to open serial port {0} - {1}.", portName, ex.Message));
}
catch (InvalidOperationException ex)
{
UploaderLogger.LogErrorAndQuit(
string.Format("Unable to open serial port {0} - {1}.", portName, ex.Message));
}
logger.Trace("Opened serial port {0} with baud rate {1}!", portName, baudRate);
}
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.LogErrorAndThrow(
string.Format(
"Unable to establish sync after {0} retries.", MaxSyncRetries));
}
}
public override void EstablishSync()
{
var ports = SerialPortStream.GetPortNames();
var newPort = ports.Except(originalPorts).SingleOrDefault();
if (newPort == null)
{
UploaderLogger.LogErrorAndThrow(
string.Format(
"No (unambiguous) virtual COM port detected (after {0}ms).",
VIRTUAL_COM_CREATION_TIMEOUT));
}
SerialPort = new SerialPortStream
{
BaudRate = 57600,
PortName = newPort,
DataBits = 8,
Parity = Parity.None,
StopBits = StopBits.One,
Handshake = Handshake.DtrRts
};
try
{
SerialPort.Open();
}
catch (Exception ex)
{
UploaderLogger.LogErrorAndThrow(
string.Format("Unable to open serial port - {0}.", ex.Message));
}
}
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.LogErrorAndThrow(
string.Format("Retrieving parameter '{0}' failed!", param));
}
if (nextByte != Constants.RESP_STK_OK)
{
UploaderLogger.LogErrorAndThrow(
string.Format(
"General protocol error while retrieving parameter '{0}'.",
param));
}
return(paramValue);
}
private static void Main(string[] args)
{
var commandLineOptions = new CommandLineOptions();
if (!CommandLine.Parser.Default.ParseArguments(args, commandLineOptions))
{
return;
}
var options = new ArduinoSketchUploaderOptions
{
PortName = commandLineOptions.PortName,
FileName = commandLineOptions.FileName,
ArduinoModel = commandLineOptions.ArduinoModel
};
var progress = new Progress <double>(p => logger.Info("{0:F1}%", p * 100));
var uploader = new ArduinoUploader.ArduinoSketchUploader(options, progress);
try
{
uploader.UploadSketch();
Environment.Exit((int)StatusCodes.Success);
}
catch (ArduinoUploaderException)
{
Environment.Exit((int)StatusCodes.ArduinoUploaderException);
}
catch (Exception ex)
{
UploaderLogger.LogError(string.Format("Unexpected exception: {0}!", ex.Message), ex);
Environment.Exit((int)StatusCodes.GeneralRuntimeException);
}
}
public override void EnableProgrammingMode()
{
Send(new EnterProgrammingModeRequest());
var response = ReceiveNext();
if (response != Constants.CARRIAGE_RETURN)
{
UploaderLogger.LogErrorAndThrow("Unable to enter programming mode!");
}
}
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.LogErrorAndThrow(
"Unable to leave programming mode on the device!");
}
}
public override void CheckDeviceSignature()
{
logger.Debug("Expecting to find '{0}'...", MCU.DeviceSignature);
if (!deviceSignature.Equals(MCU.DeviceSignature))
{
UploaderLogger.LogErrorAndThrow(
string.Format("Unexpected device signature - found '{0}'- expected '{1}'.",
deviceSignature, MCU.DeviceSignature));
}
}
public override void LoadAddress(IMemory memory, int offset)
{
logger.Trace("Sending load address request: {0}.", offset);
Send(new SetAddressRequest(offset / 2));
var response = ReceiveNext();
if (response != Constants.CARRIAGE_RETURN)
{
UploaderLogger.LogErrorAndThrow("Unable to execute set address request!");
}
}
public override void EnableProgrammingMode()
{
Send(new EnableProgrammingModeRequest(MCU));
var response = Receive <EnableProgrammingModeResponse>();
if (response == null)
{
UploaderLogger.LogAndThrowError <IOException>(
"Unable to enable programming mode on the device!");
}
}
public override void ExecuteWritePage(IMemory memory, int offset, byte[] bytes)
{
SendWithSyncRetry(new ExecuteProgramPageRequest(memory, bytes));
var nextByte = ReceiveNext();
if (nextByte == Constants.RESP_STK_OK)
{
return;
}
UploaderLogger.LogErrorAndThrow(
string.Format("Write at offset {0} failed!", offset));
}
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));
}
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 ExecuteWritePage(IMemory memory, int offset, byte[] bytes)
{
var type = memory.Type;
var blockSize = memory.PageSize;
Send(new StartBlockLoadRequest(type, blockSize, bytes));
var response = ReceiveNext();
if (response != Constants.CARRIAGE_RETURN)
{
UploaderLogger.LogErrorAndThrow("Unable to execute write page!");
}
}
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.LogErrorAndThrow(
string.Format("Retrieving parameter '{0}' failed!", param));
}
return(response.ParameterValue);
}
public override void LoadAddress(IMemory memory, int offset)
{
logger.Trace("Sending load address request: {0}.", offset);
offset = offset >> 1;
Send(new LoadAddressRequest(memory, offset));
var response = Receive <LoadAddressResponse>();
if (response == null || !response.Succeeded)
{
UploaderLogger.LogErrorAndThrow(
"Unable to execute load address!");
}
}
public override void LoadAddress(IMemory memory, 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.LogErrorAndThrow(string.Format("LoadAddress failed with result {0}!", result));
}
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.LogErrorAndThrow(
"Unable to leave programming mode on the device!");
}
}
public override void Close()
{
try
{
logger.Info("Closing...");
SerialPort.Close();
logger.Info("Waiting for virtual port to disappear...");
Thread.Sleep(VIRTUAL_COM_CREATION_TIMEOUT);
}
catch (Exception ex)
{
UploaderLogger.LogErrorAndThrow(
string.Format("Exception during close of the programmer: '{0}'.",
ex.Message));
}
}
public override byte[] ExecuteReadPage(IMemory memory)
{
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.LogErrorAndThrow("Executing read page request failed!");
}
var responseBytes = new byte[memory.PageSize];
Buffer.BlockCopy(response.Bytes, 2, responseBytes, 0, responseBytes.Length);
return(responseBytes);
}
public override void LeaveProgrammingMode()
{
Send(new LeaveProgrammingModeRequest());
var leaveProgModeResp = ReceiveNext();
if (leaveProgModeResp != Constants.CARRIAGE_RETURN)
{
UploaderLogger.LogErrorAndThrow("Unable to leave programming mode!");
}
Send(new ExitBootLoaderRequest());
var exitBootloaderResp = ReceiveNext();
if (exitBootloaderResp != Constants.CARRIAGE_RETURN)
{
UploaderLogger.LogErrorAndThrow("Unable to exit boot loader!");
}
}
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.LogErrorAndThrow(
"Unable to set device programming parameters!");
}
}
public override void ExecuteWritePage(IMemory memory, int offset, byte[] bytes)
{
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.LogErrorAndThrow(
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);
}
public override byte[] ExecuteReadPage(IMemory memory)
{
var pageSize = memory.PageSize;
SendWithSyncRetry(new ExecuteReadPageRequest(memory.Type, pageSize));
var bytes = ReceiveNext(pageSize);
if (bytes == null)
{
UploaderLogger.LogErrorAndThrow("Execute read page failed!");
}
var nextByte = ReceiveNext();
if (nextByte == Constants.RESP_STK_OK)
{
return(bytes);
}
UploaderLogger.LogErrorAndThrow("Execute read page failed!");
return(null);
}
public override void CheckDeviceSignature()
{
logger.Debug("Expecting to find '{0}'...", MCU.DeviceSignature);
Send(new ReadSignatureBytesRequest());
var response = Receive <ReadSignatureBytesResponse>(3);
if (response == null)
{
UploaderLogger.LogErrorAndThrow(
"Unable to check device signature!");
}
var signature = response.Signature;
if (BitConverter.ToString(signature) != MCU.DeviceSignature)
{
UploaderLogger.LogErrorAndThrow(
string.Format(
"Unexpected device signature - found '{0}'- expected '{1}'.",
BitConverter.ToString(signature),
MCU.DeviceSignature));
}
}
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.LogErrorAndThrow(
string.Format(
"Unable to aqcuire sync in SendWithSyncRetry for request of type {0}!",
request.GetType()));
}
}
