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; +}