Implemented burn-bootloader

Author: cmaglie

cli/upload/upload.go

@@ -31,12 +31,13 @@ import (
 )
 
 var (
-	fqbn       string
-	port       string
-	verbose    bool
-	verify     bool
-	importDir  string
-	programmer string
+	fqbn           string
+	port           string
+	verbose        bool
+	verify         bool
+	importDir      string
+	programmer     string
+	burnBootloader bool
 )
 
 // NewCommand created a new `upload` command
@@ -56,6 +57,7 @@ func NewCommand() *cobra.Command {
 	uploadCommand.Flags().BoolVarP(&verify, "verify", "t", false, "Verify uploaded binary after the upload.")
 	uploadCommand.Flags().BoolVarP(&verbose, "verbose", "v", false, "Optional, turns on verbose mode.")
 	uploadCommand.Flags().StringVarP(&programmer, "programmer", "P", "", "Optional, use the specified programmer to upload or 'list' to list supported programmers.")
+	uploadCommand.Flags().BoolVar(&burnBootloader, "burn-bootloader", false, "Burn bootloader (some platforms performs chip-erase too).")
 
 	return uploadCommand
 }
@@ -88,6 +90,24 @@ func run(command *cobra.Command, args []string) {
 	}
 	sketchPath := initSketchPath(path)
 
