MultiRoombaRover/pi/roverd/cmd/roverd/main.go

package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"os"
	"os/signal"
	"syscall"
	"time"

	roverd "multiroombarover/pi/roverd"
)

func main() {
	var cfgPath string
	flag.StringVar(&cfgPath, "config", "/etc/roverd.yaml", "path to roverd configuration file")
	flag.Parse()

	cfg, err := roverd.LoadConfig(cfgPath)
	if err != nil {
		log.Fatalf("load config: %v", err)
	}
	if err := roverd.UpdatePublisherEnv(cfg.Media); err != nil {
		log.Fatalf("prepare media env: %v", err)
	}

	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer cancel()

	logger := log.New(os.Stdout, "roverd: ", log.LstdFlags|log.Lmicroseconds|log.LUTC)
	console := roverd.NewConsoleNotifier(logger)

	serialPort, err := roverd.OpenSerial(cfg.Serial)
	if err != nil {
		logger.Fatalf("open serial: %v", err)
	}
	defer serialPort.Close()

	// Peripheral discovery is intentionally a boot-time operation. The manager
	// keeps successful USB ports open across server WebSocket reconnects and is
	// rebuilt only when the roverd process itself restarts.
	peripherals, err := roverd.DiscoverPeripheralManager(ctx, cfg.Serial.Device, logger)
	if err != nil {
		console.Notify(fmt.Sprintf("Rover peripheral startup failed: %v", err))
		logger.Fatalf("discover rover peripherals: %v", err)
	}
	defer peripherals.Close()
	for _, message := range peripherals.StartupBroadcasts() {
		console.Notify(message)
	}

	var pulser *roverd.BRCPulser
	if cfg.BRC.Enabled() {
		pulser, err = roverd.NewBRCPulser(cfg.BRC, logger)
		if err != nil {
			logger.Fatalf("init BRC pulser: %v", err)
		}
		defer pulser.Close()
		pulser.Start(ctx)
	}

	sensorFrames := make(chan []byte, 8)
	sensorSamples := make(chan roverd.SensorSample, 8)
	eventStream := make(chan roverd.RoverEvent, 16)

	streamer := roverd.NewSensorStreamer(serialPort, sensorFrames, sensorSamples, logger)
	go streamer.Run(ctx)

	adapter := roverd.NewSerialAdapter(serialPort, logger)

	mediaSupervisor := roverd.NewMediaSupervisor(cfg.Media, logger)
	if mediaSupervisor != nil {
		mediaSupervisor.Start(ctx)
	}

	// Backend selection is identical on Pi and laptop hosts: enabled native
	// GPIO wins, otherwise a discovered ESP32 may provide the built-in role.
	hardwareControllers, err := roverd.ResolveRoverHardwareControllers(cfg, peripherals, logger)
	if err != nil {
		console.Notify(fmt.Sprintf("Rover peripheral startup failed while selecting hardware: %v", err))
		logger.Fatalf("resolve rover hardware controllers: %v", err)
	}
	defer hardwareControllers.Close()
	for _, message := range hardwareControllers.StartupBroadcasts() {
		console.Notify(message)
	}

	// A peripheral is never hot-reconnected. Report the first terminal serial
	// failure for each discovered board and tell the local operator exactly what
	// recovery action the fixed boot-time lifecycle requires.
	go func() {
		for {
			select {
			case failure := <-peripherals.Failures():
				console.Notify(fmt.Sprintf(
					"Rover peripheral %q (%s) disconnected: %v. Reconnect it and restart roverd.",
					failure.Name,
					failure.ID,
					failure.Err,
				))
			case <-ctx.Done():
				return
			}
		}
	}()

	autoCharge := roverd.NewAutoChargeController(adapter, eventStream, logger)
	go autoCharge.Run(ctx, sensorSamples)

	client := roverd.NewWSClient(cfg, adapter, sensorFrames, eventStream, mediaSupervisor, hardwareControllers.CameraServo, hardwareControllers.Headlight, hardwareControllers.Laser, peripherals, logger, console)

	// Startup is announced only after every configured hardware dependency has
	// initialized successfully. A message here therefore means the control loop
	// is genuinely ready, rather than merely that systemd launched the process.
	console.Notify("roverd started and hardware initialization completed.")
	defer console.Notify("roverd stopped.")

	retryDelay := time.Second
	for ctx.Err() == nil {
		if err := client.Run(ctx); err != nil {
			logger.Printf("websocket loop ended: %v", err)
		}

		select {
		case <-ctx.Done():
			return
		case <-time.After(retryDelay):
		}

		if retryDelay < 30*time.Second {
			retryDelay *= 2
		}
	}
}