Skip to content

Commit 117385c

Browse files
cmagliecmaglie
authored
Merge pull request #24 from arduino/retries
Added retries flag
2 parents 2ed4c0e + b299e0a commit 117385c

File tree

6 files changed

+101
-72
lines changed

6 files changed

+101
-72
lines changed

Diff for: ‎main.go

+28-7
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@ import (
77
"log"
88
"os"
99
"strings"
10+
"time"
1011

1112
"github.com/arduino/FirmwareUploader/modules/nina"
1213
"github.com/arduino/FirmwareUploader/modules/sara"
@@ -28,11 +29,11 @@ func init() {
2829
flag.StringVar(&ctx.ProgrammerPath, "programmer", "", "path of programmer in use (avrdude/bossac)")
2930
flag.StringVar(&ctx.Model, "model", "", "module model (winc, nina or sara)")
3031
flag.StringVar(&ctx.Compatible, "get_available_for", "", "Ask for available firmwares matching a given board")
32+
flag.IntVar(&ctx.Retries, "retries", 9, "Number of retries in case of upload failure")
3133
}
3234

3335
func main() {
3436
flag.Parse()
35-
3637
if ctx.Compatible != "" {
3738
el, _ := json.Marshal(utils.GetCompatibleWith(ctx.Compatible, ""))
3839
fmt.Println(string(el))
@@ -43,11 +44,31 @@ func main() {
4344
log.Fatal("Please specify a serial port")
4445
}
4546

46-
if ctx.Model == "nina" || strings.Contains(ctx.FirmwareFile, "NINA") || strings.Contains(ctx.FWUploaderBinary, "NINA") {
47-
nina.Run(ctx)
48-
} else if ctx.Model == "winc" || strings.Contains(ctx.FirmwareFile, "WINC") || strings.Contains(ctx.FWUploaderBinary, "WINC") {
49-
winc.Run(ctx)
50-
} else {
51-
sara.Run(ctx)
47+
retry := 0
48+
for {
49+
var ctxCopy context.Context
50+
ctxCopy = *ctx
51+
var err error
52+
if ctx.Model == "nina" || strings.Contains(ctx.FirmwareFile, "NINA") || strings.Contains(ctx.FWUploaderBinary, "NINA") {
53+
err = nina.Run(&ctxCopy)
54+
} else if ctx.Model == "winc" || strings.Contains(ctx.FirmwareFile, "WINC") || strings.Contains(ctx.FWUploaderBinary, "WINC") {
55+
err = winc.Run(&ctxCopy)
56+
} else {
57+
err = sara.Run(&ctxCopy)
58+
}
59+
if err == nil {
60+
log.Println("Operation completed: success! :-)")
61+
break
62+
}
63+
log.Println("Error: " + err.Error())
64+
65+
if retry >= ctx.Retries {
66+
log.Fatal("Operation failed. :-(")
67+
}
68+
69+
retry++
70+
log.Println("Waiting 1 second before retrying...")
71+
time.Sleep(time.Second)
72+
log.Printf("Retrying upload (%d of %d)", retry, ctx.Retries)
5273
}
5374
}

Diff for: ‎modules/nina/main.go

+19-16
Original file line numberDiff line numberDiff line change
@@ -28,17 +28,18 @@ import (
2828
"strconv"
2929
"strings"
3030

31-
"github.com/arduino/FirmwareUploader/programmers/rp2040load"
3231
"github.com/arduino/FirmwareUploader/programmers/avrdude"
3332
"github.com/arduino/FirmwareUploader/programmers/bossac"
33+
"github.com/arduino/FirmwareUploader/programmers/rp2040load"
3434
"github.com/arduino/FirmwareUploader/utils/context"
35+
"github.com/pkg/errors"
3536
)
3637

3738
var flasher *Flasher
3839
var payloadSize uint16
3940
var programmer context.Programmer
4041

41-
func Run(ctx *context.Context) {
42+
func Run(ctx *context.Context) error {
4243

4344
if ctx.ProgrammerPath != "" {
4445
if strings.Contains(filepath.Base(ctx.ProgrammerPath), "bossac") {
@@ -48,60 +49,61 @@ func Run(ctx *context.Context) {
4849
} else if strings.Contains(filepath.Base(ctx.ProgrammerPath), "rp2040load") {
4950
programmer = rp2040load.NewRP2040Load(ctx)
5051
} else {
51-
log.Fatal("Programmer path not specified correctly, programmer path set to: " + ctx.ProgrammerPath)
52+
return errors.New("Programmer path not specified correctly, programmer path set to: " + ctx.ProgrammerPath)
5253
}
5354
}
5455

5556
if ctx.FWUploaderBinary != "" {
5657
log.Println("Flashing firmware uploader nina")
5758
if programmer == nil {
58-
log.Fatal("ERROR: You must specify a programmer!")
59+
return errors.New("ERROR: You must specify a programmer!")
5960
}
6061
if err := programmer.Flash(ctx.FWUploaderBinary, nil); err != nil {
61-
log.Fatal(err)
62+
return err
6263
}
6364
}
6465

6566
log.Println("Connecting to programmer")
6667
if f, err := OpenFlasher(ctx.PortName); err != nil {
67-
log.Fatal(err)
68+
return err
6869
} else {
6970
flasher = f
7071
}
72+
defer flasher.Close()
7173

7274
// Synchronize with programmer
7375
log.Println("Sync with programmer")
7476
if err := flasher.Hello(); err != nil {
75-
log.Fatal(err)
77+
return err
7678
}
7779

7880
// Check maximum supported payload size
7981
log.Println("Reading max payload size")
8082
if _payloadSize, err := flasher.GetMaximumPayloadSize(); err != nil {
81-
log.Fatal(err)
83+
return err
8284
} else {
8385
payloadSize = _payloadSize
8486
}
8587
if payloadSize < 1024 {
86-
log.Fatalf("Programmer reports %d as maximum payload size (1024 is needed)", payloadSize)
88+
return errors.Errorf("Programmer reports %d as maximum payload size (1024 is needed)", payloadSize)
8789
}
8890

8991
if ctx.FirmwareFile != "" {
9092
if err := flashFirmware(ctx); err != nil {
91-
log.Fatal(err)
93+
return err
9294
}
9395
}
9496

9597
if ctx.RootCertDir != "" || len(ctx.Addresses) != 0 {
9698
if err := flashCerts(ctx); err != nil {
97-
log.Fatal(err)
99+
return err
98100
}
99101
}
100102

101103
if ctx.ReadAll {
102104
log.Println("Reading all flash")
103105
if err := readAllFlash(); err != nil {
104-
log.Fatal(err)
106+
return err
105107
}
106108
}
107109

@@ -110,18 +112,19 @@ func Run(ctx *context.Context) {
110112
if ctx.BinaryToRestore != "" {
111113
log.Println("Restoring binary")
112114
if programmer == nil {
113-
log.Fatal("ERROR: You must specify a programmer!")
115+
errors.New("ERROR: You must specify a programmer!")
114116
}
115117
if err := programmer.Flash(ctx.BinaryToRestore, nil); err != nil {
116-
log.Fatal(err)
118+
return err
117119
}
118120
}
121+
return nil
119122
}
120123

121124
func readAllFlash() error {
122125
for i := 0; i < 256; i++ {
123126
if data, err := flasher.Read(uint32(i*1024), 1024); err != nil {
124-
log.Fatal(err)
127+
return err
125128
} else {
126129
os.Stdout.Write(data)
127130
}
@@ -142,7 +145,7 @@ func flashCerts(ctx *context.Context) error {
142145
}
143146

144147
if len(certificatesData) > 0x20000 {
145-
log.Fatal("Too many certificates! Aborting")
148+
errors.New("Too many certificates! Aborting")
146149
}
147150

148151
// pad certificatesData to flash page

Diff for: ‎modules/sara/flasher.go

+3-4
Original file line numberDiff line numberDiff line change
@@ -41,10 +41,9 @@ type Flasher struct {
4141
}
4242

4343
func (flasher *Flasher) Hello() error {
44-
45-
f.Expect("ATE0", "OK", 100)
46-
f.Expect("ATE0", "OK", 100)
47-
f.Expect("ATE0", "OK", 100)
44+
flasher.Expect("ATE0", "OK", 100)
45+
flasher.Expect("ATE0", "OK", 100)
46+
flasher.Expect("ATE0", "OK", 100)
4847
_, err := flasher.Expect("AT", "OK", 100)
4948
return err
5049
}

Diff for: ‎modules/sara/main.go

+26-23
Original file line numberDiff line numberDiff line change
@@ -21,48 +21,50 @@ package sara
2121

2222
import (
2323
"fmt"
24-
"github.com/arduino/FirmwareUploader/programmers/bossac"
25-
"github.com/arduino/FirmwareUploader/utils/context"
2624
"io/ioutil"
2725
"log"
2826
"strconv"
2927
"time"
28+
29+
"github.com/arduino/FirmwareUploader/programmers/bossac"
30+
"github.com/arduino/FirmwareUploader/utils/context"
3031
)
3132

32-
var f *Flasher
33+
var flasher *Flasher
3334
var payloadSize uint16
3435
var programmer context.Programmer
3536

36-
func Run(ctx *context.Context) {
37+
func Run(ctx *context.Context) error {
3738
programmer := bossac.NewBossac(ctx)
3839

3940
if ctx.FWUploaderBinary != "" {
4041
log.Println("Flashing firmware uploader sara")
4142
if err := programmer.Flash(ctx.FWUploaderBinary, nil); err != nil {
42-
log.Fatal(err)
43+
return err
4344
}
4445
}
4546

4647
log.Println("Connecting to programmer")
47-
if _f, err := OpenFlasher(ctx.PortName); err != nil {
48-
log.Fatal(err)
48+
if f, err := OpenFlasher(ctx.PortName); err != nil {
49+
return err
4950
} else {
50-
f = _f
51+
flasher = f
5152
}
53+
defer flasher.Close()
5254

5355
time.Sleep(2 * time.Second)
5456

5557
// Synchronize with programmer
5658
log.Println("Sync with programmer")
57-
if err := f.Hello(); err != nil {
58-
log.Fatal(err)
59+
if err := flasher.Hello(); err != nil {
60+
return err
5961
}
6062

6163
// Check maximum supported payload size
6264
log.Println("Reading actual firmware version")
6365

64-
if fwVersion, err := f.GetFwVersion(); err != nil {
65-
log.Fatal(err)
66+
if fwVersion, err := flasher.GetFwVersion(); err != nil {
67+
return err
6668
} else {
6769
log.Println("Initial firmware version: " + fwVersion)
6870
}
@@ -71,25 +73,26 @@ func Run(ctx *context.Context) {
7173

7274
if ctx.FirmwareFile != "" {
7375
if err := flashFirmware(ctx); err != nil {
74-
log.Fatal(err)
76+
return err
7577
}
7678
}
7779

78-
if fwVersion, err := f.GetFwVersion(); err != nil {
79-
log.Fatal(err)
80+
if fwVersion, err := flasher.GetFwVersion(); err != nil {
81+
return err
8082
} else {
8183
log.Println("After applying update firmware version: " + fwVersion)
8284
}
8385

84-
f.Close()
86+
flasher.Close()
8587

8688
if ctx.BinaryToRestore != "" {
8789
log.Println("Restoring previous sketch")
8890

8991
if err := programmer.Flash(ctx.BinaryToRestore, nil); err != nil {
90-
log.Fatal(err)
92+
return err
9193
}
9294
}
95+
return nil
9396
}
9497

9598
func flashFirmware(ctx *context.Context) error {
@@ -102,12 +105,12 @@ func flashFirmware(ctx *context.Context) error {
102105
return err
103106
}
104107

105-
_, err = f.Expect("AT+ULSTFILE", "+ULSTFILE:", 1000)
108+
_, err = flasher.Expect("AT+ULSTFILE", "+ULSTFILE:", 1000)
106109
if err != nil {
107110
return err
108111
}
109112

110-
_, err = f.Expect("AT+UDWNFILE=\"UPDATE.BIN\","+strconv.Itoa(len(fwData))+",\"FOAT\"", ">", 20000)
113+
_, err = flasher.Expect("AT+UDWNFILE=\"UPDATE.BIN\","+strconv.Itoa(len(fwData))+",\"FOAT\"", ">", 20000)
111114
if err != nil {
112115
return err
113116
}
@@ -119,12 +122,12 @@ func flashFirmware(ctx *context.Context) error {
119122

120123
time.Sleep(1 * time.Second)
121124

122-
_, err = f.Expect("", "OK", 1000)
125+
_, err = flasher.Expect("", "OK", 1000)
123126
if err != nil {
124127
return err
125128
}
126129

127-
_, err = f.Expect("AT+UFWINSTALL", "OK", 60000)
130+
_, err = flasher.Expect("AT+UFWINSTALL", "OK", 60000)
128131
if err != nil {
129132
return err
130133
}
@@ -134,7 +137,7 @@ func flashFirmware(ctx *context.Context) error {
134137
// wait up to 20 minutes trying to ping the module. After 20 minutes signal the error
135138
start := time.Now()
136139
for time.Since(start) < time.Minute*20 {
137-
err = f.Hello()
140+
err = flasher.Hello()
138141
if err == nil {
139142
return nil
140143
}
@@ -154,7 +157,7 @@ func flashChunk(offset int, buffer []byte) error {
154157
if end > bufferLength {
155158
end = bufferLength
156159
}
157-
if err := f.Write(uint32(offset+i), buffer[start:end]); err != nil {
160+
if err := flasher.Write(uint32(offset+i), buffer[start:end]); err != nil {
158161
return err
159162
}
160163
//time.Sleep(1 * time.Millisecond)

0 commit comments

Comments
 (0)