diff --git a/arduino/cores/cores.go b/arduino/cores/cores.go
index 6bf0634d86a..bcacea1154e 100644
--- a/arduino/cores/cores.go
+++ b/arduino/cores/cores.go
@@ -40,14 +40,14 @@ type PlatformRelease struct {
Resource *resources.DownloadResource
Version *semver.Version
BoardsManifest []*BoardManifest
- Dependencies ToolDependencies // The Dependency entries to load tools.
- Platform *Platform `json:"-"`
- Properties *properties.Map `json:"-"`
- Boards map[string]*Board `json:"-"`
- Programmers map[string]*properties.Map `json:"-"`
- Menus *properties.Map `json:"-"`
- InstallDir *paths.Path `json:"-"`
- IsIDEBundled bool `json:"-"`
+ Dependencies ToolDependencies // The Dependency entries to load tools.
+ Platform *Platform `json:"-"`
+ Properties *properties.Map `json:"-"`
+ Boards map[string]*Board `json:"-"`
+ Programmers map[string]*Programmer `json:"-"`
+ Menus *properties.Map `json:"-"`
+ InstallDir *paths.Path `json:"-"`
+ IsIDEBundled bool `json:"-"`
}
// BoardManifest contains information about a board. These metadata are usually
@@ -117,7 +117,7 @@ func (platform *Platform) GetOrCreateRelease(version *semver.Version) (*Platform
Version: version,
Boards: map[string]*Board{},
Properties: properties.NewMap(),
- Programmers: map[string]*properties.Map{},
+ Programmers: map[string]*Programmer{},
Platform: platform,
}
platform.Releases[tag] = release
diff --git a/arduino/cores/packagemanager/loader.go b/arduino/cores/packagemanager/loader.go
index f2ed7ff1a17..6d97f8ef66c 100644
--- a/arduino/cores/packagemanager/loader.go
+++ b/arduino/cores/packagemanager/loader.go
@@ -284,10 +284,10 @@ func (pm *PackageManager) loadPlatformRelease(platform *cores.PlatformRelease, p
// Create programmers properties
if programmersProperties, err := properties.SafeLoad(programmersTxtPath.String()); err == nil {
- platform.Programmers = properties.MergeMapsOfProperties(
- map[string]*properties.Map{},
- platform.Programmers, // TODO: Very weird, why not an empty one?
- programmersProperties.FirstLevelOf())
+ for programmerID, programmerProperties := range programmersProperties.FirstLevelOf() {
+ platform.Programmers[programmerID] = pm.loadProgrammer(programmerProperties)
+ platform.Programmers[programmerID].PlatformRelease = platform
+ }
} else {
return err
}
@@ -299,6 +299,13 @@ func (pm *PackageManager) loadPlatformRelease(platform *cores.PlatformRelease, p
return nil
}
+func (pm *PackageManager) loadProgrammer(programmerProperties *properties.Map) *cores.Programmer {
+ return &cores.Programmer{
+ Name: programmerProperties.Get("name"),
+ Properties: programmerProperties,
+ }
+}
+
func (pm *PackageManager) loadBoards(platform *cores.PlatformRelease) error {
if platform.InstallDir == nil {
return fmt.Errorf("platform not installed")
diff --git a/arduino/cores/programmers.go b/arduino/cores/programmers.go
new file mode 100644
index 00000000000..dfa89615045
--- /dev/null
+++ b/arduino/cores/programmers.go
@@ -0,0 +1,25 @@
+// This file is part of arduino-cli.
+//
+// Copyright 2020 ARDUINO SA (http://www.arduino.cc/)
+//
+// This software is released under the GNU General Public License version 3,
+// which covers the main part of arduino-cli.
+// The terms of this license can be found at:
+// https://www.gnu.org/licenses/gpl-3.0.en.html
+//
+// You can be released from the requirements of the above licenses by purchasing
+// a commercial license. Buying such a license is mandatory if you want to
+// modify or otherwise use the software for commercial activities involving the
+// Arduino software without disclosing the source code of your own applications.
+// To purchase a commercial license, send an email to license@arduino.cc.
+
+package cores
+
+import "github.com/arduino/go-properties-orderedmap"
+
+// Programmer represents an external programmer
+type Programmer struct {
+ Name string
+ Properties *properties.Map
+ PlatformRelease *PlatformRelease
+}
diff --git a/cli/burnbootloader/burnbootloader.go b/cli/burnbootloader/burnbootloader.go
new file mode 100644
index 00000000000..37fd6d10a72
--- /dev/null
+++ b/cli/burnbootloader/burnbootloader.go
@@ -0,0 +1,129 @@
+// This file is part of arduino-cli.
+//
+// Copyright 2020 ARDUINO SA (http://www.arduino.cc/)
+//
+// This software is released under the GNU General Public License version 3,
+// which covers the main part of arduino-cli.
+// The terms of this license can be found at:
+// https://www.gnu.org/licenses/gpl-3.0.en.html
+//
+// You can be released from the requirements of the above licenses by purchasing
+// a commercial license. Buying such a license is mandatory if you want to
+// modify or otherwise use the software for commercial activities involving the
+// Arduino software without disclosing the source code of your own applications.
+// To purchase a commercial license, send an email to license@arduino.cc.
+
+package burnbootloader
+
+import (
+ "context"
+ "os"
+
+ "github.com/arduino/arduino-cli/cli/errorcodes"
+ "github.com/arduino/arduino-cli/cli/feedback"
+ "github.com/arduino/arduino-cli/cli/instance"
+ "github.com/arduino/arduino-cli/commands/upload"
+ rpc "github.com/arduino/arduino-cli/rpc/commands"
+ "github.com/arduino/arduino-cli/table"
+ "github.com/arduino/go-paths-helper"
+ "github.com/sirupsen/logrus"
+ "github.com/spf13/cobra"
+)
+
+var (
+ fqbn string
+ port string
+ verbose bool
+ verify bool
+ importDir string
+ programmer string
+ burnBootloader bool
+)
+
+// NewCommand created a new `burn-bootloader` command
+func NewCommand() *cobra.Command {
+ burnBootloaderCommand := &cobra.Command{
+ Use: "burn-bootloader",
+ Short: "Upload the bootloader.",
+ Long: "Upload the bootloader on the board using an external programmer.",
+ Example: " " + os.Args[0] + " burn-bootloader -b arduino:avr:uno -P atmel-ice",
+ Args: cobra.MaximumNArgs(1),
+ Run: run,
+ }
+
+ burnBootloaderCommand.Flags().StringVarP(&fqbn, "fqbn", "b", "", "Fully Qualified Board Name, e.g.: arduino:avr:uno")
+ burnBootloaderCommand.Flags().StringVarP(&port, "port", "p", "", "Upload port, e.g.: COM10 or /dev/ttyACM0")
+ burnBootloaderCommand.Flags().BoolVarP(&verify, "verify", "t", false, "Verify uploaded binary after the upload.")
+ burnBootloaderCommand.Flags().BoolVarP(&verbose, "verbose", "v", false, "Turns on verbose mode.")
+ burnBootloaderCommand.Flags().StringVarP(&programmer, "programmer", "P", "", "Use the specified programmer to upload or 'list' to list supported programmers.")
+
+ return burnBootloaderCommand
+}
+
+func run(command *cobra.Command, args []string) {
+ instance, err := instance.CreateInstance()
+ if err != nil {
+ feedback.Errorf("Error during Upload: %v", err)
+ os.Exit(errorcodes.ErrGeneric)
+ }
+
+ if programmer == "list" {
+ resp, err := upload.ListProgrammersAvailableForUpload(context.Background(), &rpc.ListProgrammersAvailableForUploadReq{
+ Instance: instance,
+ Fqbn: fqbn,
+ })
+ if err != nil {
+ feedback.Errorf("Error listing programmers: %v", err)
+ os.Exit(errorcodes.ErrGeneric)
+ }
+ feedback.PrintResult(&programmersList{
+ Programmers: resp.GetProgrammers(),
+ })
+ os.Exit(0)
+ }
+
+ if _, err := upload.BurnBootloader(context.Background(), &rpc.BurnBootloaderReq{
+ Instance: instance,
+ Fqbn: fqbn,
+ Port: port,
+ Verbose: verbose,
+ Verify: verify,
+ Programmer: programmer,
+ }, os.Stdout, os.Stderr); err != nil {
+ feedback.Errorf("Error during Upload: %v", err)
+ os.Exit(errorcodes.ErrGeneric)
+ }
+ os.Exit(0)
+}
+
+// initSketchPath returns the current working directory
+func initSketchPath(sketchPath *paths.Path) *paths.Path {
+ if sketchPath != nil {
+ return sketchPath
+ }
+
+ wd, err := paths.Getwd()
+ if err != nil {
+ feedback.Errorf("Couldn't get current working directory: %v", err)
+ os.Exit(errorcodes.ErrGeneric)
+ }
+ logrus.Infof("Reading sketch from dir: %s", wd)
+ return wd
+}
+
+type programmersList struct {
+ Programmers []*rpc.Programmer
+}
+
+func (p *programmersList) Data() interface{} {
+ return p.Programmers
+}
+
+func (p *programmersList) String() string {
+ t := table.New()
+ t.SetHeader("ID", "Programmer Name", "Platform")
+ for _, prog := range p.Programmers {
+ t.AddRow(prog.GetId(), prog.GetName(), prog.GetPlatform())
+ }
+ return t.Render()
+}
diff --git a/cli/cli.go b/cli/cli.go
index 927ff4ed323..deee144da45 100644
--- a/cli/cli.go
+++ b/cli/cli.go
@@ -22,6 +22,7 @@ import (
"strings"
"github.com/arduino/arduino-cli/cli/board"
+ "github.com/arduino/arduino-cli/cli/burnbootloader"
"github.com/arduino/arduino-cli/cli/cache"
"github.com/arduino/arduino-cli/cli/compile"
"github.com/arduino/arduino-cli/cli/completion"
@@ -87,6 +88,7 @@ func createCliCommandTree(cmd *cobra.Command) {
cmd.AddCommand(sketch.NewCommand())
cmd.AddCommand(upload.NewCommand())
cmd.AddCommand(debug.NewCommand())
+ cmd.AddCommand(burnbootloader.NewCommand())
cmd.AddCommand(version.NewCommand())
cmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "Print the logs on the standard output.")
diff --git a/cli/compile/compile.go b/cli/compile/compile.go
index 7aeeb8c46f4..351563e20f5 100644
--- a/cli/compile/compile.go
+++ b/cli/compile/compile.go
@@ -50,6 +50,7 @@ var (
dryRun bool // Use this flag to now write the output file
libraries []string // List of custom libraries paths separated by commas. Or can be used multiple times for multiple libraries paths.
optimizeForDebug bool // Optimize compile output for debug, not for release
+ programmer string // Use the specified programmer to upload
)
// NewCommand created a new `compile` command
@@ -84,6 +85,7 @@ func NewCommand() *cobra.Command {
command.Flags().StringSliceVar(&libraries, "libraries", []string{},
"List of custom libraries paths separated by commas. Or can be used multiple times for multiple libraries paths.")
command.Flags().BoolVar(&optimizeForDebug, "optimize-for-debug", false, "Optional, optimize compile output for debug, not for release.")
+ command.Flags().StringVarP(&programmer, "programmer", "P", "", "Optional, use the specified programmer to upload.")
return command
}
@@ -135,6 +137,7 @@ func run(cmd *cobra.Command, args []string) {
Verbose: verbose,
Verify: verify,
ImportDir: exportDir,
+ Programmer: programmer,
}, os.Stdout, os.Stderr)
if err != nil {
diff --git a/cli/upload/upload.go b/cli/upload/upload.go
index 0a09668cd49..5afd6510926 100644
--- a/cli/upload/upload.go
+++ b/cli/upload/upload.go
@@ -24,17 +24,20 @@ import (
"github.com/arduino/arduino-cli/cli/instance"
"github.com/arduino/arduino-cli/commands/upload"
rpc "github.com/arduino/arduino-cli/rpc/commands"
+ "github.com/arduino/arduino-cli/table"
"github.com/arduino/go-paths-helper"
"github.com/sirupsen/logrus"
"github.com/spf13/cobra"
)
var (
- fqbn string
- port string
- verbose bool
- verify bool
- importDir string
+ fqbn string
+ port string
+ verbose bool
+ verify bool
+ importDir string
+ programmer string
+ burnBootloader bool
)
// NewCommand created a new `upload` command
@@ -53,6 +56,7 @@ func NewCommand() *cobra.Command {
uploadCommand.Flags().StringVarP(&importDir, "input-dir", "", "", "Direcory containing binaries to upload.")
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.")
return uploadCommand
}
@@ -64,12 +68,44 @@ func run(command *cobra.Command, args []string) {
os.Exit(errorcodes.ErrGeneric)
}
+ if programmer == "list" {
+ resp, err := upload.ListProgrammersAvailableForUpload(context.Background(), &rpc.ListProgrammersAvailableForUploadReq{
+ Instance: instance,
+ Fqbn: fqbn,
+ })
+ if err != nil {
+ feedback.Errorf("Error listing programmers: %v", err)
+ os.Exit(errorcodes.ErrGeneric)
+ }
+ feedback.PrintResult(&programmersList{
+ Programmers: resp.GetProgrammers(),
+ })
+ os.Exit(0)
+ }
+
var path *paths.Path
if len(args) > 0 {
path = paths.New(args[0])
}
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,
+ }, 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,
@@ -78,6 +114,7 @@ func run(command *cobra.Command, args []string) {
Verbose: verbose,
Verify: verify,
ImportDir: importDir,
+ Programmer: programmer,
}, os.Stdout, os.Stderr); err != nil {
feedback.Errorf("Error during Upload: %v", err)
os.Exit(errorcodes.ErrGeneric)
@@ -98,3 +135,20 @@ func initSketchPath(sketchPath *paths.Path) *paths.Path {
logrus.Infof("Reading sketch from dir: %s", wd)
return wd
}
+
+type programmersList struct {
+ Programmers []*rpc.Programmer
+}
+
+func (p *programmersList) Data() interface{} {
+ return p.Programmers
+}
+
+func (p *programmersList) String() string {
+ t := table.New()
+ t.SetHeader("ID", "Programmer Name", "Platform")
+ for _, prog := range p.Programmers {
+ t.AddRow(prog.GetId(), prog.GetName(), prog.GetPlatform())
+ }
+ return t.Render()
+}
diff --git a/commands/daemon/daemon.go b/commands/daemon/daemon.go
index 2dd088beff9..5ade70e06e5 100644
--- a/commands/daemon/daemon.go
+++ b/commands/daemon/daemon.go
@@ -216,6 +216,24 @@ func (s *ArduinoCoreServerImpl) Upload(req *rpc.UploadReq, stream rpc.ArduinoCor
return stream.Send(resp)
}
+// BurnBootloader FIXMEDOC
+func (s *ArduinoCoreServerImpl) BurnBootloader(req *rpc.BurnBootloaderReq, stream rpc.ArduinoCore_BurnBootloaderServer) error {
+ resp, err := upload.BurnBootloader(
+ stream.Context(), req,
+ utils.FeedStreamTo(func(data []byte) { stream.Send(&rpc.BurnBootloaderResp{OutStream: data}) }),
+ utils.FeedStreamTo(func(data []byte) { stream.Send(&rpc.BurnBootloaderResp{ErrStream: data}) }),
+ )
+ if err != nil {
+ return err
+ }
+ return stream.Send(resp)
+}
+
+// ListProgrammersAvailableForUpload FIXMEDOC
+func (s *ArduinoCoreServerImpl) ListProgrammersAvailableForUpload(ctx context.Context, req *rpc.ListProgrammersAvailableForUploadReq) (*rpc.ListProgrammersAvailableForUploadResp, error) {
+ return upload.ListProgrammersAvailableForUpload(ctx, req)
+}
+
// LibraryDownload FIXMEDOC
func (s *ArduinoCoreServerImpl) LibraryDownload(req *rpc.LibraryDownloadReq, stream rpc.ArduinoCore_LibraryDownloadServer) error {
resp, err := lib.LibraryDownload(
diff --git a/commands/upload/burnbootloader.go b/commands/upload/burnbootloader.go
new file mode 100644
index 00000000000..212c1f50ff7
--- /dev/null
+++ b/commands/upload/burnbootloader.go
@@ -0,0 +1,54 @@
+// This file is part of arduino-cli.
+//
+// Copyright 2020 ARDUINO SA (http://www.arduino.cc/)
+//
+// This software is released under the GNU General Public License version 3,
+// which covers the main part of arduino-cli.
+// The terms of this license can be found at:
+// https://www.gnu.org/licenses/gpl-3.0.en.html
+//
+// You can be released from the requirements of the above licenses by purchasing
+// a commercial license. Buying such a license is mandatory if you want to
+// modify or otherwise use the software for commercial activities involving the
+// Arduino software without disclosing the source code of your own applications.
+// To purchase a commercial license, send an email to license@arduino.cc.
+
+package upload
+
+import (
+ "context"
+ "io"
+
+ "github.com/arduino/arduino-cli/commands"
+ rpc "github.com/arduino/arduino-cli/rpc/commands"
+ "github.com/sirupsen/logrus"
+)
+
+// BurnBootloader FIXMEDOC
+func BurnBootloader(ctx context.Context, req *rpc.BurnBootloaderReq, outStream io.Writer, errStream io.Writer) (*rpc.BurnBootloaderResp, error) {
+ logrus.
+ WithField("fqbn", req.GetFqbn()).
+ WithField("port", req.GetPort()).
+ WithField("programmer", req.GetProgrammer()).
+ Trace("BurnBootloader started", req.GetFqbn())
+
+ pm := commands.GetPackageManager(req.GetInstance().GetId())
+
+ err := runProgramAction(
+ pm,
+ nil, // sketch
+ "", // importDir
+ req.GetFqbn(),
+ req.GetPort(),
+ req.GetProgrammer(),
+ req.GetVerbose(),
+ req.GetVerify(),
+ true, // burnBootloader
+ outStream,
+ errStream,
+ )
+ if err != nil {
+ return nil, err
+ }
+ return &rpc.BurnBootloaderResp{}, nil
+}
diff --git a/commands/upload/programmers_list.go b/commands/upload/programmers_list.go
new file mode 100644
index 00000000000..9cb74c535b2
--- /dev/null
+++ b/commands/upload/programmers_list.go
@@ -0,0 +1,66 @@
+// This file is part of arduino-cli.
+//
+// Copyright 2020 ARDUINO SA (http://www.arduino.cc/)
+//
+// This software is released under the GNU General Public License version 3,
+// which covers the main part of arduino-cli.
+// The terms of this license can be found at:
+// https://www.gnu.org/licenses/gpl-3.0.en.html
+//
+// You can be released from the requirements of the above licenses by purchasing
+// a commercial license. Buying such a license is mandatory if you want to
+// modify or otherwise use the software for commercial activities involving the
+// Arduino software without disclosing the source code of your own applications.
+// To purchase a commercial license, send an email to license@arduino.cc.
+
+package upload
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/arduino/arduino-cli/arduino/cores"
+ "github.com/arduino/arduino-cli/commands"
+ rpc "github.com/arduino/arduino-cli/rpc/commands"
+)
+
+// ListProgrammersAvailableForUpload FIXMEDOC
+func ListProgrammersAvailableForUpload(ctx context.Context, req *rpc.ListProgrammersAvailableForUploadReq) (*rpc.ListProgrammersAvailableForUploadResp, error) {
+ pm := commands.GetPackageManager(req.GetInstance().GetId())
+
+ fqbnIn := req.GetFqbn()
+ if fqbnIn == "" {
+ return nil, fmt.Errorf("no Fully Qualified Board Name provided")
+ }
+ fqbn, err := cores.ParseFQBN(fqbnIn)
+ if err != nil {
+ return nil, fmt.Errorf("incorrect FQBN: %s", err)
+ }
+
+ // Find target platforms
+ _, platform, _, _, refPlatform, err := pm.ResolveFQBN(fqbn)
+ if err != nil {
+ return nil, fmt.Errorf("incorrect FQBN: %s", err)
+ }
+
+ result := []*rpc.Programmer{}
+ createRPCProgrammer := func(id string, programmer *cores.Programmer) *rpc.Programmer {
+ return &rpc.Programmer{
+ Id: id,
+ Platform: programmer.PlatformRelease.String(),
+ Name: programmer.Name,
+ }
+ }
+ if refPlatform != platform {
+ for id, programmer := range refPlatform.Programmers {
+ result = append(result, createRPCProgrammer(id, programmer))
+ }
+ }
+ for id, programmer := range platform.Programmers {
+ result = append(result, createRPCProgrammer(id, programmer))
+ }
+
+ return &rpc.ListProgrammersAvailableForUploadResp{
+ Programmers: result,
+ }, nil
+}
diff --git a/commands/upload/upload.go b/commands/upload/upload.go
index b2af6eae18f..99fe3643280 100644
--- a/commands/upload/upload.go
+++ b/commands/upload/upload.go
@@ -24,6 +24,7 @@ import (
"time"
"github.com/arduino/arduino-cli/arduino/cores"
+ "github.com/arduino/arduino-cli/arduino/cores/packagemanager"
"github.com/arduino/arduino-cli/arduino/sketches"
"github.com/arduino/arduino-cli/cli/feedback"
"github.com/arduino/arduino-cli/commands"
@@ -50,75 +51,144 @@ func Upload(ctx context.Context, req *rpc.UploadReq, outStream io.Writer, errStr
return nil, fmt.Errorf("opening sketch: %s", err)
}
+ pm := commands.GetPackageManager(req.GetInstance().GetId())
+
+ err = runProgramAction(
+ pm,
+ sketch,
+ req.GetImportDir(),
+ req.GetFqbn(),
+ req.GetPort(),
+ req.GetProgrammer(),
+ req.GetVerbose(),
+ req.GetVerify(),
+ false, // burnBootloader
+ outStream,
+ errStream,
+ )
+ if err != nil {
+ return nil, err
+ }
+ return &rpc.UploadResp{}, nil
+}
+
+func runProgramAction(pm *packagemanager.PackageManager,
+ sketch *sketches.Sketch, importDir string, fqbnIn string, port string,
+ programmerID string,
+ verbose, verify, burnBootloader bool,
+ outStream io.Writer, errStream io.Writer) error {
+
+ if burnBootloader && programmerID == "" {
+ return fmt.Errorf("no programmer specified for burning bootloader")
+ }
+
// FIXME: make a specification on how a port is specified via command line
- port := req.GetPort()
if port == "" && sketch != nil && sketch.Metadata != nil {
deviceURI, err := url.Parse(sketch.Metadata.CPU.Port)
if err != nil {
- return nil, fmt.Errorf("invalid Device URL format: %s", err)
+ return fmt.Errorf("invalid Device URL format: %s", err)
}
if deviceURI.Scheme == "serial" {
port = deviceURI.Host + deviceURI.Path
}
}
- if port == "" {
- return nil, fmt.Errorf("no upload port provided")
- }
+ logrus.WithField("port", port).Tracef("Upload port")
- fqbnIn := req.GetFqbn()
if fqbnIn == "" && sketch != nil && sketch.Metadata != nil {
fqbnIn = sketch.Metadata.CPU.Fqbn
}
if fqbnIn == "" {
- return nil, fmt.Errorf("no Fully Qualified Board Name provided")
+ return fmt.Errorf("no Fully Qualified Board Name provided")
}
fqbn, err := cores.ParseFQBN(fqbnIn)
if err != nil {
- return nil, fmt.Errorf("incorrect FQBN: %s", err)
+ return fmt.Errorf("incorrect FQBN: %s", err)
}
-
- pm := commands.GetPackageManager(req.GetInstance().GetId())
+ logrus.WithField("fqbn", fqbn).Tracef("Detected FQBN")
// Find target board and board properties
- _, _, board, boardProperties, _, err := pm.ResolveFQBN(fqbn)
+ _, boardPlatform, board, boardProperties, buildPlatform, err := pm.ResolveFQBN(fqbn)
if err != nil {
- return nil, fmt.Errorf("incorrect FQBN: %s", err)
+ return fmt.Errorf("incorrect FQBN: %s", err)
}
-
- // Load programmer tool
- uploadToolPattern, have := boardProperties.GetOk("upload.tool")
- if !have || uploadToolPattern == "" {
- return nil, fmt.Errorf("cannot get programmer tool: undefined 'upload.tool' property")
+ logrus.
+ WithField("boardPlatform", boardPlatform).
+ WithField("board", board).
+ WithField("buildPlatform", buildPlatform).
+ Tracef("Upload data")
+
+ // Load upload tool definitions
+ var uploadToolName string
+ var uploadToolPlatform *cores.PlatformRelease
+ var programmer *cores.Programmer
+
+ if burnBootloader {
+ uploadToolName = boardProperties.Get("bootloader.tool")
+ uploadToolPlatform = boardPlatform
+ if uploadToolName == "" {
+ return fmt.Errorf("cannot get programmer tool: undefined 'bootloader.tool' in boards.txt")
+ }
+ logrus.
+ WithField("uploadToolName", uploadToolName).
+ WithField("uploadToolPlatform", uploadToolPlatform).
+ Trace("Upload tool from 'bootloader.tool' property")
}
- var referencedPlatformRelease *cores.PlatformRelease
- if split := strings.Split(uploadToolPattern, ":"); len(split) > 2 {
- return nil, fmt.Errorf("invalid 'upload.tool' property: %s", uploadToolPattern)
- } else if len(split) == 2 {
- referencedPackageName := split[0]
- uploadToolPattern = split[1]
- architecture := board.PlatformRelease.Platform.Architecture
-
- if referencedPackage := pm.Packages[referencedPackageName]; referencedPackage == nil {
- return nil, fmt.Errorf("required platform %s:%s not installed", referencedPackageName, architecture)
- } else if referencedPlatform := referencedPackage.Platforms[architecture]; referencedPlatform == nil {
- return nil, fmt.Errorf("required platform %s:%s not installed", referencedPackageName, architecture)
- } else {
- referencedPlatformRelease = pm.GetInstalledPlatformRelease(referencedPlatform)
+ if programmerID != "" {
+ programmer = boardPlatform.Programmers[programmerID]
+ if programmer == nil {
+ // Try to find the programmer in the referenced build platform
+ programmer = buildPlatform.Programmers[programmerID]
}
+ if programmer == nil {
+ return fmt.Errorf("programmer '%s' not available", programmerID)
+ }
+ uploadToolName = programmer.Properties.Get("program.tool")
+ uploadToolPlatform = programmer.PlatformRelease
+ if uploadToolName == "" {
+ return fmt.Errorf("cannot get programmer tool: undefined 'program.tool' property")
+ }
+ logrus.
+ WithField("uploadToolName", uploadToolName).
+ WithField("uploadToolPlatform", uploadToolPlatform).
+ Trace("Upload tool from --programmer parameter")
+ } else {
+ uploadToolName = boardProperties.Get("upload.tool")
+ uploadToolPlatform = boardPlatform
+ if uploadToolName == "" {
+ return fmt.Errorf("cannot get upload tool: undefined 'upload.tool' property")
+ }
+ if split := strings.Split(uploadToolName, ":"); len(split) > 2 {
+ return fmt.Errorf("invalid 'upload.tool' property: %s", uploadToolName)
+ } else if len(split) == 2 {
+ uploadToolName = split[1]
+ uploadToolPlatform = pm.GetInstalledPlatformRelease(
+ pm.FindPlatform(&packagemanager.PlatformReference{
+ Package: split[0],
+ PlatformArchitecture: boardPlatform.Platform.Architecture,
+ }),
+ )
+ }
+ logrus.
+ WithField("uploadToolName", uploadToolName).
+ WithField("uploadToolPlatform", uploadToolPlatform).
+ Trace("Upload tool")
}
// Build configuration for upload
uploadProperties := properties.NewMap()
- if referencedPlatformRelease != nil {
- uploadProperties.Merge(referencedPlatformRelease.Properties)
+ if uploadToolPlatform != nil {
+ uploadProperties.Merge(uploadToolPlatform.Properties)
}
- uploadProperties.Merge(board.PlatformRelease.Properties)
- uploadProperties.Merge(board.PlatformRelease.RuntimeProperties())
+ uploadProperties.Merge(boardPlatform.Properties)
+ uploadProperties.Merge(boardPlatform.RuntimeProperties())
uploadProperties.Merge(boardProperties)
- uploadToolProperties := uploadProperties.SubTree("tools." + uploadToolPattern)
+ uploadToolProperties := uploadProperties.SubTree("tools." + uploadToolName)
uploadProperties.Merge(uploadToolProperties)
+ if programmer != nil {
+ uploadProperties.Merge(programmer.Properties)
+ }
if requiredTools, err := pm.FindToolsRequiredForBoard(board); err == nil {
for _, requiredTool := range requiredTools {
@@ -128,112 +198,179 @@ func Upload(ctx context.Context, req *rpc.UploadReq, outStream io.Writer, errStr
}
// Set properties for verbose upload
- if req.GetVerbose() {
+ if verbose {
if v, ok := uploadProperties.GetOk("upload.params.verbose"); ok {
uploadProperties.Set("upload.verbose", v)
}
+ 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
- if req.GetVerify() {
+ if verify {
uploadProperties.Set("upload.verify", uploadProperties.Get("upload.params.verify"))
+ uploadProperties.Set("program.verify", uploadProperties.Get("program.params.verify"))
} else {
uploadProperties.Set("upload.verify", uploadProperties.Get("upload.params.noverify"))
+ uploadProperties.Set("program.verify", uploadProperties.Get("program.params.noverify"))
}
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 sketch == nil {
+ return fmt.Errorf(("no sketch specified"))
+ }
- 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")
+ if 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)
+ }
- // Perform reset via 1200bps touch if requested
- if uploadProperties.GetBoolean("upload.use_1200bps_touch") {
- ports, err := serial.GetPortsList()
- if err != nil {
- return nil, fmt.Errorf("cannot get serial port list: %s", err)
+ if !importPath.Exist() {
+ return fmt.Errorf("compiled sketch not found in %s", importPath)
}
- for _, p := range ports {
- if p == port {
- if req.GetVerbose() {
- outStream.Write([]byte(fmt.Sprintf("Performing 1200-bps touch reset on serial port %s", p)))
- outStream.Write([]byte(fmt.Sprintln()))
- }
- if err := touchSerialPortAt1200bps(p); err != nil {
- return nil, fmt.Errorf("cannot perform reset: %s", err)
+ if !importPath.IsDir() {
+ return 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")
+ }
+
+ // If not using programmer perform some action required
+ // to set the board in bootloader mode
+ actualPort := port
+ if programmer == nil && !burnBootloader {
+ // Perform reset via 1200bps touch if requested
+ if uploadProperties.GetBoolean("upload.use_1200bps_touch") {
+ if port == "" {
+ return fmt.Errorf("no upload port provided")
+ }
+
+ ports, err := serial.GetPortsList()
+ if err != nil {
+ return fmt.Errorf("cannot get serial port list: %s", err)
+ }
+ for _, p := range ports {
+ if p == port {
+ if verbose {
+ outStream.Write([]byte(fmt.Sprintf("Performing 1200-bps touch reset on serial port %s", p)))
+ outStream.Write([]byte(fmt.Sprintln()))
+ }
+ if err := touchSerialPortAt1200bps(p); err != nil {
+ return fmt.Errorf("cannot perform reset: %s", err)
+ }
+ break
}
- break
}
+
+ // Scanning for available ports seems to open the port or
+ // otherwise assert DTR, which would cancel the WDT reset if
+ // it happened within 250 ms. So we wait until the reset should
+ // have already occurred before we start scanning.
+ time.Sleep(500 * time.Millisecond)
}
- // Scanning for available ports seems to open the port or
- // otherwise assert DTR, which would cancel the WDT reset if
- // it happened within 250 ms. So we wait until the reset should
- // have already occurred before we start scanning.
- time.Sleep(500 * time.Millisecond)
- }
+ // Wait for upload port if requested
+ if uploadProperties.GetBoolean("upload.wait_for_upload_port") {
+ if verbose {
+ outStream.Write([]byte(fmt.Sprintln("Waiting for upload port...")))
+ }
+ if p, err := waitForNewSerialPort(); err != nil {
+ return fmt.Errorf("cannot detect serial ports: %s", err)
+ } else if p == "" {
+ feedback.Print("No new serial port detected.")
+ } else {
+ actualPort = p
+ }
- // Wait for upload port if requested
- actualPort := port // default
- if uploadProperties.GetBoolean("upload.wait_for_upload_port") {
- if req.GetVerbose() {
- outStream.Write([]byte(fmt.Sprintln("Waiting for upload port...")))
+ // on OS X, if the port is opened too quickly after it is detected,
+ // a "Resource busy" error occurs, add a delay to workaround.
+ // This apply to other platforms as well.
+ time.Sleep(500 * time.Millisecond)
}
- if p, err := waitForNewSerialPort(); err != nil {
- return nil, fmt.Errorf("cannot detect serial ports: %s", err)
- } else if p == "" {
- feedback.Print("No new serial port detected.")
+ }
+
+ if port != "" {
+ // Set serial port property
+ uploadProperties.Set("serial.port", actualPort)
+ if strings.HasPrefix(actualPort, "/dev/") {
+ uploadProperties.Set("serial.port.file", actualPort[5:])
} else {
- actualPort = p
+ uploadProperties.Set("serial.port.file", actualPort)
}
-
- // on OS X, if the port is opened too quickly after it is detected,
- // a "Resource busy" error occurs, add a delay to workaround.
- // This apply to other platforms as well.
- time.Sleep(500 * time.Millisecond)
}
- // Set serial port property
- uploadProperties.Set("serial.port", actualPort)
- if strings.HasPrefix(actualPort, "/dev/") {
- uploadProperties.Set("serial.port.file", actualPort[5:])
+ // Build recipe for upload
+ if burnBootloader {
+ if err := runTool("erase.pattern", uploadProperties, outStream, errStream, verbose); err != nil {
+ return fmt.Errorf("chip erase error: %s", err)
+ }
+ if err := runTool("bootloader.pattern", uploadProperties, outStream, errStream, verbose); err != nil {
+ return fmt.Errorf("burn bootloader error: %s", err)
+ }
+ } else if programmer != nil {
+ if err := runTool("program.pattern", uploadProperties, outStream, errStream, verbose); err != nil {
+ return fmt.Errorf("programming error: %s", err)
+ }
} else {
- uploadProperties.Set("serial.port.file", actualPort)
+ if err := runTool("upload.pattern", uploadProperties, outStream, errStream, verbose); err != nil {
+ return fmt.Errorf("uploading error: %s", err)
+ }
}
- // Build recipe for upload
- recipe := uploadProperties.Get("upload.pattern")
- cmdLine := uploadProperties.ExpandPropsInString(recipe)
+ logrus.Tracef("Upload successful")
+ return nil
+}
+
+func runTool(recipeID string, props *properties.Map, outStream, errStream io.Writer, verbose bool) error {
+ recipe, ok := props.GetOk(recipeID)
+ if !ok {
+ return fmt.Errorf("recipe not found '%s'", recipeID)
+ }
+ if strings.TrimSpace(recipe) == "" {
+ return nil // Nothing to run
+ }
+ if props.IsProertyMissingInExpandPropsInString("serial.port", recipe) {
+ return fmt.Errorf("no upload port provided")
+ }
+ cmdLine := props.ExpandPropsInString(recipe)
cmdArgs, err := properties.SplitQuotedString(cmdLine, `"'`, false)
if err != nil {
- return nil, fmt.Errorf("invalid recipe '%s': %s", recipe, err)
+ return fmt.Errorf("invalid recipe '%s': %s", recipe, err)
}
// Run Tool
- if req.GetVerbose() {
+ if verbose {
outStream.Write([]byte(fmt.Sprintln(cmdLine)))
}
cmd, err := executils.Command(cmdArgs)
if err != nil {
- return nil, fmt.Errorf("cannot execute upload tool: %s", err)
+ return fmt.Errorf("cannot execute upload tool: %s", err)
}
executils.AttachStdoutListener(cmd, executils.PrintToStdout)
@@ -242,16 +379,14 @@ func Upload(ctx context.Context, req *rpc.UploadReq, outStream io.Writer, errStr
cmd.Stderr = errStream
if err := cmd.Start(); err != nil {
- return nil, fmt.Errorf("cannot execute upload tool: %s", err)
+ return fmt.Errorf("cannot execute upload tool: %s", err)
}
if err := cmd.Wait(); err != nil {
- return nil, fmt.Errorf("uploading error: %s", err)
+ return fmt.Errorf("uploading error: %s", err)
}
- logrus.Tracef("Upload %s on %s successful", sketch.Name, fqbnIn)
-
- return &rpc.UploadResp{}, nil
+ return nil
}
func touchSerialPortAt1200bps(port string) error {
diff --git a/go.mod b/go.mod
index 71e07589b9b..aaef35eada6 100644
--- a/go.mod
+++ b/go.mod
@@ -7,7 +7,7 @@ require (
github.com/GeertJohan/go.rice v1.0.0
github.com/arduino/board-discovery v0.0.0-20180823133458-1ba29327fb0c
github.com/arduino/go-paths-helper v1.2.0
- github.com/arduino/go-properties-orderedmap v1.0.0
+ github.com/arduino/go-properties-orderedmap v1.2.0
github.com/arduino/go-timeutils v0.0.0-20171220113728-d1dd9e313b1b
github.com/arduino/go-win32-utils v0.0.0-20180330194947-ed041402e83b
github.com/cmaglie/pb v1.0.27
diff --git a/go.sum b/go.sum
index 440b2c2cb67..099067dc63c 100644
--- a/go.sum
+++ b/go.sum
@@ -18,8 +18,8 @@ github.com/arduino/go-paths-helper v1.0.1 h1:utYXLM2RfFlc9qp/MJTIYp3t6ux/xM6mWje
github.com/arduino/go-paths-helper v1.0.1/go.mod h1:HpxtKph+g238EJHq4geEPv9p+gl3v5YYu35Yb+w31Ck=
github.com/arduino/go-paths-helper v1.2.0 h1:qDW93PR5IZUN/jzO4rCtexiwF8P4OIcOmcSgAYLZfY4=
github.com/arduino/go-paths-helper v1.2.0/go.mod h1:HpxtKph+g238EJHq4geEPv9p+gl3v5YYu35Yb+w31Ck=
-github.com/arduino/go-properties-orderedmap v1.0.0 h1:caaM25TQZKkytoKQUsgqtOVbrM5i8Gb427JmW0KL05s=
-github.com/arduino/go-properties-orderedmap v1.0.0/go.mod h1:DKjD2VXY/NZmlingh4lSFMEYCVubfeArCsGPGDwb2yk=
+github.com/arduino/go-properties-orderedmap v1.2.0 h1:H7sub5hjAtFLZYd/NVWBOr6Jw7U1CnamYvNSM3dDdyE=
+github.com/arduino/go-properties-orderedmap v1.2.0/go.mod h1:DKjD2VXY/NZmlingh4lSFMEYCVubfeArCsGPGDwb2yk=
github.com/arduino/go-timeutils v0.0.0-20171220113728-d1dd9e313b1b h1:9hDi4F2st6dbLC3y4i02zFT5quS4X6iioWifGlVwfy4=
github.com/arduino/go-timeutils v0.0.0-20171220113728-d1dd9e313b1b/go.mod h1:uwGy5PpN4lqW97FiLnbcx+xx8jly5YuPMJWfVwwjJiQ=
github.com/arduino/go-win32-utils v0.0.0-20180330194947-ed041402e83b h1:3PjgYG5gVPA7cipp7vIR2lF96KkEJIFBJ+ANnuv6J20=
@@ -80,7 +80,6 @@ github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4er
github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.3 h1:gyjaxf+svBWX08ZjK86iN9geUJF0H6gp2IRKX6Nf6/I=
github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
@@ -101,7 +100,6 @@ github.com/imjasonmiller/godice v0.1.2 h1:T1/sW/HoDzFeuwzOOuQjmeMELz9CzZ53I2CnD+
github.com/imjasonmiller/godice v0.1.2/go.mod h1:8cTkdnVI+NglU2d6sv+ilYcNaJ5VSTBwvMbFULJd/QQ=
github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
-github.com/jessevdk/go-flags v1.4.0 h1:4IU2WS7AumrZ/40jfhf4QVDMsQwqA7VEHozFRrGARJA=
github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
@@ -125,7 +123,6 @@ github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/leonelquinteros/gotext v1.4.0 h1:2NHPCto5IoMXbrT0bldPrxj0qM5asOCwtb1aUQZ1tys=
github.com/leonelquinteros/gotext v1.4.0/go.mod h1:yZGXREmoGTtBvZHNcc+Yfug49G/2spuF/i/Qlsvz1Us=
-github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY=
github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
github.com/magiconair/properties v1.8.1 h1:ZC2Vc7/ZFkGmsVC9KvOjumD+G5lXy2RtTKyzRKO2BQ4=
github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
@@ -143,12 +140,10 @@ github.com/mdlayher/netlink v0.0.0-20190313131330-258ea9dff42c/go.mod h1:eQB3mZE
github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072/go.mod h1:sGdS7A6CAETR53zkdjGkgoFlh1vSm7MtX+i8XfEsTMA=
github.com/miekg/dns v1.0.5 h1:MQBGf2JEJDu0rg9WOpQZzeO+zW8UKwgkvP3R1dUU1Yw=
github.com/miekg/dns v1.0.5/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
-github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
-github.com/nkovacs/streamquote v0.0.0-20170412213628-49af9bddb229 h1:E2B8qYyeSgv5MXpmzZXRNp8IAQ4vjxIjhpAf5hv/tAg=
github.com/nkovacs/streamquote v0.0.0-20170412213628-49af9bddb229/go.mod h1:0aYXnNPJ8l7uZxf45rWW1a/uME32OF0rhiYGNQ2oF2E=
github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
github.com/oleksandr/bonjour v0.0.0-20160508152359-5dcf00d8b228 h1:Cvfd2dOlXIPTeEkOT/h8PyK4phBngOM4at9/jlgy7d4=
@@ -210,16 +205,13 @@ github.com/spf13/jwalterweatherman v1.0.0 h1:XHEdyB+EcvlqZamSM4ZOMGlc93t6AcsBEu9
github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/spf13/viper v1.3.2 h1:VUFqw5KcqRf7i70GOzW7N+Q7+gxVBkSSqiXB12+JQ4M=
github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
github.com/spf13/viper v1.6.2 h1:7aKfF+e8/k68gda3LOjo5RxiUqddoFxVq4BKBPrxk5E=
github.com/spf13/viper v1.6.2/go.mod h1:t3iDnF5Jlj76alVNuyFBk5oUMCvsrkbvZK0WQdfDi5k=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A=
github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
@@ -228,9 +220,7 @@ github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69
github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
-github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
-github.com/valyala/fasttemplate v1.0.1 h1:tY9CJiPnMXf1ERmG2EyK7gNUd+c6RKGD0IfU8WdUSz8=
github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
@@ -255,14 +245,12 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk
golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
-golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3 h1:XQyxROzUlZH+WIQwySDgnISgOivlhjIEwaQaJEJrrN0=
golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a h1:oWX7TPOiFAMXLq8o0ikBYfCJVlRHBcsciT5bXOrH628=
golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
@@ -281,13 +269,10 @@ golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5h
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190422165155-953cdadca894 h1:Cz4ceDQGXuKRnVBDTS23GTn/pU5OE2C0WrNTOYK1Uuc=
golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9 h1:ZBzSG/7F4eNKz2L3GE9o300RX0Az1Bw5HF7PDraD+qU=
golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5 h1:LfCXLvNmTYH9kEmVgqbnsWfruoXZIrh4YBgqVHtDvw0=
golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
@@ -297,14 +282,11 @@ golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGm
golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190328211700-ab21143f2384 h1:TFlARGu6Czu1z7q93HTxcP1P+/ZFC/IKythI5RzrnRg=
golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135 h1:5Beo0mZN8dRzgrMMkDp0jc8YXQKx9DiJ2k1dkvGsn5A=
golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55 h1:gSJIx1SDwno+2ElGhA4+qG2zF97qiUzTM+rQ0klBOcE=
google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90 h1:7THRSvPuzF1bql5kyFzX0JM0vpGhwuhskgJrJsbZ80Y=
google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
@@ -314,7 +296,6 @@ google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyac
google.golang.org/grpc v1.27.0 h1:rRYRFMVgRv6E0D70Skyfsr28tDXIuuPZyWGMPdMcnXg=
google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
@@ -326,7 +307,6 @@ gopkg.in/mgo.v2 v2.0.0-20180705113604-9856a29383ce/go.mod h1:yeKp02qBN3iKW1OzL3M
gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.4 h1:/eiJrUcujPVeJ3xlSWaiNi3uSVmDGBK1pDHUHAnao1I=
gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
diff --git a/legacy/builder/test/hardware_loader_test.go b/legacy/builder/test/hardware_loader_test.go
index a6767ec5aa8..f73676378e9 100644
--- a/legacy/builder/test/hardware_loader_test.go
+++ b/legacy/builder/test/hardware_loader_test.go
@@ -62,7 +62,7 @@ func TestLoadHardware(t *testing.T) {
require.Equal(t, "-v", avrPlatform.Releases[""].Properties.Get("tools.avrdude.bootloader.params.verbose"))
require.Equal(t, "/my/personal/avrdude", avrPlatform.Releases[""].Properties.Get("tools.avrdude.cmd.path"))
- require.Equal(t, "AVRISP mkII", avrPlatform.Releases[""].Programmers["avrispmkii"].Get("name"))
+ require.Equal(t, "AVRISP mkII", avrPlatform.Releases[""].Programmers["avrispmkii"].Name)
//require.Equal(t, "{runtime.tools.ctags.path}", packages.Properties.Get("tools.ctags.path"])
//require.Equal(t, "\"{cmd.path}\" -u --language-force=c++ -f - --c++-kinds=svpf --fields=KSTtzns --line-directives \"{source_file}\"", packages.Properties.Get("tools.ctags.pattern"])
@@ -114,7 +114,7 @@ func TestLoadHardwareMixingUserHardwareFolder(t *testing.T) {
require.Equal(t, "-v", avrPlatform.Properties.Get("tools.avrdude.bootloader.params.verbose"))
require.Equal(t, "/my/personal/avrdude", avrPlatform.Properties.Get("tools.avrdude.cmd.path"))
- require.Equal(t, "AVRISP mkII", avrPlatform.Programmers["avrispmkii"].Get("name"))
+ require.Equal(t, "AVRISP mkII", avrPlatform.Programmers["avrispmkii"].Name)
require.Equal(t, "-w -x c++ -M -MG -MP", avrPlatform.Properties.Get("preproc.includes.flags"))
require.Equal(t, "-w -x c++ -E -CC", avrPlatform.Properties.Get("preproc.macros.flags"))
@@ -177,8 +177,8 @@ func TestLoadHardwareWithBoardManagerFolderStructure(t *testing.T) {
require.Equal(t, 3, len(samdPlatform.Programmers))
- require.Equal(t, "Atmel EDBG", samdPlatform.Programmers["edbg"].Get("name"))
- require.Equal(t, "openocd", samdPlatform.Programmers["edbg"].Get("program.tool"))
+ require.Equal(t, "Atmel EDBG", samdPlatform.Programmers["edbg"].Name)
+ require.Equal(t, "openocd", samdPlatform.Programmers["edbg"].Properties.Get("program.tool"))
avrRedBearPlatform := packages["RedBearLab"].Platforms["avr"].Releases["1.0.0"]
require.Equal(t, 3, len(avrRedBearPlatform.Boards))
diff --git a/rpc/commands/commands.pb.go b/rpc/commands/commands.pb.go
index d5009ec209b..d76443758d9 100644
--- a/rpc/commands/commands.pb.go
+++ b/rpc/commands/commands.pb.go
@@ -554,67 +554,71 @@ func init() {
func init() { proto.RegisterFile("commands/commands.proto", fileDescriptor_3690061a1131852d) }
var fileDescriptor_3690061a1131852d = []byte{
- // 948 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x97, 0xdd, 0x52, 0x1b, 0x37,
- 0x14, 0xc7, 0xb3, 0x24, 0x05, 0x7c, 0x0c, 0x24, 0x51, 0x9c, 0xe0, 0xf1, 0x95, 0xb3, 0x69, 0x8a,
- 0x81, 0x62, 0x28, 0xed, 0xb4, 0x17, 0x9d, 0x5e, 0x90, 0xd0, 0x0b, 0xd2, 0x74, 0xc8, 0x2c, 0x85,
- 0xe9, 0xe4, 0xc6, 0x95, 0x77, 0x15, 0xd0, 0xb0, 0xac, 0x14, 0x69, 0xa1, 0xf5, 0x55, 0x9f, 0xa0,
- 0x2f, 0xd4, 0x17, 0xe9, 0xeb, 0x74, 0xa4, 0x95, 0xe4, 0x35, 0x78, 0x3f, 0x1c, 0xc8, 0x15, 0xec,
- 0x39, 0xbf, 0xf3, 0x3f, 0xab, 0xf3, 0x21, 0xdb, 0xb0, 0x1a, 0xb2, 0x8b, 0x0b, 0x9c, 0x44, 0x72,
- 0xdb, 0xfe, 0xd3, 0xe7, 0x82, 0xa5, 0x0c, 0xad, 0x86, 0x61, 0x1f, 0x8b, 0xe8, 0x92, 0x26, 0xac,
- 0x1f, 0xc6, 0xb4, 0x6f, 0xdd, 0x9d, 0xa7, 0x13, 0x11, 0x2c, 0xc9, 0xf8, 0x4e, 0xcb, 0x99, 0x87,
- 0x0c, 0x8b, 0xc8, 0x58, 0x9f, 0xe5, 0x61, 0x4e, 0x63, 0x62, 0xec, 0x4f, 0x72, 0x76, 0x61, 0x8d,
- 0x63, 0xe5, 0x4b, 0x1e, 0x33, 0x6c, 0x35, 0x90, 0x33, 0xc7, 0x74, 0x98, 0xd9, 0xfc, 0x1f, 0x61,
- 0xe1, 0x20, 0xa1, 0x69, 0x40, 0x3e, 0xa2, 0x1d, 0x68, 0xc5, 0x74, 0x28, 0xb0, 0x18, 0x0d, 0x2e,
- 0x70, 0x82, 0x4f, 0x89, 0x18, 0xb0, 0x24, 0x1e, 0xb5, 0xe7, 0xba, 0x5e, 0x6f, 0x31, 0x40, 0xc6,
- 0xf7, 0x6b, 0xe6, 0x3a, 0x4c, 0xe2, 0x91, 0xff, 0xdf, 0x1c, 0x2c, 0x66, 0xd1, 0x92, 0xa3, 0x9f,
- 0x60, 0x91, 0x26, 0x32, 0xc5, 0x49, 0x48, 0xda, 0x5e, 0xd7, 0xeb, 0x35, 0x77, 0x9f, 0xf7, 0x0b,
- 0x8e, 0xde, 0x3f, 0x30, 0x60, 0xe0, 0x42, 0xd0, 0x77, 0xf0, 0x8c, 0xc7, 0x38, 0xfd, 0xc0, 0xc4,
- 0x85, 0x1c, 0xd0, 0x24, 0x22, 0x7f, 0x0d, 0x88, 0x10, 0x4c, 0xc8, 0xf6, 0x5c, 0xf7, 0x7e, 0xaf,
- 0x11, 0xb4, 0x9c, 0xf7, 0x40, 0x39, 0x7f, 0xd6, 0x3e, 0xb4, 0x0b, 0x4f, 0xb3, 0xf7, 0xa2, 0x64,
- 0x22, 0xaa, 0x7d, 0xbf, 0xeb, 0xf5, 0x1a, 0xc1, 0x13, 0xe7, 0x1c, 0x07, 0xa1, 0x13, 0x78, 0x1c,
- 0xb1, 0x3f, 0x13, 0x55, 0x98, 0x01, 0x17, 0xec, 0x54, 0x10, 0x29, 0xdb, 0x0f, 0xf4, 0x1b, 0xaf,
- 0x17, 0xbe, 0xf1, 0xbe, 0x89, 0x78, 0x67, 0x02, 0x82, 0x47, 0xd1, 0x35, 0x0b, 0x7a, 0x03, 0xcb,
- 0x29, 0x96, 0xe7, 0x63, 0xcd, 0x2f, 0xb4, 0xe6, 0xcb, 0x42, 0xcd, 0xdf, 0xb0, 0x3c, 0x77, 0x7a,
- 0x4b, 0x69, 0xee, 0xc9, 0xff, 0x05, 0x60, 0x9f, 0xc8, 0x54, 0xb0, 0x91, 0xea, 0xcc, 0xed, 0x4a,
- 0xeb, 0x2f, 0x43, 0xd3, 0x89, 0x49, 0xee, 0xbf, 0x81, 0x46, 0x40, 0x64, 0x88, 0x93, 0x3b, 0x90,
- 0xbe, 0x02, 0xb0, 0x5a, 0x92, 0x97, 0xf4, 0xd0, 0xfb, 0x94, 0x1e, 0xce, 0x15, 0xf6, 0xd0, 0x3f,
- 0x84, 0x95, 0x63, 0x1e, 0xe1, 0x94, 0x68, 0xdb, 0x1d, 0x1c, 0x84, 0xc2, 0xc3, 0x09, 0x41, 0xc9,
- 0xa7, 0xcf, 0x89, 0x77, 0xeb, 0x39, 0xf1, 0x7f, 0x87, 0xd5, 0x2c, 0xd5, 0xdb, 0x89, 0x83, 0xdd,
- 0xc1, 0x21, 0x04, 0xb4, 0xa7, 0x2b, 0x7f, 0xc6, 0xd3, 0x2c, 0x01, 0x9c, 0x10, 0x21, 0x29, 0x53,
- 0xe3, 0xe4, 0xaf, 0x41, 0xd3, 0x3d, 0x49, 0x8e, 0xda, 0xb0, 0x70, 0x95, 0x3d, 0xea, 0x54, 0x8d,
- 0xc0, 0x3e, 0xee, 0xfe, 0xdb, 0x82, 0xe6, 0x5e, 0x96, 0xf2, 0x35, 0x13, 0x04, 0x1d, 0xc2, 0x03,
- 0x75, 0x93, 0xa0, 0x6e, 0xc9, 0x79, 0xf5, 0x35, 0xd5, 0x79, 0x5e, 0x41, 0x48, 0xee, 0xdf, 0xdb,
- 0xf1, 0xd0, 0x09, 0x2c, 0x98, 0xa1, 0x47, 0x2f, 0x8a, 0xcf, 0xe7, 0x76, 0xac, 0xf3, 0x65, 0x35,
- 0xa4, 0x94, 0xd1, 0x11, 0xcc, 0x67, 0x13, 0x8f, 0xfc, 0xc2, 0x08, 0xb7, 0x5e, 0x9d, 0x17, 0x95,
- 0x8c, 0x16, 0x8d, 0xa0, 0x99, 0x9b, 0x3e, 0xb4, 0x56, 0x18, 0x35, 0x39, 0xf4, 0x9d, 0x5e, 0x3d,
- 0xd0, 0x94, 0xe4, 0x6f, 0x68, 0x4d, 0x1b, 0x0f, 0xb4, 0x53, 0xa1, 0x72, 0x63, 0x4e, 0x3b, 0xdf,
- 0xcc, 0x18, 0x31, 0xee, 0x89, 0x99, 0x8e, 0x92, 0x9e, 0x8c, 0xa7, 0xa9, 0xa4, 0x27, 0xb9, 0x21,
- 0xf3, 0xef, 0xa1, 0x10, 0x96, 0x5e, 0xa9, 0xcf, 0xca, 0x7d, 0x92, 0x62, 0x1a, 0x4b, 0x54, 0x5c,
- 0x96, 0x3c, 0xa6, 0x32, 0xac, 0xd7, 0x24, 0x25, 0x47, 0x43, 0x68, 0x6a, 0xdb, 0x5e, 0x9a, 0xe2,
- 0xf0, 0xac, 0xa4, 0x47, 0x39, 0xaa, 0xbc, 0x47, 0x13, 0xa0, 0xe4, 0x3b, 0x1e, 0x7a, 0x0f, 0x0d,
- 0x6d, 0x7c, 0x4b, 0x65, 0x8a, 0x5e, 0x96, 0x07, 0x2a, 0x46, 0xe9, 0x7f, 0x55, 0x07, 0x93, 0xdc,
- 0x15, 0x49, 0x19, 0xf6, 0xe2, 0xb8, 0xaa, 0x48, 0x06, 0xab, 0x51, 0x24, 0x47, 0xea, 0x5b, 0x66,
- 0xe1, 0x75, 0xf6, 0xfd, 0xa4, 0xa4, 0xc3, 0x86, 0x28, 0xef, 0xb0, 0x83, 0x74, 0x61, 0x12, 0x78,
- 0xf8, 0xce, 0x7c, 0x76, 0xe8, 0x7b, 0x2f, 0x8e, 0xd1, 0x66, 0x61, 0xe8, 0x35, 0x52, 0xe5, 0xf9,
- 0xba, 0x3e, 0xac, 0xf3, 0x7d, 0x84, 0x47, 0xd6, 0x61, 0xef, 0x40, 0x54, 0xad, 0x61, 0x51, 0x95,
- 0x71, 0x6b, 0x06, 0x5a, 0xa7, 0x4c, 0xe1, 0xb1, 0xf5, 0x1c, 0x27, 0xd4, 0x1c, 0xb2, 0x5a, 0xc5,
- 0xb1, 0x2a, 0x69, 0x7f, 0x16, 0xfc, 0x7a, 0x61, 0x8f, 0xf9, 0xa9, 0xc0, 0x11, 0xa9, 0x51, 0x58,
- 0x43, 0xd6, 0x2b, 0xac, 0x83, 0x75, 0xbe, 0x23, 0x98, 0x3f, 0xd6, 0xdf, 0x49, 0x4b, 0xae, 0xcf,
- 0x0c, 0x28, 0xbf, 0x3e, 0x2d, 0xa3, 0x45, 0x29, 0xac, 0xd8, 0x6c, 0x47, 0x04, 0x8b, 0xf0, 0x0c,
- 0x6d, 0x54, 0xbe, 0x56, 0x06, 0xaa, 0x24, 0x9b, 0xb5, 0xd9, 0x6c, 0x8b, 0xac, 0x55, 0x2f, 0x69,
- 0xaf, 0x32, 0xd8, 0xee, 0xe9, 0x7a, 0x4d, 0x52, 0x72, 0xd5, 0x94, 0xec, 0x06, 0x1d, 0xb9, 0xe1,
- 0x2b, 0x7e, 0xc9, 0x6b, 0x64, 0x79, 0x53, 0x6e, 0xc0, 0xba, 0x7e, 0xe7, 0xb0, 0x62, 0x1c, 0x76,
- 0xb9, 0x36, 0xaa, 0x14, 0x72, 0xbb, 0xb5, 0x59, 0x9b, 0xb5, 0xab, 0x65, 0xec, 0xe3, 0x31, 0xaf,
- 0x7c, 0xe1, 0x89, 0x29, 0xdf, 0x9a, 0x81, 0xb6, 0xab, 0x65, 0x3d, 0xd9, 0x30, 0xee, 0x95, 0xae,
- 0xd6, 0x0d, 0xb6, 0x7c, 0xb5, 0xa6, 0xe0, 0x3a, 0xeb, 0x3f, 0x1e, 0x74, 0x8c, 0x2f, 0x20, 0x92,
- 0xc5, 0x57, 0x64, 0x9f, 0x70, 0x92, 0x44, 0x24, 0x09, 0x29, 0x91, 0xe8, 0xfb, 0x2a, 0xc1, 0x29,
- 0x41, 0xea, 0x45, 0x7e, 0xf8, 0xa4, 0x38, 0xc9, 0xd1, 0x07, 0x58, 0x36, 0x84, 0x59, 0x92, 0xf5,
- 0x2a, 0xa5, 0xf1, 0x8e, 0x6c, 0xd4, 0x45, 0x25, 0x47, 0x7f, 0x40, 0xd3, 0x18, 0xf5, 0x86, 0xac,
- 0x55, 0x85, 0xda, 0x05, 0xe9, 0xd5, 0x03, 0x25, 0x7f, 0xb5, 0xf5, 0x7e, 0xf3, 0x94, 0xa6, 0x67,
- 0x97, 0x43, 0x85, 0x6c, 0x9b, 0x10, 0xfb, 0x77, 0x2b, 0x8c, 0xe9, 0xb6, 0xe0, 0xa1, 0xfb, 0x1d,
- 0x3e, 0x9c, 0xd7, 0x3f, 0x75, 0xbf, 0xfd, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xd5, 0xf5, 0x48, 0xa1,
- 0xa3, 0x0f, 0x00, 0x00,
+ // 1012 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x98, 0xdd, 0x52, 0xdb, 0x46,
+ 0x14, 0x80, 0x23, 0x92, 0x02, 0x3e, 0x06, 0x92, 0x6c, 0x08, 0x78, 0x7c, 0x65, 0x94, 0xa6, 0x18,
+ 0x5c, 0x0c, 0xa5, 0x9d, 0xf6, 0xa2, 0x93, 0xce, 0x98, 0xd0, 0xce, 0x90, 0xa6, 0x43, 0x46, 0x14,
+ 0xa6, 0x93, 0x1b, 0x77, 0x2d, 0x6d, 0x60, 0x07, 0x59, 0xbb, 0xd9, 0x15, 0xb4, 0xbe, 0xea, 0x13,
+ 0xf4, 0x25, 0xfa, 0x3c, 0xbd, 0xef, 0xeb, 0x74, 0x76, 0xb5, 0x2b, 0x5b, 0x60, 0xfd, 0xf0, 0x93,
+ 0x2b, 0xd0, 0x39, 0xdf, 0x39, 0x67, 0xf7, 0xfc, 0x49, 0x00, 0xab, 0x3e, 0x1b, 0x0e, 0x71, 0x14,
+ 0xc8, 0x6d, 0xfb, 0x4b, 0x97, 0x0b, 0x16, 0x33, 0xb4, 0xea, 0xfb, 0x5d, 0x2c, 0x82, 0x0b, 0x1a,
+ 0xb1, 0xae, 0x1f, 0xd2, 0xae, 0x55, 0x37, 0x9f, 0x67, 0x2c, 0x58, 0x94, 0xf0, 0xcd, 0xe5, 0x54,
+ 0x3c, 0x60, 0x58, 0x04, 0x46, 0xba, 0x32, 0x09, 0x73, 0x1a, 0x12, 0x23, 0x7f, 0x36, 0x21, 0x17,
+ 0x56, 0x38, 0xf6, 0x7c, 0xc1, 0x43, 0x86, 0xad, 0x0f, 0x94, 0x8a, 0x43, 0x3a, 0x48, 0x64, 0xee,
+ 0xf7, 0x30, 0x77, 0x10, 0xd1, 0xd8, 0x23, 0x1f, 0xd1, 0x0e, 0x2c, 0x87, 0x74, 0x20, 0xb0, 0x18,
+ 0xf5, 0x87, 0x38, 0xc2, 0xa7, 0x44, 0xf4, 0x59, 0x14, 0x8e, 0x1a, 0x33, 0x2d, 0xa7, 0x3d, 0xef,
+ 0x21, 0xa3, 0xfb, 0x25, 0x51, 0x1d, 0x46, 0xe1, 0xc8, 0xfd, 0x6f, 0x06, 0xe6, 0x13, 0x6b, 0xc9,
+ 0xd1, 0x2b, 0x98, 0xa7, 0x91, 0x8c, 0x71, 0xe4, 0x93, 0x86, 0xd3, 0x72, 0xda, 0xf5, 0xdd, 0xb5,
+ 0x6e, 0xce, 0xd5, 0xbb, 0x07, 0x06, 0xf4, 0x52, 0x13, 0xf4, 0x0d, 0xac, 0xf0, 0x10, 0xc7, 0x1f,
+ 0x98, 0x18, 0xca, 0x3e, 0x8d, 0x02, 0xf2, 0x67, 0x9f, 0x08, 0xc1, 0x84, 0x6c, 0xcc, 0xb4, 0x1e,
+ 0xb6, 0x6b, 0xde, 0x72, 0xaa, 0x3d, 0x50, 0xca, 0x1f, 0xb5, 0x0e, 0xed, 0xc2, 0xf3, 0xe4, 0x5c,
+ 0x94, 0x64, 0xac, 0x1a, 0x0f, 0x5b, 0x4e, 0xbb, 0xe6, 0x3d, 0x4b, 0x95, 0x63, 0x23, 0x74, 0x02,
+ 0x4f, 0x03, 0xf6, 0x47, 0xa4, 0x12, 0xd3, 0xe7, 0x82, 0x9d, 0x0a, 0x22, 0x65, 0xe3, 0x91, 0x3e,
+ 0xf1, 0x46, 0xee, 0x89, 0xf7, 0x8d, 0xc5, 0x3b, 0x63, 0xe0, 0x3d, 0x09, 0xae, 0x48, 0xd0, 0x1b,
+ 0x58, 0x8c, 0xb1, 0x3c, 0x1f, 0xfb, 0xfc, 0x4c, 0xfb, 0x7c, 0x99, 0xeb, 0xf3, 0x57, 0x2c, 0xcf,
+ 0x53, 0x7f, 0x0b, 0xf1, 0xc4, 0x93, 0xfb, 0x33, 0xc0, 0x3e, 0x91, 0xb1, 0x60, 0x23, 0x55, 0x99,
+ 0xbb, 0xa5, 0xd6, 0x5d, 0x84, 0x7a, 0xea, 0x4c, 0x72, 0xf7, 0x0d, 0xd4, 0x3c, 0x22, 0x7d, 0x1c,
+ 0xdd, 0x83, 0xeb, 0x4b, 0x00, 0xeb, 0x4b, 0xf2, 0x82, 0x1a, 0x3a, 0xb7, 0xa9, 0xe1, 0x4c, 0x6e,
+ 0x0d, 0xdd, 0x43, 0x58, 0x3a, 0xe6, 0x01, 0x8e, 0x89, 0x96, 0xdd, 0xc3, 0x45, 0x28, 0x3c, 0xce,
+ 0x38, 0x94, 0x7c, 0x7a, 0x9f, 0x38, 0x77, 0xee, 0x13, 0xf7, 0x37, 0x58, 0x4d, 0x42, 0xbd, 0xcd,
+ 0x5c, 0xec, 0x1e, 0x2e, 0x21, 0xa0, 0x31, 0xdd, 0xf3, 0x27, 0xbc, 0xcd, 0x02, 0xc0, 0x09, 0x11,
+ 0x92, 0x32, 0xd5, 0x4e, 0xee, 0x3a, 0xd4, 0xd3, 0x27, 0xc9, 0x51, 0x03, 0xe6, 0x2e, 0x93, 0x47,
+ 0x1d, 0xaa, 0xe6, 0xd9, 0xc7, 0xdd, 0x7f, 0x57, 0xa0, 0xde, 0x4b, 0x42, 0xbe, 0x66, 0x82, 0xa0,
+ 0x43, 0x78, 0xa4, 0x36, 0x09, 0x6a, 0x15, 0xdc, 0x57, 0xaf, 0xa9, 0xe6, 0x5a, 0x09, 0x21, 0xb9,
+ 0xfb, 0x60, 0xc7, 0x41, 0x27, 0x30, 0x67, 0x9a, 0x1e, 0xbd, 0xc8, 0xbf, 0x5f, 0x3a, 0x63, 0xcd,
+ 0xcf, 0xcb, 0x21, 0xe5, 0x19, 0x1d, 0xc1, 0x6c, 0xd2, 0xf1, 0xc8, 0xcd, 0xb5, 0x48, 0xc7, 0xab,
+ 0xf9, 0xa2, 0x94, 0xd1, 0x4e, 0x03, 0xa8, 0x4f, 0x74, 0x1f, 0x5a, 0xcf, 0xb5, 0xca, 0x36, 0x7d,
+ 0xb3, 0x5d, 0x0d, 0x34, 0x29, 0xf9, 0x0b, 0x96, 0xa7, 0xb5, 0x07, 0xda, 0x29, 0xf1, 0x72, 0xad,
+ 0x4f, 0x9b, 0x5f, 0xdd, 0xd0, 0x62, 0x5c, 0x13, 0xd3, 0x1d, 0x05, 0x35, 0x19, 0x77, 0x53, 0x41,
+ 0x4d, 0x26, 0x9a, 0xcc, 0x7d, 0x80, 0x7c, 0x58, 0xd8, 0x53, 0xef, 0xca, 0x7d, 0x12, 0x63, 0x1a,
+ 0x4a, 0x94, 0x9f, 0x96, 0x49, 0x4c, 0x45, 0xd8, 0xa8, 0x48, 0x4a, 0x8e, 0x06, 0x50, 0xd7, 0xb2,
+ 0x5e, 0x1c, 0x63, 0xff, 0xac, 0xa0, 0x46, 0x13, 0x54, 0x71, 0x8d, 0x32, 0xa0, 0xe4, 0x3b, 0x0e,
+ 0x7a, 0x0f, 0x35, 0x2d, 0x7c, 0x4b, 0x65, 0x8c, 0x5e, 0x16, 0x1b, 0x2a, 0x46, 0xf9, 0xff, 0xa2,
+ 0x0a, 0x26, 0x79, 0x9a, 0x24, 0x25, 0xe8, 0x85, 0x61, 0x59, 0x92, 0x0c, 0x56, 0x21, 0x49, 0x29,
+ 0xa9, 0xb7, 0xcc, 0xdc, 0xeb, 0xe4, 0xfb, 0xa4, 0xa0, 0xc2, 0x86, 0x28, 0xae, 0x70, 0x0a, 0xe9,
+ 0xc4, 0x44, 0xf0, 0xf8, 0x9d, 0x79, 0x77, 0xe8, 0xbd, 0x17, 0x86, 0xa8, 0x93, 0x6b, 0x7a, 0x85,
+ 0x54, 0x71, 0xbe, 0xac, 0x0e, 0xeb, 0x78, 0x1f, 0xe1, 0x89, 0x55, 0xd8, 0x1d, 0x88, 0xca, 0x7d,
+ 0x58, 0x54, 0x45, 0xdc, 0xba, 0x01, 0xad, 0x43, 0xc6, 0xf0, 0xd4, 0x6a, 0x8e, 0x23, 0x6a, 0x2e,
+ 0x59, 0xee, 0x25, 0x65, 0x55, 0xd0, 0xee, 0x4d, 0xf0, 0xab, 0x89, 0x3d, 0xe6, 0xa7, 0x02, 0x07,
+ 0xa4, 0x42, 0x62, 0x0d, 0x59, 0x2d, 0xb1, 0x29, 0xac, 0xe3, 0x1d, 0xc1, 0xec, 0xb1, 0xfe, 0x26,
+ 0x2d, 0x58, 0x9f, 0x09, 0x50, 0xbc, 0x3e, 0x2d, 0xa3, 0x9d, 0xfe, 0xe3, 0xc0, 0x9a, 0xea, 0x42,
+ 0xfd, 0x52, 0xc2, 0xc3, 0x21, 0x11, 0xb2, 0x77, 0x89, 0x69, 0x88, 0x07, 0x21, 0xf9, 0x89, 0x09,
+ 0x13, 0xf0, 0x55, 0xae, 0xb3, 0x52, 0x5b, 0x75, 0x96, 0x1f, 0xee, 0x62, 0x2e, 0x39, 0x3a, 0x87,
+ 0xa5, 0xbd, 0x0b, 0x11, 0xed, 0x31, 0x16, 0x2b, 0x19, 0x11, 0x68, 0x33, 0x7f, 0xae, 0x32, 0xa0,
+ 0x8a, 0xde, 0xa9, 0xcc, 0xea, 0x8c, 0x50, 0x58, 0xb2, 0xf9, 0x3f, 0x22, 0x58, 0xf8, 0x67, 0x05,
+ 0xc1, 0xb2, 0x60, 0x71, 0xb0, 0xab, 0x6c, 0xb2, 0x57, 0xac, 0x54, 0xaf, 0xad, 0x76, 0xa9, 0xb1,
+ 0xdd, 0x5c, 0x1b, 0x15, 0x49, 0xc9, 0x55, 0x9b, 0x26, 0xef, 0x94, 0x51, 0x3a, 0x8e, 0x9d, 0x82,
+ 0x7a, 0x64, 0xc8, 0xe2, 0x36, 0xbd, 0x06, 0xeb, 0xfc, 0x9d, 0xc3, 0x92, 0x51, 0xd8, 0x75, 0xb3,
+ 0x59, 0xe6, 0x61, 0x62, 0xdb, 0x74, 0x2a, 0xb3, 0x76, 0xd9, 0x18, 0xf9, 0x78, 0xf0, 0x4b, 0x0f,
+ 0x9c, 0x99, 0xfb, 0xad, 0x1b, 0xd0, 0x76, 0xd9, 0x58, 0x4d, 0x32, 0x9e, 0xbd, 0xc2, 0x65, 0x73,
+ 0x8d, 0x2d, 0x5e, 0x36, 0x53, 0x70, 0x1d, 0xf5, 0x6f, 0x07, 0x9a, 0x46, 0xe7, 0x11, 0xc9, 0xc2,
+ 0x4b, 0xb2, 0x4f, 0x38, 0x89, 0x02, 0x12, 0xf9, 0x94, 0x48, 0xf4, 0x6d, 0x99, 0xc3, 0x29, 0x46,
+ 0xea, 0x20, 0xdf, 0xdd, 0xca, 0x4e, 0x72, 0xf4, 0x01, 0x16, 0x0d, 0x61, 0x86, 0x64, 0xa3, 0xcc,
+ 0xd3, 0x78, 0x46, 0x36, 0xab, 0xa2, 0x92, 0xa3, 0xdf, 0xa1, 0x6e, 0x84, 0x7a, 0x42, 0xd6, 0xcb,
+ 0x4c, 0xed, 0x80, 0xb4, 0xab, 0x81, 0x92, 0xef, 0x6d, 0xbd, 0xef, 0x9c, 0xd2, 0xf8, 0xec, 0x62,
+ 0xa0, 0x90, 0x6d, 0x63, 0x62, 0x7f, 0x6e, 0xf9, 0x21, 0xdd, 0x16, 0xdc, 0x4f, 0xff, 0x33, 0x31,
+ 0x98, 0xd5, 0x7f, 0xfc, 0x7f, 0xfd, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbe, 0x72, 0x97, 0x90,
+ 0xb5, 0x10, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@@ -664,6 +668,9 @@ type ArduinoCoreClient interface {
PlatformUpgrade(ctx context.Context, in *PlatformUpgradeReq, opts ...grpc.CallOption) (ArduinoCore_PlatformUpgradeClient, error)
// Upload a compiled sketch to an Arduino board.
Upload(ctx context.Context, in *UploadReq, opts ...grpc.CallOption) (ArduinoCore_UploadClient, error)
+ ListProgrammersAvailableForUpload(ctx context.Context, in *ListProgrammersAvailableForUploadReq, opts ...grpc.CallOption) (*ListProgrammersAvailableForUploadResp, error)
+ // Burn bootloader to a board.
+ BurnBootloader(ctx context.Context, in *BurnBootloaderReq, opts ...grpc.CallOption) (ArduinoCore_BurnBootloaderClient, error)
// Search for a platform in the platforms indexes.
PlatformSearch(ctx context.Context, in *PlatformSearchReq, opts ...grpc.CallOption) (*PlatformSearchResp, error)
// List all installed platforms.
@@ -1059,6 +1066,47 @@ func (x *arduinoCoreUploadClient) Recv() (*UploadResp, error) {
return m, nil
}
+func (c *arduinoCoreClient) ListProgrammersAvailableForUpload(ctx context.Context, in *ListProgrammersAvailableForUploadReq, opts ...grpc.CallOption) (*ListProgrammersAvailableForUploadResp, error) {
+ out := new(ListProgrammersAvailableForUploadResp)
+ err := c.cc.Invoke(ctx, "/cc.arduino.cli.commands.ArduinoCore/ListProgrammersAvailableForUpload", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *arduinoCoreClient) BurnBootloader(ctx context.Context, in *BurnBootloaderReq, opts ...grpc.CallOption) (ArduinoCore_BurnBootloaderClient, error) {
+ stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[10], "/cc.arduino.cli.commands.ArduinoCore/BurnBootloader", opts...)
+ if err != nil {
+ return nil, err
+ }
+ x := &arduinoCoreBurnBootloaderClient{stream}
+ if err := x.ClientStream.SendMsg(in); err != nil {
+ return nil, err
+ }
+ if err := x.ClientStream.CloseSend(); err != nil {
+ return nil, err
+ }
+ return x, nil
+}
+
+type ArduinoCore_BurnBootloaderClient interface {
+ Recv() (*BurnBootloaderResp, error)
+ grpc.ClientStream
+}
+
+type arduinoCoreBurnBootloaderClient struct {
+ grpc.ClientStream
+}
+
+func (x *arduinoCoreBurnBootloaderClient) Recv() (*BurnBootloaderResp, error) {
+ m := new(BurnBootloaderResp)
+ if err := x.ClientStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
func (c *arduinoCoreClient) PlatformSearch(ctx context.Context, in *PlatformSearchReq, opts ...grpc.CallOption) (*PlatformSearchResp, error) {
out := new(PlatformSearchResp)
err := c.cc.Invoke(ctx, "/cc.arduino.cli.commands.ArduinoCore/PlatformSearch", in, out, opts...)
@@ -1078,7 +1126,7 @@ func (c *arduinoCoreClient) PlatformList(ctx context.Context, in *PlatformListRe
}
func (c *arduinoCoreClient) LibraryDownload(ctx context.Context, in *LibraryDownloadReq, opts ...grpc.CallOption) (ArduinoCore_LibraryDownloadClient, error) {
- stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[10], "/cc.arduino.cli.commands.ArduinoCore/LibraryDownload", opts...)
+ stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[11], "/cc.arduino.cli.commands.ArduinoCore/LibraryDownload", opts...)
if err != nil {
return nil, err
}
@@ -1110,7 +1158,7 @@ func (x *arduinoCoreLibraryDownloadClient) Recv() (*LibraryDownloadResp, error)
}
func (c *arduinoCoreClient) LibraryInstall(ctx context.Context, in *LibraryInstallReq, opts ...grpc.CallOption) (ArduinoCore_LibraryInstallClient, error) {
- stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[11], "/cc.arduino.cli.commands.ArduinoCore/LibraryInstall", opts...)
+ stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[12], "/cc.arduino.cli.commands.ArduinoCore/LibraryInstall", opts...)
if err != nil {
return nil, err
}
@@ -1142,7 +1190,7 @@ func (x *arduinoCoreLibraryInstallClient) Recv() (*LibraryInstallResp, error) {
}
func (c *arduinoCoreClient) LibraryUninstall(ctx context.Context, in *LibraryUninstallReq, opts ...grpc.CallOption) (ArduinoCore_LibraryUninstallClient, error) {
- stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[12], "/cc.arduino.cli.commands.ArduinoCore/LibraryUninstall", opts...)
+ stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[13], "/cc.arduino.cli.commands.ArduinoCore/LibraryUninstall", opts...)
if err != nil {
return nil, err
}
@@ -1174,7 +1222,7 @@ func (x *arduinoCoreLibraryUninstallClient) Recv() (*LibraryUninstallResp, error
}
func (c *arduinoCoreClient) LibraryUpgradeAll(ctx context.Context, in *LibraryUpgradeAllReq, opts ...grpc.CallOption) (ArduinoCore_LibraryUpgradeAllClient, error) {
- stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[13], "/cc.arduino.cli.commands.ArduinoCore/LibraryUpgradeAll", opts...)
+ stream, err := c.cc.NewStream(ctx, &_ArduinoCore_serviceDesc.Streams[14], "/cc.arduino.cli.commands.ArduinoCore/LibraryUpgradeAll", opts...)
if err != nil {
return nil, err
}
@@ -1269,6 +1317,9 @@ type ArduinoCoreServer interface {
PlatformUpgrade(*PlatformUpgradeReq, ArduinoCore_PlatformUpgradeServer) error
// Upload a compiled sketch to an Arduino board.
Upload(*UploadReq, ArduinoCore_UploadServer) error
+ ListProgrammersAvailableForUpload(context.Context, *ListProgrammersAvailableForUploadReq) (*ListProgrammersAvailableForUploadResp, error)
+ // Burn bootloader to a board.
+ BurnBootloader(*BurnBootloaderReq, ArduinoCore_BurnBootloaderServer) error
// Search for a platform in the platforms indexes.
PlatformSearch(context.Context, *PlatformSearchReq) (*PlatformSearchResp, error)
// List all installed platforms.
@@ -1334,6 +1385,12 @@ func (*UnimplementedArduinoCoreServer) PlatformUpgrade(req *PlatformUpgradeReq,
func (*UnimplementedArduinoCoreServer) Upload(req *UploadReq, srv ArduinoCore_UploadServer) error {
return status.Errorf(codes.Unimplemented, "method Upload not implemented")
}
+func (*UnimplementedArduinoCoreServer) ListProgrammersAvailableForUpload(ctx context.Context, req *ListProgrammersAvailableForUploadReq) (*ListProgrammersAvailableForUploadResp, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method ListProgrammersAvailableForUpload not implemented")
+}
+func (*UnimplementedArduinoCoreServer) BurnBootloader(req *BurnBootloaderReq, srv ArduinoCore_BurnBootloaderServer) error {
+ return status.Errorf(codes.Unimplemented, "method BurnBootloader not implemented")
+}
func (*UnimplementedArduinoCoreServer) PlatformSearch(ctx context.Context, req *PlatformSearchReq) (*PlatformSearchResp, error) {
return nil, status.Errorf(codes.Unimplemented, "method PlatformSearch not implemented")
}
@@ -1684,6 +1741,45 @@ func (x *arduinoCoreUploadServer) Send(m *UploadResp) error {
return x.ServerStream.SendMsg(m)
}
+func _ArduinoCore_ListProgrammersAvailableForUpload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(ListProgrammersAvailableForUploadReq)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(ArduinoCoreServer).ListProgrammersAvailableForUpload(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/cc.arduino.cli.commands.ArduinoCore/ListProgrammersAvailableForUpload",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(ArduinoCoreServer).ListProgrammersAvailableForUpload(ctx, req.(*ListProgrammersAvailableForUploadReq))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _ArduinoCore_BurnBootloader_Handler(srv interface{}, stream grpc.ServerStream) error {
+ m := new(BurnBootloaderReq)
+ if err := stream.RecvMsg(m); err != nil {
+ return err
+ }
+ return srv.(ArduinoCoreServer).BurnBootloader(m, &arduinoCoreBurnBootloaderServer{stream})
+}
+
+type ArduinoCore_BurnBootloaderServer interface {
+ Send(*BurnBootloaderResp) error
+ grpc.ServerStream
+}
+
+type arduinoCoreBurnBootloaderServer struct {
+ grpc.ServerStream
+}
+
+func (x *arduinoCoreBurnBootloaderServer) Send(m *BurnBootloaderResp) error {
+ return x.ServerStream.SendMsg(m)
+}
+
func _ArduinoCore_PlatformSearch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PlatformSearchReq)
if err := dec(in); err != nil {
@@ -1886,6 +1982,10 @@ var _ArduinoCore_serviceDesc = grpc.ServiceDesc{
MethodName: "BoardListAll",
Handler: _ArduinoCore_BoardListAll_Handler,
},
+ {
+ MethodName: "ListProgrammersAvailableForUpload",
+ Handler: _ArduinoCore_ListProgrammersAvailableForUpload_Handler,
+ },
{
MethodName: "PlatformSearch",
Handler: _ArduinoCore_PlatformSearch_Handler,
@@ -1958,6 +2058,11 @@ var _ArduinoCore_serviceDesc = grpc.ServiceDesc{
Handler: _ArduinoCore_Upload_Handler,
ServerStreams: true,
},
+ {
+ StreamName: "BurnBootloader",
+ Handler: _ArduinoCore_BurnBootloader_Handler,
+ ServerStreams: true,
+ },
{
StreamName: "LibraryDownload",
Handler: _ArduinoCore_LibraryDownload_Handler,
diff --git a/rpc/commands/commands.proto b/rpc/commands/commands.proto
index 82f78d57d0d..7c65ec47478 100644
--- a/rpc/commands/commands.proto
+++ b/rpc/commands/commands.proto
@@ -85,6 +85,11 @@ service ArduinoCore {
// Upload a compiled sketch to an Arduino board.
rpc Upload(UploadReq) returns (stream UploadResp);
+ rpc ListProgrammersAvailableForUpload(ListProgrammersAvailableForUploadReq) returns (ListProgrammersAvailableForUploadResp);
+
+ // Burn bootloader to a board.
+ rpc BurnBootloader(BurnBootloaderReq) returns (stream BurnBootloaderResp);
+
// Search for a platform in the platforms indexes.
rpc PlatformSearch(PlatformSearchReq) returns (PlatformSearchResp);
diff --git a/rpc/commands/compile.pb.go b/rpc/commands/compile.pb.go
index e00cd60c078..6fd68105474 100644
--- a/rpc/commands/compile.pb.go
+++ b/rpc/commands/compile.pb.go
@@ -39,6 +39,7 @@ type CompileReq struct {
OptimizeForDebug bool `protobuf:"varint,16,opt,name=optimizeForDebug,proto3" json:"optimizeForDebug,omitempty"`
DryRun bool `protobuf:"varint,17,opt,name=dryRun,proto3" json:"dryRun,omitempty"`
ExportDir string `protobuf:"bytes,18,opt,name=export_dir,json=exportDir,proto3" json:"export_dir,omitempty"`
+ Programmer string `protobuf:"bytes,19,opt,name=programmer,proto3" json:"programmer,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@@ -196,6 +197,13 @@ func (m *CompileReq) GetExportDir() string {
return ""
}
+func (m *CompileReq) GetProgrammer() string {
+ if m != nil {
+ return m.Programmer
+ }
+ return ""
+}
+
type CompileResp struct {
OutStream []byte `protobuf:"bytes,1,opt,name=out_stream,json=outStream,proto3" json:"out_stream,omitempty"`
ErrStream []byte `protobuf:"bytes,2,opt,name=err_stream,json=errStream,proto3" json:"err_stream,omitempty"`
@@ -251,34 +259,35 @@ func init() {
func init() { proto.RegisterFile("commands/compile.proto", fileDescriptor_86bc582849c76c3d) }
var fileDescriptor_86bc582849c76c3d = []byte{
- // 453 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0x41, 0x6f, 0xd3, 0x40,
- 0x10, 0x85, 0xe5, 0x34, 0x49, 0xe3, 0x49, 0x69, 0xcb, 0x0a, 0xca, 0xaa, 0x02, 0x64, 0x72, 0x40,
- 0x16, 0xa8, 0x8e, 0x04, 0x67, 0x2e, 0x6d, 0x55, 0x09, 0x71, 0x89, 0xcc, 0x8d, 0x4b, 0x65, 0xaf,
- 0x97, 0x78, 0xc0, 0xf6, 0x3a, 0xb3, 0xeb, 0x06, 0xf8, 0x9d, 0xfc, 0x20, 0xe4, 0x71, 0x9c, 0x44,
- 0x41, 0x3d, 0xc5, 0xf3, 0xcd, 0xdb, 0xb7, 0x2f, 0xab, 0x07, 0x17, 0xca, 0x94, 0x65, 0x52, 0x65,
- 0x76, 0xae, 0x4c, 0x59, 0x63, 0xa1, 0xa3, 0x9a, 0x8c, 0x33, 0xe2, 0x85, 0x52, 0x51, 0x42, 0x59,
- 0x83, 0x95, 0x89, 0x54, 0x81, 0x51, 0x2f, 0xbb, 0x7c, 0xbe, 0x7f, 0xa0, 0x34, 0x55, 0xa7, 0x9f,
- 0xfd, 0x1d, 0x02, 0xdc, 0x74, 0x0e, 0xb1, 0x5e, 0x89, 0x4f, 0x30, 0xc1, 0xca, 0xba, 0xa4, 0x52,
- 0x5a, 0x7a, 0x81, 0x17, 0x4e, 0x3f, 0xbc, 0x89, 0x1e, 0x71, 0x8c, 0x3e, 0x6f, 0x84, 0xf1, 0xf6,
- 0x88, 0x10, 0x30, 0xfc, 0xbe, 0x4a, 0x2b, 0x39, 0x08, 0xbc, 0xd0, 0x8f, 0xf9, 0x5b, 0xbc, 0x06,
- 0xb0, 0x3f, 0xb5, 0x53, 0xf9, 0x22, 0x71, 0xb9, 0x3c, 0xe2, 0xcd, 0x1e, 0x11, 0x6f, 0xe1, 0xd4,
- 0xe6, 0x66, 0xbd, 0x20, 0x53, 0x6b, 0x72, 0xa8, 0xad, 0x1c, 0x06, 0x5e, 0x38, 0x89, 0x0f, 0x68,
- 0xeb, 0x53, 0x93, 0xae, 0xc9, 0x28, 0x6d, 0xad, 0x1c, 0xb1, 0x66, 0x8f, 0xb4, 0x3e, 0x69, 0x83,
- 0x45, 0x76, 0x93, 0xa8, 0x5c, 0xf3, 0x5d, 0x63, 0xbe, 0xeb, 0x80, 0x8a, 0x97, 0xe0, 0x33, 0x61,
- 0xc9, 0x31, 0x4b, 0x76, 0x40, 0x84, 0x70, 0xd6, 0x0d, 0xbb, 0x38, 0x93, 0xe0, 0x28, 0xf4, 0xe3,
- 0x43, 0x2c, 0x2e, 0x61, 0xb2, 0x4e, 0xa8, 0xc2, 0x6a, 0x69, 0xa5, 0xcf, 0x36, 0xdb, 0x59, 0x48,
- 0x38, 0x7e, 0xd0, 0x94, 0x1a, 0xab, 0x25, 0x70, 0xd0, 0x7e, 0x14, 0xcf, 0x60, 0xb4, 0x6a, 0x50,
- 0x3b, 0x39, 0x65, 0xde, 0x0d, 0xe2, 0x02, 0xc6, 0x0f, 0x98, 0x2d, 0x30, 0x93, 0x27, 0xec, 0xb4,
- 0x99, 0xc4, 0x0c, 0x40, 0xff, 0xaa, 0x0d, 0xb9, 0x3b, 0x2c, 0xb4, 0x7c, 0xd2, 0xee, 0xae, 0x07,
- 0xd2, 0x8b, 0xf7, 0x68, 0xfb, 0xe6, 0x3f, 0x4c, 0x6a, 0xe5, 0x69, 0xe0, 0x85, 0xa3, 0x98, 0xbf,
- 0xdb, 0xff, 0x58, 0x60, 0x4a, 0x09, 0xb5, 0xf9, 0xcf, 0x38, 0xff, 0x0e, 0x88, 0x77, 0x70, 0x6e,
- 0x6a, 0x87, 0x25, 0xfe, 0xd1, 0x77, 0x86, 0x6e, 0x75, 0xda, 0x2c, 0xe5, 0x39, 0xc7, 0xf9, 0x8f,
- 0xb7, 0xc9, 0x32, 0xfa, 0x1d, 0x37, 0x95, 0x7c, 0xca, 0x8a, 0xcd, 0x24, 0x5e, 0xf5, 0xc9, 0xee,
- 0x33, 0x24, 0x29, 0xba, 0x67, 0xec, 0xc8, 0x2d, 0xd2, 0xec, 0x0b, 0x4c, 0xb7, 0xad, 0xb2, 0x75,
- 0xab, 0x36, 0x8d, 0xbb, 0xb7, 0x8e, 0x74, 0x52, 0x72, 0xb1, 0x4e, 0x62, 0xdf, 0x34, 0xee, 0x2b,
- 0x03, 0x36, 0x23, 0xea, 0xd7, 0x83, 0x6e, 0xad, 0x89, 0xba, 0xf5, 0xf5, 0xd5, 0xb7, 0xf7, 0x4b,
- 0x74, 0x79, 0x93, 0xb6, 0xdd, 0x9b, 0x6f, 0xba, 0xd8, 0xff, 0x5e, 0xa9, 0x02, 0xe7, 0x54, 0xab,
- 0x79, 0xdf, 0xcb, 0x74, 0xcc, 0xcd, 0xfe, 0xf8, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x40, 0x39, 0x20,
- 0x0a, 0x23, 0x03, 0x00, 0x00,
+ // 467 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0xc1, 0x6f, 0xd3, 0x30,
+ 0x14, 0xc6, 0x95, 0xad, 0xed, 0xda, 0xd7, 0xb1, 0x0d, 0x03, 0xc3, 0x9a, 0x00, 0x85, 0x1e, 0x50,
+ 0x04, 0x5a, 0x2a, 0xc1, 0x99, 0xcb, 0x36, 0x4d, 0x42, 0x5c, 0xaa, 0x70, 0xe3, 0x32, 0x25, 0xce,
+ 0xa3, 0x31, 0x24, 0x71, 0xfa, 0xec, 0x6c, 0xc0, 0xdf, 0xcd, 0x1f, 0x80, 0xf2, 0xdc, 0xb4, 0x55,
+ 0x11, 0xa7, 0xf8, 0xfd, 0xde, 0xe7, 0xcf, 0x5f, 0xec, 0x07, 0xe7, 0xca, 0x54, 0x55, 0x5a, 0xe7,
+ 0x76, 0xae, 0x4c, 0xd5, 0xe8, 0x12, 0xe3, 0x86, 0x8c, 0x33, 0xe2, 0xb9, 0x52, 0x71, 0x4a, 0x79,
+ 0xab, 0x6b, 0x13, 0xab, 0x52, 0xc7, 0xbd, 0xec, 0xe2, 0xd9, 0xee, 0x86, 0xca, 0xd4, 0x5e, 0x3f,
+ 0xfb, 0x33, 0x00, 0xb8, 0xf6, 0x0e, 0x09, 0xae, 0xc4, 0x47, 0x18, 0xeb, 0xda, 0xba, 0xb4, 0x56,
+ 0x28, 0x83, 0x30, 0x88, 0xa6, 0xef, 0x5f, 0xc7, 0xff, 0x71, 0x8c, 0x3f, 0xad, 0x85, 0xc9, 0x66,
+ 0x8b, 0x10, 0x30, 0xf8, 0xb6, 0xca, 0x6a, 0x79, 0x10, 0x06, 0xd1, 0x24, 0xe1, 0xb5, 0x78, 0x05,
+ 0x60, 0x7f, 0xa0, 0x53, 0xc5, 0x22, 0x75, 0x85, 0x3c, 0xe4, 0xce, 0x0e, 0x11, 0x6f, 0xe0, 0xc4,
+ 0x16, 0xe6, 0x61, 0x41, 0xa6, 0x41, 0x72, 0x1a, 0xad, 0x1c, 0x84, 0x41, 0x34, 0x4e, 0xf6, 0x68,
+ 0xe7, 0xd3, 0x10, 0x36, 0x64, 0x14, 0x5a, 0x2b, 0x87, 0xac, 0xd9, 0x21, 0x9d, 0x4f, 0xd6, 0xea,
+ 0x32, 0xbf, 0x4e, 0x55, 0x81, 0x7c, 0xd6, 0x88, 0xcf, 0xda, 0xa3, 0xe2, 0x05, 0x4c, 0x98, 0xb0,
+ 0xe4, 0x88, 0x25, 0x5b, 0x20, 0x22, 0x38, 0xf5, 0xc5, 0x36, 0xce, 0x38, 0x3c, 0x8c, 0x26, 0xc9,
+ 0x3e, 0x16, 0x17, 0x30, 0x7e, 0x48, 0xa9, 0xd6, 0xf5, 0xd2, 0xca, 0x09, 0xdb, 0x6c, 0x6a, 0x21,
+ 0xe1, 0xe8, 0x1e, 0x29, 0x33, 0x16, 0x25, 0x70, 0xd0, 0xbe, 0x14, 0x4f, 0x61, 0xb8, 0x6a, 0x35,
+ 0x3a, 0x39, 0x65, 0xee, 0x0b, 0x71, 0x0e, 0xa3, 0x7b, 0x9d, 0x2f, 0x74, 0x2e, 0x8f, 0xd9, 0x69,
+ 0x5d, 0x89, 0x19, 0x00, 0xfe, 0x6c, 0x0c, 0xb9, 0x5b, 0x5d, 0xa2, 0x7c, 0xd4, 0xf5, 0xae, 0x0e,
+ 0x64, 0x90, 0xec, 0xd0, 0xee, 0xce, 0xbf, 0x9b, 0xcc, 0xca, 0x93, 0x30, 0x88, 0x86, 0x09, 0xaf,
+ 0xbb, 0x7f, 0x2c, 0x75, 0x46, 0x29, 0x75, 0xf9, 0x4f, 0x39, 0xff, 0x16, 0x88, 0xb7, 0x70, 0x66,
+ 0x1a, 0xa7, 0x2b, 0xfd, 0x1b, 0x6f, 0x0d, 0xdd, 0x60, 0xd6, 0x2e, 0xe5, 0x19, 0xc7, 0xf9, 0x87,
+ 0x77, 0xc9, 0x72, 0xfa, 0x95, 0xb4, 0xb5, 0x7c, 0xcc, 0x8a, 0x75, 0x25, 0x5e, 0xf6, 0xc9, 0xee,
+ 0x72, 0x4d, 0x52, 0xf8, 0x6b, 0xf4, 0xe4, 0x46, 0x93, 0x7f, 0x2c, 0xb3, 0xa4, 0xb4, 0xaa, 0x90,
+ 0xe4, 0x13, 0xff, 0xe8, 0x5b, 0x32, 0xfb, 0x0c, 0xd3, 0xcd, 0xd4, 0xd9, 0xa6, 0x73, 0x33, 0xad,
+ 0xbb, 0xb3, 0x8e, 0x30, 0xad, 0x78, 0xf0, 0x8e, 0x93, 0x89, 0x69, 0xdd, 0x17, 0x06, 0x7c, 0x18,
+ 0x51, 0xdf, 0x3e, 0xf0, 0x6d, 0x24, 0xf2, 0xed, 0xab, 0xcb, 0xaf, 0xef, 0x96, 0xda, 0x15, 0x6d,
+ 0xd6, 0xcd, 0xe6, 0x7c, 0x3d, 0xab, 0xfd, 0xf7, 0x52, 0x95, 0x7a, 0x4e, 0x8d, 0x9a, 0xf7, 0x73,
+ 0x9b, 0x8d, 0x78, 0xf2, 0x3f, 0xfc, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x91, 0xad, 0xf5, 0x19, 0x43,
+ 0x03, 0x00, 0x00,
}
diff --git a/rpc/commands/compile.proto b/rpc/commands/compile.proto
index 050c1d8bb9a..51f833701ca 100644
--- a/rpc/commands/compile.proto
+++ b/rpc/commands/compile.proto
@@ -40,6 +40,7 @@ message CompileReq {
bool optimizeForDebug = 16; // Optimize compile output for debug, not for release.
bool dryRun = 17; // When set to `true` the compiled binary will not be copied to the export directory.
string export_dir = 18; // Optional: save the build artifacts in this directory, the directory must exist.
+ string programmer = 19; // External programmer for upload
}
message CompileResp {
diff --git a/rpc/commands/upload.pb.go b/rpc/commands/upload.pb.go
index a7606d4695b..bc150f1e057 100644
--- a/rpc/commands/upload.pb.go
+++ b/rpc/commands/upload.pb.go
@@ -42,6 +42,7 @@ type UploadReq struct {
// Custom path to a directory containing compiled files. When `import_dir` is
// not specified, the standard build directory under `sketch_path` is used.
ImportDir string `protobuf:"bytes,8,opt,name=import_dir,json=importDir,proto3" json:"import_dir,omitempty"`
+ Programmer string `protobuf:"bytes,9,opt,name=programmer,proto3" json:"programmer,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@@ -129,6 +130,13 @@ func (m *UploadReq) GetImportDir() string {
return ""
}
+func (m *UploadReq) GetProgrammer() string {
+ if m != nil {
+ return m.Programmer
+ }
+ return ""
+}
+
type UploadResp struct {
// The output of the upload process.
OutStream []byte `protobuf:"bytes,1,opt,name=out_stream,json=outStream,proto3" json:"out_stream,omitempty"`
@@ -178,33 +186,323 @@ func (m *UploadResp) GetErrStream() []byte {
return nil
}
+type BurnBootloaderReq struct {
+ // Arduino Core Service instance from the `Init` response.
+ Instance *Instance `protobuf:"bytes,1,opt,name=instance,proto3" json:"instance,omitempty"`
+ // Fully qualified board name of the target board (e.g., `arduino:avr:uno`).
+ Fqbn string `protobuf:"bytes,2,opt,name=fqbn,proto3" json:"fqbn,omitempty"`
+ // The port of the programmer used to program the bootloader.
+ Port string `protobuf:"bytes,3,opt,name=port,proto3" json:"port,omitempty"`
+ // Whether to turn on verbose output during the programming.
+ Verbose bool `protobuf:"varint,4,opt,name=verbose,proto3" json:"verbose,omitempty"`
+ // After programming, verify the contents of the memory on the board match the
+ // uploaded binary.
+ Verify bool `protobuf:"varint,5,opt,name=verify,proto3" json:"verify,omitempty"`
+ // The programmer to use for burning bootloader.
+ Programmer string `protobuf:"bytes,6,opt,name=programmer,proto3" json:"programmer,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *BurnBootloaderReq) Reset() { *m = BurnBootloaderReq{} }
+func (m *BurnBootloaderReq) String() string { return proto.CompactTextString(m) }
+func (*BurnBootloaderReq) ProtoMessage() {}
+func (*BurnBootloaderReq) Descriptor() ([]byte, []int) {
+ return fileDescriptor_cd642cc079f8acdb, []int{2}
+}
+
+func (m *BurnBootloaderReq) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_BurnBootloaderReq.Unmarshal(m, b)
+}
+func (m *BurnBootloaderReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_BurnBootloaderReq.Marshal(b, m, deterministic)
+}
+func (m *BurnBootloaderReq) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_BurnBootloaderReq.Merge(m, src)
+}
+func (m *BurnBootloaderReq) XXX_Size() int {
+ return xxx_messageInfo_BurnBootloaderReq.Size(m)
+}
+func (m *BurnBootloaderReq) XXX_DiscardUnknown() {
+ xxx_messageInfo_BurnBootloaderReq.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BurnBootloaderReq proto.InternalMessageInfo
+
+func (m *BurnBootloaderReq) GetInstance() *Instance {
+ if m != nil {
+ return m.Instance
+ }
+ return nil
+}
+
+func (m *BurnBootloaderReq) GetFqbn() string {
+ if m != nil {
+ return m.Fqbn
+ }
+ return ""
+}
+
+func (m *BurnBootloaderReq) GetPort() string {
+ if m != nil {
+ return m.Port
+ }
+ return ""
+}
+
+func (m *BurnBootloaderReq) GetVerbose() bool {
+ if m != nil {
+ return m.Verbose
+ }
+ return false
+}
+
+func (m *BurnBootloaderReq) GetVerify() bool {
+ if m != nil {
+ return m.Verify
+ }
+ return false
+}
+
+func (m *BurnBootloaderReq) GetProgrammer() string {
+ if m != nil {
+ return m.Programmer
+ }
+ return ""
+}
+
+type BurnBootloaderResp struct {
+ // The output of the burn bootloader process.
+ OutStream []byte `protobuf:"bytes,1,opt,name=out_stream,json=outStream,proto3" json:"out_stream,omitempty"`
+ // The error output of the burn bootloader process.
+ ErrStream []byte `protobuf:"bytes,2,opt,name=err_stream,json=errStream,proto3" json:"err_stream,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *BurnBootloaderResp) Reset() { *m = BurnBootloaderResp{} }
+func (m *BurnBootloaderResp) String() string { return proto.CompactTextString(m) }
+func (*BurnBootloaderResp) ProtoMessage() {}
+func (*BurnBootloaderResp) Descriptor() ([]byte, []int) {
+ return fileDescriptor_cd642cc079f8acdb, []int{3}
+}
+
+func (m *BurnBootloaderResp) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_BurnBootloaderResp.Unmarshal(m, b)
+}
+func (m *BurnBootloaderResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_BurnBootloaderResp.Marshal(b, m, deterministic)
+}
+func (m *BurnBootloaderResp) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_BurnBootloaderResp.Merge(m, src)
+}
+func (m *BurnBootloaderResp) XXX_Size() int {
+ return xxx_messageInfo_BurnBootloaderResp.Size(m)
+}
+func (m *BurnBootloaderResp) XXX_DiscardUnknown() {
+ xxx_messageInfo_BurnBootloaderResp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BurnBootloaderResp proto.InternalMessageInfo
+
+func (m *BurnBootloaderResp) GetOutStream() []byte {
+ if m != nil {
+ return m.OutStream
+ }
+ return nil
+}
+
+func (m *BurnBootloaderResp) GetErrStream() []byte {
+ if m != nil {
+ return m.ErrStream
+ }
+ return nil
+}
+
+type ListProgrammersAvailableForUploadReq struct {
+ Instance *Instance `protobuf:"bytes,1,opt,name=instance,proto3" json:"instance,omitempty"`
+ Fqbn string `protobuf:"bytes,2,opt,name=fqbn,proto3" json:"fqbn,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ListProgrammersAvailableForUploadReq) Reset() { *m = ListProgrammersAvailableForUploadReq{} }
+func (m *ListProgrammersAvailableForUploadReq) String() string { return proto.CompactTextString(m) }
+func (*ListProgrammersAvailableForUploadReq) ProtoMessage() {}
+func (*ListProgrammersAvailableForUploadReq) Descriptor() ([]byte, []int) {
+ return fileDescriptor_cd642cc079f8acdb, []int{4}
+}
+
+func (m *ListProgrammersAvailableForUploadReq) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ListProgrammersAvailableForUploadReq.Unmarshal(m, b)
+}
+func (m *ListProgrammersAvailableForUploadReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ListProgrammersAvailableForUploadReq.Marshal(b, m, deterministic)
+}
+func (m *ListProgrammersAvailableForUploadReq) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ListProgrammersAvailableForUploadReq.Merge(m, src)
+}
+func (m *ListProgrammersAvailableForUploadReq) XXX_Size() int {
+ return xxx_messageInfo_ListProgrammersAvailableForUploadReq.Size(m)
+}
+func (m *ListProgrammersAvailableForUploadReq) XXX_DiscardUnknown() {
+ xxx_messageInfo_ListProgrammersAvailableForUploadReq.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ListProgrammersAvailableForUploadReq proto.InternalMessageInfo
+
+func (m *ListProgrammersAvailableForUploadReq) GetInstance() *Instance {
+ if m != nil {
+ return m.Instance
+ }
+ return nil
+}
+
+func (m *ListProgrammersAvailableForUploadReq) GetFqbn() string {
+ if m != nil {
+ return m.Fqbn
+ }
+ return ""
+}
+
+type ListProgrammersAvailableForUploadResp struct {
+ Programmers []*Programmer `protobuf:"bytes,1,rep,name=programmers,proto3" json:"programmers,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ListProgrammersAvailableForUploadResp) Reset() { *m = ListProgrammersAvailableForUploadResp{} }
+func (m *ListProgrammersAvailableForUploadResp) String() string { return proto.CompactTextString(m) }
+func (*ListProgrammersAvailableForUploadResp) ProtoMessage() {}
+func (*ListProgrammersAvailableForUploadResp) Descriptor() ([]byte, []int) {
+ return fileDescriptor_cd642cc079f8acdb, []int{5}
+}
+
+func (m *ListProgrammersAvailableForUploadResp) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ListProgrammersAvailableForUploadResp.Unmarshal(m, b)
+}
+func (m *ListProgrammersAvailableForUploadResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ListProgrammersAvailableForUploadResp.Marshal(b, m, deterministic)
+}
+func (m *ListProgrammersAvailableForUploadResp) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ListProgrammersAvailableForUploadResp.Merge(m, src)
+}
+func (m *ListProgrammersAvailableForUploadResp) XXX_Size() int {
+ return xxx_messageInfo_ListProgrammersAvailableForUploadResp.Size(m)
+}
+func (m *ListProgrammersAvailableForUploadResp) XXX_DiscardUnknown() {
+ xxx_messageInfo_ListProgrammersAvailableForUploadResp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ListProgrammersAvailableForUploadResp proto.InternalMessageInfo
+
+func (m *ListProgrammersAvailableForUploadResp) GetProgrammers() []*Programmer {
+ if m != nil {
+ return m.Programmers
+ }
+ return nil
+}
+
+type Programmer struct {
+ Platform string `protobuf:"bytes,1,opt,name=platform,proto3" json:"platform,omitempty"`
+ Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
+ Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Programmer) Reset() { *m = Programmer{} }
+func (m *Programmer) String() string { return proto.CompactTextString(m) }
+func (*Programmer) ProtoMessage() {}
+func (*Programmer) Descriptor() ([]byte, []int) {
+ return fileDescriptor_cd642cc079f8acdb, []int{6}
+}
+
+func (m *Programmer) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Programmer.Unmarshal(m, b)
+}
+func (m *Programmer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Programmer.Marshal(b, m, deterministic)
+}
+func (m *Programmer) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Programmer.Merge(m, src)
+}
+func (m *Programmer) XXX_Size() int {
+ return xxx_messageInfo_Programmer.Size(m)
+}
+func (m *Programmer) XXX_DiscardUnknown() {
+ xxx_messageInfo_Programmer.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Programmer proto.InternalMessageInfo
+
+func (m *Programmer) GetPlatform() string {
+ if m != nil {
+ return m.Platform
+ }
+ return ""
+}
+
+func (m *Programmer) GetId() string {
+ if m != nil {
+ return m.Id
+ }
+ return ""
+}
+
+func (m *Programmer) GetName() string {
+ if m != nil {
+ return m.Name
+ }
+ return ""
+}
+
func init() {
proto.RegisterType((*UploadReq)(nil), "cc.arduino.cli.commands.UploadReq")
proto.RegisterType((*UploadResp)(nil), "cc.arduino.cli.commands.UploadResp")
+ proto.RegisterType((*BurnBootloaderReq)(nil), "cc.arduino.cli.commands.BurnBootloaderReq")
+ proto.RegisterType((*BurnBootloaderResp)(nil), "cc.arduino.cli.commands.BurnBootloaderResp")
+ proto.RegisterType((*ListProgrammersAvailableForUploadReq)(nil), "cc.arduino.cli.commands.ListProgrammersAvailableForUploadReq")
+ proto.RegisterType((*ListProgrammersAvailableForUploadResp)(nil), "cc.arduino.cli.commands.ListProgrammersAvailableForUploadResp")
+ proto.RegisterType((*Programmer)(nil), "cc.arduino.cli.commands.Programmer")
}
func init() { proto.RegisterFile("commands/upload.proto", fileDescriptor_cd642cc079f8acdb) }
var fileDescriptor_cd642cc079f8acdb = []byte{
- // 312 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x91, 0x41, 0x4b, 0xfc, 0x30,
- 0x10, 0xc5, 0x69, 0xff, 0xfb, 0xdf, 0xdd, 0xce, 0x7a, 0x0a, 0xa8, 0x41, 0x10, 0xd7, 0xf5, 0xb2,
- 0x20, 0xdb, 0x82, 0x9e, 0xbd, 0x2c, 0x22, 0xe8, 0x49, 0x2a, 0x5e, 0xbc, 0x94, 0x34, 0xcd, 0xda,
- 0x60, 0xdb, 0x74, 0x27, 0xe9, 0x82, 0x1f, 0xc1, 0x6f, 0x2d, 0x49, 0x1a, 0x3d, 0x79, 0xea, 0xcc,
- 0xfb, 0xbd, 0x37, 0x85, 0x17, 0x38, 0xe6, 0xaa, 0x6d, 0x59, 0x57, 0xe9, 0x6c, 0xe8, 0x1b, 0xc5,
- 0xaa, 0xb4, 0x47, 0x65, 0x14, 0x39, 0xe5, 0x3c, 0x65, 0x58, 0x0d, 0xb2, 0x53, 0x29, 0x6f, 0x64,
- 0x1a, 0x5c, 0x67, 0xbf, 0x7e, 0x3b, 0xa8, 0xce, 0xfb, 0x57, 0x5f, 0x31, 0x24, 0xaf, 0xee, 0x40,
- 0x2e, 0xf6, 0xe4, 0x0e, 0xe6, 0xb2, 0xd3, 0x86, 0x75, 0x5c, 0xd0, 0x68, 0x19, 0xad, 0x17, 0x37,
- 0x97, 0xe9, 0x1f, 0x07, 0xd3, 0xc7, 0xd1, 0x98, 0xff, 0x44, 0x08, 0x81, 0xc9, 0x6e, 0x5f, 0x76,
- 0x34, 0x5e, 0x46, 0xeb, 0x24, 0x77, 0x33, 0xb9, 0x80, 0x85, 0xfe, 0x10, 0x86, 0xd7, 0x45, 0xcf,
- 0x4c, 0x4d, 0xff, 0x39, 0x04, 0x5e, 0x7a, 0x66, 0xa6, 0xb6, 0xa1, 0x5e, 0xa1, 0xa1, 0x13, 0x1f,
- 0xb2, 0x33, 0xa1, 0x30, 0x3b, 0x08, 0x2c, 0x95, 0x16, 0xf4, 0xff, 0x32, 0x5a, 0xcf, 0xf3, 0xb0,
- 0x92, 0x13, 0x98, 0x1e, 0x04, 0xca, 0xdd, 0x27, 0x9d, 0x3a, 0x30, 0x6e, 0xe4, 0x0a, 0x16, 0xb2,
- 0xb5, 0xd9, 0x62, 0x27, 0x1b, 0x41, 0x67, 0xf6, 0xd8, 0x36, 0xa6, 0x51, 0x0e, 0x5e, 0x7e, 0x90,
- 0x8d, 0x20, 0xe7, 0x30, 0x6e, 0x45, 0x25, 0x91, 0xce, 0xdd, 0x0f, 0x13, 0xaf, 0xdc, 0x4b, 0x5c,
- 0x3d, 0x01, 0x84, 0x2a, 0x74, 0x6f, 0xcd, 0x6a, 0x30, 0x85, 0x36, 0x28, 0x58, 0xeb, 0xda, 0x38,
- 0xca, 0x13, 0x35, 0x98, 0x17, 0x27, 0x58, 0x2c, 0x10, 0x03, 0x8e, 0x3d, 0x16, 0x88, 0x1e, 0x6f,
- 0x37, 0x6f, 0xd7, 0xef, 0xd2, 0xd4, 0x43, 0x69, 0x0b, 0xcb, 0xc6, 0x02, 0xc3, 0x77, 0xc3, 0x1b,
- 0x99, 0x61, 0xcf, 0xb3, 0x50, 0x66, 0x39, 0x75, 0xaf, 0x71, 0xfb, 0x1d, 0x00, 0x00, 0xff, 0xff,
- 0xb9, 0xb9, 0xe0, 0xf7, 0xd6, 0x01, 0x00, 0x00,
+ // 463 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x94, 0x51, 0x8b, 0xd3, 0x40,
+ 0x10, 0xc7, 0x49, 0xda, 0xeb, 0x35, 0x13, 0x11, 0x5c, 0x50, 0x97, 0x03, 0xb5, 0xe6, 0x14, 0x0a,
+ 0x72, 0x29, 0x9c, 0xcf, 0x3e, 0x58, 0xf4, 0x40, 0xb9, 0x87, 0x23, 0xe2, 0x8b, 0x2f, 0x65, 0x93,
+ 0x6c, 0xaf, 0x8b, 0xc9, 0xee, 0xde, 0xec, 0xa6, 0x70, 0x1f, 0xc9, 0xef, 0xe2, 0x87, 0x92, 0xcd,
+ 0x26, 0x8d, 0xa7, 0x16, 0x84, 0xa3, 0x4f, 0x9d, 0x99, 0xff, 0xcc, 0x7f, 0xa6, 0xbf, 0x84, 0xc0,
+ 0xe3, 0x42, 0xd5, 0x35, 0x93, 0xa5, 0x59, 0x34, 0xba, 0x52, 0xac, 0x4c, 0x35, 0x2a, 0xab, 0xc8,
+ 0xd3, 0xa2, 0x48, 0x19, 0x96, 0x8d, 0x90, 0x2a, 0x2d, 0x2a, 0x91, 0xf6, 0x5d, 0x27, 0x43, 0xbf,
+ 0x0b, 0x94, 0xf4, 0xfd, 0xc9, 0x8f, 0x10, 0xa2, 0xaf, 0xad, 0x41, 0xc6, 0x6f, 0xc8, 0x3b, 0x98,
+ 0x0a, 0x69, 0x2c, 0x93, 0x05, 0xa7, 0xc1, 0x2c, 0x98, 0xc7, 0xe7, 0x2f, 0xd3, 0x3d, 0x86, 0xe9,
+ 0xa7, 0xae, 0x31, 0xdb, 0x8d, 0x10, 0x02, 0xe3, 0xf5, 0x4d, 0x2e, 0x69, 0x38, 0x0b, 0xe6, 0x51,
+ 0xd6, 0xc6, 0xe4, 0x05, 0xc4, 0xe6, 0x3b, 0xb7, 0xc5, 0x66, 0xa5, 0x99, 0xdd, 0xd0, 0x51, 0x2b,
+ 0x81, 0x2f, 0x5d, 0x31, 0xbb, 0x71, 0x43, 0x5a, 0xa1, 0xa5, 0x63, 0x3f, 0xe4, 0x62, 0x42, 0xe1,
+ 0x78, 0xcb, 0x31, 0x57, 0x86, 0xd3, 0xa3, 0x59, 0x30, 0x9f, 0x66, 0x7d, 0x4a, 0x9e, 0xc0, 0x64,
+ 0xcb, 0x51, 0xac, 0x6f, 0xe9, 0xa4, 0x15, 0xba, 0x8c, 0x9c, 0x42, 0x2c, 0x6a, 0x37, 0xbb, 0x5a,
+ 0x8b, 0x8a, 0xd3, 0x63, 0x67, 0xb6, 0x0c, 0x69, 0x90, 0x81, 0x2f, 0x5f, 0x88, 0x8a, 0x93, 0x67,
+ 0xd0, 0x65, 0xab, 0x52, 0x20, 0x9d, 0xb6, 0x0b, 0x23, 0x5f, 0xf9, 0x20, 0x90, 0x3c, 0x07, 0xd0,
+ 0xa8, 0xae, 0x91, 0xd5, 0x35, 0x47, 0x1a, 0xf9, 0x4b, 0x87, 0x4a, 0xf2, 0x19, 0xa0, 0x47, 0x65,
+ 0xb4, 0x33, 0x53, 0x8d, 0x5d, 0x19, 0x8b, 0x9c, 0xd5, 0x2d, 0xad, 0x07, 0x59, 0xa4, 0x1a, 0xfb,
+ 0xa5, 0x2d, 0x38, 0x99, 0x23, 0xf6, 0x72, 0xe8, 0x65, 0x8e, 0xe8, 0xe5, 0xe4, 0x67, 0x00, 0x8f,
+ 0x96, 0x0d, 0xca, 0xa5, 0x52, 0xd6, 0x59, 0x72, 0x3c, 0x10, 0xff, 0x1e, 0xef, 0xe8, 0xdf, 0x78,
+ 0xc7, 0xfb, 0xf0, 0x1e, 0xdd, 0xc1, 0x7b, 0x17, 0xcd, 0xe4, 0x2f, 0x34, 0x19, 0x90, 0x3f, 0xff,
+ 0xcd, 0xbd, 0x11, 0xdd, 0xc2, 0xab, 0x4b, 0x61, 0xec, 0xd5, 0x6e, 0x8b, 0x79, 0xbf, 0x65, 0xa2,
+ 0x62, 0x79, 0xc5, 0x2f, 0x14, 0x1e, 0xf2, 0xa5, 0x4d, 0x24, 0xbc, 0xfe, 0x8f, 0xd5, 0x46, 0x93,
+ 0x8f, 0x10, 0x0f, 0x14, 0x0c, 0x0d, 0x66, 0xa3, 0x79, 0x7c, 0x7e, 0xba, 0x77, 0xfd, 0x60, 0x98,
+ 0xfd, 0x3e, 0x97, 0x5c, 0x02, 0x0c, 0x12, 0x39, 0x81, 0xa9, 0xae, 0x98, 0x5d, 0x2b, 0xf4, 0xd0,
+ 0xa2, 0x6c, 0x97, 0x93, 0x87, 0x10, 0x8a, 0xb2, 0xbb, 0x35, 0x14, 0xa5, 0xbb, 0x5e, 0xb2, 0x9a,
+ 0xf7, 0x8f, 0xd7, 0xc5, 0xcb, 0xb3, 0x6f, 0x6f, 0xae, 0x85, 0xdd, 0x34, 0xb9, 0x5b, 0xbc, 0xe8,
+ 0x0e, 0xe9, 0x7f, 0xcf, 0x8a, 0x4a, 0x2c, 0x50, 0x17, 0x8b, 0xfe, 0xa8, 0x7c, 0xd2, 0x7e, 0x09,
+ 0xde, 0xfe, 0x0a, 0x00, 0x00, 0xff, 0xff, 0xfd, 0x43, 0xdb, 0xdc, 0x52, 0x04, 0x00, 0x00,
}
diff --git a/rpc/commands/upload.proto b/rpc/commands/upload.proto
index 82b936eb293..2c02c361e90 100644
--- a/rpc/commands/upload.proto
+++ b/rpc/commands/upload.proto
@@ -43,6 +43,7 @@ message UploadReq {
// Custom path to a directory containing compiled files. When `import_dir` is
// not specified, the standard build directory under `sketch_path` is used.
string import_dir = 8;
+ string programmer = 9;
}
message UploadResp {
@@ -50,4 +51,42 @@ message UploadResp {
bytes out_stream = 1;
// The error output of the upload process.
bytes err_stream = 2;
-}
\ No newline at end of file
+}
+
+message BurnBootloaderReq {
+ // Arduino Core Service instance from the `Init` response.
+ Instance instance = 1;
+ // Fully qualified board name of the target board (e.g., `arduino:avr:uno`).
+ string fqbn = 2;
+ // The port of the programmer used to program the bootloader.
+ string port = 3;
+ // Whether to turn on verbose output during the programming.
+ bool verbose = 4;
+ // After programming, verify the contents of the memory on the board match the
+ // uploaded binary.
+ bool verify = 5;
+ // The programmer to use for burning bootloader.
+ string programmer = 6;
+}
+
+message BurnBootloaderResp {
+ // The output of the burn bootloader process.
+ bytes out_stream = 1;
+ // The error output of the burn bootloader process.
+ bytes err_stream = 2;
+}
+
+message ListProgrammersAvailableForUploadReq {
+ Instance instance = 1;
+ string fqbn = 2;
+}
+
+message ListProgrammersAvailableForUploadResp {
+ repeated Programmer programmers = 1;
+}
+
+message Programmer {
+ string platform = 1;
+ string id = 2;
+ string name = 3;
+}
pFad - Phonifier reborn
Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies:
Alternative Proxy
pFad Proxy
pFad v3 Proxy
pFad v4 Proxy