/// <summary> /// Populates the list of COM ports. /// </summary> private void PopulateComPorts() { // Don't refresh if the control is not enabled if (!this.comPortSelector.Enabled) { return; } // Get the current list from the combobox so we can auto-select the new device var oldPortList = this.comPortSelector.Items; // Cache the selected item so we can try to re-select it later object selectedValue = null; selectedValue = this.GetSelectedPort(); // Enumerate the COM ports and bind the COM port selector List <ComPort> comPorts = new List <ComPort>(); comPorts = ComPort.EnumeratePortList(); // Check if we have a Maple device MapleDevice mapleCheck = MapleDevice.FindMaple(); // Populate the COM port selector this.PopulatePortSelector(comPorts); // If we had an old list, compare it to the new one and pick the first item which is new if (oldPortList.Count > 0) { foreach (ComPort newPort in comPorts) { bool found = false; foreach (ComPort oldPort in oldPortList) { if (newPort.Name == oldPort.Name) { found = true; } } if (found == false) { Debug.WriteLine($"{newPort.Name} was added."); selectedValue = newPort.Name; } } } // Re-select the previously selected item this.SelectPort(selectedValue); // Set the width of the dropdown // this.comPortSelector.DropDownWidth = comPorts.Select(c => c.DisplayName).ToList().Max(x => TextRenderer.MeasureText(x, this.comPortSelector.Font).Width); // Make sure the Update button is disabled if there is no port selected this.CheckControls(); }
/// <summary> /// Enumerates the available COM ports using WMI, including the device description. /// </summary> /// <returns>Returns an ordered list of ports <see cref="ComPort"/>.</returns> public static List <ComPort> EnumeratePortList2() { List <ComPort> comPorts = new List <ComPort>(); // Get all the COM ports using WMI using (ManagementObjectSearcher searcher = new ManagementObjectSearcher( "root\\cimv2", "SELECT * FROM Win32_PnPEntity WHERE ClassGuid=\"{4d36e978-e325-11ce-bfc1-08002be10318}\"")) { // Add all available ports to the list foreach (ManagementObject queryObj in searcher.Get()) { string portCaption = queryObj["Caption"].ToString(); if (portCaption.Contains("(COM")) { // Get the index number where "(COM" starts in the string int indexOfCom = portCaption.IndexOf("(COM"); string portName = portCaption.Substring(indexOfCom + 1, portCaption.Length - indexOfCom - 2); string portDescription = portCaption.Substring(0, indexOfCom - 1); ComPort thisPort = new ComPort { Name = portName, Description = portDescription, DisplayName = $"{portName} ({portDescription})", }; comPorts.Add(thisPort); } } } // Sort the list of ports comPorts = comPorts.OrderBy(c => c.Name.Length).ThenBy(c => c.Name).ToList(); // Check if we there's a Maple device in DFU mode plugged in if (MapleDevice.FindMaple().DfuMode) { ComPort dfuPort = new ComPort { Name = "DFU Device", Description = "Maple DFU Device", DisplayName = "DFU Device", }; comPorts.Add(dfuPort); } // Return a list of COM ports return(comPorts); }
/// <summary> /// Enumerates the available COM ports without using WMI. /// </summary> /// <returns>Returns an ordered list of ports <see cref="ComPort"/>.</returns> public static List <ComPort> EnumeratePortList() { // Get the start time so we can write how long this takes to the debug window DateTime start = DateTime.Now; Debug.WriteLine("Enumerating COM ports"); // Create a list to store the COM port names List <ComPort> comPorts = new List <ComPort>(); // Get all the COM port names string[] comPortNames = SerialPort.GetPortNames().Distinct().ToArray(); // Add all the COM ports to the list foreach (string portName in comPortNames) { // We only know the port name, so write that to all three properties ComPort thisPort = new ComPort { Name = portName, Description = portName, DisplayName = portName, }; comPorts.Add(thisPort); } // Sort the list of ports by name comPorts = comPorts.OrderBy(c => c.Name.Length).ThenBy(c => c.Name).ToList(); // Check if we there's a Maple DFU device plugged in and add it to the list if (MapleDevice.FindMaple().DfuMode) { ComPort dfuPort = new ComPort { Name = "DFU Device", Description = "DFU Device", DisplayName = "DFU Device", }; comPorts.Add(dfuPort); } // Get the time now and write how long that took DateTime end = DateTime.Now; Debug.WriteLine($"COM ports enumerated in {end - start}."); // Return the list of COM ports return(comPorts); }
/// <summary> /// Enumerates the available COM ports without using WMI. /// </summary> /// <returns>Returns an ordered list of ports <see cref="ComPort"/>.</returns> public static List <ComPort> EnumeratePortList() { DateTime start = DateTime.Now; Debug.WriteLine("Enumerating COM ports"); List <ComPort> comPorts = new List <ComPort>(); // Get all the COM ports string[] comPortNames = SerialPort.GetPortNames(); // Add all available to the list foreach (string portName in comPortNames) { ComPort thisPort = new ComPort { Name = portName, Description = portName, DisplayName = portName, }; comPorts.Add(thisPort); } // Sort the list of ports comPorts = comPorts.OrderBy(c => c.Name.Length).ThenBy(c => c.Name).ToList(); // Check if we there's a Maple device in DFU mode plugged in if (MapleDevice.FindMaple().DfuMode) { ComPort dfuPort = new ComPort { Name = "DFU Device", Description = "DFU Device", DisplayName = "DFU Device", }; comPorts.Add(dfuPort); } DateTime end = DateTime.Now; Debug.WriteLine($"COM ports enumerated in {end - start}."); // Return a list of COM ports return(comPorts); }
/// <summary> /// Gets the name of the Maple Device COM port. /// </summary> /// <returns>A string containing the COM port name.</returns> public static string GetMapleComPort() { string portName = null; MapleDevice device = FindMaple(); if (device.DeviceFound) { _ = new List <ComPort>(); List <ComPort> comPorts = ComPort.EnumeratePortList(); foreach (ComPort port in comPorts) { if (device.DeviceName.Contains(port.Name)) { portName = port.Name; } } } return(portName); }
/// <summary> /// Writes the firmware to a Maple serial or DFU device. /// </summary> /// <param name="flashMulti">An instance of the <see cref="FlashMulti"/> class.</param> /// <param name="fileName">The path of the file to flash.</param> /// <param name="comPort">The COM port where the Maple USB device can be found.</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public static async Task WriteFlash(FlashMulti flashMulti, string fileName, string comPort) { string command; string commandArgs; int returnCode = -1; flashMulti.AppendLog("Starting Multimodule update via native USB\r\n"); // Stop the serial monitor if it's active SerialMonitor serialMonitor = null; bool reconnectSerialMonitor = false; if (Application.OpenForms.OfType <SerialMonitor>().Any()) { Debug.WriteLine("Serial monitor window is open"); serialMonitor = Application.OpenForms.OfType <SerialMonitor>().First(); if (serialMonitor != null && serialMonitor.SerialPort != null && serialMonitor.SerialPort.IsOpen) { reconnectSerialMonitor = true; Debug.WriteLine($"Serial monitor is connected to {serialMonitor.SerialPort.PortName}"); Debug.WriteLine($"Closing serial monitor connection to {serialMonitor.SerialPort.PortName}"); serialMonitor.SerialDisconnect(); } } else { Debug.WriteLine("Serial monitor is not open"); } // Check if the port can be opened if (!ComPort.CheckPort(comPort)) { flashMulti.AppendLog(string.Format("Couldn't open port {0}", comPort)); MessageBox.Show(string.Format("Couldn't open port {0}", comPort), "Write Firmware", MessageBoxButtons.OK, MessageBoxIcon.Error); flashMulti.EnableControls(true); return; } string mapleMode = MapleDevice.FindMaple().Mode; if (mapleMode == "USB") { flashMulti.AppendLog("Switching Multimodule into DFU mode ..."); command = ".\\tools\\maple-reset.exe"; commandArgs = comPort; await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); if (returnCode != 0) { flashMulti.EnableControls(true); flashMulti.AppendLog(" failed!"); MessageBox.Show("Failed to get module to DFU mode.", "Firmware Update", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } flashMulti.AppendLog(" done\r\n"); // Check for a Maple DFU device flashMulti.AppendLog("Waiting for DFU device ..."); bool dfuCheck = false; await Task.Run(() => { dfuCheck = WaitForDFU(2000); }); if (dfuCheck) { flashMulti.AppendLog(" got it\r\n"); } else { flashMulti.AppendLog(" failed!\r\n"); flashMulti.AppendLog("Attempting DFU Recovery Mode.\r\n"); // Show the recovery mode dialog DfuRecoveryDialog recoveryDialog = new DfuRecoveryDialog(flashMulti); var recoveryResult = recoveryDialog.ShowDialog(); // Stop if we didn't made it into recovery mode if (recoveryResult == DialogResult.Cancel) { flashMulti.AppendLog("DFU Recovery cancelled."); flashMulti.EnableControls(true); return; } else if (recoveryResult == DialogResult.Abort) { flashMulti.AppendLog("DFU Recovery failed."); flashMulti.EnableControls(true); return; } } } // First attempt to flash the firmware flashMulti.AppendLog("Writing firmware to Multimodule ..."); command = ".\\tools\\dfu-util.exe"; commandArgs = string.Format("-R -a 2 -d 1EAF:0003 -D \"{0}\"", fileName, comPort); await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); if (returnCode != 0) { // First attempt failed so we need to try bootloader recovery flashMulti.AppendLog(" failed!\r\n"); flashMulti.AppendLog("Attempting DFU Recovery Mode.\r\n"); // Show the recovery mode dialog DfuRecoveryDialog recoveryDialog = new DfuRecoveryDialog(flashMulti); var recoveryResult = recoveryDialog.ShowDialog(); // If we made it into recovery mode, flash the module if (recoveryResult == DialogResult.OK) { // Run the recovery flash command flashMulti.AppendLog("Writing firmware to Multimodule ..."); await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); if (returnCode != 0) { flashMulti.AppendLog(" failed!\r\n"); MessageBox.Show("Failed to write the firmware.", "Firmware Update", MessageBoxButtons.OK, MessageBoxIcon.Error); flashMulti.EnableControls(true); return; } } else if (recoveryResult == DialogResult.Cancel) { flashMulti.AppendLog("DFU Recovery cancelled."); flashMulti.EnableControls(true); return; } else { flashMulti.AppendLog("DFU Recovery failed."); flashMulti.EnableControls(true); return; } } flashMulti.AppendLog(" done\r\n"); flashMulti.AppendLog("\r\nMultimodule updated sucessfully"); // Reconnect the serial monitor if (serialMonitor != null && reconnectSerialMonitor) { Thread.Sleep(1000); serialMonitor.SerialConnect(comPort); } MessageBox.Show("Multimodule updated sucessfully.", "Firmware Update", MessageBoxButtons.OK, MessageBoxIcon.Information); flashMulti.EnableControls(true); }
/// <summary> /// Resets the Maple USB Serial device to DFU mode. /// </summary> /// <param name="flashMulti">An instance of the <see cref="FlashMulti"/> class.</param> /// <param name="comPort">The COM port where the Maple USB device can be found.</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public static async Task <bool> ResetToDfuMode(FlashMulti flashMulti, string comPort) { string command; string commandArgs; int returnCode = -1; // Stop the serial monitor if it's active SerialMonitor serialMonitor = null; if (Application.OpenForms.OfType <SerialMonitor>().Any()) { Debug.WriteLine("Serial monitor window is open"); serialMonitor = Application.OpenForms.OfType <SerialMonitor>().First(); if (serialMonitor != null && serialMonitor.SerialPort != null && serialMonitor.SerialPort.IsOpen) { Debug.WriteLine($"Serial monitor is connected to {serialMonitor.SerialPort.PortName}"); Debug.WriteLine($"Closing serial monitor connection to {serialMonitor.SerialPort.PortName}"); serialMonitor.SerialDisconnect(); } } else { Debug.WriteLine("Serial monitor is not open"); } // Check if the port can be opened if (!ComPort.CheckPort(comPort)) { flashMulti.AppendLog($"{Strings.failedToOpenPort} {comPort}"); using (new CenterWinDialog(flashMulti)) { MessageBox.Show($"{Strings.failedToOpenPort} {comPort}", Strings.dialogTitleRead, MessageBoxButtons.OK, MessageBoxIcon.Error); } flashMulti.EnableControls(true); return(false); } string mapleMode = MapleDevice.FindMaple().Mode; if (mapleMode == "USB") { flashMulti.AppendLog($"{Strings.progressSwitchingToDfuMode}"); command = ".\\tools\\maple-reset.exe"; commandArgs = $"{comPort} 2000"; await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); if (returnCode == 0) { flashMulti.AppendLog($" {Strings.done}\r\n"); flashMulti.AppendVerbose(string.Empty); } else { if (MapleDevice.FindMaple().DfuMode == false) { flashMulti.AppendLog($" {Strings.failed}\r\n"); using (new CenterWinDialog(flashMulti)) { MessageBox.Show(Strings.failedToReadModule, Strings.dialogTitleRead, MessageBoxButtons.OK, MessageBoxIcon.Error); } flashMulti.EnableControls(true); return(false); } } } return(true); }
/// <summary> /// Upgrades the bootloader of a Maple serial or DFU device. /// </summary> /// <param name="flashMulti">An instance of the <see cref="FlashMulti"/> class.</param> /// <param name="comPort">The COM port where the Maple USB device can be found.</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public static async Task <bool> UpgradeBootloader(FlashMulti flashMulti, string comPort) { string command; string commandArgs; int returnCode = -1; flashMulti.AppendLog($"{Strings.modeBootloaderUpgrade} {Strings.viaNativeUSB}\r\n"); // Stop the serial monitor if it's active SerialMonitor serialMonitor = null; if (Application.OpenForms.OfType <SerialMonitor>().Any()) { Debug.WriteLine("Serial monitor window is open"); serialMonitor = Application.OpenForms.OfType <SerialMonitor>().First(); if (serialMonitor != null && serialMonitor.SerialPort != null && serialMonitor.SerialPort.IsOpen) { Debug.WriteLine($"Serial monitor is connected to {serialMonitor.SerialPort.PortName}"); Debug.WriteLine($"Closing serial monitor connection to {serialMonitor.SerialPort.PortName}"); serialMonitor.SerialDisconnect(); } } else { Debug.WriteLine("Serial monitor is not open"); } // Check if the port can be opened if (!ComPort.CheckPort(comPort)) { flashMulti.AppendLog($"{Strings.failedToOpenPort} {comPort}"); using (new CenterWinDialog(flashMulti)) { MessageBox.Show($"{Strings.failedToOpenPort} {comPort}", Strings.dialogTitleBootloaderUpgrade, MessageBoxButtons.OK, MessageBoxIcon.Error); } flashMulti.EnableControls(true); return(false); } string mapleMode = MapleDevice.FindMaple().Mode; if (mapleMode == "USB") { flashMulti.AppendLog(Strings.progressSwitchingToDfuMode); command = ".\\tools\\maple-reset.exe"; commandArgs = $"{comPort} 2000"; await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); if (returnCode == 0) { flashMulti.AppendLog($" {Strings.done}\r\n"); flashMulti.AppendVerbose(string.Empty); } else { if (MapleDevice.FindMaple().DfuMode == false) { flashMulti.AppendLog($" {Strings.failed}\r\n"); using (new CenterWinDialog(flashMulti)) { MessageBox.Show(Strings.failedToWriteBootReloader, Strings.dialogTitleBootloaderUpgrade, MessageBoxButtons.OK, MessageBoxIcon.Error); } flashMulti.EnableControls(true); return(false); } } } // The bootreloader.bin file string fileName; if (Properties.Settings.Default.ErrorIfNoUSB) { fileName = ".\\tools\\bootreloader_legacy.bin"; } else { fileName = ".\\tools\\bootreloader_stickydfu.bin"; } // Erase the the flash flashMulti.AppendLog(Strings.progressWritingBootReloader); command = ".\\tools\\dfu-util-multi.exe"; commandArgs = string.Format("-a 2 -d 1EAF:0003 -D \"{0}\" -v -R", fileName, comPort); await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); if (returnCode != 0) { // First attempt failed so we need to try bootloader recovery flashMulti.AppendLog($" {Strings.failed}\r\n"); flashMulti.AppendLog($"{Strings.dfuAttemptingRecovery}\r\n"); // Show the recovery mode dialog DfuRecoveryDialog recoveryDialog = new DfuRecoveryDialog(flashMulti); var recoveryResult = recoveryDialog.ShowDialog(); // If we made it into recovery mode, flash the module if (recoveryResult == DialogResult.OK) { // Run the recovery flash command flashMulti.AppendLog(Strings.progressWritingBootReloader); await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); if (returnCode != 0) { flashMulti.AppendLog($" {Strings.failed}!\r\n"); using (new CenterWinDialog(flashMulti)) { MessageBox.Show(Strings.failedToWriteFirmware, Strings.dialogTitleWrite, MessageBoxButtons.OK, MessageBoxIcon.Error); } flashMulti.EnableControls(true); return(false); } } else if (recoveryResult == DialogResult.Cancel) { flashMulti.AppendLog(Strings.dfuRecoveryCancelled); flashMulti.EnableControls(true); return(false); } else { flashMulti.AppendLog(Strings.dfuRecoveryFailed); flashMulti.EnableControls(true); return(false); } } // Write a success message to the log flashMulti.AppendLog($" {Strings.done}\r\n"); flashMulti.AppendLog($"\r\n{Strings.succeededWritingBootReloader}"); // Re-enable the form controls flashMulti.EnableControls(true); return(true); }
/// <summary> /// Writes the firmware to a Maple serial or DFU device. /// </summary> /// <param name="flashMulti">An instance of the <see cref="FlashMulti"/> class.</param> /// <param name="fileName">The path of the file to flash.</param> /// <param name="comPort">The COM port where the Maple USB device can be found.</param> /// <param name="runAfterUpload">Indicates if the firmware should be run when the upload is finished.</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public static async Task WriteFlash(FlashMulti flashMulti, string fileName, string comPort, bool runAfterUpload) { string command; string commandArgs; int returnCode = -1; flashMulti.AppendLog($"{Strings.modeWriting} {Strings.viaNativeUSB}\r\n"); // Stop the serial monitor if it's active SerialMonitor serialMonitor = null; bool reconnectSerialMonitor = false; if (Application.OpenForms.OfType <SerialMonitor>().Any()) { Debug.WriteLine("Serial monitor window is open"); serialMonitor = Application.OpenForms.OfType <SerialMonitor>().First(); if (serialMonitor != null && serialMonitor.SerialPort != null && serialMonitor.SerialPort.IsOpen) { reconnectSerialMonitor = true; Debug.WriteLine($"Serial monitor is connected to {serialMonitor.SerialPort.PortName}"); Debug.WriteLine($"Closing serial monitor connection to {serialMonitor.SerialPort.PortName}"); serialMonitor.SerialDisconnect(); } } else { Debug.WriteLine("Serial monitor is not open"); } // Check if the port can be opened if (!ComPort.CheckPort(comPort)) { flashMulti.AppendLog($"{Strings.failedToOpenPort} {comPort}"); using (new CenterWinDialog(flashMulti)) { MessageBox.Show($"{Strings.failedToOpenPort} {comPort}", Strings.dialogTitleWrite, MessageBoxButtons.OK, MessageBoxIcon.Error); } flashMulti.EnableControls(true); return; } string mapleMode = MapleDevice.FindMaple().Mode; if (mapleMode == "USB") { flashMulti.AppendLog(Strings.progressSwitchingToDfuMode); command = ".\\tools\\maple-reset.exe"; commandArgs = $"{comPort} 2000"; await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); if (returnCode == 0) { flashMulti.AppendLog($" {Strings.done}\r\n"); flashMulti.AppendVerbose(string.Empty); } else { if (MapleDevice.FindMaple().DfuMode == false) { flashMulti.AppendLog($" {Strings.failed}\r\n"); flashMulti.AppendLog($"{Strings.dfuAttemptingRecovery}\r\n"); // Show the recovery mode dialog DfuRecoveryDialog recoveryDialog = new DfuRecoveryDialog(flashMulti); var recoveryResult = recoveryDialog.ShowDialog(); // Stop if we didn't make it into recovery mode if (recoveryResult == DialogResult.Cancel) { flashMulti.AppendLog(Strings.dfuRecoveryCancelled); flashMulti.EnableControls(true); return; } else if (recoveryResult == DialogResult.Abort) { flashMulti.AppendLog(Strings.dfuRecoveryFailed); flashMulti.EnableControls(true); return; } } else { flashMulti.AppendLog($" {Strings.done}\r\n"); flashMulti.AppendVerbose(string.Empty); } } } if (!Properties.Settings.Default.DisableFlashVerification) { // Check that the STM32 MCU supports 128KB flashMulti.AppendLog($"{Strings.progressCheckingFlashSize}"); // Create a temporary file name to read into string tempFileName = Path.GetTempFileName(); // Read the flash memory into a temp file command = ".\\tools\\dfu-util-multi.exe"; commandArgs = string.Format("-a 2 -d 1EAF:0003 -U \"{0}\" -v", tempFileName, comPort); await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); // If we failed we need to try DFU Recovery Mode if (returnCode != 0) { // First attempt failed so we need to try bootloader recovery flashMulti.AppendLog($" {Strings.failed}\r\n"); flashMulti.AppendLog($"{Strings.dfuAttemptingRecovery}\r\n"); // Show the recovery mode dialog DfuRecoveryDialog recoveryDialog = new DfuRecoveryDialog(flashMulti); var recoveryResult = recoveryDialog.ShowDialog(); // If we made it into recovery mode, flash the module if (recoveryResult == DialogResult.OK) { // Run the recovery flash command flashMulti.AppendLog(Strings.progressCheckingFlashSize); await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); if (returnCode != 0) { flashMulti.AppendLog($" {Strings.failed}!\r\n"); using (new CenterWinDialog(flashMulti)) { MessageBox.Show(Strings.failedToWriteFirmware, Strings.dialogTitleWrite, MessageBoxButtons.OK, MessageBoxIcon.Error); } flashMulti.EnableControls(true); return; } } else if (recoveryResult == DialogResult.Cancel) { flashMulti.AppendLog(Strings.dfuRecoveryCancelled); flashMulti.EnableControls(true); return; } else { flashMulti.AppendLog(Strings.dfuRecoveryFailed); flashMulti.EnableControls(true); return; } } flashMulti.AppendLog($" {Strings.done}\r\n"); // Get the file size long length = new FileInfo(tempFileName).Length; // Compare the size of the data we read to the size we expect if (length < 122880) { // Throw a message and stop flashMulti.EnableControls(true); using (new CenterWinDialog(flashMulti)) { MessageBox.Show(Strings.failedToVerifyMcuFlash, Strings.dialogTitleWrite, MessageBoxButtons.OK, MessageBoxIcon.Error); } return; } } // First attempt to flash the firmware flashMulti.AppendLog(Strings.progressWritingFirmware); command = ".\\tools\\dfu-util-multi.exe"; commandArgs = string.Format("-a 2 -d 1EAF:0003 -D \"{0}\" -v", fileName, comPort); if (runAfterUpload) { commandArgs += " -R"; } await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); if (returnCode != 0) { // First attempt failed so we need to try bootloader recovery flashMulti.AppendLog($" {Strings.failed}\r\n"); flashMulti.AppendLog($"{Strings.dfuAttemptingRecovery}\r\n"); // Show the recovery mode dialog DfuRecoveryDialog recoveryDialog = new DfuRecoveryDialog(flashMulti); var recoveryResult = recoveryDialog.ShowDialog(); // If we made it into recovery mode, flash the module if (recoveryResult == DialogResult.OK) { // Run the recovery flash command flashMulti.AppendLog(Strings.progressWritingFirmware); await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); if (returnCode != 0) { flashMulti.AppendLog($" {Strings.failed}!\r\n"); using (new CenterWinDialog(flashMulti)) { MessageBox.Show(Strings.failedToWriteFirmware, Strings.dialogTitleWrite, MessageBoxButtons.OK, MessageBoxIcon.Error); } flashMulti.EnableControls(true); return; } } else if (recoveryResult == DialogResult.Cancel) { flashMulti.AppendLog(Strings.dfuRecoveryCancelled); flashMulti.EnableControls(true); return; } else { flashMulti.AppendLog(Strings.dfuRecoveryFailed); flashMulti.EnableControls(true); return; } } flashMulti.AppendLog($" {Strings.done}\r\n"); flashMulti.AppendLog($"\r\n{Strings.succeededWritingFirmware}"); // Reconnect the serial monitor if (serialMonitor != null && reconnectSerialMonitor) { Thread.Sleep(1000); serialMonitor.SerialConnect(comPort); } // Re-enable the form controls flashMulti.EnableControls(true); // Show a success message box using (new CenterWinDialog(flashMulti)) { MessageBox.Show(Strings.succeededWritingFirmware, Strings.dialogTitleWrite, MessageBoxButtons.OK, MessageBoxIcon.Information); } }
/// <summary> /// Reads the flash memory of a Maple USB device. /// </summary> /// <param name="flashMulti">An instance of the <see cref="FlashMulti"/> class.</param> /// <param name="fileName">The path of the file to write to.</param> /// <param name="comPort">The COM port where the Maple USB device can be found.</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public static async Task <bool> ReadFlash(FlashMulti flashMulti, string fileName, string comPort) { string command; string commandArgs; int returnCode = -1; flashMulti.AppendLog($"{Strings.modeReading} {Strings.viaNativeUSB}\r\n"); // Stop the serial monitor if it's active SerialMonitor serialMonitor = null; bool reconnectSerialMonitor = false; if (Application.OpenForms.OfType <SerialMonitor>().Any()) { Debug.WriteLine("Serial monitor window is open"); serialMonitor = Application.OpenForms.OfType <SerialMonitor>().First(); if (serialMonitor != null && serialMonitor.SerialPort != null && serialMonitor.SerialPort.IsOpen) { reconnectSerialMonitor = true; Debug.WriteLine($"Serial monitor is connected to {serialMonitor.SerialPort.PortName}"); Debug.WriteLine($"Closing serial monitor connection to {serialMonitor.SerialPort.PortName}"); serialMonitor.SerialDisconnect(); } } else { Debug.WriteLine("Serial monitor is not open"); } // Check if the port can be opened if (!ComPort.CheckPort(comPort)) { flashMulti.AppendLog($"{Strings.failedToOpenPort} {comPort}"); using (new CenterWinDialog(flashMulti)) { MessageBox.Show($"{Strings.failedToOpenPort} {comPort}", Strings.dialogTitleRead, MessageBoxButtons.OK, MessageBoxIcon.Error); } flashMulti.EnableControls(true); return(false); } string mapleMode = MapleDevice.FindMaple().Mode; if (mapleMode == "USB") { flashMulti.AppendLog($"{Strings.progressSwitchingToDfuMode}"); command = ".\\tools\\maple-reset.exe"; commandArgs = $"{comPort} 2000"; await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); if (returnCode == 0) { flashMulti.AppendLog($" {Strings.done}\r\n"); flashMulti.AppendVerbose(string.Empty); } else { if (MapleDevice.FindMaple().DfuMode == false) { flashMulti.AppendLog($" {Strings.failed}\r\n"); using (new CenterWinDialog(flashMulti)) { MessageBox.Show(Strings.failedToReadModule, Strings.dialogTitleRead, MessageBoxButtons.OK, MessageBoxIcon.Error); } flashMulti.EnableControls(true); return(false); } } } // Read the flash memory flashMulti.AppendLog(Strings.progressReadingFlash); command = ".\\tools\\dfu-util-multi.exe"; commandArgs = string.Format("-a 2 -d 1EAF:0003 -U \"{0}\" -v", fileName, comPort); await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); if (returnCode != 0) { flashMulti.AppendLog($" {Strings.failed}\r\n"); using (new CenterWinDialog(flashMulti)) { MessageBox.Show(Strings.failedToReadModule, Strings.dialogTitleRead, MessageBoxButtons.OK, MessageBoxIcon.Error); } flashMulti.EnableControls(true); return(false); } // Write a success message to the log flashMulti.AppendLog($" {Strings.done}\r\n\r\n"); // Reconnect the serial monitor if (serialMonitor != null && reconnectSerialMonitor) { Thread.Sleep(1000); serialMonitor.SerialConnect(comPort); } // Re-enable the form controls flashMulti.EnableControls(true); return(true); }
/// <summary> /// Erases the flash memory of a Maple USB device. /// </summary> /// <param name="flashMulti">An instance of the <see cref="FlashMulti"/> class.</param> /// <param name="comPort">The COM port where the Maple USB device can be found.</param> /// <param name="eraseEeprom">Flag indicating if the EEPROM should be erased.</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public static async Task <bool> EraseFlash(FlashMulti flashMulti, string comPort, bool eraseEeprom) { string command; string commandArgs; int returnCode = -1; flashMulti.AppendLog($"{Strings.modeErasing} {Strings.viaNativeUSB}\r\n"); // Stop the serial monitor if it's active SerialMonitor serialMonitor = null; if (Application.OpenForms.OfType <SerialMonitor>().Any()) { Debug.WriteLine("Serial monitor window is open"); serialMonitor = Application.OpenForms.OfType <SerialMonitor>().First(); if (serialMonitor != null && serialMonitor.SerialPort != null && serialMonitor.SerialPort.IsOpen) { Debug.WriteLine($"Serial monitor is connected to {serialMonitor.SerialPort.PortName}"); Debug.WriteLine($"Closing serial monitor connection to {serialMonitor.SerialPort.PortName}"); serialMonitor.SerialDisconnect(); } } else { Debug.WriteLine("Serial monitor is not open"); } // Check if the port can be opened if (!ComPort.CheckPort(comPort)) { flashMulti.AppendLog($"{Strings.failedToOpenPort} {comPort}"); using (new CenterWinDialog(flashMulti)) { MessageBox.Show($"{Strings.failedToOpenPort} {comPort}", Strings.dialogTitleErase, MessageBoxButtons.OK, MessageBoxIcon.Error); } flashMulti.EnableControls(true); return(false); } string mapleMode = MapleDevice.FindMaple().Mode; if (mapleMode == "USB") { flashMulti.AppendLog(Strings.progressSwitchingToDfuMode); command = ".\\tools\\maple-reset.exe"; commandArgs = $"{comPort} 2000"; await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); if (returnCode == 0) { flashMulti.AppendLog($" {Strings.done}\r\n"); flashMulti.AppendVerbose(string.Empty); } else { if (MapleDevice.FindMaple().DfuMode == false) { flashMulti.AppendLog($" {Strings.failed}\r\n"); using (new CenterWinDialog(flashMulti)) { MessageBox.Show(Strings.failedtoEraseModule, Strings.dialogTitleErase, MessageBoxButtons.OK, MessageBoxIcon.Error); } flashMulti.EnableControls(true); return(false); } } } // It's not actually possible to erase a device with dfu-util so we write a file full of FF bytes. string fileName = string.Empty; if (eraseEeprom) { // 120KB file overwrites the EEPROM fileName = ".\\tools\\erase120.bin"; } else { // 118KB file preserves the EEPROM fileName = ".\\tools\\erase118.bin"; } // Erase the the flash flashMulti.AppendLog(Strings.progressErasingFlash); command = ".\\tools\\dfu-util-multi.exe"; commandArgs = string.Format("-a 2 -d 1EAF:0003 -D \"{0}\" -v", fileName, comPort); await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); if (returnCode != 0) { flashMulti.AppendLog($" {Strings.failed}\r\n"); using (new CenterWinDialog(flashMulti)) { MessageBox.Show(Strings.failedtoEraseModule, Strings.dialogTitleErase, MessageBoxButtons.OK, MessageBoxIcon.Error); } flashMulti.EnableControls(true); return(false); } // Write a success message to the log flashMulti.AppendLog($" {Strings.done}\r\n"); flashMulti.AppendLog($"\r\n{Strings.succeededErasing}"); // Re-enable the form controls flashMulti.EnableControls(true); return(true); }
/// <summary> /// Reads the flash memory of a serial device. /// </summary> /// <param name="flashMulti">An instance of the <see cref="FlashMulti"/> class.</param> /// <param name="fileName">The path of the file to write to.</param> /// <param name="comPort">The COM port where the serial device can be found.</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public static async Task <bool> ReadFlash(FlashMulti flashMulti, string fileName, string comPort) { // Path to the flashing tool, stm32flash.exe string command = ".\\tools\\stm32flash.exe"; // Baud rate for serial flash commands int serialBaud = Properties.Settings.Default.SerialBaudRate; // Arguments for the command line - will vary at each step of the process string commandArgs; // Variable to keep the return code from executed commands int returnCode = -1; // Write to the log flashMulti.AppendLog($"{Strings.modeReading} {Strings.viaSerial}\r\n"); // Stop the serial monitor if it's active SerialMonitor serialMonitor = null; bool reconnectSerialMonitor = false; if (Application.OpenForms.OfType <SerialMonitor>().Any()) { Debug.WriteLine("Serial monitor window is open"); serialMonitor = Application.OpenForms.OfType <SerialMonitor>().First(); if (serialMonitor != null && serialMonitor.SerialPort != null && serialMonitor.SerialPort.IsOpen) { reconnectSerialMonitor = true; Debug.WriteLine($"Serial monitor is connected to {serialMonitor.SerialPort.PortName}"); Debug.WriteLine($"Closing serial monitor connection to {serialMonitor.SerialPort.PortName}"); serialMonitor.SerialDisconnect(); } } else { Debug.WriteLine("Serial monitor is not open"); } // Check if the port can be opened if (!ComPort.CheckPort(comPort)) { flashMulti.AppendLog($"{Strings.failedToOpenPort} {comPort}"); MessageBox.Show($"{Strings.failedToOpenPort} {comPort}", Strings.dialogTitleRead, MessageBoxButtons.OK, MessageBoxIcon.Error); flashMulti.EnableControls(true); return(false); } // Write to the log flashMulti.AppendLog($"[1/1] {Strings.progressReadingFlash}"); // Prepare the command line arguments for writing the firmware commandArgs = $"-b {serialBaud} -r \"{fileName}\" {comPort}"; // Run the write command asynchronously and wait for it to finish await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); // Show an error message if the command failed for any reason if (returnCode != 0) { flashMulti.AppendLog($" {Strings.failed}"); MessageBox.Show(Strings.failedToReadModule, Strings.dialogTitleRead, MessageBoxButtons.OK, MessageBoxIcon.Error); flashMulti.EnableControls(true); return(false); } // Reconnect the serial monitor if it was connected before if (serialMonitor != null && serialMonitor.IsDisposed != true && reconnectSerialMonitor) { serialMonitor.SerialConnect(comPort); } // Write a success message to the log flashMulti.AppendLog($" {Strings.done}\r\n\r\n"); // Re-enable the form controls flashMulti.EnableControls(true); return(true); }
/// <summary> /// Writes the firmware to a serial device. /// </summary> /// <param name="flashMulti">An instance of the <see cref="FlashMulti"/> class.</param> /// <param name="fileName">The path of the file to flash.</param> /// <param name="comPort">The COM port where the serial device can be found.</param> /// <param name="writeBootloader">Indicates whether or not the bootloader should be written.</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public static async Task WriteFlash(FlashMulti flashMulti, string fileName, string comPort, bool writeBootloader) { // Path to the flashing tool, stm32flash.exe string command = ".\\tools\\stm32flash.exe"; // Path to the bootloader file string bootLoaderPath = ".\\bootloaders\\StmMulti4in1.bin"; // Baud rate for serial flash commands int serialBaud = Properties.Settings.Default.SerialBaudRate; // Arguments for the command line - will vary at each step of the process string commandArgs; // Variable to keep the return code from executed commands int returnCode = -1; // First step in flash process int flashStep = 1; // Total number of steps in flash process int flashSteps = 2; // Page in the STM32 flash memory where we will begin writing int flashStart = 0; // Address where we will start execution after flashing string executionAddress = "0x8000000"; if (writeBootloader) { // Increase the total number of steps flashSteps = 3; // The bootloader occupies the first 8 pages (0-7), so start writing after it flashStart = 8; // Start execution at the Multiprotocol code rather than the bootloader executionAddress = "0x8002000"; } // Write to the log flashMulti.AppendLog("Starting Multimodule update via serial\r\n"); // Stop the serial monitor if it's active SerialMonitor serialMonitor = null; bool reconnectSerialMonitor = false; if (Application.OpenForms.OfType <SerialMonitor>().Any()) { Debug.WriteLine("Serial monitor window is open"); serialMonitor = Application.OpenForms.OfType <SerialMonitor>().First(); if (serialMonitor != null && serialMonitor.SerialPort != null && serialMonitor.SerialPort.IsOpen) { reconnectSerialMonitor = true; Debug.WriteLine($"Serial monitor is connected to {serialMonitor.SerialPort.PortName}"); Debug.WriteLine($"Closing serial monitor connection to {serialMonitor.SerialPort.PortName}"); serialMonitor.SerialDisconnect(); } } else { Debug.WriteLine("Serial monitor is not open"); } // Check if the port can be opened if (!ComPort.CheckPort(comPort)) { flashMulti.AppendLog(string.Format("Couldn't open port {0}", comPort)); MessageBox.Show(string.Format("Couldn't open port {0}", comPort), "Write Firmware", MessageBoxButtons.OK, MessageBoxIcon.Error); flashMulti.EnableControls(true); return; } // Erase the flash flashMulti.AppendLog($"[{flashStep}/{flashSteps}] Erasing flash memory..."); // Set the stm32flash.exe command line arguments for erasing // We preserve the last 2KB of flash, which is where the EEPROM data lives. commandArgs = $"-o -S 0x8000000:129024 -b {serialBaud} {comPort}"; // Run the erase command asynchronously and wait for it to finish await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); // Show an error message if the erase command failed for any reason if (returnCode != 0) { flashMulti.EnableControls(true); flashMulti.AppendLog(" failed!"); MessageBox.Show("Failed to erase flash memory.", "Firmware Update", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } flashMulti.AppendLog(" done\r\n"); // Write the bootloader if required if (writeBootloader) { // Increment the step counter and write to the log flashStep++; flashMulti.AppendLog($"[{flashStep}/{flashSteps}] Writing bootloader..."); // Prepare the command line arguments for writing the bootloader commandArgs = $"-v -e 0 -g 0x8000000 -b {serialBaud} -w \"{bootLoaderPath}\" {comPort}"; // Run the write command asynchronously and wait for it to finish await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); // Show an error message if the command failed for any reason if (returnCode != 0) { flashMulti.EnableControls(true); flashMulti.AppendLog(" failed!"); MessageBox.Show("Failed to write the bootloader.", "Firmware Update", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } flashMulti.AppendLog(" done\r\n"); } // Increment the step counter and write to the log flashStep++; flashMulti.AppendLog($"[{flashStep}/{flashSteps}] Writing Multimodule firmware..."); // Prepare the command line arguments for writing the firmware commandArgs = $"-v -s {flashStart} -e 0 -g {executionAddress} -b {serialBaud} -w \"{fileName}\" {comPort}"; // Run the write command asynchronously and wait for it to finish await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); // Show an error message if the command failed for any reason if (returnCode != 0) { flashMulti.EnableControls(true); flashMulti.AppendLog(" failed!"); MessageBox.Show("Failed to write the firmware.", "Firmware Update", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } // Reconnect the serial monitor if it was connected before if (serialMonitor != null && serialMonitor.IsDisposed != true && reconnectSerialMonitor) { serialMonitor.SerialConnect(comPort); } // Write a success message to the log flashMulti.AppendLog(" done\r\n"); flashMulti.AppendLog("\r\nMultimodule updated sucessfully"); // Show a success message box MessageBox.Show("Multimodule updated sucessfully.", "Firmware Update", MessageBoxButtons.OK, MessageBoxIcon.Information); // Re-enable the form controls flashMulti.EnableControls(true); }
/// <summary> /// Main method where all the action happens. /// Called by the Upload button. /// </summary> private void ButtonUpload_Click(object sender, EventArgs e) { // Clear the output box Debug.WriteLine("Clearing the output textboxes..."); this.textActivity.Clear(); this.textVerbose.Clear(); this.progressBar1.Value = 0; // Check if the file exists if (!File.Exists(this.textFileName.Text)) { this.AppendLog(string.Format("File {0} does not exist", this.textFileName.Text)); MessageBox.Show("Firmware file does not exist.", "Write Firmware", MessageBoxButtons.OK, MessageBoxIcon.Error); this.EnableControls(true); return; } // Check that the file size is OK // Max size is 120,832B (118KB) with bootloader, 129,024B (126KB) without int maxFileSize = 129024; if (this.writeBootloader_Yes.Checked) { maxFileSize = 120832; } long length = new System.IO.FileInfo(this.textFileName.Text).Length; if (length > maxFileSize) { this.AppendLog(string.Format("Firmware file is too large.\r\nFile is {1:n0} KB, maximum size is {2:n0} KB.", this.textFileName.Text, length / 1024, maxFileSize / 1024)); MessageBox.Show("Firmware file is too large.", "Write Firmware", MessageBoxButtons.OK, MessageBoxIcon.Error); this.EnableControls(true); return; } // Get the selected COM port string comPort = this.comPortSelector.SelectedValue.ToString(); // Check if the port can be opened if (!ComPort.CheckPort(comPort)) { this.AppendLog(string.Format("Couldn't open port {0}", comPort)); MessageBox.Show(string.Format("Couldn't open port {0}", comPort), "Write Firmware", MessageBoxButtons.OK, MessageBoxIcon.Error); this.EnableControls(true); return; } // Disable the buttons until this flash attempt is complete Debug.WriteLine("Disabling the controls..."); this.EnableControls(false); // Determine if we should use Maple or serial interface MapleDevice mapleResult = MapleDevice.FindMaple(); if (mapleResult.DeviceFound == true) { this.AppendLog(string.Format("Maple device found in {0} mode\r\n", mapleResult.Mode)); } // Do the selected flash using the appropriate method if (mapleResult.DeviceFound == true) { // MapleFlashWrite(textFileName.Text, comPort); MapleDevice.WriteFlash(this, this.textFileName.Text, comPort); } else { SerialDevice.WriteFlash(this, this.textFileName.Text, comPort); } }
/// <summary> /// Populates the list of COM ports. /// </summary> private void PopulateComPorts() { if (this.InvokeRequired) { this.Invoke(new Action(this.PopulateComPorts)); return; } // Don't refresh if the control is not enabled if (!this.comPortSelector.Enabled) { return; } // Get the current list from the combobox so we can auto-select the new device var oldPortList = this.comPortSelector.Items; // Cache the selected item so we can try to re-select it later object selectedValue = null; selectedValue = this.comPortSelector.SelectedValue; // Enumerate the COM ports and bind the COM port selector List <ComPort> comPorts = new List <ComPort>(); comPorts = ComPort.EnumeratePortList(); // Check if we have a Maple device MapleDevice mapleCheck = MapleDevice.FindMaple(); this.comPortSelector.DataSource = comPorts; this.comPortSelector.DisplayMember = "Name"; this.comPortSelector.ValueMember = "Name"; // If we had an old list, compare it to the new one and pick the first item which is new if (oldPortList.Count > 0) { foreach (ComPort newPort in comPorts) { bool found = false; foreach (ComPort oldPort in oldPortList) { if (newPort.Name == oldPort.Name) { found = true; } } if (found == false) { Debug.WriteLine($"{newPort.Name} was added."); selectedValue = newPort.Name; } } } // Re-select the previously selected item if (selectedValue != null) { this.comPortSelector.SelectedValue = selectedValue; } else { this.comPortSelector.SelectedItem = null; } // Check if we there's a Maple device plugged in if (mapleCheck.DeviceFound) { // Set the Write Bootloader radio button and disable the controls if a Maple device is present // Required so that the firmware size is calculated correctly this.writeBootloader_Yes.Checked = true; this.writeBootloader_Yes.Enabled = false; this.writeBootloader_No.Enabled = false; } else { this.writeBootloader_Yes.Enabled = true; this.writeBootloader_No.Enabled = true; } // Set the width of the dropdown // this.comPortSelector.DropDownWidth = comPorts.Select(c => c.DisplayName).ToList().Max(x => TextRenderer.MeasureText(x, this.comPortSelector.Font).Width); // Make sure the Update button is disabled if there is no port selected this.CheckControls(); }
/// <summary> /// Erases the flash memory of a serial device. /// </summary> /// <param name="flashMulti">An instance of the <see cref="FlashMulti"/> class.</param> /// <param name="comPort">The COM port where the serial device can be found.</param> /// <param name="eraseEeprom">Flag indicating if the EEPROM should be erased.</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public static async Task <bool> EraseFlash(FlashMulti flashMulti, string comPort, bool eraseEeprom) { // Path to the flashing tool, stm32flash.exe string command = ".\\tools\\stm32flash.exe"; // Baud rate for serial flash commands int serialBaud = Properties.Settings.Default.SerialBaudRate; // Arguments for the command line - will vary at each step of the process string commandArgs; // Variable to keep the return code from executed commands int returnCode = -1; // By default we preserve the last 2KB of flash, which is where the EEPROM data lives. int eraseBytes = 129024; // But if we're writing the EEPROM we need to erase it first if (eraseEeprom) { eraseBytes = 131072; } // Write to the log flashMulti.AppendLog($"{Strings.modeErasing} {Strings.viaSerial}\r\n"); // Stop the serial monitor if it's active SerialMonitor serialMonitor = null; if (Application.OpenForms.OfType <SerialMonitor>().Any()) { Debug.WriteLine("Serial monitor window is open"); serialMonitor = Application.OpenForms.OfType <SerialMonitor>().First(); if (serialMonitor != null && serialMonitor.SerialPort != null && serialMonitor.SerialPort.IsOpen) { Debug.WriteLine($"Serial monitor is connected to {serialMonitor.SerialPort.PortName}"); Debug.WriteLine($"Closing serial monitor connection to {serialMonitor.SerialPort.PortName}"); serialMonitor.SerialDisconnect(); } } else { Debug.WriteLine("Serial monitor is not open"); } // Check if the port can be opened if (!ComPort.CheckPort(comPort)) { flashMulti.AppendLog($"{Strings.failedToOpenPort} {comPort}"); MessageBox.Show($"{Strings.failedToOpenPort} {comPort}", Strings.dialogTitleErase, MessageBoxButtons.OK, MessageBoxIcon.Error); flashMulti.EnableControls(true); return(false); } // Write to the log flashMulti.AppendLog($"[1/1] {Strings.progressErasingFlash}"); // Prepare the command line arguments for erasing the firmware commandArgs = $"-o -S 0x8000000:{eraseBytes} -b {serialBaud} {comPort}"; // Run the write command asynchronously and wait for it to finish await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); // Show an error message if the command failed for any reason if (returnCode != 0) { flashMulti.EnableControls(true); flashMulti.AppendLog(Strings.failed); MessageBox.Show(Strings.failedtoEraseModule, Strings.dialogTitleErase, MessageBoxButtons.OK, MessageBoxIcon.Error); return(false); } // Write a success message to the log flashMulti.AppendLog($" {Strings.done}\r\n"); flashMulti.AppendLog($"\r\n{Strings.succeededErasing}"); // Re-enable the form controls flashMulti.EnableControls(true); return(true); }
/// <summary> /// Writes the firmware to a serial device. /// </summary> /// <param name="flashMulti">An instance of the <see cref="FlashMulti"/> class.</param> /// <param name="fileName">The path of the file to flash.</param> /// <param name="comPort">The COM port where the serial device can be found.</param> /// <param name="writeBootloader">Indicates whether or not the bootloader should be written.</param> /// <param name="writeEeprom">Indicates whether or not the EEPROM is being written, therefore should be erased before the write.</param> /// <param name="runAfterUpload">Indicates whether or not the firmware should run after it is uploaded.</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public static async Task WriteFlash(FlashMulti flashMulti, string fileName, string comPort, bool writeBootloader, bool writeEeprom, bool runAfterUpload) { // Path to the flashing tool, stm32flash.exe string command = ".\\tools\\stm32flash.exe"; // Path to the bootloader file string bootLoaderPath = ".\\bootloaders\\StmMulti4in1_StickyDfu.bin"; // Baud rate for serial flash commands int serialBaud = Properties.Settings.Default.SerialBaudRate; // Arguments for the command line - will vary at each step of the process string commandArgs; // Variable to keep the return code from executed commands int returnCode = -1; // First step in flash process int flashStep = 0; // Total number of steps in flash process int flashSteps = 2; // Page in the STM32 flash memory where we will begin writing int flashStart = 0; // By default we preserve the last 2KB of flash, which is where the EEPROM data lives. int eraseBytes = 129024; // But if we're writing the EEPROM we need to erase it first if (writeEeprom) { eraseBytes = 131072; } // Address where we will start execution after flashing string executionAddress = "0x8000000"; if (writeBootloader) { // Increase the total number of steps flashSteps++; // The bootloader occupies the first 8 pages (0-7), so start writing after it flashStart = 8; // Start execution at the MULTI-Module code rather than the bootloader executionAddress = "0x8002000"; } // Write to the log flashMulti.AppendLog($"{Strings.modeWriting} {Strings.viaSerial}\r\n"); // Stop the serial monitor if it's active SerialMonitor serialMonitor = null; bool reconnectSerialMonitor = false; if (Application.OpenForms.OfType <SerialMonitor>().Any()) { Debug.WriteLine("Serial monitor window is open"); serialMonitor = Application.OpenForms.OfType <SerialMonitor>().First(); if (serialMonitor != null && serialMonitor.SerialPort != null && serialMonitor.SerialPort.IsOpen) { reconnectSerialMonitor = true; Debug.WriteLine($"Serial monitor is connected to {serialMonitor.SerialPort.PortName}"); Debug.WriteLine($"Closing serial monitor connection to {serialMonitor.SerialPort.PortName}"); serialMonitor.SerialDisconnect(); } } else { Debug.WriteLine("Serial monitor is not open"); } // Check if the port can be opened if (!ComPort.CheckPort(comPort)) { flashMulti.AppendLog($"{Strings.failedToOpenPort} {comPort}"); MessageBox.Show($"{Strings.failedToOpenPort} {comPort}", Strings.dialogTitleWrite, MessageBoxButtons.OK, MessageBoxIcon.Error); flashMulti.EnableControls(true); return; } if (!Properties.Settings.Default.DisableFlashVerification) { flashStep++; // Increase the total number of steps flashSteps++; // Check that the STM32 MCU supports 128KB flashMulti.AppendLog($"[{flashStep}/{flashSteps}] {Strings.progressCheckingFlashSize}"); // Create a temporary file name to read into string tempFileName = Path.GetTempFileName(); // Set the stm32flash.exe command line arguments for reading the 32B of flash above 64KB commandArgs = $"-r {tempFileName} -S 0x8010000:32 -b {serialBaud} {comPort}"; // Run the read command asynchronously and wait for it to finish await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); // Show an error message if the read command failed for any reason if (returnCode != 0) { flashMulti.EnableControls(true); flashMulti.AppendLog($" {Strings.failed}"); MessageBox.Show(Strings.failedToReadModule, Strings.dialogTitleWrite, MessageBoxButtons.OK, MessageBoxIcon.Error); return; } flashMulti.AppendLog($" {Strings.done}\r\n"); // Read the data we read from the module byte[] byteBuffer = File.ReadAllBytes(tempFileName); // 32 Bytes of bad data to compare to byte[] badData = { 7, 73, 8, 128, 7, 73, 8, 128, 7, 73, 8, 128, 7, 73, 8, 128, 7, 73, 8, 128, 7, 73, 8, 128, 7, 73, 8, 128, 7, 73, 8, 128 }; // Compare the data we read to the known 'bad' data if (StructuralComparisons.StructuralEqualityComparer.Equals(byteBuffer, badData)) { // Throw a message and stop flashMulti.EnableControls(true); MessageBox.Show(Strings.failedToVerifyMcuFlash, Strings.dialogTitleWrite, MessageBoxButtons.OK, MessageBoxIcon.Error); return; } } // Increment the step counter and write to the log flashStep++; flashMulti.AppendLog($"[{flashStep}/{flashSteps}] {Strings.progressErasingFlash}"); // Set the stm32flash.exe command line arguments for erasing commandArgs = $"-o -S 0x8000000:{eraseBytes} -b {serialBaud} {comPort}"; // Run the erase command asynchronously and wait for it to finish await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); // Show an error message if the erase command failed for any reason if (returnCode != 0) { flashMulti.EnableControls(true); flashMulti.AppendLog($" {Strings.failed}"); MessageBox.Show(Strings.failedtoEraseModule, Strings.dialogTitleWrite, MessageBoxButtons.OK, MessageBoxIcon.Error); return; } flashMulti.AppendLog($" {Strings.done}\r\n"); // Write the bootloader if required if (writeBootloader) { // Increment the step counter and write to the log flashStep++; flashMulti.AppendLog($"[{flashStep}/{flashSteps}] {Strings.progressWritingBootloader}"); // Prepare the command line arguments for writing the bootloader commandArgs = $"-v -e 0 -g 0x8000000 -b {serialBaud} -w \"{bootLoaderPath}\" {comPort}"; // Run the write command asynchronously and wait for it to finish await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); // Show an error message if the command failed for any reason if (returnCode != 0) { flashMulti.EnableControls(true); flashMulti.AppendLog($" {Strings.failed}"); MessageBox.Show(Strings.failedToWriteBootloader, Strings.dialogTitleWrite, MessageBoxButtons.OK, MessageBoxIcon.Error); return; } flashMulti.AppendLog($" {Strings.done}\r\n"); } // Increment the step counter and write to the log flashStep++; flashMulti.AppendLog($"[{flashStep}/{flashSteps}] {Strings.progressWritingFirmware}"); // Prepare the command line arguments for writing the firmware commandArgs = $"-v -s {flashStart} -e 0 -b {serialBaud} -w \"{fileName}\" {comPort}"; if (runAfterUpload) { commandArgs += $" -g {executionAddress}"; } // Run the write command asynchronously and wait for it to finish await Task.Run(() => { returnCode = RunCommand.Run(flashMulti, command, commandArgs); }); // Show an error message if the command failed for any reason if (returnCode != 0) { flashMulti.EnableControls(true); flashMulti.AppendLog($" {Strings.failed}"); MessageBox.Show(Strings.failedToWriteFirmware, Strings.dialogTitleWrite, MessageBoxButtons.OK, MessageBoxIcon.Error); return; } // Reconnect the serial monitor if it was connected before if (serialMonitor != null && serialMonitor.IsDisposed != true && reconnectSerialMonitor) { serialMonitor.SerialConnect(comPort); } // Write a success message to the log flashMulti.AppendLog($" {Strings.done}\r\n"); flashMulti.AppendLog($"\r\n{Strings.succeededWritingFirmware}"); // Re-enable the form controls flashMulti.EnableControls(true); // Show a success message box MessageBox.Show(Strings.succeededWritingFirmware, Strings.succeededWritingFirmware, MessageBoxButtons.OK, MessageBoxIcon.Information); }