settings save optimizations

peripheral setting save
peripheral selection optimized
2025-01-25 18:30:48 +01:00 · 2025-01-25 16:00:02 +01:00 · 2025-01-25 12:16:29 +01:00 · 2025-01-25 11:06:03 +01:00 · 2025-01-18 16:25:09 +01:00
10 changed files with 258 additions and 52 deletions
--- a/app.go
+++ b/app.go
@@ -28,9 +28,9 @@ type App struct {
 func NewApp() *App {
 	// Create a new hadware manager
 	hardwareManager := hardware.NewHardwareManager()
-	// hardwareManager.RegisterFinder(hardware.NewMIDIFinder(5 * time.Second))
+	hardwareManager.RegisterFinder(hardware.NewMIDIFinder(5 * time.Second))
 	hardwareManager.RegisterFinder(hardware.NewFTDIFinder(5 * time.Second))
-	// hardwareManager.RegisterFinder(hardware.NewOS2LFinder())
+	hardwareManager.RegisterFinder(hardware.NewOS2LFinder())
 	return &App{
 		hardwareManager: hardwareManager,
 		projectSave:     "",
--- a/frontend/src/components/Settings/DeviceCard.svelte
+++ b/frontend/src/components/Settings/DeviceCard.svelte
@@ -15,6 +15,7 @@
    export let signalizable = false;
    export let signalized = false;
    export let disconnected = false;
+    export let selected = false;

    // Emit a delete event when the device is being removed
    const dispatch = createEventDispatcher();
@@ -36,7 +37,7 @@
 </script>

 <div class="card" on:dblclick={dblclick}>
-    <div class="profile" on:mousedown={click} style="color: {disconnected ? $colors.first : $colors.white};">
+    <div class="profile {selected ? "selected" : "unselected"}" on:mousedown={click} style="color: {disconnected ? $colors.first : $colors.white};">
        <div>
            <p>{#if disconnected}<i class='bx bx-no-signal' style="font-size:100%; color: var(--nok-color);"></i> {/if}{title}</p>
            <h6 class="subtitle">{type} {location != '' ? "- " : ""}<i>{location}</i></h6>
@@ -59,16 +60,29 @@


 <style>
-    .profile:hover{
-        background-color: var(--third-color);
+    .unselected:hover{
+        background: linear-gradient(to bottom right, var(--second-color), var(--third-color));
    }
    .card{
        position: relative;   
    }
-    .profile {
-        background-color: var(--second-color);
+    .selected {
+        background-color: var(--first-color);
        margin: 0.2em;
        padding-left: 0.3em;
+        padding-bottom: 0.3em;
+        border-radius: 0.2em;
+        display: flex;
+        justify-content: space-between;
+        text-align: left;
+        cursor: pointer;
+    }
+    .unselected{
+        background-color: var(--third-color);
+        background: fixed;
+        margin: 0.2em;
+        padding-left: 0.3em;
+        padding-bottom: 0.3em;
        border-radius: 0.2em;
        display: flex;
        justify-content: space-between;
--- a/frontend/src/components/Settings/InputsOutputsContent.svelte
+++ b/frontend/src/components/Settings/InputsOutputsContent.svelte
@@ -1,10 +1,11 @@
 <script lang=ts>
    import DeviceCard from "./DeviceCard.svelte";
    import Tab from "../General/Tab.svelte";
-    import { _ } from 'svelte-i18n'
+    import Input from "../General/Input.svelte";
+    import { t, _ } from 'svelte-i18n'
    import { generateToast, needProjectSave, peripherals } from "../../stores";
    import { get } from "svelte/store"
-    import { AddOS2LPeripheral, RemovePeripheral, ConnectFTDI, ActivateFTDI, DeactivateFTDI, DisconnectFTDI, SetDeviceFTDI, AddPeripheral } from "../../../wailsjs/go/main/App";
+    import { UpdatePeripheralSettings, GetPeripheralSettings, AddOS2LPeripheral, RemovePeripheral, ConnectFTDI, ActivateFTDI, DeactivateFTDI, DisconnectFTDI, SetDeviceFTDI, AddPeripheral } from "../../../wailsjs/go/main/App";
    import RoundedButton from "../General/RoundedButton.svelte";

    function ftdiConnect(){
@@ -84,6 +85,11 @@
                return { ...storedPeripherals };
            })
            $needProjectSave = true
+            // If the peripheral is currently selected, unselect it
+            if (selectedPeripheralSN == peripheral.SerialNumber) {
+                selectedPeripheralSN = null
+                selectedPeripheralSettings = {}
+            }
        }).catch((error) => {
            console.log("Unable to remove the peripheral from the project: " + error)
            generateToast('danger', 'bx-error', $_("removePeripheralErrorToast"))
@@ -107,15 +113,62 @@
        })
    }

+    // Select the peripheral to edit its settings
+    let selectedPeripheralSN = null
+    let selectedPeripheralSettings = {}
+    function selectPeripheral(peripheral){
+        // Load the settings array if the peripheral is detected
+        if (peripheral.isDetected){
+            GetPeripheralSettings(peripheral.ProtocolName, peripheral.SerialNumber).then((peripheralSettings) => {
+                selectedPeripheralSettings = peripheralSettings
+            }).catch((error) => {
+                console.log("Unable to get the peripheral settings: " + error)
+                generateToast('danger', 'bx-error', $_("getPeripheralSettingsErrorToast"))
+            })
+            // Select the current peripheral
+            selectedPeripheralSN = peripheral.SerialNumber
+        }
+    }
+
+    // Unselect the peripheral if it is disconnect
+    $: {
+        Object.entries($peripherals).filter(([serialNumber, peripheral]) => {
+            if (!peripheral.isDetected && peripheral.isSaved && selectedPeripheralSN == serialNumber) {
+                selectedPeripheralSN = null
+                selectedPeripheralSettings = {}
+            }
+        });
+    }
+    
    // Get the number of saved peripherals
    $: savedPeripheralNumber = Object.values($peripherals).filter(peripheral => peripheral.isSaved).length;
+
+    // Validate the peripheral settings
+    function validate(settingName, settingValue){
+        console.log("Peripheral setting '" + settingName + "' set to '" + settingValue + "'")
+        // Get the old setting type and convert the new setting to this type
+        const convert = {
+            number: Number,
+            string: String,
+            boolean: Boolean,
+        }[typeof(selectedPeripheralSettings[settingName])] || (x => x)
+        selectedPeripheralSettings[settingName] = convert(settingValue)
+        console.log(typeof(selectedPeripheralSettings[settingName]))
+        let peripheralProtocolName = get(peripherals)[selectedPeripheralSN].ProtocolName
+        UpdatePeripheralSettings(peripheralProtocolName, selectedPeripheralSN, selectedPeripheralSettings).then(()=> {
+            $needProjectSave = true
+        }).catch((error) => {
+            console.log("Unable to save the peripheral setting: " + error)
+            generateToast('danger', 'bx-error', $_("peripheralSettingSaveErrorToast"))
+        })
+    }
 </script>

 <div class="hardware">
    <div style="padding: 0.5em;">
-        <p style="margin-bottom: 1em;">Available peripherals</p>
+        <p style="margin-bottom: 1em;">{$_("projectHardwareAvailableLabel")}</p>
        <div class="availableHardware">
-            <p style="color: var(--first-color);"><i class='bx bxs-plug'></i> Detected</p>
+            <p style="color: var(--first-color);"><i class='bx bxs-plug'></i> {$_("projectHardwareDetectedLabel")}</p>
                {#each Object.entries($peripherals) as [serialNumber, peripheral]}
                    {#if peripheral.isDetected}
                        <DeviceCard on:add={() => addPeripheral(peripheral)} on:dblclick={() => {
@@ -125,40 +178,59 @@
                            title={peripheral.Name} type={peripheral.ProtocolName} location={peripheral.Location ? peripheral.Location : ""} line1={"S/N: " + peripheral.SerialNumber} addable={!peripheral.isSaved}/>
                    {/if}
                {/each}
-            <p style="color: var(--first-color);"><i class='bx bxs-network-chart' ></i> Others</p>
+            <p style="color: var(--first-color);"><i class='bx bxs-network-chart' ></i> {$_("projectHardwareOthersLabel")}</p>
            <RoundedButton on:click={createOS2L} text="Add an OS2L peripheral" icon="bx-plus-circle" tooltip="Configure an OS2L connection"/>
        </div>
    </div>

    <div style="padding: 0.5em; flex:2; width:100%;">
-        <p style="margin-bottom: 1em;">Project peripherals</p>
+        <p style="margin-bottom: 1em;">{$_("projectHardwareSavedLabel")}</p>
        <div class="configuredHardware">
            {#if savedPeripheralNumber > 0}    
                {#each Object.entries($peripherals) as [serialNumber, peripheral]}
                    {#if peripheral.isSaved}
-                        <DeviceCard on:delete={() => removePeripheral(peripheral)} on:dblclick={() => removePeripheral(peripheral)}
-                        disconnected={!peripheral.isDetected} title={peripheral.Name == "" ? "Please wait..." : peripheral.Name} type={peripheral.ProtocolName} location={peripheral.Location ? peripheral.Location : ""} line1={peripheral.SerialNumber ? "S/N: " + peripheral.SerialNumber : ""} removable signalizable/>
+                        <DeviceCard on:delete={() => removePeripheral(peripheral)} on:dblclick={() => removePeripheral(peripheral)} on:click={() => selectPeripheral(peripheral)}
+                        disconnected={!peripheral.isDetected} title={peripheral.Name} type={peripheral.ProtocolName} location={peripheral.Location ? peripheral.Location : ""} line1={peripheral.SerialNumber ? "S/N: " + peripheral.SerialNumber : ""} selected={serialNumber == selectedPeripheralSN} removable signalizable/>
                    {/if}
                {/each}
            {:else}              
-                <i>No hardware saved for this project.</i>
+                <i>{$_("projectHardwareEmptyLabel")}</i>
            {/if}    
        </div>
-        <p style="margin-bottom: 1em;">Peripheral settings</p>
-        <div>
-            <p><i>Select a peripheral to edit its settings</i></p>
-            <button on:click={ftdiConnect}>Connect FTDI 0</button>
+        <p style="margin-bottom: 1em;">{$_("projectHardwareSettingsLabel")} (<b>{selectedPeripheralSN == null ? $_("projectHardwareNoSelection") : selectedPeripheralSN}</b>)</p>
+        <div class='flexSettings'>
+            {#if Object.keys(selectedPeripheralSettings).length > 0}    
+                {#each Object.entries(selectedPeripheralSettings) as [settingName, settingValue]}
+                    <div class="peripheralSetting">
+                        <Input on:blur={(event) => validate(settingName, event.detail.target.value)} label={$t(settingName)} type="{typeof(settingValue)}" width='100%' value="{settingValue}"/>
+                    </div>
+                {/each}
+            {:else}              
+                <i>{$_("projectHardwareNoSettingLabel")}</i>
+            {/if}   
+
+            <!-- <button on:click={ftdiConnect}>Connect FTDI 0</button>
            <button on:click={ftdiActivate}>Activate FTDI 0</button>
            <div class="slidecontainer">
                <input type="range" min="0" max="255" class="slider" bind:value={sliderValue} on:input={() => ftdiSetDevice(sliderValue)}>
            </div>
            <button on:click={ftdiDeactivate}>Deactivate FTDI 0</button>
-            <button on:click={ftdiDisconnect}>Disconnect FTDI 0</button>
+            <button on:click={ftdiDisconnect}>Disconnect FTDI 0</button> -->
        </div>
    </div>
 </div>

 <style>
+    .peripheralSetting{
+        margin: 0.5em;
+    }
+    .flexSettings{
+        display: flex;
+        flex-wrap: wrap;
+        width: 100%;
+        overflow-y: auto;
+    }
+
    p {
        margin: 0;
    }
--- a/frontend/src/components/Settings/ProjectPropertiesContent.svelte
+++ b/frontend/src/components/Settings/ProjectPropertiesContent.svelte
@@ -18,6 +18,7 @@
        })
    }

+    // Validate the project information
    function validate(field, value){
        $showInformation[field] = value
        console.log($showInformation)
--- a/frontend/src/lang/en.json
+++ b/frontend/src/lang/en.json
@@ -15,7 +15,7 @@
  "openProjectTooltip": "Open an existing project",
  "projectPropertiesTab": "Project properties",
  "projectPropertiesTooltip": "The project properties",
-  "projectInputOutputTab": "Inputs & outputs",
+  "projectInputOutputTab": "Hardware",
  "projectInputOutputTooltip": "The input/output hardware definition",
  
  "projectShowNameLabel": "Show name",
@@ -35,6 +35,14 @@
  "projectHardwareOutputsLabel": "OUTPUTS",
  "projectHardwareDeleteTooltip": "Delete this peripheral",
  "projectHardwareAddTooltip": "Add this peripheral to project",
+  "projectHardwareNoSelection": "Empty",
+  "projectHardwareAvailableLabel": "Available peripherals",
+  "projectHardwareSavedLabel": "Project peripherals",
+  "projectHardwareDetectedLabel": "Detected",
+  "projectHardwareOthersLabel": "Others",
+  "projectHardwareEmptyLabel": "No hardware saved for this project",
+  "projectHardwareSettingsLabel": "Peripheral settings",
+  "projectHardwareNoSettingLabel": "No setting can be displayed",

  "peripheralArrivalToast": "Peripheral inserted:",
  "peripheralRemovalToast": "Peripheral removed:",
@@ -44,8 +52,14 @@
  "removePeripheralErrorToast": "Unable to remove this peripheral from project",
  "os2lPeripheralCreatedToast": "Your OS2L peripheral has been created",
  "os2lPeripheralCreateErrorToast": "Unable to create the OS2L peripheral",
+  "getPeripheralSettingsErrorToast": "Unable to get the peripheral settings",
  "projectsLoadErrorToast": "Unable to get the projects list",
  "projectOpenedToast": "The project was opened:",
  "projectOpenErrorToast": "Unable to open the project",
-  "projectCreatedToast": "The project was created"
+  "projectCreatedToast": "The project was created",
+  "peripheralSettingSaveErrorToast": "Unable to save the peripheral settings",
+
+  "os2lIp": "OS2L server IP",
+  "os2lPort": "OS2L server port"
+
 }
--- a/hardware/FTDIPeripheral.go
+++ b/hardware/FTDIPeripheral.go
@@ -21,30 +21,31 @@ const (

 // FTDIPeripheral contains the data of an FTDI peripheral
 type FTDIPeripheral struct {
-	name            string         // The name of the peripheral
-	serialNumber    string         // The S/N of the FTDI peripheral
-	location        int            // The location of the peripheral
-	universesNumber int            // The number of DMX universes handled by this peripheral
-	programName     string         // The temp file name of the executable
-	dmxSender       *exec.Cmd      // The command to pilot the DMX sender program
-	stdin           io.WriteCloser // For writing in the DMX sender
-	stdout          io.ReadCloser  // For reading from the DMX sender
-	stderr          io.ReadCloser  // For reading the errors
-	disconnectChan  chan struct{}  // Channel to cancel the connection
-	errorsChan      chan error     // Channel to get the errors
+	name           string                 // The name of the peripheral
+	serialNumber   string                 // The S/N of the FTDI peripheral
+	location       int                    // The location of the peripheral
+	programName    string                 // The temp file name of the executable
+	settings       map[string]interface{} // The settings of the peripheral
+	dmxSender      *exec.Cmd              // The command to pilot the DMX sender program
+	stdin          io.WriteCloser         // For writing in the DMX sender
+	stdout         io.ReadCloser          // For reading from the DMX sender
+	stderr         io.ReadCloser          // For reading the errors
+	disconnectChan chan struct{}          // Channel to cancel the connection
+	errorsChan     chan error             // Channel to get the errors
 }

 // NewFTDIPeripheral creates a new FTDI peripheral
 func NewFTDIPeripheral(name string, serialNumber string, location int) (*FTDIPeripheral, error) {
 	log.Info().Str("file", "FTDIPeripheral").Str("name", name).Str("s/n", serialNumber).Int("location", location).Msg("FTDI peripheral created")
+	settings := make(map[string]interface{})
 	return &FTDIPeripheral{
-		name:            name,
-		dmxSender:       nil,
-		serialNumber:    serialNumber,
-		location:        location,
-		universesNumber: 1,
-		disconnectChan:  make(chan struct{}),
-		errorsChan:      make(chan error, 1),
+		name:           name,
+		dmxSender:      nil,
+		serialNumber:   serialNumber,
+		location:       location,
+		settings:       settings,
+		disconnectChan: make(chan struct{}),
+		errorsChan:     make(chan error, 1),
 	}, nil
 }

@@ -170,6 +171,12 @@ func (p *FTDIPeripheral) Deactivate(ctx context.Context) error {
 	return fmt.Errorf("unable to deactivate: not connected")
 }

+// SetPeripheralSettings sets a specific setting for this peripheral
+func (p *FTDIPeripheral) SetPeripheralSettings(settings map[string]interface{}) error {
+	p.settings = settings
+	return nil
+}
+
 // SetDeviceProperty sends a command to the specified device
 func (p *FTDIPeripheral) SetDeviceProperty(ctx context.Context, uint32, channelNumber uint32, channelValue byte) error {
 	if p.dmxSender != nil {
@@ -186,6 +193,11 @@ func (p *FTDIPeripheral) SetDeviceProperty(ctx context.Context, uint32, channelN
 	return fmt.Errorf("unable to set device property: not connected")
 }

+// GetSettings gets the peripheral settings
+func (p *FTDIPeripheral) GetSettings() map[string]interface{} {
+	return p.settings
+}
+
 // GetInfo gets all the peripheral information
 func (p *FTDIPeripheral) GetInfo() PeripheralInfo {
 	return PeripheralInfo{
--- a/hardware/MIDIPeripheral.go
+++ b/hardware/MIDIPeripheral.go
@@ -8,18 +8,21 @@ import (

 // MIDIPeripheral contains the data of a MIDI peripheral
 type MIDIPeripheral struct {
-	name         string // The name of the peripheral
-	location     int    // The location of the peripheral
-	serialNumber string // The S/N of the peripheral
+	name         string                 // The name of the peripheral
+	location     int                    // The location of the peripheral
+	serialNumber string                 // The S/N of the peripheral
+	settings     map[string]interface{} // The settings of the peripheral
 }

 // NewMIDIPeripheral creates a new MIDI peripheral
 func NewMIDIPeripheral(name string, location int, serialNumber string) *MIDIPeripheral {
 	log.Trace().Str("file", "MIDIPeripheral").Str("name", name).Str("s/n", serialNumber).Int("location", location).Msg("MIDI peripheral created")
+	settings := make(map[string]interface{})
 	return &MIDIPeripheral{
 		name:         name,
 		location:     location,
 		serialNumber: serialNumber,
+		settings:     settings,
 	}
 }

@@ -43,11 +46,22 @@ func (p *MIDIPeripheral) Deactivate(ctx context.Context) error {
 	return nil
 }

+// SetPeripheralSettings sets a specific setting for this peripheral
+func (p *MIDIPeripheral) SetPeripheralSettings(settings map[string]interface{}) error {
+	p.settings = settings
+	return nil
+}
+
 // SetDeviceProperty - not implemented for this kind of peripheral
 func (p *MIDIPeripheral) SetDeviceProperty(context.Context, uint32, uint32, byte) error {
 	return nil
 }

+// GetSettings gets the peripheral settings
+func (p *MIDIPeripheral) GetSettings() map[string]interface{} {
+	return p.settings
+}
+
 // GetInfo gets the peripheral information
 func (p *MIDIPeripheral) GetInfo() PeripheralInfo {
 	return PeripheralInfo{
--- a/hardware/OS2LPeripheral.go
+++ b/hardware/OS2LPeripheral.go
@@ -2,6 +2,7 @@ package hardware

 import (
 	"context"
+	"fmt"

 	"github.com/rs/zerolog/log"
 )
@@ -10,6 +11,8 @@ import (
 type OS2LPeripheral struct {
 	name         string // The name of the peripheral
 	serialNumber string // The serial number of the peripheral
+	serverIP     string // OS2L server IP
+	serverPort   int    // OS2L server port
 }

 // NewOS2LPeripheral creates a new OS2L peripheral
@@ -17,6 +20,8 @@ func NewOS2LPeripheral(name string, serialNumber string) *OS2LPeripheral {
 	log.Trace().Str("file", "OS2LPeripheral").Str("name", name).Str("s/n", serialNumber).Msg("OS2L peripheral created")
 	return &OS2LPeripheral{
 		name:         name,
+		serverIP:     "127.0.0.1",
+		serverPort:   9995,
 		serialNumber: serialNumber,
 	}
 }
@@ -45,11 +50,49 @@ func (p *OS2LPeripheral) Deactivate(ctx context.Context) error {
 	return nil
 }

+// SetPeripheralSettings sets a specific setting for this peripheral
+func (p *OS2LPeripheral) SetPeripheralSettings(settings map[string]interface{}) error {
+	// Check if the IP exists
+	serverIP, found := settings["os2lIp"]
+	if !found {
+		return fmt.Errorf("Unable to find the OS2L server IP")
+	}
+	// Check if it is a string
+	ipSetting, ok := serverIP.(string)
+	if ok {
+		p.serverIP = ipSetting
+
+	} else {
+		return fmt.Errorf("The specified IP is not a string")
+	}
+	// Check if the port exists
+	serverPort, found := settings["os2lPort"]
+	if !found {
+		return fmt.Errorf("Unable to find the OS2L server port")
+	}
+	// Check if it is a float and convert to int
+	portFloat, ok := serverPort.(float64)
+	if ok {
+		p.serverPort = int(portFloat)
+	} else {
+		return fmt.Errorf("The specified port is not an int")
+	}
+	return nil
+}
+
 // SetDeviceProperty - not implemented for this kind of peripheral
 func (p *OS2LPeripheral) SetDeviceProperty(context.Context, uint32, uint32, byte) error {
 	return nil
 }

+// GetSettings gets the peripheral settings
+func (p *OS2LPeripheral) GetSettings() map[string]interface{} {
+	return map[string]interface{}{
+		"os2lIp":   p.serverIP,
+		"os2lPort": p.serverPort,
+	}
+}
+
 // GetInfo gets the peripheral information
 func (p *OS2LPeripheral) GetInfo() PeripheralInfo {
 	return PeripheralInfo{
--- a/hardware/interfaces.go
+++ b/hardware/interfaces.go
@@ -8,17 +8,19 @@ type Peripheral interface {
 	Disconnect(context.Context) error                              // Disconnect the peripheral
 	Activate(context.Context) error                                // Activate the peripheral
 	Deactivate(context.Context) error                              // Deactivate the peripheral
+	SetPeripheralSettings(map[string]interface{}) error            // Set a peripheral setting
 	SetDeviceProperty(context.Context, uint32, uint32, byte) error // Update a device property

-	GetInfo() PeripheralInfo // Get the peripheral information
+	GetInfo() PeripheralInfo             // Get the peripheral information
+	GetSettings() map[string]interface{} // Get the peripheral settings
 }

 // PeripheralInfo represents a peripheral information
 type PeripheralInfo struct {
-	Name         string        `yaml:"name"`     // Name of the peripheral
-	SerialNumber string        `yaml:"sn"`       // S/N of the peripheral
-	ProtocolName string        `yaml:"protocol"` // Protocol name of the peripheral
-	Settings     []interface{} `yaml:"settings"` // Number of DMX universes handled by the peripheral
+	Name         string                 `yaml:"name"`     // Name of the peripheral
+	SerialNumber string                 `yaml:"sn"`       // S/N of the peripheral
+	ProtocolName string                 `yaml:"protocol"` // Protocol name of the peripheral
+	Settings     map[string]interface{} `yaml:"settings"` // Peripheral settings
 }

 // PeripheralFinder represents how compatible peripheral drivers are implemented
--- a/peripherals.go
+++ b/peripherals.go
@@ -9,13 +9,16 @@ import (

 // AddPeripheral adds a peripheral to the project
 func (a *App) AddPeripheral(protocolName string, peripheralID string) error {
-	// Get the device from its finder
+	// Get the peripheral from its finder
 	p, found := a.hardwareManager.GetPeripheral(protocolName, peripheralID)
 	if !found {
 		log.Error().Str("file", "peripheral").Str("protocolName", protocolName).Str("periphID", peripheralID).Msg("unable to found the specified peripheral")
 		return fmt.Errorf("unable to found the peripheral ID '%s'", peripheralID)
 	}
 	// Add the peripheral ID to the project
+	if a.projectInfo.PeripheralsInfo == nil {
+		a.projectInfo.PeripheralsInfo = make(map[string]hardware.PeripheralInfo)
+	}
 	a.projectInfo.PeripheralsInfo[peripheralID] = p.GetInfo()
 	log.Info().Str("file", "peripheral").Str("protocolName", protocolName).Str("periphID", peripheralID).Msg("peripheral added to project")

@@ -23,6 +26,37 @@ func (a *App) AddPeripheral(protocolName string, peripheralID string) error {
 	return nil
 }

+// GetPeripheralSettings gets the peripheral settings
+func (a *App) GetPeripheralSettings(protocolName, peripheralID string) (map[string]interface{}, error) {
+	// Get the peripheral from its finder
+	p, found := a.hardwareManager.GetPeripheral(protocolName, peripheralID)
+	if !found {
+		log.Error().Str("file", "peripheral").Str("protocolName", protocolName).Str("periphID", peripheralID).Msg("unable to found the specified peripheral")
+		return nil, fmt.Errorf("unable to found the peripheral ID '%s'", peripheralID)
+	}
+	// Return the peripheral settings
+	return p.GetSettings(), nil
+}
+
+// UpdatePeripheralSettings updates a specific setting of a peripheral
+func (a *App) UpdatePeripheralSettings(protocolName, peripheralID string, settings map[string]interface{}) error {
+	// Get the peripheral from its finder
+	p, found := a.hardwareManager.GetPeripheral(protocolName, peripheralID)
+	if !found {
+		log.Error().Str("file", "peripheral").Str("protocolName", protocolName).Str("periphID", peripheralID).Msg("unable to found the specified peripheral")
+		return fmt.Errorf("unable to found the peripheral ID '%s'", peripheralID)
+	}
+	// Save the settings in the application
+	if a.projectInfo.PeripheralsInfo == nil {
+		a.projectInfo.PeripheralsInfo = make(map[string]hardware.PeripheralInfo)
+	}
+	pInfo := a.projectInfo.PeripheralsInfo[peripheralID]
+	pInfo.Settings = settings
+	a.projectInfo.PeripheralsInfo[peripheralID] = pInfo
+	// Apply changes in the peripheral
+	return p.SetPeripheralSettings(pInfo.Settings)
+}
+
 // RemovePeripheral adds a peripheral to the project
 func (a *App) RemovePeripheral(protocolName string, peripheralID string) error {
 	// TODO: Disconnect the peripheral
@@ -34,7 +68,7 @@ func (a *App) RemovePeripheral(protocolName string, peripheralID string) error {

 // AddOS2LPeripheral adds a new OS2L peripheral
 func (a *App) AddOS2LPeripheral() (hardware.PeripheralInfo, error) {
-	// Get the OS2L driver
+	// Get the OS2L finder
 	os2lDriver, err := a.hardwareManager.GetFinder("OS2L")
 	if err != nil {
 		log.Err(err).Str("file", "peripheral").Msg("unable to found the OS2L driver")
@@ -42,7 +76,7 @@ func (a *App) AddOS2LPeripheral() (hardware.PeripheralInfo, error) {
 	}
 	log.Trace().Str("file", "peripheral").Msg("OS2L driver got")

-	// Create a new OS2L peripheral with this driver
+	// Create a new OS2L peripheral with this finder
 	os2lPeripheral, err := os2lDriver.CreatePeripheral(a.ctx)
 	if err != nil {
 		log.Err(err).Str("file", "peripheral").Msg("unable to create the OS2L peripheral")
Author	SHA1	Message	Date
Valentin Boulanger	1d6bbdc370	settings save optimizations	2025-01-25 18:30:48 +01:00
Valentin Boulanger	9d00b99730	peripheral setting save	2025-01-25 16:00:02 +01:00
Valentin Boulanger	0114ed03bf	peripheral selection optimized	2025-01-25 12:16:29 +01:00
Valentin Boulanger	6941c06661	load peripheral settings in front	2025-01-25 11:06:03 +01:00
Valentin Boulanger	3fbf4b5df4	added the settings structure to the peripherals	2025-01-18 16:25:09 +01:00