orion/example/updater/main.go

package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"strings"
	"time"

	"forge.cadoles.com/Pyxis/orion/emlid"
	"forge.cadoles.com/Pyxis/orion/emlid/updater"
)

const stepSleep = 5

const (
	phaseConfigureWifi    = "configure-wifi"
	phaseUpdateThenReboot = "update-then-reboot"
)

var (
	phase    = phaseConfigureWifi
	host     = "192.168.42.1"
	ssid     = ""
	security = string(updater.SecurityWPAPSK)
	password = ""
)

func init() {
	phases := []string{phaseConfigureWifi, phaseUpdateThenReboot}
	flag.StringVar(
		&phase, "phase", phase,
		fmt.Sprintf("The configuration phase. Available: %v", strings.Join(phases, ", ")),
	)
	flag.StringVar(&host, "host", host, "ReachRS module host")
	flag.StringVar(&ssid, "ssid", ssid, "The WiFi SSID to connect the module to")
	flag.StringVar(&security, "security", security, "The WiFi security algorithm")
	flag.StringVar(&password, "password", password, "The WiFi password")
}

func main() {

	flag.Parse()

	switch phase {
	case phaseConfigureWifi:
		configureWifi()
	case phaseUpdateThenReboot:
		updateThenReboot()
	default:
		log.Fatalf("unknown phase '%s'", phase)
	}

	log.Println("done")

}

func connect() *updater.Client {

	c := updater.NewClient(
		emlid.WithEndpoint(host, 80),
	)

	log.Printf("connecting to module '%s'", host)
	if err := c.Connect(); err != nil {
		log.Fatal(err)
	}

	log.Println("connected")

	return c

}

func configureWifi() {

	if ssid == "" {
		log.Fatal("you must provide a WiFi SSID with the -ssid flag")
	}

	c := connect()
	defer c.Close()

	ctx := context.Background()

	log.Println("checking module status")

	ctx, testResultsCancel := context.WithTimeout(ctx, 5*time.Second)
	defer testResultsCancel()
	results, err := c.TestResults(ctx)
	if err != nil {
		log.Fatal(err)
	}

	log.Printf("device: '%s'", results.Device)
	log.Printf("lora activated ? %v", results.Lora)
	log.Printf("mpu activated ? %v", results.MPU)
	log.Printf("stc activated ? %v", results.STC)
	log.Printf("ublox activated ? %v", results.UBlox)

	sleep(stepSleep)

	log.Printf("adding wifi network '%s'", ssid)

	ctx, addWifiCancel := context.WithTimeout(ctx, 5*time.Second)
	defer addWifiCancel()
	done, err := c.AddWifiNetwork(ctx, ssid, updater.WifiSecurity(security), password)
	if err != nil {
		log.Fatal(err)
	}

	if !done {
		log.Fatal("couldnt add wifi network")
	}

	sleep(stepSleep)

	log.Println("connecting module to wifi network")
	ctx, joinWifiCancel := context.WithTimeout(ctx, 5*time.Second)
	defer joinWifiCancel()
	if err := c.JoinWifiNetwork(ctx, ssid, true); err != nil {
		log.Fatal(err)
	}
	log.Printf("you can now switch to the wifi network and start phase '%s'", phaseUpdateThenReboot)

}

func updateThenReboot() {

	c := connect()
	defer c.Close()

	log.Println("checking module status")
	ctx, testResultsCancel := context.WithTimeout(context.Background(), 20*time.Second)
	defer testResultsCancel()
	results, err := c.TestResults(ctx)
	if err != nil {
		log.Fatalf("error while checking device state: %s", err)
	}

	log.Printf("device: '%s'", results.Device)
	log.Printf("lora activated ? %v", results.Lora)
	log.Printf("mpu activated ? %v", results.MPU)
	log.Printf("stc activated ? %v", results.STC)
	log.Printf("ublox activated ? %v", results.UBlox)

	sleep(stepSleep)

	log.Println("checking time sync")
	ctx, timeSyncedCancel := context.WithTimeout(context.Background(), 20*time.Second)
	defer timeSyncedCancel()
	synced, err := c.TimeSynced(ctx)
	if err != nil {
		log.Fatalf("error while checking time sync status: %s", err)
	}
	log.Printf("time synced ? %v", synced)

	sleep(stepSleep)

	log.Println("checking for upgrade")
	ctx, upgradeAvailableCancel := context.WithTimeout(context.Background(), 20*time.Second)
	defer upgradeAvailableCancel()
	_, _, err = c.ReceiverUpgradeAvailable(ctx)
	if err != nil {
		log.Fatalf("error while checking for upgrade: %s", err)
	}

	sleep(stepSleep)

	log.Println("checking reachview version")
	ctx, reachviewVersionCancel := context.WithTimeout(context.Background(), 20*time.Second)
	defer reachviewVersionCancel()
	version, err := c.ReachViewVersion(ctx)
	if err != nil {
		log.Fatalf("error while checking version: %s", err)
	}
	log.Printf("reachview version ? '%s'", version)

	sleep(stepSleep)

	log.Println("skipping update")
	if err := c.SkipUpdate(); err != nil {
		log.Fatalf("error while skipping update: %s", err)
	}

	sleep(stepSleep)

	log.Println("rebooting device")
	ctx, rebootCancel := context.WithTimeout(context.Background(), 20*time.Second)
	defer rebootCancel()
	if err := c.RebootNow(ctx, true); err != nil {
		log.Fatalf("error while rebooting: %s", err)
	}

}

func sleep(seconds int) {
	log.Printf("sleeping for %d seconds...", seconds)
	time.Sleep(time.Duration(seconds) * time.Second)
}