+	if burnBootloader {
+		if _, err := upload.Upload(context.Background(), &rpc.UploadReq{
+			Instance:       instance,
+			Fqbn:           fqbn,
+			SketchPath:     sketchPath.String(),
+			Port:           port,
+			Verbose:        verbose,
+			Verify:         verify,
+			ImportDir:      importDir,
+			Programmer:     programmer,
+			BurnBootloader: true,
+		}, os.Stdout, os.Stderr); err != nil {
+			feedback.Errorf("Error during Upload: %v", err)
+			os.Exit(errorcodes.ErrGeneric)
+		}
+		os.Exit(0)
+	}
+
 	if _, err := upload.Upload(context.Background(), &rpc.UploadReq{
 		Instance:   instance,
 		Fqbn:       fqbn,

commands/upload/upload.go

@@ -90,7 +90,15 @@ func Upload(ctx context.Context, req *rpc.UploadReq, outStream io.Writer, errStr
 	var uploadToolName string
 	var uploadToolPlatform *cores.PlatformRelease
 	var programmer *cores.Programmer
-	if programmerID := req.GetProgrammer(); programmerID != "" {
+
+	burnBootloader := req.GetBurnBootloader()
+	if burnBootloader {
+		uploadToolName = boardProperties.Get("bootloader.tool")
+		uploadToolPlatform = boardPlatform
+		if uploadToolName == "" {
+			return nil, fmt.Errorf("cannot get programmer tool: undefined 'bootloader.tool' in boards.txt")
+		}
+	} else if programmerID := req.GetProgrammer(); programmerID != "" {
 		programmer = boardPlatform.Programmers[programmerID]
 		if programmer == nil {
 			// Try to find the programmer in the referenced build platform
@@ -153,13 +161,25 @@ func Upload(ctx context.Context, req *rpc.UploadReq, outStream io.Writer, errStr
 		if v, ok := uploadProperties.GetOk("program.params.verbose"); ok {
 			uploadProperties.Set("program.verbose", v)
 		}
+		if v, ok := uploadProperties.GetOk("erase.params.verbose"); ok {
+			uploadProperties.Set("erase.verbose", v)
+		}
+		if v, ok := uploadProperties.GetOk("bootloader.params.verbose"); ok {
+			uploadProperties.Set("bootloader.verbose", v)
+		}
 	} else {
 		if v, ok := uploadProperties.GetOk("upload.params.quiet"); ok {
 			uploadProperties.Set("upload.verbose", v)
 		}
 		if v, ok := uploadProperties.GetOk("program.params.quiet"); ok {
 			uploadProperties.Set("program.verbose", v)
 		}
+		if v, ok := uploadProperties.GetOk("erase.params.quiet"); ok {
+			uploadProperties.Set("erase.verbose", v)
+		}
+		if v, ok := uploadProperties.GetOk("bootloader.params.quiet"); ok {
+			uploadProperties.Set("bootloader.verbose", v)
+		}
 	}
 
 	// Set properties for verify
@@ -172,29 +192,31 @@ func Upload(ctx context.Context, req *rpc.UploadReq, outStream io.Writer, errStr
 	}
 
 	var importPath *paths.Path
-	if importDir := req.GetImportDir(); importDir != "" {
-		importPath = paths.New(importDir)
-	} else {
-		// TODO: Create a function to obtain importPath from sketch
-		importPath = sketch.FullPath
-		// Add FQBN (without configs part) to export path
-		fqbnSuffix := strings.Replace(fqbn.StringWithoutConfig(), ":", ".", -1)
-		importPath = importPath.Join("build").Join(fqbnSuffix)
-	}
+	if !burnBootloader {
+		if importDir := req.GetImportDir(); importDir != "" {
+			importPath = paths.New(importDir)
+		} else {
+			// TODO: Create a function to obtain importPath from sketch
+			importPath = sketch.FullPath
+			// Add FQBN (without configs part) to export path
+			fqbnSuffix := strings.Replace(fqbn.StringWithoutConfig(), ":", ".", -1)
+			importPath = importPath.Join("build").Join(fqbnSuffix)
+		}
 
-	if !importPath.Exist() {
-		return nil, fmt.Errorf("compiled sketch not found in %s", importPath)
-	}
-	if !importPath.IsDir() {
-		return nil, fmt.Errorf("expected compiled sketch in directory %s, but is a file instead", importPath)
+		if !importPath.Exist() {
+			return nil, fmt.Errorf("compiled sketch not found in %s", importPath)
+		}
+		if !importPath.IsDir() {
+			return nil, fmt.Errorf("expected compiled sketch in directory %s, but is a file instead", importPath)
+		}
+		uploadProperties.SetPath("build.path", importPath)
+		uploadProperties.Set("build.project_name", sketch.Name+".ino")
 	}
-	uploadProperties.SetPath("build.path", importPath)
-	uploadProperties.Set("build.project_name", sketch.Name+".ino")
 
 	// If not using programmer perform some action required
 	// to set the board in bootloader mode
 	actualPort := port
-	if programmer == nil {
+	if programmer == nil && !burnBootloader {
 		// Perform reset via 1200bps touch if requested
 		if uploadProperties.GetBoolean("upload.use_1200bps_touch") {
 			ports, err := serial.GetPortsList()
@@ -250,8 +272,14 @@ func Upload(ctx context.Context, req *rpc.UploadReq, outStream io.Writer, errStr
 	}
 
 	// Build recipe for upload
-	var recipe string
-	if programmer != nil {
+	if burnBootloader {
+		if err := runTool("erase.pattern", uploadProperties, outStream, errStream, req.GetVerbose()); err != nil {
+			return nil, fmt.Errorf("chip erase error: %s", err)
+		}
+		if err := runTool("bootloader.pattern", uploadProperties, outStream, errStream, req.GetVerbose()); err != nil {
+			return nil, fmt.Errorf("burn bootloader error: %s", err)
+		}
+	} else if programmer != nil {
 		if err := runTool("program.pattern", uploadProperties, outStream, errStream, req.GetVerbose()); err != nil {
 			return nil, fmt.Errorf("programming error: %s", err)
 		}

rpc/commands/upload.pb.go

@@ -44,6 +44,10 @@ message UploadReq {
 	// not specified, the standard build directory under `sketch_path` is used.
 	string import_dir = 8;
 	string programmer = 9;
+	// Set to true if you want to program the bootloader. This option requires a
+	// programmer. If sketch_path and import_path are empty only the bootloader is
+	// uploaded.
+	bool burn_bootloader = 10;
 }
 
 message UploadResp {