Switch commands to slog, disable net_poll pending fix

cmd/info/main.go

@@ -1,7 +1,8 @@
 package main
 
 import (
-	"fmt"
+	"encoding/hex"
+	"log/slog"
 	"net"
 	"os"
 	"sync"
@@ -18,7 +19,7 @@ type deviceResult struct {
 
 func main() {
 	if err := run(); err != nil {
-		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		slog.Error("fatal", "err", err)
 		os.Exit(1)
 	}
 }
@@ -29,39 +30,46 @@ func run() error {
 		return err
 	}
 	if len(devs) == 0 {
-		return fmt.Errorf("no devices found")
+		slog.Error("no devices found")
+		os.Exit(1)
 	}
 
 	results := make([]deviceResult, len(devs))
 	var wg sync.WaitGroup
 	for i, dev := range devs {
 		results[i].dev = dev
+		log := slog.With("dev", dev)
 		wg.Go(func() {
+			log.Info("connecting")
 			c, err := client.NewSerial(dev, 2*time.Second)
 			if err != nil {
 				results[i].err = err
 				return
 			}
+			log.Info("requesting info")
 			info, err := c.Info()
 			c.Close()
+			if err != nil {
+				results[i].err = err
+				return
+			}
+			log.Info("got info", "firmware", info.FirmwareName)
 			results[i].info = info
-			results[i].err = err
 		})
 	}
 	wg.Wait()
 
 	for _, r := range results {
-		fmt.Printf("Device: %s\n", r.dev)
 		if r.err != nil {
-			fmt.Fprintf(os.Stderr, "  error: %v\n", r.err)
+			slog.Error("device error", "dev", r.dev, "err", r.err)
 			continue
 		}
-		fmt.Printf("  Board ID: %02X%02X%02X%02X%02X%02X%02X%02X\n",
-			r.info.BoardID[0], r.info.BoardID[1], r.info.BoardID[2], r.info.BoardID[3],
-			r.info.BoardID[4], r.info.BoardID[5], r.info.BoardID[6], r.info.BoardID[7])
-		fmt.Printf("  MAC: %s\n", net.HardwareAddr(r.info.MAC[:]))
-		fmt.Printf("  IP: %s\n", net.IP(r.info.IP[:]))
-		fmt.Printf("  Firmware: %s\n", r.info.FirmwareName)
+		slog.Info("device",
+			"dev", r.dev,
+			"board_id", hex.EncodeToString(r.info.BoardID[:]),
+			"mac", net.HardwareAddr(r.info.MAC[:]).String(),
+			"ip", net.IP(r.info.IP[:]).String(),
+			"firmware", r.info.FirmwareName)
 	}
 
 	return nil

cmd/load/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"log/slog"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -15,19 +16,19 @@ import (
 func main() {
 	wd, err := os.Getwd()
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		slog.Error("fatal", "err", err)
 		os.Exit(1)
 	}
 	buildDir := filepath.Join(wd, "firmware", "build")
 
 	if err := run(buildDir); err != nil {
-		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		slog.Error("fatal", "err", err)
 		os.Exit(1)
 	}
 }
 
 func build(buildDir string) error {
-	fmt.Println("Configuring...")
+	slog.Info("configuring")
 	cmake := exec.Command("cmake", "-S", filepath.Join(filepath.Dir(buildDir)), "-B", buildDir)
 	cmake.Stdout = os.Stdout
 	cmake.Stderr = os.Stderr
@@ -35,7 +36,7 @@ func build(buildDir string) error {
 		return fmt.Errorf("cmake failed: %w", err)
 	}
 
-	fmt.Println("Building...")
+	slog.Info("building")
 	cmd := exec.Command("make", "-C", buildDir)
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
@@ -65,10 +66,13 @@ func run(buildDir string) error {
 
 	serials := make([]string, 2)
 	errs := make([]error, 2)
+	uf2Names := []string{"picomap", "picomap_test"}
 
 	var wg sync.WaitGroup
 	for i := range 2 {
+		log := slog.With("dev", devs[i])
 		wg.Go(func() {
+			log.Info("connecting for info")
 			c, err := client.NewSerial(devs[i], 2*time.Second)
 			if err != nil {
 				errs[i] = err
@@ -81,18 +85,20 @@ func run(buildDir string) error {
 				return
 			}
 			serials[i] = boardSerial(info.BoardID)
+			log.Info("got info", "serial", serials[i], "firmware", info.FirmwareName)
 		})
 	}
 	wg.Wait()
 	for i, err := range errs {
 		if err != nil {
-			return fmt.Errorf("info %s: %w", devs[i], err)
+			return fmt.Errorf("[%s] info: %w", devs[i], err)
 		}
 	}
 
-	fmt.Println("Sending PICOBOOT requests...")
 	for i := range 2 {
+		log := slog.With("serial", serials[i])
 		wg.Go(func() {
+			log.Info("sending PICOBOOT")
 			c, err := client.NewSerial(devs[i], 2*time.Second)
 			if err != nil {
 				errs[i] = err
@@ -101,8 +107,10 @@ func run(buildDir string) error {
 			err = c.PICOBOOT()
 			c.Close()
 			if err != nil {
-				errs[i] = fmt.Errorf("PICOBOOT %s: %w", devs[i], err)
+				errs[i] = fmt.Errorf("PICOBOOT %s: %w", serials[i], err)
+				return
 			}
+			log.Info("PICOBOOT sent")
 		})
 	}
 	wg.Wait()
@@ -117,19 +125,23 @@ func run(buildDir string) error {
 		filepath.Join(buildDir, "picomap_test.uf2"),
 	}
 
-	fmt.Println("Loading firmware...")
 	for i := range 2 {
+		log := slog.With("serial", serials[i])
 		wg.Go(func() {
+			log.Info("loading", "uf2", uf2Names[i])
 			errs[i] = picotool.Load(uf2s[i], serials[i], 10*time.Second)
+			if errs[i] == nil {
+				log.Info("loaded", "uf2", uf2Names[i])
+			}
 		})
 	}
 	wg.Wait()
 	for i, err := range errs {
 		if err != nil {
-			return fmt.Errorf("load %s: %w", serials[i], err)
+			return fmt.Errorf("[%s] load: %w", serials[i], err)
 		}
 	}
 
-	fmt.Println("Done.")
+	slog.Info("done")
 	return nil
 }

cmd/test/main.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"fmt"
+	"log/slog"
 	"os"
 	"time"
 
@@ -10,12 +10,12 @@ import (
 
 func main() {
 	if len(os.Args) < 2 {
-		fmt.Fprintf(os.Stderr, "usage: test <name>\n")
+		slog.Error("usage: test <name>")
 		os.Exit(1)
 	}
 
 	if err := run(os.Args[1]); err != nil {
-		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		slog.Error("fatal", "err", err)
 		os.Exit(1)
 	}
 }
@@ -28,25 +28,32 @@ func run(name string) error {
 
 	var testDev string
 	for _, dev := range devs {
+		log := slog.With("dev", dev)
+		log.Info("connecting for info")
 		c, err := client.NewSerial(dev, 2*time.Second)
 		if err != nil {
+			log.Warn("connect error", "err", err)
 			continue
 		}
 		info, err := c.Info()
 		c.Close()
 		if err != nil {
+			log.Warn("info error", "err", err)
 			continue
 		}
+		log.Info("got info", "firmware", info.FirmwareName)
 		if info.FirmwareName == "picomap_test" {
 			testDev = dev
 			break
 		}
 	}
 	if testDev == "" {
-		return fmt.Errorf("no picomap_test device found")
+		slog.Error("no picomap_test device found")
+		os.Exit(1)
 	}
 
-	fmt.Printf("test %s on %s\n", name, testDev)
+	log := slog.With("dev", testDev)
+	log.Info("running test", "name", name)
 
 	c, err := client.NewSerial(testDev, 10*time.Second)
 	if err != nil {
@@ -56,17 +63,18 @@ func run(name string) error {
 
 	result, err := c.Test(name)
 	if err != nil {
-		return fmt.Errorf("remote: %w", err)
+		slog.Error("remote error", "dev", testDev, "err", err)
+		os.Exit(1)
 	}
 
 	for _, msg := range result.Messages {
-		fmt.Printf("  [remote] %s\n", msg)
+		log.Info("remote", "msg", msg)
 	}
 
 	if result.Pass {
-		fmt.Println("PASS")
+		log.Info("PASS")
 	} else {
-		fmt.Println("FAIL")
+		log.Error("FAIL")
 		os.Exit(1)
 	}
 	return nil

firmware/lib/dispatch.cpp

@@ -33,7 +33,7 @@ void dispatch_schedule_ms(uint32_t ms, std::function<void()> fn) {
 
         usb.drain();
         timers.run();
-        net_poll();
+        //net_poll();
 
         while (tud_cdc_available()) {
             uint8_t byte;