Bf/controller iface

cmd/hilapp/main.go

@@ -25,7 +25,6 @@ import (
 	"github.com/macformula/hil/macformula/state"
 	"github.com/macformula/hil/orchestrator"
 	"github.com/macformula/hil/results"
-	"github.com/macformula/hil/utils"
 	"github.com/pkg/errors"
 )
 
@@ -53,6 +52,20 @@ var (
 	logLevelStr = flag.String("log", _defaultLogLevel.String(), "Changes the log level (debug, info, warn, error)")
 )
 
+func CastPins[T_IO any, T_SIL any](m map[pinout.PhysicalIo]T_IO) ([]*T_SIL, error) {
+	out := make([]*T_SIL, 0, len(m))
+
+	for _, v := range m {
+		impl, ok := any(v).(*T_SIL)
+		if !ok {
+			return nil, fmt.Errorf("Expected a sil.DigitalPin (got %T)", v)
+		}
+		out = append(out, impl)
+	}
+
+	return out, nil
+}
+
 func main() {
 	// Parse command-line flags before accessing them.
 	flag.Parse()
@@ -153,21 +166,40 @@ func main() {
 			canlink.WithFileName(_ptCan),
 		)
 	}
-
 	// Get controllers
-	var ioOpts = make([]iocontrol.IOControlOption, 0)
+
+	var ioController iocontrol.IOController
 
 	switch rev {
 	case pinout.Sil:
-		silController = sil.NewController(cfg.SilPort, logger, utils.GetValues(pinout.SilDigitalInputPins), utils.GetValues(pinout.SilDigitalOutputPins), utils.GetValues(pinout.SilAnalogInputPins), utils.GetValues(pinout.SilAnalogOutputPins))
-		ioOpts = append(ioOpts, iocontrol.WithSil(silController))
+		pinout := pinout.Pinouts[pinout.Sil]
+
+		// Yes this casting is ugly. It will change soon (bfreer)
+		diPins, err := CastPins[iocontrol.DigitalPin, sil.DigitalPin](pinout.DigitalInputs)
+		if err != nil {
+			panic("Invalid SIL pins")
+		}
+		doPins, err := CastPins[iocontrol.DigitalPin, sil.DigitalPin](pinout.DigitalOutputs)
+		if err != nil {
+			panic("Invalid SIL pins")
+		}
+
+		aiPins, err := CastPins[iocontrol.AnalogPin, sil.AnalogPin](pinout.AnalogInputs)
+		if err != nil {
+			panic("Invalid SIL pins")
+		}
+
+		aoPins, err := CastPins[iocontrol.AnalogPin, sil.AnalogPin](pinout.AnalogOutputs)
+		if err != nil {
+			panic("Invalid SIL pins")
+		}
+
+		silController = sil.NewController(cfg.SilPort, logger, diPins, doPins, aiPins, aoPins)
+		ioController = silController
 	default:
 		panic("unconfigured revision")
 	}
 
-	// Create io controller.
-	ioController := iocontrol.NewIOControl(logger, ioOpts...)
-
 	err = ioController.Open(ctx)
 	if err != nil {
 		logger.Error("failed to open io controller",

cmd/iocheckout/main.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/macformula/hil/iocontrol"
 	"github.com/macformula/hil/iocontrol/raspi"
+
 	// "github.com/macformula/hil/iocontrol/sil"
 	"github.com/macformula/hil/iocontrol/speedgoat"
 	"github.com/macformula/hil/macformula"
@@ -54,25 +55,23 @@ func main() {
 
 	logger.Info("starting iocheckout", zap.String("revision", revision.String()))
 
-	var ioControlOpts []iocontrol.IOControlOption
+	var ioControl iocontrol.IOController
 
 	if *useSpeedgoat {
 		sg := speedgoat.NewController(logger, _speedgoatAddr, speedgoat.WithModelAutoload(_speedgoatScriptPath, _speedgoatPw, _speedgoatAddrFromPi, _speedgoatModelName))
-		ioControlOpts = append(ioControlOpts, iocontrol.WithSpeedgoat(sg))
+		ioControl = sg
 	}
 
 	if *useRaspi {
 		rp := raspi.NewController(logger)
-		ioControlOpts = append(ioControlOpts, iocontrol.WithRaspi(rp))
+		ioControl = rp
 	}
 
 	// if *useSil {
 	// 	s := sil.NewController(_silPort, logger)
 	// 	ioControlOpts = append(ioControlOpts, iocontrol.WithSil(s))
 	// }
 
-	ioControl := iocontrol.NewIOControl(logger, ioControlOpts...)
-
 	iocheckout := macformula.NewIoCheckout(revision, ioControl, logger)
 
 	logger.Info("opening iocheckout")

cmd/raspitest/main.go

@@ -51,12 +51,12 @@ func main() {
 		case *oneSet != "":
 			switch strings.ToLower(*oneSet) {
 			case "high", "1", "on":
-				if err := ctrl.SetDigital(pin, true); err != nil {
+				if err := ctrl.WriteDigital(pin, true); err != nil {
 					log.Fatalf("set high: %v", err)
 				}
 				fmt.Printf("P1-%d -> HIGH\n", *boardPin)
 			case "low", "0", "off":
-				if err := ctrl.SetDigital(pin, false); err != nil {
+				if err := ctrl.WriteDigital(pin, false); err != nil {
 					log.Fatalf("set low: %v", err)
 				}
 				fmt.Printf("P1-%d -> LOW\n", *boardPin)
@@ -99,13 +99,13 @@ func main() {
 
 		switch cmd {
 		case "high", "1", "on":
-			if err := ctrl.SetDigital(pin, true); err != nil {
+			if err := ctrl.WriteDigital(pin, true); err != nil {
 				fmt.Fprintf(tty, "error setting HIGH: %v\n", err)
 				continue
 			}
 			fmt.Fprintln(tty, "-> HIGH")
 		case "low", "0", "off":
-			if err := ctrl.SetDigital(pin, false); err != nil {
+			if err := ctrl.WriteDigital(pin, false); err != nil {
 				fmt.Fprintf(tty, "error setting LOW: %v\n", err)
 				continue
 			}

cmd/speedgoattest/main.go

@@ -27,10 +27,10 @@ func main() {
 	}
 
 	pin := speedgoat.NewDigitalPin(8) // First digital output pin (idx 8-15)
-	controller.SetDigital(pin, true)
+	controller.WriteDigital(pin, true)
 
 	pin2 := speedgoat.NewDigitalPin(15) // Last digital output pin
-	controller.SetDigital(pin2, true)
+	controller.WriteDigital(pin2, true)
 
 	pin3 := speedgoat.NewAnalogPin(8) // First analog output pin (idx 8-11)
 	controller.WriteVoltage(pin3, 2.5)
@@ -39,7 +39,7 @@ func main() {
 
 	// Verify that these change on the Speedgoat via Simulink or LED
 	// If they don't change (or take a while), verify that the Simulink TCP server has a sufficiently small sample time
-	err = controller.SetDigital(pin2, false)
+	err = controller.WriteDigital(pin2, false)
 	if err != nil {
 		panic(err)
 	}