rework on the peripherals and finders

hardware/FTDIFinder.go

@@ -24,22 +24,48 @@ const (
 
 // FTDIFinder represents how the protocol is defined
 type FTDIFinder struct {
-	findTicker  time.Ticker           // Peripherals find ticker
-	peripherals map[string]Peripheral // The list of peripherals handled by this finder
-	scanChannel chan struct{}         // The channel to trigger a scan event
-	goWait      sync.WaitGroup        // Check goroutines execution
+	findTicker            time.Ticker               // Peripherals find ticker
+	foundPeripherals      map[string]PeripheralInfo // The list of peripherals handled by this finder
+	registeredPeripherals map[string]FTDIPeripheral // The list of found peripherals
+	scanChannel           chan struct{}             // The channel to trigger a scan event
+	goWait                sync.WaitGroup            // Check goroutines execution
 }
 
 // NewFTDIFinder creates a new FTDI finder
 func NewFTDIFinder(findPeriod time.Duration) *FTDIFinder {
 	log.Trace().Str("file", "FTDIFinder").Msg("FTDI finder created")
 	return &FTDIFinder{
-		findTicker:  *time.NewTicker(findPeriod),
-		peripherals: make(map[string]Peripheral),
-		scanChannel: make(chan struct{}),
+		findTicker:            *time.NewTicker(findPeriod),
+		foundPeripherals:      make(map[string]PeripheralInfo),
+		registeredPeripherals: make(map[string]FTDIPeripheral),
+		scanChannel:           make(chan struct{}),
 	}
 }
 
+// RegisterPeripheral registers a new peripheral
+func (f *FTDIFinder) RegisterPeripheral(ctx context.Context, peripheralData PeripheralInfo) (string, error) {
+	ftdiPeripheral, err := NewFTDIPeripheral(peripheralData)
+	if err != nil {
+		return "", fmt.Errorf("unable to create the FTDI peripheral: %v", err)
+	}
+	f.registeredPeripherals[peripheralData.SerialNumber] = *ftdiPeripheral
+	log.Trace().Any("periph", &ftdiPeripheral).Str("file", "FTDIFinder").Str("peripheralName", peripheralData.Name).Msg("FTDI peripheral has been created")
+	return peripheralData.SerialNumber, nil
+}
+
+// UnregisterPeripheral unregisters an existing peripheral
+func (f *FTDIFinder) UnregisterPeripheral(ctx context.Context, peripheralID string) error {
+	peripheral, registered := f.registeredPeripherals[peripheralID]
+	if registered {
+		err := peripheral.Disconnect(ctx)
+		if err != nil {
+			return err
+		}
+	}
+	delete(f.registeredPeripherals, peripheralID)
+	return nil
+}
+
 //go:embed third-party/ftdi/detectFTDI.exe
 var finderExe []byte
 
@@ -58,7 +84,7 @@ func (f *FTDIFinder) Initialize() error {
 	if err != nil {
 		return err
 	}
-	createExecutable(ftdiSenderExecutableName, senderExe)
+	err = createExecutable(ftdiSenderExecutableName, senderExe)
 	if err != nil {
 		return err
 	}
@@ -144,16 +170,28 @@ func (f *FTDIFinder) GetName() string {
 	return "FTDI"
 }
 
-// GetPeripheral gets the peripheral that correspond to the specified ID
-func (f *FTDIFinder) GetPeripheral(peripheralID string) (Peripheral, bool) {
+// GetPeripheralSettings gets the peripheral settings
+func (f *FTDIFinder) GetPeripheralSettings(peripheralID string) (map[string]interface{}, error) {
 	// Return the specified peripheral
-	peripheral := f.peripherals[peripheralID]
-	if peripheral == nil {
+	peripheral, found := f.registeredPeripherals[peripheralID]
+	if !found {
 		log.Error().Str("file", "FTDIFinder").Str("peripheralID", peripheralID).Msg("unable to get this peripheral from the FTDI finder")
-		return nil, false
+		return nil, fmt.Errorf("unable to found the peripheral")
 	}
 	log.Debug().Str("file", "FTDIFinder").Str("peripheralID", peripheralID).Msg("peripheral found by the FTDI finder")
-	return peripheral, true
+	return peripheral.GetSettings(), nil
+}
+
+// SetPeripheralSettings sets the peripheral settings
+func (f *FTDIFinder) SetPeripheralSettings(peripheralID string, settings map[string]interface{}) error {
+	// Return the specified peripheral
+	peripheral, found := f.registeredPeripherals[peripheralID]
+	if !found {
+		log.Error().Str("file", "FTDIFinder").Str("peripheralID", peripheralID).Msg("unable to get this peripheral from the FTDI finder")
+		return fmt.Errorf("unable to found the peripheral")
+	}
+	log.Debug().Str("file", "FTDIFinder").Str("peripheralID", peripheralID).Msg("peripheral found by the FTDI finder")
+	return peripheral.SetSettings(settings)
 }
 
 // scanPeripherals scans the FTDI peripherals
@@ -163,8 +201,6 @@ func (f *FTDIFinder) scanPeripherals(ctx context.Context) error {
 
 	log.Trace().Str("file", "FTDIFinder").Msg("FTDI scan triggered")
 
-	ftdiPeripherals := make(map[string]Peripheral)
-
 	finder := exec.CommandContext(detectionCtx, filepath.Join(os.TempDir(), ftdiFinderExecutableName))
 	log.Trace().Str("file", "FTDIFinder").Msg("has executed the FIND executable")
 
@@ -190,6 +226,8 @@ func (f *FTDIFinder) scanPeripherals(ctx context.Context) error {
 		return fmt.Errorf("unable to find FTDI peripherals: %s", scannerErr.Text())
 	}
 
+	temporaryPeripherals := make(map[string]PeripheralInfo)
+
 	scanner := bufio.NewScanner(stdout)
 	for scanner.Scan() {
 		peripheralString := scanner.Text()
@@ -203,29 +241,27 @@ func (f *FTDIFinder) scanPeripherals(ctx context.Context) error {
 			log.Warn().Str("file", "FTDIFinder").Str("peripheralName", peripheralInfo[2]).Msg("no location provided for this FTDI peripheral")
 			location = -1
 		}
-		// Add the peripheral to the temporary list
-		peripheral, err := NewFTDIPeripheral(peripheralInfo[2], peripheralInfo[1], location)
-		if err != nil {
-			return fmt.Errorf("unable to create the FTDI peripheral: %v", err)
+		// Add the peripheral info to the found list
+		temporaryPeripherals[peripheralInfo[1]] = PeripheralInfo{
+			Name:         peripheralInfo[2],
+			SerialNumber: peripheralInfo[1],
+			ProtocolName: "FTDI",
 		}
-		log.Trace().Any("periph", &peripheral).Str("file", "FTDIFinder").Str("peripheralName", peripheralInfo[2]).Msg("has been created")
 
-		ftdiPeripherals[peripheralInfo[1]] = peripheral
-		log.Trace().Any("periph", ftdiPeripherals).Str("file", "FTDIFinder").Str("peripheralName", peripheralInfo[2]).Msg("successfully added the FTDI peripheral to the finder")
+		// If this peripheral is already registered, connect it
+		peripheral, registered := f.registeredPeripherals[peripheralInfo[1]]
+		if registered {
+			err := peripheral.Connect(ctx, location)
+			if err != nil {
+				log.Err(err).Str("file", "FTDIFinder").Str("peripheralSN", peripheralInfo[1]).Msg("unable to connect the peripheral")
+			}
+		}
+
+		log.Trace().Any("periph", temporaryPeripherals).Str("file", "FTDIFinder").Str("peripheralName", peripheralInfo[2]).Msg("successfully added the FTDI peripheral to the finder")
 	}
 	// Emit the peripherals changes to the front
-	emitPeripheralsChanges(ctx, f.peripherals, ftdiPeripherals)
+	emitPeripheralsChanges(ctx, f.foundPeripherals, temporaryPeripherals)
 	// Store the new peripherals list
-	f.peripherals = ftdiPeripherals
-	return nil
-}
-
-// CreatePeripheral is not implemented here
-func (f *FTDIFinder) CreatePeripheral(context.Context) (Peripheral, error) {
-	return nil, nil
-}
-
-// DeletePeripheral is not implemented here
-func (f *FTDIFinder) DeletePeripheral(serialNumber string) error {
+	f.foundPeripherals = temporaryPeripherals
 	return nil
 }