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())); } }