fixed: FTDI get settings when disconnected

Resolved CPU usage for FTDI peripherals.

.gitignore

@@ -1,8 +1,14 @@
-build
+build/bin
+projects
 node_modules
 frontend/.vscode
 frontend/dist
 frontend/wailsjs
 */package-lock.json
 */package.json.md5
-*.exe
+*.exe
+*.o
+*.rc
+*.dll
+*.dll.a
+frontend/public

.vscode/settings.json

@@ -0,0 +1,66 @@
+{
+    "files.associations": {
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "*.tcc": "cpp",
+        "cctype": "cpp",
+        "charconv": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "format": "cpp",
+        "fstream": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "new": "cpp",
+        "numbers": "cpp",
+        "ostream": "cpp",
+        "semaphore": "cpp",
+        "span": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "stop_token": "cpp",
+        "streambuf": "cpp",
+        "thread": "cpp",
+        "typeinfo": "cpp",
+        "variant": "cpp",
+        "queue": "cpp",
+        "ranges": "cpp",
+        "text_encoding": "cpp"
+    }
+}

app.go

@@ -2,26 +2,120 @@ package main
 
 import (
 	"context"
+	"dmxconnect/hardware"
 	"fmt"
+	"io"
+	"time"
+
+	"github.com/rs/zerolog/log"
+
+	"os"
+	"strings"
+	"sync"
 )
 
 // App struct
 type App struct {
-	ctx context.Context
+	ctx        context.Context
+	cancelFunc context.CancelFunc
+	wait       sync.WaitGroup
+
+	hardwareManager *hardware.HardwareManager // For managing all the hardware
+	wmiMutex        sync.Mutex                // Avoid some WMI operations at the same time
+	projectInfo     ProjectInfo               // The project information structure
+	projectSave     string                    // The file name of the project
 }
 
 // NewApp creates a new App application struct
 func NewApp() *App {
-	return &App{}
+	// Create a new hadware manager
+	hardwareManager := hardware.NewHardwareManager()
+	// hardwareManager.RegisterFinder(hardware.NewMIDIFinder(5 * time.Second))
+	hardwareManager.RegisterFinder(hardware.NewFTDIFinder(5 * time.Second))
+	hardwareManager.RegisterFinder(hardware.NewOS2LFinder())
+	return &App{
+		hardwareManager: hardwareManager,
+		projectSave:     "",
+		projectInfo: ProjectInfo{
+			PeripheralsInfo: make(map[string]hardware.PeripheralInfo),
+		},
+	}
 }
 
 // startup is called when the app starts. The context is saved
 // so we can call the runtime methods
-func (a *App) startup(ctx context.Context) {
-	a.ctx = ctx
+func (a *App) onStartup(ctx context.Context) {
+	a.ctx, a.cancelFunc = context.WithCancel(ctx)
+
+	// Starting the hardware manager
+	a.wait.Add(1)
+	go func() {
+		defer a.wait.Done()
+		err := a.hardwareManager.Start(a.ctx)
+		if err != nil {
+			log.Err(err).Str("file", "app").Msg("unable to start the hardware manager")
+			return
+		}
+	}()
 }
 
-// Greet returns a greeting for the given name
-func (a *App) Greet(name string) string {
-	return fmt.Sprintf("Hello %s, It's show time!", name)
+// onReady is called when the DOM is ready
+// We get the current peripherals connected
+func (a *App) onReady(ctx context.Context) {
+	// log.Debug().Str("file", "peripherals").Msg("getting peripherals...")
+	// err := a.hardwareManager.Scan()
+	// if err != nil {
+	// 	log.Err(err).Str("file", "app").Msg("unable to get the peripherals")
+	// }
+	return
+}
+
+// onShutdown is called when the app is closing
+// We stop all the pending processes
+func (a *App) onShutdown(ctx context.Context) {
+	// Close the application properly
+	log.Trace().Str("file", "app").Msg("app is closing")
+	// Explicitly close the context
+	a.cancelFunc()
+	// Wait for application to close properly
+	a.hardwareManager.WaitStop()
+	// a.cancelFunc()
+	// err := a.hardwareManager.Stop()
+	// if err != nil {
+	// 	log.Err(err).Str("file", "app").Msg("unable to stop the hardware manager")
+	// }
+	return
+}
+
+func formatString(input string) string {
+	// Convertir en minuscules
+	lowerCaseString := strings.ToLower(input)
+	// Remplacer les espaces par des underscores
+	formattedString := strings.ReplaceAll(lowerCaseString, " ", "_")
+	return formattedString
+}
+
+func copy(src, dst string) (int64, error) {
+	sourceFileStat, err := os.Stat(src)
+	if err != nil {
+		return 0, err
+	}
+
+	if !sourceFileStat.Mode().IsRegular() {
+		return 0, fmt.Errorf("%s is not a regular file", src)
+	}
+
+	source, err := os.Open(src)
+	if err != nil {
+		return 0, err
+	}
+	defer source.Close()
+
+	destination, err := os.Create(dst)
+	if err != nil {
+		return 0, err
+	}
+	defer destination.Close()
+	nBytes, err := io.Copy(destination, source)
+	return nBytes, err
 }

build.bat

@@ -0,0 +1,55 @@
+@echo off
+setlocal
+
+echo ============================================
+echo [INFO] Starting Wails build script
+echo ============================================
+
+rem Détection du mode (par défaut : build)
+set "MODE=build"
+if /i "%~1"=="-dev" set "MODE=dev"
+
+rem 1️⃣ Essayer de récupérer le dernier tag
+for /f "tokens=*" %%i in ('git describe --tags --abbrev=0 2^>nul') do set "GIT_TAG=%%i"
+
+rem 2️⃣ Si pas de tag, utiliser le hash du commit
+if "%GIT_TAG%"=="" (
+    for /f "tokens=*" %%i in ('git rev-parse --short HEAD 2^>nul') do set "GIT_TAG=%%i"
+)
+
+rem 3️⃣ Si Git n’est pas dispo, mettre "unknown"
+if "%GIT_TAG%"=="" set "GIT_TAG=unknown"
+
+echo [INFO] Git version detected: %GIT_TAG%
+
+
+echo [INFO] Mode selectionne : %MODE%
+
+echo [INFO] Moving to the C++ folder...
+cd /d "%~dp0hardware\cpp" || (
+    echo [ERROR] Impossible d'accéder à hardware\cpp
+    exit /b 1
+)
+
+echo [INFO] Compiling C++ libraries...
+call generate.bat || (
+    echo [ERROR] Échec de la compilation C++
+    exit /b 1
+)
+
+echo [INFO] Returning to project root...
+cd /d "%~dp0" || exit /b 1
+
+if /i "%MODE%"=="dev" (
+    echo [INFO] Launching Wails in DEV mode...
+    wails dev
+) else (
+    echo [INFO] Building Wails application...
+    wails build -o "dmxconnect-%GIT_TAG%.exe"
+)
+
+echo ============================================
+echo [SUCCESS] Done!
+echo ============================================
+
+endlocal

build/windows/info.json

@@ -0,0 +1,15 @@
+{
+	"fixed": {
+		"file_version": "{{.Info.ProductVersion}}"
+	},
+	"info": {
+		"0000": {
+			"ProductVersion": "{{.Info.ProductVersion}}",
+			"CompanyName": "{{.Info.CompanyName}}",
+			"FileDescription": "{{.Info.ProductName}}",
+			"LegalCopyright": "{{.Info.Copyright}}",
+			"ProductName": "{{.Info.ProductName}}",
+			"Comments": "{{.Info.Comments}}"
+		}
+	}
+}

build/windows/wails.exe.manifest

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
+    <assemblyIdentity type="win32" name="com.wails.{{.Name}}" version="{{.Info.ProductVersion}}.0" processorArchitecture="*"/>
+    <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+        <security>
+            <requestedPrivileges>
+                <requestedExecutionLevel level="requireAdministrator" uiAccess="false"/>
+            </requestedPrivileges>
+        </security>
+    </trustInfo>
+    <dependency>
+        <dependentAssembly>
+            <assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="*" publicKeyToken="6595b64144ccf1df" language="*"/>
+        </dependentAssembly>
+    </dependency>
+    <asmv3:application>
+        <asmv3:windowsSettings>
+            <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/pm</dpiAware> <!-- fallback for Windows 7 and 8 -->
+            <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">permonitorv2,permonitor</dpiAwareness> <!-- falls back to per-monitor if per-monitor v2 is not supported -->
+        </asmv3:windowsSettings>
+    </asmv3:application>
+</assembly>

frontend/index.html

@@ -5,7 +5,6 @@
     <meta content="width=device-width, initial-scale=1.0" name="viewport"/>
     <link href='https://unpkg.com/boxicons@2.1.4/css/boxicons.min.css' rel='stylesheet'>
     <link rel='stylesheet' href='./src/style.css'>
-    <link rel="shortcut icon" type="image/x-icon" href="./src/assets/images/logo-universal.png" />
     <title>DMXConnect</title>
 </head>
 <body style="background-color:#1B262C;">

frontend/src/App.svelte

@@ -1,41 +1,138 @@
 <script>
-  import logo from './assets/images/logo-universal.png'
-  import {Greet} from '../wailsjs/go/main/App.js'
   import { _ } from 'svelte-i18n'
-	import NavigationBar from './components/NavigationBar.svelte';
-  import Clock from './components/Clock.svelte'
-  import Stage from './components/Stage.svelte';
-  import Atmo from './components/Atmo.svelte';
-  import Settings from './components/Settings.svelte';
-  import DevicesLibrary from './components/DevicesLibrary.svelte';
+	import NavigationBar from './components/General/NavigationBar.svelte';
+  import Clock from './components/General/Clock.svelte'
+  import Preparation from './components/Preparation/Preparation.svelte';
+  import Animation from './components/Animation/Animation.svelte';
+  import Settings from './components/Settings/Settings.svelte';
+  import Devices from './components/Devices/Devices.svelte';
+  import Show from './components/Show/Show.svelte';
+  import RoundDropdownList from "./components/General/RoundDropdownList.svelte";
+  import GeneralConsole from './components/Console/GeneralConsole.svelte';
+  import RoundIconButton from './components/General/RoundIconButton.svelte';
+  import { generateToast, showInformation, needProjectSave, projectsList } from './stores.js';
+  import { GetProjects, CreateProject, OpenProjectFromDisk, SaveProject } from '../wailsjs/go/main/App.js';
+  import { WindowSetTitle } from "../wailsjs/runtime/runtime"
+  import ToastNotification from './components/General/ToastNotification.svelte';
+  import { onMount, onDestroy } from 'svelte'
+  import { destroyRuntimeEvents, initRuntimeEvents } from './runtime-events.js'
 
-  let selectedMenu = "stage"
+  function initializeNewProject(){
+      // Instanciate a new project
+      CreateProject().then(() => {
+        // Project created, we set the needSave flag to true (not already saved)
+        needProjectSave.set(true)
+      }).catch((error) => {
+        console.error(`Unable to create the project: ${error}`)
+        generateToast('danger', 'bx-error', $_("projectCreateErrorToast"))
+      })
+  }
+
+  // Initialize runtime events at startup
+  onMount(() => {
+    initRuntimeEvents()
+
+    // Handle window shortcuts
+    document.addEventListener('keydown', function(event) {
+      // Check the CTRL+S keys
+      if ((event.ctrlKey || event.metaKey) && event.key === 's') {
+          // Avoid the natural behaviour
+          event.preventDefault();
+          // Save the current project
+          saveProject()
+      }
+    });
+
+    // Initialize a new project
+    initializeNewProject()
+  })
+
+  // Destroy runtime events at shutdown
+  onDestroy(() => {
+    destroyRuntimeEvents()
+  })
+
+  // Set the window title
+  $: {
+    WindowSetTitle("DMXConnect - " + $showInformation.Name + ($needProjectSave ? " (" + $_("unsavedProjectFlag") + ")" : ""))
+  }
+
+  let selectedMenu = "settings"
   // When the navigation menu changed, update the selected menu
 	function onNavigationChanged(event){
     selectedMenu = event.detail.menu;
 	}
+
+  // Save the project
+  function saveProject(){
+    SaveProject().then((filePath) => {
+      needProjectSave.set(false)
+      console.log("Project has been saved to " + filePath)
+      generateToast('info', 'bxs-save', $_("projectSavedToast"))
+    }).catch((error) => {
+      console.error(`Unable to save the project: ${error}`)
+      generateToast('danger', 'bx-error', $_("projectSaveErrorToast") + ' ' + error)
+    })
+  }
+
+  // Open the selected project
+  function openSelectedProject(event){
+      let selectedOption = event.detail.key
+      // Open the selected project
+      OpenProjectFromDisk(selectedOption).then(() => {
+          // Project opened, we set the needSave flag to false (already saved)
+          needProjectSave.set(false)
+      }).catch((error) => {
+          console.error(`Unable to open the project: ${error}`)
+          generateToast('danger', 'bx-error', $_("projectOpenErrorToast"))
+      })
+  }
+
+  // Refresh the projects list
+  let choices = new Map()
+  function loadProjectsList(){
+      GetProjects().then((projects) => {
+          choices = new Map(projects.map(item => [item.Save, item.Name]));
+          $projectsList = projects
+      }).catch((error) => {
+          console.error(`Unable to get the projects list: ${error}`)
+          generateToast('danger', 'bx-error', $_("projectsLoadErrorToast"))
+      })
+  }
+
 </script>
 
 <header>
+    <!-- Project buttons -->   
+    <RoundIconButton on:mouseup={initializeNewProject} icon='bxs-plus-square' width="2.5em" tooltip={$_("newProjectTooltip")}/>
+    <RoundDropdownList on:click={loadProjectsList} on:selected={openSelectedProject} choices={choices} icon='bxs-folder-open' width="2.5em" tooltip={$_("openProjectTooltip")}/>
+
     <NavigationBar on:navigationChanged="{onNavigationChanged}"/>
+    {#if $needProjectSave}
+      <RoundIconButton on:mouseup={saveProject} icon="bx-save" width="2.5em" tooltip={$_("saveButtonTooltip")}/>
+    {/if}
     <Clock/>
 </header>
 <main>
-	{#if selectedMenu === "stage"}
-  <Stage />
-  {:else if selectedMenu === "atmo"}
-  <Atmo />
-  {:else if selectedMenu === "settings"}
+	{#if selectedMenu === "settings"}
   <Settings />
-  {:else if selectedMenu === "devicesLibrary"}
-  <DevicesLibrary />
+  {:else if selectedMenu === "devices"}
+  <Devices />
+  {:else if selectedMenu === "preparation"}
+  <Preparation />
+  {:else if selectedMenu === "animation"}
+  <Animation />
+  {:else if selectedMenu === "show"}
+  <Show />
+  {:else if selectedMenu === "console"}
+  <GeneralConsole />
   {/if}
+  <ToastNotification/>
 </main>
 
 <style>
 	main {
 		text-align: left;
-		padding: 1em;
 		max-width: 240px;
 		margin: 0 auto;
 	}

frontend/src/components/Animation/Animation.svelte

@@ -0,0 +1 @@
+<h1>Animation creator</h1>

frontend/src/components/Atmo.svelte

@@ -1 +0,0 @@
-<h1>Atmo</h1>

frontend/src/components/Clock.svelte

@@ -1,50 +0,0 @@
-
-<script>
-    import { onDestroy } from 'svelte';
-    import * as SoftwareVariables from '../stores.js';
-
-    // Import the main colors from the store
-    let firstColor, secondColor, thirdColor, fourthColor, okColor, nokColor
-    const unsubscribeFirstColor = SoftwareVariables.firstColor.subscribe((value) => (firstColor = value));
-    const unsubscribeSecondColor = SoftwareVariables.secondColor.subscribe((value) => (secondColor = value));
-    const unsubscribeThirdColor = SoftwareVariables.thirdColor.subscribe((value) => (thirdColor = value));
-    const unsubscribeFourthColor = SoftwareVariables.fourthColor.subscribe((value) => (fourthColor = value));
-    const unsubscribeOkColor = SoftwareVariables.okColor.subscribe((value) => (okColor = value));
-    const unsubscribeNokColor = SoftwareVariables.nokColor.subscribe((value) => (nokColor = value));
-
-    let time = new Date()
-
-    $: hours = time.getHours().toLocaleString('en-US', { minimumIntegerDigits: 2, useGrouping: false })
-    $: minutes = time.getMinutes().toLocaleString('en-US', { minimumIntegerDigits: 2, useGrouping: false })
-    $: seconds = time.getSeconds().toLocaleString('en-US', { minimumIntegerDigits: 2, useGrouping: false })
-
-    const interval = setInterval(() => {
-        time = new Date()
-    }, 1000);
-
-    onDestroy(() => {
-        clearInterval(interval);
-        unsubscribeFirstColor();
-        unsubscribeSecondColor();
-        unsubscribeThirdColor();
-        unsubscribeFourthColor();
-        unsubscribeOkColor();
-        unsubscribeNokColor();
-    });
-</script>
-
-<div style='color:{fourthColor}'>
-    <span class="bold">{hours}:{minutes}</span><span>{seconds}</span>
-</div>
-
-<style>
-    div{
-        float:right;
-    }
-    
-    .bold {
-        font-weight: bold;
-        font-size: 2em;
-    }
-</style>
-

frontend/src/components/Console/GeneralConsole.svelte

@@ -0,0 +1 @@
+<h1>General console</h1>

frontend/src/components/Devices/Devices.svelte

@@ -0,0 +1 @@
+<h1>Devices configuration</h1>

frontend/src/components/DevicesLibrary.svelte

@@ -1 +0,0 @@
-<h1>Devices Library</h1>

frontend/src/components/General/Clock.svelte

@@ -0,0 +1,32 @@
+
+<script>
+    import { onDestroy } from 'svelte';
+    import {colors} from '../../stores.js';
+
+    let time = new Date()
+
+    $: hours = time.getHours().toLocaleString('en-US', { minimumIntegerDigits: 2, useGrouping: false })
+    $: minutes = time.getMinutes().toLocaleString('en-US', { minimumIntegerDigits: 2, useGrouping: false })
+    $: seconds = time.getSeconds().toLocaleString('en-US', { minimumIntegerDigits: 2, useGrouping: false })
+
+    const interval = setInterval(() => {
+        time = new Date()
+    }, 1000);
+
+</script>
+
+<div style='color:{$colors.fourth}'>
+    <span class="bold">{hours}:{minutes}</span><span>{seconds}</span>
+</div>
+
+<style>
+    div{
+        float:right;
+    }
+    
+    .bold {
+        font-weight: bold;
+        font-size: 2em;
+    }
+</style>
+

frontend/src/components/General/DropdownList.svelte

@@ -0,0 +1,103 @@
+<script lang=ts>
+    import { createEventDispatcher, onDestroy } from 'svelte';
+    import {colors} from '../../stores.js';
+    import Tooltip from './Tooltip.svelte';
+
+    export let text = 'Default button';
+    export let icon = ''
+    export let tooltip = "Default tooltip"
+    export let choices = new Map()
+    export let active = false;
+    export let style = '';
+
+    let tooltipPosition = {top: 0, left: 0}
+
+    // Show a tooltip on mouse hover
+    let tooltipShowing = false
+    let buttonRef
+    function toggleTooltip(active){
+        const rect = buttonRef.getBoundingClientRect();
+        tooltipPosition = {
+            top: rect.bottom + 5, // Ajouter une marge en bas
+            left: rect.left, // Centrer horizontalement
+        };
+        tooltipShowing = active
+    }
+
+    // Emit a click event when the button is clicked
+    const dispatch = createEventDispatcher();
+    function handleclick(key){
+        // Deactivate the list visibility
+        hideList()
+        dispatch('selected', key)
+    }
+
+    // Show the option list
+    let listShowing = false
+    function toggleList(){
+        if (!listShowing) {
+            dispatch('click')
+        }
+        listShowing = !listShowing
+    }
+    function hideList(){
+        listShowing = false
+    }
+</script>
+
+<!-- <Tooltip message={tooltip} show={tooltipShowing}></Tooltip> -->
+<div class="container">
+    <button bind:this={buttonRef}
+        on:mouseenter={() => { toggleTooltip(true) }}
+        on:mouseleave={() => { toggleTooltip(false) }}
+        on:click={toggleList}
+        style='color: {$colors.white}; background-color: { active ? $colors.second : $colors.third }; border:none; {style}'><i class='bx { icon}'></i> { text }
+    </button>
+    <Tooltip message={tooltip} show={tooltipShowing} position={tooltipPosition}></Tooltip>
+    <div class="list" style="color: {$colors.white}; display: {listShowing ? "block" : "none"};"
+        on:mouseleave={hideList}>
+        {#each Array.from(choices) as [key, value]}
+            <div class="item" on:click={() => handleclick({key})}>{value}</div>
+        {/each}
+    </div>
+</div>
+
+<style>
+    .item{
+        border-radius: 0.3em;
+        padding: 0.3em;
+    }
+    .item:hover {
+        background-color: var(--second-color);
+        color: var(--white-color);
+    }
+    .container{
+        position: relative;
+        display: inline-block;
+    }
+    .list {
+        z-index: 200;
+        padding: 0.2em;
+        backdrop-filter: blur(20px);
+        margin-top: 0.2em;
+        position: absolute;
+        width: auto;
+        cursor: pointer;
+        border-radius: 0.5em;
+        white-space: nowrap;
+        text-overflow: ellipsis;
+        overflow: hidden;
+        max-width: 30em;
+        max-height: 40vh;
+        overflow-y: scroll;
+        scrollbar-width: none;
+    }
+    button{
+        cursor: pointer;
+        border-radius: 0.5em;
+        margin: 0;
+    }
+    button:hover{
+        box-shadow: 1px 1px 3px 0px rgba(0, 0, 0, 0.25) inset;
+    }
+</style>

frontend/src/components/General/InfoButton.svelte

@@ -0,0 +1,63 @@
+
+<script>
+    import { stop_propagation } from 'svelte/internal';
+    import Tooltip from '../General/Tooltip.svelte';
+    import { createEventDispatcher } from 'svelte';
+
+    export let width = '20px';
+    export let background = '';
+    export let icon = '';
+    export let color = 'white';
+    export let style = '';
+    export let interactive = false;
+    export let message = '';
+    export let hide = false;
+
+    let tooltipPosition = {top: 0, left: 0}
+
+    // Show a tooltip on mouse hover
+    let tooltipShowing = false
+    let buttonRef
+    function toggleTooltip(active){
+        const rect = buttonRef.getBoundingClientRect();
+        tooltipPosition = {
+            top: rect.bottom + 5, // Ajouter une marge en bas
+            left: rect.left, // Centrer horizontalement
+        };
+        tooltipShowing = active
+    }
+    
+    // Emit a click event when the button is being clicked
+    const dispatch = createEventDispatcher();
+    function click(event){
+        event.stopPropagation()
+        dispatch('click')
+    }
+</script>
+
+<div class="container">
+    <div class="badge" bind:this={buttonRef}
+        style="opacity: {hide ? 0 : 1}; pointer-events: {hide ? 'none' : 'all'}; width: {width}; height: {width}; color: {color}; background-color: {background}; border-radius: calc({width} / 2); cursor: {interactive ? 'pointer' : ''}; {style}"
+        on:mousedown={click}
+        on:mouseenter={() => { toggleTooltip(true) }}
+        on:mouseleave={() => { toggleTooltip(false) }}>
+        <i class='bx {icon}' style="font-size:100%;"></i>
+    </div>
+    {#if message} 
+        <Tooltip message={message} show={tooltipShowing} position={tooltipPosition}></Tooltip>
+    {/if}
+</div>
+
+
+<style>
+    .container{
+        position: relative;
+    }
+    .badge {
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        padding: 0;
+    }
+</style>
+

frontend/src/components/General/Input.svelte

@@ -0,0 +1,90 @@
+<script lang=ts>
+    import { createEventDispatcher } from 'svelte';
+    import {colors} from '../../stores.js';
+
+    export let label = '';
+    export let type = 'text';
+    export let min = undefined;
+    export let max = undefined;
+    export let src = undefined;
+    export let alt = undefined;
+    export let width = undefined;
+    export let height = undefined;
+    export let value = '';
+    export let placeholder = undefined;
+
+    const dispatch = createEventDispatcher();
+
+    function handleInput(){
+        dispatch('input')
+    }
+
+    function handleBlur(event){
+        dispatch('blur', event)
+    }
+
+    function handleDblClick(){
+        dispatch('dblclick')
+    }
+</script>
+
+<div style="width: {width}; height: {height};">
+    <p style="color: {$colors.white};">{label}</p>
+    <!-- Handle the textarea input -->
+    {#if type === 'large'}
+        <textarea style="background-color: {$colors.second}; color: {$colors.white};" placeholder={placeholder} value={value} on:dblclick={handleDblClick} on:input={handleInput} on:blur={handleBlur}/>
+    <!-- Handle the simple inputs -->
+    {:else}
+        <input style="background-color: {$colors.second}; color: {$colors.white};" type={type} min={min} max={max} src={src} alt={alt} value={value} placeholder={placeholder} on:dblclick={handleDblClick} on:input={handleInput} on:blur={handleBlur}/>
+    {/if}
+</div>
+
+<style>
+    div{
+        display:inline-block;
+    }
+    p{
+        margin:0;
+    }
+    input{
+        border:none;
+        border-radius: 0.5em;
+        text-align: center;
+        width: 100%;
+    }
+
+    input::selection {
+        background: var(--first-color); /* Couleur de fond de la sélection */
+        color: var(--white-color); /* Couleur du texte de la sélection */
+    }
+
+    /* Pour Firefox */
+    input::-moz-selection {
+        background: var(--first-color); /* Couleur de fond de la sélection */
+        color: var(--white-color); /* Couleur du texte de la sélection */
+    }
+    input:focus {
+        outline: 1px solid #BBE1FA;
+    }
+
+    textarea{
+        border:none;
+        border-radius: 0.5em;
+        resize: none;
+        width: 100%;
+    }
+
+    textarea::selection {
+        background: var(--first-color); /* Couleur de fond de la sélection */
+        color: var(--white-color); /* Couleur du texte de la sélection */
+    }
+
+    /* Pour Firefox */
+    textarea::-moz-selection {
+        background: var(--first-color); /* Couleur de fond de la sélection */
+        color: var(--white-color); /* Couleur du texte de la sélection */
+    }
+    textarea:focus {
+        outline: 1px solid #BBE1FA;
+    }
+</style>

frontend/src/components/General/NavigationBar.svelte

@@ -0,0 +1,62 @@
+<script>
+    import RoundIconButton from './RoundIconButton.svelte';
+    import Toggle from './Toggle.svelte';
+    import { createEventDispatcher, onDestroy } from 'svelte';
+    import {colors} from '../../stores.js';
+    import { _ } from 'svelte-i18n'
+
+    //---Navigation System---//
+
+    let menuStates = {
+        settings: true,
+        devices: false,
+        preparation: false,
+        animation: false,
+        show: false,
+        console:false
+    };
+
+    // Handle the click on a navigation button
+    function handleNavigation(menu) {
+        emitNavigationEvent(menu);
+        deselectMenus();
+        menuStates[menu] = true;
+    }
+
+    // Deselect all menus from the navigation bar
+    function deselectMenus(){
+        for (const menu in menuStates) {
+            menuStates[menu] = false;
+        }
+    }
+
+    // Emit navigation events
+    const dispatch = createEventDispatcher();
+    function emitNavigationEvent(menu) {
+        dispatch('navigationChanged', {
+            menu: menu
+        });
+    }
+
+</script>
+
+<div style="background-color: {$colors.second};">
+    <RoundIconButton on:mousedown="{() => handleNavigation("settings")}" icon="bx-cog" width="2.5em" tooltip={$_("settingsMenuTooltip")} active={menuStates.settings}></RoundIconButton>
+    <RoundIconButton on:mousedown="{() => handleNavigation("devices")}" icon="bx-video-plus" width="2.5em" tooltip={$_("devicesMenuTooltip")} active={menuStates.devices}></RoundIconButton>
+    <RoundIconButton on:mousedown="{() => handleNavigation("preparation")}" icon="bx-layer" width="2.5em" tooltip="{$_("preparationMenuTooltip")}" active={menuStates.preparation}></RoundIconButton>
+    <RoundIconButton on:mousedown="{() => handleNavigation("animation")}" icon="bx-film" width="2.5em" tooltip="{$_("animationMenuTooltip")}" active={menuStates.animation}></RoundIconButton>
+    <RoundIconButton on:mousedown="{() => handleNavigation("show")}" icon="bxs-grid" width="2.5em" tooltip="{$_("showMenuTooltip")}" active={menuStates.show}></RoundIconButton>
+    <RoundIconButton on:mousedown="{() => handleNavigation("console")}" icon="bx-slider" width="2.5em" tooltip="{$_("consoleMenuTooltip")}" active={menuStates.console}></RoundIconButton>
+    <Toggle icon="bx-shape-square" width="2.5em" height="1.3em" tooltip="{$_("stageRenderingToggleTooltip")}"></Toggle>
+    <Toggle icon="bx-play" width="2.5em" height="1.3em" tooltip="{$_("showActivationToggleTooltip")}"></Toggle>
+</div>
+<style>
+    div {
+        display: inline-flex;
+        align-items: center;
+        padding: 4px;
+        border-radius: 40px;
+        gap: 0.3em;
+        flex-wrap: wrap;
+    }
+</style>

frontend/src/components/General/RoundDropdownList.svelte

@@ -0,0 +1,156 @@
+<!-- Create a round icon button -->
+
+<script>
+    import { createEventDispatcher, onDestroy } from 'svelte';
+    import {colors} from '../../stores.js';
+    import Tooltip from './Tooltip.svelte';
+    import { _ } from 'svelte-i18n'
+
+    export let icon = "bxs-heart" // The icon wanted 
+    export let width = "10em" // The button width
+    export let active = false // If the button is active or not
+    export let tooltip = "Default tooltip" // The description shown in the tooltip
+    export let operationalStatus = undefined// The optional button status
+    export let okStatusLabel = "" // The label shown when the button is OK
+    export let nokStatusLabel = "" // The label shown when the button is NOK
+    export let choices = new Map()
+    export let style = '';
+
+    let tooltipMessage = tooltip
+
+    // Default values for background and foreground
+    $: background = $colors.first
+    $: foreground = $colors.first
+
+    // Change the background when the selected prop changed
+    $: {
+        if (active === true) {
+            background = $colors.third
+            foreground = $colors.fourth
+        } else {
+            background = $colors.fourth
+            foreground = $colors.second
+        }
+    }
+
+    // Show the operational status if specified
+    // undefined => no status displayed
+    // operationalStatus = true => OK color displayed
+    // operationalStatus = false => NOK color displayed
+    $: statusColor = $colors.nok
+    $: {    
+        if (operationalStatus === true){
+            statusColor = $colors.ok
+            tooltipMessage = tooltip + " " + okStatusLabel
+        } else {
+            statusColor = $colors.nok
+            tooltipMessage = tooltip + " " + nokStatusLabel
+        }
+    }
+
+    // Emit a click event when the button is clicked
+    const dispatch = createEventDispatcher();
+    function handleclick(key){
+        // Deactivate the list visibility
+        hideList()
+        dispatch('selected', key)
+    }
+       
+    // Show the option list
+    let listShowing = false
+    function toggleList(){
+        if (!listShowing) {
+            dispatch('click')
+        }
+        listShowing = !listShowing
+    }
+    function hideList(){
+        listShowing = false
+    }
+
+    let tooltipPosition = {top: 0, left: 0}
+
+    // Show a tooltip on mouse hover
+    let tooltipShowing = false
+    let buttonRef
+    function toggleTooltip(active){
+        const rect = buttonRef.getBoundingClientRect();
+        tooltipPosition = {
+            top: rect.bottom + 5, // Ajouter une marge en bas
+            left: rect.left, // Centrer horizontalement
+        };
+        tooltipShowing = active
+    }
+
+</script>
+
+<div class="container">
+    <button bind:this={buttonRef}
+        style="width:{width}; height:{width}; border-radius:{width}; background-color:{background}; color:{foreground};"
+        on:mouseenter={() => { toggleTooltip(true) }}
+        on:mouseleave={() => { toggleTooltip(false) }}
+        on:click={toggleList}>
+        <i class='bx {icon}' style="font-size:100%;"></i>
+    </button>
+    <!-- Showing the badge status if the button has an operational status -->
+    {#if (operationalStatus !== undefined)}
+        <div class="badge"
+        style="width: calc({width} / 3); height: calc({width} / 3); border-radius: calc({width}); background-color:{statusColor}; display:block;">
+        </div>
+    {/if}
+    <Tooltip message={tooltipMessage} show={tooltipShowing} position={tooltipPosition}></Tooltip>
+    <div class="list" style="color: {$colors.white}; display: {listShowing ? "block" : "none"}; border: 2px solid {$colors.second}; background-color: {$colors.first};"
+        on:mouseleave={hideList}>
+        {#if choices.size != 0}
+            {#each Array.from(choices) as [key, value]}
+                <div class="item" on:click={() => handleclick({key})}>{value}</div>
+            {/each}
+        {:else}
+            <div class="item"><i>{$_("openProjectEmpty")}</i></div>
+        {/if}
+    </div>
+</div>
+
+<style>
+    .item{
+        border-radius: 0.3em;
+        padding: 0.3em;
+    }
+    .item:hover {
+        background-color: var(--second-color);
+        color: var(--white-color);
+    }
+
+    .container {
+        position: relative;
+        display: inline-block;
+    }
+
+    .list {
+        z-index: 200;
+        padding: 0.2em;
+        margin-top: 0.2em;
+        position: absolute;
+        width: auto;
+        cursor: pointer;
+        border-radius: 0.5em;
+        white-space: nowrap;
+        text-overflow: ellipsis;
+        overflow: hidden;
+        max-width: 30em;
+        max-height: 40vh;
+        overflow-y: scroll;
+        scrollbar-width: none;
+    }
+
+    button{
+        display: inline-block;
+        margin: 0;
+        border:none;
+        cursor: pointer;
+    }
+    
+    button:hover{
+        box-shadow: 1px 1px 3px 0px rgba(0, 0, 0, 0.25) inset;
+    }
+</style>

frontend/src/components/General/RoundIconButton.svelte

@@ -2,7 +2,7 @@
 
 <script>
     import { createEventDispatcher, onDestroy } from 'svelte';
-    import * as SoftwareVariables from '../stores.js';
+    import {colors} from '../../stores.js';
     import Tooltip from './Tooltip.svelte';
     import { _ } from 'svelte-i18n'
 
@@ -10,31 +10,24 @@
     export let width = "10em" // The button width
     export let active = false // If the button is active or not
     export let tooltip = "Default tooltip" // The description shown in the tooltip
-    export let operationalStatus // The optional button status
+    export let operationalStatus = undefined// The optional button status
     export let okStatusLabel = "" // The label shown when the button is OK
     export let nokStatusLabel = "" // The label shown when the button is NOK
 
     let tooltipMessage = tooltip
 
-    // Import the main colors from the store
-    let firstColor, secondColor, thirdColor, fourthColor, okColor, nokColor
-    const unsubscribeFirstColor = SoftwareVariables.firstColor.subscribe((value) => (firstColor = value));
-    const unsubscribeSecondColor = SoftwareVariables.secondColor.subscribe((value) => (secondColor = value));
-    const unsubscribeThirdColor = SoftwareVariables.thirdColor.subscribe((value) => (thirdColor = value));
-    const unsubscribeFourthColor = SoftwareVariables.fourthColor.subscribe((value) => (fourthColor = value));
-    const unsubscribeOkColor = SoftwareVariables.okColor.subscribe((value) => (okColor = value));
-    const unsubscribeNokColor = SoftwareVariables.nokColor.subscribe((value) => (nokColor = value));
-
     // Default values for background and foreground
-    $: background = firstColor
-    $: foreground = firstColor
+    $: background = $colors.first
+    $: foreground = $colors.first
 
     // Change the background when the selected prop changed
     $: {
         if (active === true) {
-            background = thirdColor
+            background = $colors.third
+            foreground = $colors.fourth
         } else {
-            background = fourthColor
+            background = $colors.fourth
+            foreground = $colors.second
         }
     }
 
@@ -42,62 +35,70 @@
     // undefined => no status displayed
     // operationalStatus = true => OK color displayed
     // operationalStatus = false => NOK color displayed
-    $: statusColor = nokColor
+    $: statusColor = $colors.nok
     $: {    
         if (operationalStatus === true){
-            statusColor = okColor
+            statusColor = $colors.ok
             tooltipMessage = tooltip + " " + okStatusLabel
         } else {
-            statusColor = nokColor
+            statusColor = $colors.nok
             tooltipMessage = tooltip + " " + nokStatusLabel
         }
     }
        
     // Emit a click event when the button is clicked
     const dispatch = createEventDispatcher();
-    function emitClick() {
-        dispatch('click');
+    function emitMouseDown() {
+        dispatch('mousedown');
     }
+    function emitMouseUp() {
+        dispatch('mouseup');
+    }
+
+    let tooltipPosition = {top: 0, left: 0}
 
     // Show a tooltip on mouse hover
     let tooltipShowing = false
-    function toggleTooltip(){
-        tooltipShowing = !tooltipShowing
+    let buttonRef
+    function toggleTooltip(active){
+        const rect = buttonRef.getBoundingClientRect();
+        tooltipPosition = {
+            top: rect.bottom + 5, // Ajouter une marge en bas
+            left: rect.left, // Centrer horizontalement
+        };
+        tooltipShowing = active
     }
 
-    // Unsubscribe for all variables used from the store
-    onDestroy(() => {
-        unsubscribeFirstColor();
-        unsubscribeSecondColor();
-        unsubscribeThirdColor();
-        unsubscribeFourthColor();
-        unsubscribeOkColor();
-        unsubscribeNokColor();
-    })
 </script>
 
-<div>
-    <Tooltip message={tooltipMessage} show={tooltipShowing}></Tooltip>
-    <button
-        style="width:{width}; height:{width}; border:none; border-radius:{width}; background-color:{background}; color:{foreground};"
-        on:mousedown={emitClick}
-        on:mouseenter={toggleTooltip}
-        on:mouseleave={toggleTooltip}>
-        <i class='bx {icon}' style="font-size:calc({width} - 80%);"></i>
+<div class="container">
+    <button bind:this={buttonRef}
+        style="width:{width}; height:{width}; border-radius:{width}; background-color:{background}; color:{foreground};"
+        on:mousedown={emitMouseDown}
+        on:mouseup={emitMouseUp}
+        on:mouseenter={() => { toggleTooltip(true) }}
+        on:mouseleave={() => { toggleTooltip(false) }}>
+        <i class='bx {icon}' style="font-size:100%;"></i>
     </button>
-
     <!-- Showing the badge status if the button has an operational status -->
     {#if (operationalStatus !== undefined)}
         <div class="badge"
         style="width: calc({width} / 3); height: calc({width} / 3); border-radius: calc({width}); background-color:{statusColor}; display:block;">
         </div>
     {/if}
+    <Tooltip message={tooltipMessage} show={tooltipShowing} position={tooltipPosition}></Tooltip>
 </div>
 
 <style>
+    .container {
+        position: relative;
+        display: inline-block;
+    }
     button{
         display: inline-block;
         margin: 0;
+        border:none;
+        cursor: pointer;
     }
     button:hover{
         box-shadow: 1px 1px 3px 0px rgba(0, 0, 0, 0.25) inset;

frontend/src/components/General/RoundedButton.svelte

@@ -0,0 +1,62 @@
+<script lang=ts>
+    import { createEventDispatcher, onDestroy } from 'svelte';
+    import {colors} from '../../stores.js';
+    import Tooltip from './Tooltip.svelte';
+
+    export let text = 'Default button';
+    export let icon = ''
+    export let tooltip = "Default tooltip"
+    export let active = false;
+    export let style = '';
+
+    let tooltipPosition = {top: 0, left: 0}
+
+    // Show a tooltip on mouse hover
+    let tooltipShowing = false
+    let buttonRef
+    function toggleTooltip(active){
+        const rect = buttonRef.getBoundingClientRect();
+        tooltipPosition = {
+            top: rect.bottom + 5, // Ajouter une marge en bas
+            left: rect.left, // Centrer horizontalement
+        };
+        tooltipShowing = active
+    }
+
+    // Emit a click event when the button is clicked
+    const dispatch = createEventDispatcher();
+    function emitClick() {
+        dispatch('click');
+    }
+
+    function handleBlur(){
+        dispatch('blur')
+    }
+
+</script>
+
+<div class="container">
+    <button bind:this={buttonRef}
+        on:blur={handleBlur}
+        on:mousedown={emitClick}
+        on:mouseenter={() => { toggleTooltip(true) }}
+        on:mouseleave={() => { toggleTooltip(false) }}
+        style='color: {$colors.white}; background-color: { active ? $colors.second : $colors.third }; {style}'><i class='bx { icon}'></i> { text }
+    </button>
+    <Tooltip message={tooltip} show={tooltipShowing} position={tooltipPosition}></Tooltip>
+</div>
+<style>
+    .container{
+        position: relative;
+        display: inline-block;
+    }
+    button{
+        cursor: pointer;
+        border-radius: 0.5em;
+        margin: 0;
+        border:none;
+    }
+    button:hover{
+        box-shadow: 1px 1px 3px 0px rgba(0, 0, 0, 0.25) inset;
+    }
+</style>

frontend/src/components/General/Tab.svelte

@@ -0,0 +1,50 @@
+<script lang=ts>
+    import RoundedButton from "./RoundedButton.svelte";
+    import { onDestroy } from 'svelte';
+    import {colors} from '../../stores.js';
+
+    export let tabs = [];
+    export let maxWidth = undefined;
+    export let maxHeight = undefined;
+
+    let activeTab = 0;
+
+    function setActiveTab(index) {
+        activeTab = index;
+    }
+</script>
+
+<div class="tabContainer" style="color: {$colors.white};">
+    <div class="headerContainer">
+        {#each tabs as tab, index}
+            <RoundedButton style="margin: 0.1em;" text={tab.title} icon={tab.icon} tooltip={tab.tooltip} active={ (activeTab !== index) ? true : false } on:click={() => setActiveTab(index)}/>
+        {/each}
+    </div>
+
+    <div class="bodyContainer"
+    style='background-color: {$colors.first}; max-width: {maxWidth};'>
+    {#if tabs[activeTab]}
+        <svelte:component this={tabs[activeTab].component} />
+    {/if}
+    </div>
+</div>
+
+<style>
+    .headerContainer{
+        margin:0;
+        border-radius: 0.5em;
+    }
+    .tabContainer{
+        margin-top: 1em;
+        color: white;
+    }
+    .headerContainer{
+        padding: 0.1em;
+        border-radius: 0.5em;
+    }
+    .bodyContainer{
+        padding: 0.5em;
+        background-color: red;
+        border-radius: 0.5em;
+    }
+</style>

frontend/src/components/General/ToastNotification.svelte

@@ -0,0 +1,94 @@
+<script lang=ts>
+    import { time } from 'svelte-i18n';
+   import {messages, colors} from '../../stores.js';
+
+   let timers = {};
+
+   function removeToast(id) {
+        // Supprime un toast par son ID
+        $messages = $messages.filter(message => message.id !== id);
+        clearTimeout(timers[id]);
+    }
+
+    $: {
+        // Ajoute un timer pour supprimer automatiquement les toasts
+        for (const message of $messages) {
+            if (!timers[message.id]) {
+                timers[message.id] = setTimeout(() => removeToast(message.id), 5000);
+            }
+        }
+    }
+</script>
+
+<div class="notificationsPanel">
+    {#each $messages as message}
+        <div class="toastMessage" style="background-color: {$colors.second}; color: {$colors.white}" on:mouseup={() => removeToast(message.id)}>
+            <div class="toastIndicator" style="background-color:{(message.type == 'danger') ? $colors.nok : (message.type == 'warning') ? $colors.orange : $colors.third};"></div>
+            <p><i class='bx {message.icon}'></i> {@html message.text}</p>
+        </div>
+    {/each}
+</div>
+
+<style>
+    p{
+        margin: 0.5em;
+    }
+
+    .toastIndicator{
+        width: 10px;
+        border-top-left-radius: 0.5em;
+        border-bottom-left-radius: 0.5em;
+    }
+
+    .toastMessage:hover {
+        opacity: 1;
+    }
+
+    .toastMessage{
+        word-wrap: break-word;
+        overflow-wrap: break-word;
+        white-space: normal;
+        z-index: 150;
+        display: flex;
+        opacity: 0.8;
+        border-radius: 0.5em;
+        border: 1px solid rgba(255, 255, 255, 0.3);
+        box-shadow: 0px 4px 6px rgba(0, 0, 0, 0.1), /* Ombre principale douce */
+              0px 1px 3px rgba(0, 0, 0, 0.06); /* Ombre plus subtile */
+        animation: fade-in 0.3s ease-out, fade-out 0.3s ease-in 4.7s;
+    }
+
+    @keyframes fade-in {
+        from {
+        opacity: 0;
+        transform: translateY(20px);
+        }
+        to {
+        opacity: 0.9;
+        transform: translateY(0);
+        }
+    }
+
+    @keyframes fade-out {
+        from {
+        opacity: 0.9;
+        transform: translateY(0);
+        }
+        to {
+        opacity: 0;
+        transform: translateY(20px);
+        }
+    }
+
+    .notificationsPanel{
+        max-width: 50em;
+        align-items: flex-end;
+        position: fixed;
+        bottom: 1rem;
+        right: 1rem;
+        display: flex;
+        flex-direction: column;
+        gap: 0.5rem;
+        z-index: 1000;
+    }
+</style>

frontend/src/components/General/Toggle.svelte

@@ -0,0 +1,113 @@
+<!-- Create a toggle button -->
+
+<script lang=ts>
+    import { createEventDispatcher, onDestroy } from 'svelte';
+    import {colors} from '../../stores.js';
+    import Tooltip from './Tooltip.svelte';
+    import { _ } from 'svelte-i18n'
+
+    export let icon = "" // The icon wanted 
+    export let width = "10em" // The button width
+    export let height = "5em" // The button height
+    export let tooltip = "Default tooltip" // The description shown in the tooltip
+    export let checked = false
+
+    let tooltipMessage = tooltip
+
+    $: cssVarStyles = `--thumb-background:${$colors.second};--thumb-background-selected:${$colors.third};--thumb-color:${$colors.fourth}`;
+       
+    // Emit a click event when the button is clicked
+    const dispatch = createEventDispatcher();
+    function emitClick(event) {
+        event.preventDefault();
+        event.target.blur();
+        dispatch('click', event);
+    }
+
+    let tooltipPosition = {top: 0, left: 0}
+
+    // Show a tooltip on mouse hover
+    let tooltipShowing = false
+    let buttonRef
+    function toggleTooltip(active){
+        const rect = buttonRef.getBoundingClientRect();
+        tooltipPosition = {
+            top: rect.bottom + 5, // Ajouter une marge en bas
+            left: rect.left, // Centrer horizontalement
+        };
+        tooltipShowing = active
+    }
+</script>
+
+<div class="container" style="{cssVarStyles}">
+    <label class="customToggle" bind:this={buttonRef}
+        on:mousedown={emitClick}
+        on:mouseenter={() => { toggleTooltip(true) }}
+        on:mouseleave={() => { toggleTooltip(false) }}
+        style="width:{width}; height:{height}; border-radius:{width}; background-color:{$colors.fourth};">
+        <input type="checkbox" {checked}>
+        <span class="checkmark" style="width: {height}; height: 100%; border-radius:{height};">
+            <i class='bx {icon}' style="font-size:{height};"/>
+        </span>
+    </label>
+    <Tooltip message={tooltipMessage} show={tooltipShowing} position={tooltipPosition}></Tooltip>
+</div>
+
+<style>
+    .container {
+        position: relative;
+        display: inline-block;
+    }
+    div{
+        display:inline-block;
+    }
+
+    .customToggle {
+            cursor: pointer;
+            overflow: hidden;
+            padding: 0.1em;
+    }
+
+    .customToggle:hover{
+        box-shadow: 1px 1px 3px 0px rgba(0, 0, 0, 0.25) inset;
+    }
+
+    .customToggle input[type="checkbox"] {
+        opacity: 0;
+        position: absolute; /* Position absolue pour garder l'élément dans le flux */
+        cursor: pointer;
+    }
+
+    .customToggle input[type="checkbox"]:checked + .checkmark {
+        background-color: var(--thumb-background-selected); /* Couleur lorsque la case est cochée */
+        float: right;
+        animation: checkmark-slide-in 0.2s cubic-bezier(0.68, -0.55, 0.27, 1.55) forwards;
+    }
+
+    @keyframes checkmark-slide-in {
+        0% {
+            transform: translateX(-50px) scale(1);
+            opacity: 1;
+        }
+        50% {
+            transform: translateX(0) scale(1);
+            opacity: 1;
+        }
+        70% {
+            transform: translateX(-5px) scale(1);
+            opacity: 1;
+        }
+        100% {
+            transform: translateX(0) scale(1);
+            opacity: 1;
+        }
+    }
+
+    .checkmark {
+        text-align:center;
+        float: left;
+        background-color: var(--thumb-background);
+        color: var(--thumb-color);
+        transition: opacity 0.3s, transform 0.3s;
+    }
+</style>

frontend/src/components/General/Tooltip.svelte

@@ -0,0 +1,46 @@
+<script>
+    export let message = "Default tooltip"
+    export let show = false
+    export let position = { top: 0, left: 0 }
+    export let duration = 3000
+
+    import {colors} from '../../stores.js';
+    import { onDestroy } from 'svelte';
+
+    let tooltipTimeout
+    $:{
+        if (show) {
+            tooltipTimeout = setTimeout(() => {
+                show = false
+            }, duration)
+        } else {
+            clearTimeout(tooltipTimeout)
+        }
+    }
+</script>
+
+<div class="tooltip {show ? 'visible' : ''}" style="background-color:{$colors.fourth}; top: {position.top}px; left: {position.left}px;">
+    <p style="color:{$colors.first};">{message}</p>
+</div>
+
+<style>
+    .tooltip {
+        position: fixed;
+        border-radius: 0.5em;
+        white-space: nowrap;
+        z-index: 100;
+        visibility: hidden;
+        opacity: 0;
+        transition: opacity 0.2s, visibility 0.2s;
+    }
+
+    .tooltip.visible {
+        visibility: visible;
+        opacity: 1;
+    }
+
+    p{
+        margin:5px;
+        font-size: 13px;
+    }
+</style>

frontend/src/components/NavigationBar.svelte

@@ -1,72 +0,0 @@
-<script>
-    import RoundIconButton from './RoundIconButton.svelte';
-    import { createEventDispatcher, onDestroy } from 'svelte';
-    import * as SoftwareVariables from '../stores.js';
-    import { _ } from 'svelte-i18n'
-
-    // Import the main colors from the store
-    let firstColor, secondColor, thirdColor, fourthColor, okColor, nokColor
-    const unsubscribeFirstColor = SoftwareVariables.firstColor.subscribe((value) => (firstColor = value));
-    const unsubscribeSecondColor = SoftwareVariables.secondColor.subscribe((value) => (secondColor = value));
-    const unsubscribeThirdColor = SoftwareVariables.thirdColor.subscribe((value) => (thirdColor = value));
-    const unsubscribeFourthColor = SoftwareVariables.fourthColor.subscribe((value) => (fourthColor = value));
-    const unsubscribeOkColor = SoftwareVariables.okColor.subscribe((value) => (okColor = value));
-    const unsubscribeNokColor = SoftwareVariables.nokColor.subscribe((value) => (nokColor = value));
-
-    //---Navigation System---//
-
-    let menuStates = {
-        stage: true,
-        atmo: false,
-        devicesLibrary: false,
-        settings: false
-    };
-
-    // Handle the click on a navigation button
-    function handleNavigation(menu) {
-        emitNavigationEvent(menu);
-        deselectMenus();
-        menuStates[menu] = true;
-    }
-
-    // Deselect all menus from the navigation bar
-    function deselectMenus(){
-        for (const menu in menuStates) {
-            menuStates[menu] = false;
-        }
-    }
-
-    // Emit navigation events
-    const dispatch = createEventDispatcher();
-    function emitNavigationEvent(menu) {
-        dispatch('navigationChanged', {
-            menu: menu
-        });
-    }
-
-    // Unsubscribe for all variables used from the store
-    onDestroy(() => {
-        unsubscribeFirstColor();
-        unsubscribeSecondColor();
-        unsubscribeThirdColor();
-        unsubscribeFourthColor();
-        unsubscribeOkColor();
-        unsubscribeNokColor();
-    })
-</script>
-
-<div style="background-color: {secondColor};">
-    <RoundIconButton id="stageMenu" on:click="{() => handleNavigation("stage")}" icon="bx-shape-square" width="2.5em" tooltip="{$_("stageMenuTooltip")}" active={menuStates.stage}></RoundIconButton>
-    <RoundIconButton id="atmoMenu" on:click="{() => handleNavigation("atmo")}" icon="bxl-deezer" width="2.5em" tooltip="{$_("atmoMenuTooltip")}" active={menuStates.atmo}></RoundIconButton>
-    <RoundIconButton id="devicesLibraryMenu" on:click="{() => handleNavigation("devicesLibrary")}" icon="bx-hdd" width="2.5em" tooltip={$_("devicesLibraryMenuTooltip")} active={menuStates.devicesLibrary}></RoundIconButton>
-    <RoundIconButton id="settingsMenu" on:click="{() => handleNavigation("settings")}" icon="bx-cog" width="2.5em" tooltip={$_("settingsMenuTooltip")} active={menuStates.settings}></RoundIconButton>
-    <RoundIconButton icon="bx-broadcast" width="2.5em" tooltip="{$_("dmxBoxStatusTooltip")}" operationalStatus=false okStatusLabel="{$_("dmxBoxOkStatusTooltip")}" nokStatusLabel="{$_("dmxBoxNokStatusTooltip")}"></RoundIconButton>
-</div>
-
-<style>
-    div {
-        display: inline-block;
-        padding: 4px;
-        border-radius: 40px;
-    }
-</style>

frontend/src/components/Preparation/Preparation.svelte

@@ -0,0 +1 @@
+<h1>Show preparation</h1>

frontend/src/components/Settings.svelte

@@ -1 +0,0 @@
-<h1>Settings</h1>

frontend/src/components/Settings/DeviceCard.svelte

@@ -0,0 +1,134 @@
+<script lang=ts>
+    import {colors} from '../../stores.js';
+    import InfoButton from "../General/InfoButton.svelte";
+    import { _ } from 'svelte-i18n'
+    import { createEventDispatcher } from 'svelte';
+    import Input from "../General/Input.svelte";
+
+    export let title = 'Default card';
+    export let type = '';
+    export let location = '';
+    export let line1 = '';
+    export let line2 = '';
+    export let removable = false;
+    export let addable = false;
+    export let signalizable = false;
+    export let signalized = false;
+    export let selected = false;
+    export let status = "PERIPHERAL_DISCONNECTED";
+
+    // Emit a delete event when the device is being removed
+    const dispatch = createEventDispatcher();
+    function remove(event){
+        dispatch('delete')
+    }
+    
+    function add(event){
+        dispatch('add')
+    }
+
+    function click(){
+        dispatch('click')
+    }
+
+    function dblclick(){
+        dispatch('dblclick')
+    }
+
+</script>
+
+<div class="card" on:dblclick={dblclick}>
+    <div class="{selected ? "selected" : "unselected"} {status == "PERIPHERAL_CONNECTING" ? "waiting" : ""}" on:mousedown={click} style="color: {$colors.white};">
+        <div style="z-index: 1;">
+            <p>{#if status == "PERIPHERAL_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>
+            {#if status == "PERIPHERAL_DISCONNECTED"}
+                <h6><b>Disconnected</b></h6>
+            {:else}
+                <h6>{line1}</h6>
+                <h6>{line2}</h6>
+            {/if}
+        </div>
+        
+        <div class="actions">
+            <InfoButton on:click={add} color="{(status == "PERIPHERAL_DISCONNECTED") ? $colors.first : $colors.white}" style="margin: 0.2em; display: { addable ? 'flex' : 'none' }" icon='bxs-message-square-add' interactive message={$_("projectHardwareAddTooltip")}/>
+            <InfoButton on:click={remove} color="{$colors.white}" style="margin: 0.2em; display: { removable ? 'flex' : 'none' }" icon='bx-trash' interactive message={$_("projectHardwareDeleteTooltip")}/>
+            <InfoButton style="transition: background-color 0.3s ease; margin: 0.2em; display: { (status == "PERIPHERAL_ACTIVATED" || status == "PERIPHERAL_DEACTIVATED")  ? 'flex' : 'none' }" background={ (signalizable && signalized) ? $colors.orange : (status == "PERIPHERAL_ACTIVATED") ? $colors.ok : (status == "PERIPHERAL_DEACTIVATED") ? $colors.nok : null} icon='bx-pulse' hide={!signalizable}/>
+        </div>
+    </div>
+</div>
+
+<style>
+    .unselected:hover{
+        background: linear-gradient(to bottom right, var(--second-color), var(--third-color));
+    }
+    .card{
+        position: relative;
+    }
+    .selected {
+        background-color: var(--third-color);
+        position: relative;
+        margin: 0.2em;
+        padding: 0.2em 0.3em 0.5em 0.5em;
+        border-radius: 0.5em;
+        display: flex;
+        justify-content: space-between;
+        text-align: left;
+        cursor: pointer;
+        overflow: hidden;
+    }
+    .unselected{
+        background-color: var(--second-color);
+        position: relative;
+        margin: 0.2em;
+        padding: 0.2em 0.3em 0.5em 0.5em;
+        border-radius: 0.5em;
+        display: flex;
+        justify-content: space-between;
+        text-align: left;
+        cursor: pointer;
+        overflow: hidden;
+    }
+
+    .subtitle{
+        margin-bottom: 0.5em;
+    }
+    .actions {
+        margin-left: 0.2em;
+        z-index: 2;
+    }
+    p{
+        margin: 0;
+    }
+    h6 {
+        margin: 0;
+        font-weight: 1;
+    }
+
+    .waiting::before{
+        content: '';
+        position: absolute;
+        background: linear-gradient(var(--first-color), var(--second-color));
+        width: 100%;
+        height: 60%;
+        animation: rotate 3s linear infinite;
+    }
+
+    .waiting::after{
+        content: '';
+        position: absolute;
+        background: var(--second-color);
+        inset: 2px;
+        border-radius: 0.2em;
+    }
+
+    /* Définition de l'animation */
+    @keyframes rotate {
+        from {
+            transform: rotate(0deg); /* Début de la rotation */
+        }
+        to {
+            transform: rotate(360deg); /* Fin de la rotation */
+        }
+    }
+</style>

frontend/src/components/Settings/InputsOutputsContent.svelte

@@ -0,0 +1,171 @@
+<script lang=ts>
+    import DeviceCard from "./DeviceCard.svelte";
+    import Input from "../General/Input.svelte";
+    import { t, _ } from 'svelte-i18n'
+    import { generateToast, needProjectSave, peripherals, colors } from "../../stores";
+    import { get } from "svelte/store"
+    import { UpdatePeripheralSettings, GetPeripheralSettings, RemovePeripheral, AddPeripheral } from "../../../wailsjs/go/main/App";
+    import RoundedButton from "../General/RoundedButton.svelte";
+
+    // Add the peripheral to the project
+    function addPeripheral(peripheral){
+        // Add the peripheral to the project (backend)
+        AddPeripheral(peripheral)
+            .catch((error) => {
+            console.log("Unable to add the peripheral to the project: " + error)
+            generateToast('danger', 'bx-error', $_("addPeripheralErrorToast"))
+        })
+    }
+
+    // Remove the peripheral from the project
+    function removePeripheral(peripheral) {
+        // Delete the peripheral from the project (backend)
+        RemovePeripheral(peripheral)       
+        .catch((error) => {
+            console.log("Unable to remove the peripheral from the project: " + error)
+            generateToast('danger', 'bx-error', $_("removePeripheralErrorToast"))
+        })
+    }
+
+    // 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.isSaved){
+            GetPeripheralSettings(peripheral.ProtocolName, peripheral.SerialNumber).then((peripheralSettings) => {
+                selectedPeripheralSettings = peripheralSettings
+                // Select the current peripheral
+                selectedPeripheralSN = peripheral.SerialNumber
+            }).catch((error) => {
+                console.log("Unable to get the peripheral settings: " + error)
+                generateToast('danger', 'bx-error', $_("getPeripheralSettingsErrorToast"))
+            })
+        }
+    }
+
+    // Unselect the peripheral if it is disconnected
+    $: {
+        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)
+        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 class="libraryPanel">
+        <div class="availableHardware">
+            <p style="color: var(--white-color);"><i class='bx bxs-plug'></i> {$_("projectHardwareDetectedLabel")}</p>
+        </div>
+        {#each Object.entries($peripherals) as [serialNumber, peripheral]}
+            {#if peripheral.isDetected}
+                <DeviceCard on:add={() => addPeripheral(peripheral)} on:dblclick={() => {
+                    if(!peripheral.isSaved) 
+                        addPeripheral(peripheral) 
+                    }}
+                    status="PERIPHERAL_CONNECTED" title={peripheral.Name} type={peripheral.ProtocolName} location={peripheral.Location ? peripheral.Location : ""} line1={"S/N: " + peripheral.SerialNumber} addable={!peripheral.isSaved}/>
+            {/if}
+        {/each}
+        <div class="availableHardware">
+            <p style="color: var(--white-color);"><i class='bx bxs-network-chart' ></i> {$_("projectHardwareOthersLabel")}</p> 
+        </div>
+        <DeviceCard on:add={() => addPeripheral({Name: "OS2L virtual device", ProtocolName: "OS2L", SerialNumber: ""})}
+            on:dblclick={() => addPeripheral({Name: "OS2L virtual device", ProtocolName: "OS2L", SerialNumber: ""})}
+            status="PERIPHERAL_CONNECTED" title={"OS2L virtual device"} type={"OS2L"} location={""} addable={true}/>
+    </div>
+
+    <div style="padding: 0.5em; flex:2; width:100%;">
+        <p style="margin-bottom: 1em;">{$_("projectHardwareSavedLabel")}</p>
+        <div class="configuredHardware">
+            {#if savedPeripheralNumber > 0}    
+                {#each Object.entries($peripherals) as [serialNumber, peripheral]}
+                    {#if peripheral.isSaved}
+                        <DeviceCard status="{peripheral.status}" on:delete={() => removePeripheral(peripheral)} on:dblclick={() => removePeripheral(peripheral)} on:click={() => selectPeripheral(peripheral)}
+                        title={peripheral.Name} type={peripheral.ProtocolName} location={peripheral.Location ? peripheral.Location : ""} line1={peripheral.SerialNumber ? "S/N: " + peripheral.SerialNumber : ""} selected={serialNumber == selectedPeripheralSN} removable signalizable signalized={peripheral.eventEmitted}/>
+                    {/if}
+                {/each}
+            {:else}              
+                <i>{$_("projectHardwareEmptyLabel")}</i>
+            {/if}    
+        </div>
+        <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}
+            {/if}   
+        </div>
+    </div>
+</div>
+
+<style>
+    .peripheralSetting{
+        margin: 0.5em;
+    }
+    .flexSettings{
+        display: flex;
+        flex-wrap: wrap;
+        width: 100%;
+        overflow-y: auto;
+    }
+
+    p {
+        margin: 0;
+    }
+    .hardware {
+        display: flex;
+        width: 100%;
+    }
+    .availableHardware {
+        background-color: var(--second-color);
+        border-radius: 0.5em;
+        padding: 0.2em;
+        max-height: calc(100vh - 300px);
+        margin-top: 0.5em;
+        margin-bottom: 0.5em; 
+    }
+
+    .libraryPanel {
+        padding: 0.5em;
+        /* width: 13em; */
+        height: calc(100vh - 2*8px - 2*4px - 40px - 1em - 2*0.1em - 2*0.1em - 2*0.4em - 21.6px - 2*0.5em);
+        overflow: auto;
+        scrollbar-width: none;
+        -ms-overflow-style: none;
+    }
+    .libraryPanel::-webkit-scrollbar {
+        display: none; /* Chrome, Safari, Edge */
+    }
+    
+    .configuredHardware {
+        display: flex;
+        flex-wrap: wrap;
+    }
+</style>

frontend/src/components/Settings/ProjectPropertiesContent.svelte

@@ -0,0 +1,51 @@
+<script lang=ts>
+    import { set_data_contenteditable } from 'svelte/internal';
+    import { ChooseAvatarPath, UpdateShowInfo } from '../../../wailsjs/go/main/App.js';
+    import { showInformation, needProjectSave } from '../../stores.js';
+    import Input from "../General/Input.svelte";
+    import RoundedButton from '../General/RoundedButton.svelte';
+    import { _ } from 'svelte-i18n'
+
+    // Choose the avatar path
+    function chooseAvatar(){
+        ChooseAvatarPath().then((avatarPath) => {
+            $showInformation["Avatar"] = avatarPath
+            UpdateShowInfo($showInformation).then(()=> {
+                $needProjectSave = true
+            })
+        }).catch((error) => {
+            console.error(`An error occured: ${error}`)
+        })
+    }
+
+    // Validate the project information
+    function validate(field, value){
+        $showInformation[field] = value
+        console.log($showInformation)
+        UpdateShowInfo($showInformation).then(()=> {
+            $needProjectSave = true
+        })
+    }
+</script>
+
+<div class='flexSettings'>
+    <div>
+        <Input on:blur={(event) => validate("Name", event.detail.target.value)} label={$_("projectShowNameLabel")} type='text' value={$showInformation.Name}/>
+        <Input on:blur={(event) => validate("Date", event.detail.target.value)} label={$_("projectShowDateLabel")} type='datetime-local' value={$showInformation.Date}/>
+    </div>
+    <div>
+        <Input on:dblclick={chooseAvatar} label={$_("projectAvatarLabel")} type='image' alt={$_("projectAvatarLabel")} width='11em' src={$showInformation.Avatar}/>
+    </div>
+</div>
+<div>
+    <Input on:blur={(event) => validate("Comments", event.detail.target.value)} label={$_("projectCommentsLabel")} type='large' width='100%' value={$showInformation.Comments}/>
+</div>
+
+<style>
+    .flexSettings{
+        display: flex;
+        flex-wrap: wrap;
+        width: 100%;
+        justify-content: space-between;
+    }
+</style>

frontend/src/components/Settings/Settings.svelte

@@ -0,0 +1,18 @@
+<script lang=ts>
+    import ProjectPropertiesContent from "./ProjectPropertiesContent.svelte";
+    import InputsOutputsContent from "./InputsOutputsContent.svelte";
+    import Tab from "../General/Tab.svelte";
+    import { _ } from 'svelte-i18n'
+
+    const tabs = [
+        { title: $_("projectPropertiesTab"), icon: 'bxs-info-circle', tooltip: $_("projectPropertiesTooltip"), component: ProjectPropertiesContent },
+        { title: $_("projectInputOutputTab"), icon: 'bxs-plug', tooltip: $_("projectInputOutputTooltip"), component: InputsOutputsContent },
+    ];
+
+</script>
+
+<!-- Project tabcontrol -->
+<Tab { tabs }/>
+
+<style>
+</style>

frontend/src/components/Show/Show.svelte

@@ -0,0 +1 @@
+<h1>Show mapping</h1>

frontend/src/components/Stage.svelte

@@ -1,17 +0,0 @@
-<div id="background"></div>
-<h1>Stage</h1>
-
-
-<style>
-     #background {
-        background-image: url('../assets/images/stage_background.png');
-        background-size: cover;
-        background-position: center;
-        height: 100%;
-        width: 100%;
-        position: absolute;
-        top: 0;
-        left: 0;
-        z-index: -1;
-    }
-</style>

frontend/src/components/Tooltip.svelte

@@ -1,44 +0,0 @@
-<script>
-    export let message = "Default tooltip"
-    export let show = false
-
-    import * as SoftwareVariables from '../stores.js';
-    import { onDestroy } from 'svelte';
-
-    // Import the main colors from the store
-    let firstColor, fourthColor
-    const unsubscribeFirstColor = SoftwareVariables.firstColor.subscribe((value) => (firstColor = value));
-    const unsubscribeFourthColor = SoftwareVariables.fourthColor.subscribe((value) => (fourthColor = value));
-
-    let mustBeDisplayed = "none"
-    $: {
-        if (show === true){
-            mustBeDisplayed = "inline-block"
-        } else {
-            mustBeDisplayed = "none"
-        }
-    }
-
-    // Unsubscribe for all variables used from the store
-    onDestroy(() => {
-        unsubscribeFirstColor();
-        unsubscribeFourthColor();
-    })
-</script>
-
-<div style="background-color:{fourthColor}; display:{mustBeDisplayed}">
-    <p style="color:{firstColor};">{message}</p>
-</div>
-
-<style>
-    div {
-        position: absolute;
-        border-radius: 15px;
-        transform: translate(0, 200%);
-    }
-
-    p{
-        margin:5px;
-        font-size: 10px;
-    }
-</style>

frontend/src/lang/en.json

@@ -1,9 +1,65 @@
 {
-  "stageMenuTooltip": "Stage configuration",
-  "atmoMenuTooltip": "Atmosphere effects",
-  "devicesLibraryMenuTooltip": "Devices library",
-  "settingsMenuTooltip": "Software settings",
-  "dmxBoxStatusTooltip": "DMXBox status:",
-  "dmxBoxOkStatusTooltip": "connected",
-  "dmxBoxNokStatusTooltip": "disconnected"
+  "settingsMenuTooltip": "Project settings",
+  "devicesMenuTooltip": "Devices configuration",
+  "preparationMenuTooltip": "Show preparation",
+  "animationMenuTooltip": "Animation creator",
+  "showMenuTooltip": "Show mapping",
+  "consoleMenuTooltip": "General console",
+  "stageRenderingToggleTooltip": "Show/hide the rendering view",
+  "showActivationToggleTooltip": "Activate/Deactivate the play mode",
+  "saveButtonTooltip": "Save the project",
+  
+  "newProjectString": "New",
+  "newProjectTooltip": "Create a new project",
+  "openProjectString": "Open",
+  "openProjectTooltip": "Open an existing project",
+  "openProjectEmpty": "No project found",
+  "unsavedProjectFlag": "unsaved",
+  "projectPropertiesTab": "Project properties",
+  "projectPropertiesTooltip": "The project properties",
+  "projectInputOutputTab": "Hardware",
+  "projectInputOutputTooltip": "The input/output hardware definition",
+  
+  "projectShowNameLabel": "Show name",
+  "projectShowDateLabel": "Show date",
+  "projectSaveLabel": "Save name",
+  "projectRenameButton": "Rename",
+  "projectRenameTooltip": "Rename the project file",
+  "projectUniversesLabel": "Number of DMX universes",
+  "projectAvatarLabel": "Show avatar",
+  "projectAvatarTooltip": "Load a new show avatar",
+  "projectCommentsLabel": "Comments",
+  "projectCommentsPlaceholder": "Leave your comments here",
+  "projectLoadAvatarButton": "Load a new avatar",
+
+  "projectHardwareShowLabel" : "My Show",
+  "projectHardwareInputsLabel": "INPUTS",
+  "projectHardwareOutputsLabel": "OUTPUTS",
+  "projectHardwareDeleteTooltip": "Delete",
+  "projectHardwareAddTooltip": "Add to project",
+  "projectHardwareNoSelection": "Empty",
+  "projectHardwareSavedLabel": "Saved in project",
+  "projectHardwareDetectedLabel": "Detected",
+  "projectHardwareOthersLabel": "Others",
+  "projectHardwareEmptyLabel": "No hardware saved for this project",
+
+  "peripheralArrivalToast": "Peripheral inserted:",
+  "peripheralRemovalToast": "Peripheral removed:",
+  "projectSavedToast": "The project has been saved",
+  "projectSaveErrorToast": "Unable to save the project:",
+  "addPeripheralErrorToast": "Unable to add this peripheral to project",
+  "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",
+  "projectCreateErrorToast": "Unable to create the project",
+  "peripheralSettingSaveErrorToast": "Unable to save the peripheral settings",
+
+  "os2lIp": "OS2L server IP",
+  "os2lPort": "OS2L server port"
+
 }

frontend/src/main.js

@@ -1,5 +1,10 @@
 import App from './App.svelte';
 
+import { WindowSetTitle } from "../wailsjs/runtime/runtime"
+import { _ } from 'svelte-i18n'
+
+import {messages, showInformation, needProjectSave} from './stores.js';
+
 // Load dictionaries
 import { addMessages, init } from 'svelte-i18n';
 
@@ -13,7 +18,7 @@ addMessages('en', en);
 init({
 	fallbackLocale: 'en',
 	initialLocale: 'en',
-  });
+});
 
 // Create the main app
 const app = new App({

frontend/src/runtime-events.js

@@ -0,0 +1,201 @@
+import { EventsOn, EventsOff } from "../wailsjs/runtime/runtime.js"
+import { peripherals, generateToast, needProjectSave, showInformation } from './stores'
+import { get } from "svelte/store"
+import { _ } from 'svelte-i18n'
+
+// New peripheral has been added to the system
+function peripheralArrival (peripheralInfo){
+    // If not exists, add it to the map
+    // isDetected key to true
+
+    peripherals.update((storedPeripherals) => {
+        return {
+        ...storedPeripherals,
+        [peripheralInfo.SerialNumber]: {
+            ...storedPeripherals[peripheralInfo.SerialNumber],
+            Name: peripheralInfo.Name,
+            ProtocolName: peripheralInfo.ProtocolName,
+            SerialNumber: peripheralInfo.SerialNumber,
+            Settings: peripheralInfo.Settings,
+            isDetected: true,
+        },
+    }})
+    console.log("Hardware has been added to the system");
+    generateToast('info', 'bxs-hdd', get(_)("peripheralArrivalToast") + ' <b>' + peripheralInfo.Name + '</b>')
+}
+
+// Peripheral is removed from the system
+function peripheralRemoval (peripheralInfo){
+    // If not exists, add it to the map
+    // isDetected key to false
+
+    peripherals.update((storedPeripherals) => {
+        return {
+        ...storedPeripherals,
+        [peripheralInfo.SerialNumber]: {
+            ...storedPeripherals[peripheralInfo.SerialNumber],
+            Name: peripheralInfo.Name,
+            ProtocolName: peripheralInfo.ProtocolName,
+            SerialNumber: peripheralInfo.SerialNumber,
+            Settings: peripheralInfo.Settings,
+            isDetected: false,
+            status: "PERIPHERAL_DISCONNECTED",
+        },
+    }})
+    console.log("Hardware has been removed from the system");
+    generateToast('warning', 'bxs-hdd', get(_)("peripheralRemovalToast") + ' <b>' + peripheralInfo.Name + '</b>')
+}
+
+// Update peripheral status
+function peripheralUpdateStatus(peripheralInfo, status){
+    // If not exists, add it to the map
+    // change status key
+
+    peripherals.update((storedPeripherals) => {
+        console.log(status)
+        return {
+        ...storedPeripherals,
+        [peripheralInfo.SerialNumber]: {
+            ...storedPeripherals[peripheralInfo.SerialNumber],
+            Name: peripheralInfo.Name,
+            ProtocolName: peripheralInfo.ProtocolName,
+            SerialNumber: peripheralInfo.SerialNumber,
+            Settings: peripheralInfo.Settings,
+            status: status,
+        },
+    }})
+
+    console.log("Hardware status has been updated to " + status);
+}
+
+// Load the peripheral in the project
+function loadPeripheral (peripheralInfo) {
+    // If not exists, add it to the map
+    // isSaved key to true
+
+    peripherals.update((storedPeripherals) => {
+        return {
+        ...storedPeripherals,
+        [peripheralInfo.SerialNumber]: {
+            ...storedPeripherals[peripheralInfo.SerialNumber],
+            Name: peripheralInfo.Name,
+            ProtocolName: peripheralInfo.ProtocolName,
+            SerialNumber: peripheralInfo.SerialNumber,
+            Settings: peripheralInfo.Settings,
+            isSaved: true,
+        },
+    }})
+    console.log("Hardware has been added to the project");
+    //TODO: Lors d'un chargement/déchargement natif au démarrage, il ne doit pas y avoir de nécessité de sauvegarder
+    needProjectSave.set(true)
+}
+
+function loadProject (showInfo){
+        // Store project information
+        showInformation.set(showInfo)
+
+        console.log("Project has been opened");
+        generateToast('info', 'bx-folder-open', get(_)("projectOpenedToast") + ' <b>' + showInfo.Name + '</b>')
+}
+
+// Unload the hardware from the project
+function unloadPeripheral (peripheralInfo) {
+    // If not exists, add it to the map
+    // isSaved key to false
+
+    peripherals.update((storedPeripherals) => {
+        return {
+        ...storedPeripherals,
+        [peripheralInfo.SerialNumber]: {
+            ...storedPeripherals[peripheralInfo.SerialNumber],
+            Name: peripheralInfo.Name,
+            ProtocolName: peripheralInfo.ProtocolName,
+            SerialNumber: peripheralInfo.SerialNumber,
+            Settings: peripheralInfo.Settings,
+            isSaved: false,
+        },
+    }})
+    console.log("Hardware has been removed from the project");
+    //TODO: Lors d'un chargement/déchargement natif au démarrage, il ne doit pas y avoir de nécessité de sauvegarder
+    needProjectSave.set(true)
+}
+
+// A peripheral event has been emitted
+function onPeripheralEvent(sn, event) {
+    // If not exists, add it to the map
+    // eventEmitted key to true for 0.2 sec 
+
+    peripherals.update((storedPeripherals) => {
+        return {
+        ...storedPeripherals,
+        [sn]: {
+            ...storedPeripherals[sn],
+            eventEmitted: true
+        },
+    }})
+
+    setTimeout(() => {
+      peripherals.update((storedPeripherals) => {
+        return {
+        ...storedPeripherals,
+        [sn]: {
+            ...storedPeripherals[sn],
+            eventEmitted: false
+        },
+    }})
+    }, 200);
+}
+
+let initialized = false
+
+export function initRuntimeEvents(){
+    if (initialized) return
+    initialized = true
+
+    // Handle the event when a new peripheral is detected
+    EventsOn('PERIPHERAL_ARRIVAL', peripheralArrival)
+
+    // Handle the event when a peripheral is removed from the system
+    EventsOn('PERIPHERAL_REMOVAL', peripheralRemoval)
+
+    // Handle the event when a peripheral status is updated
+    EventsOn('PERIPHERAL_STATUS', peripheralUpdateStatus)
+
+    // Handle the event when a new project need to be loaded
+    EventsOn('LOAD_PROJECT', loadProject)
+
+    // Handle a peripheral loaded in the project
+    EventsOn('LOAD_PERIPHERAL', loadPeripheral)
+
+    // Handle a peripheral unloaded from the project
+    EventsOn('UNLOAD_PERIPHERAL', unloadPeripheral)
+
+    // Handle a peripheral event
+    EventsOn('PERIPHERAL_EVENT_EMITTED', onPeripheralEvent)
+}
+
+export function destroyRuntimeEvents(){
+    if (!initialized) return
+    initialized = false
+
+    // Handle the event when a new peripheral is detected
+    EventsOff('PERIPHERAL_ARRIVAL')
+
+    // Handle the event when a peripheral is removed from the system
+    EventsOff('PERIPHERAL_REMOVAL')
+
+    // Handle the event when a peripheral status is updated
+    EventsOff('PERIPHERAL_STATUS')
+
+    // Handle the event when a new project need to be loaded
+    EventsOff('LOAD_PROJECT')
+
+    // Handle a peripheral loaded in the project
+    EventsOff('LOAD_PERIPHERAL')
+
+    // Handle a peripheral unloaded from the project
+    EventsOff('UNLOAD_PERIPHERAL')
+
+    // Handle a peripheral event
+    EventsOff('PERIPHERAL_EVENT_EMITTED')
+}

frontend/src/stores.js

@@ -1,14 +1,49 @@
 import { writable } from 'svelte/store';
 
-// Colors defined in the software
-export const firstColor = writable("#1B262C");
-export const secondColor = writable("#0F4C75");
-export const thirdColor = writable("#3282B8");
-export const fourthColor = writable("#BBE1FA");
-export const okColor = writable("#2BA646");
-export const nokColor = writable("#A6322B");
+// Projects management
+export let projectsList = writable([])
+export let needProjectSave = writable(true)
+
+// Show settings
+export let showInformation = writable({})
+
+// Toasts notifications
+export let messages = writable([])
+export function generateToast(type, icon, text){
+	messages.update((value) => {
+		value.push( { id: Date.now(), type: type, icon: icon, text: text } )
+		return value.slice(-5)
+	})
+}
+
+// Application colors
+export const colors = writable({
+    first: "#1B262C",
+    second: "#0F4C75",
+    third: "#3282B8",
+    fourth: "#BBE1FA",
+    ok: "#2BA646",
+    nok: "#A6322B",
+    white: "#FFFFFF",
+    orange: "#BC9714"
+})
 
 // Font sizes defined in the software
 export const firstSize = writable("10px")
 export const secondSize = writable("14px")
 export const thirdSize = writable("20px")
+
+// List of current hardware
+export let peripherals = writable({})
+
+// Peripheral structure :
+
+// 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
+
+// isSaved // if the peripheral is saved in the project
+// isDetected // if the peripheral is detected by the system
+// status // the status of connection
+// eventEmitted // if an event has been emitted for this peripheral (disappear after a delay)

frontend/src/style.css

@@ -1,7 +1,23 @@
+:root{
+  -webkit-user-select: none; /* Safari */
+  -ms-user-select: none; /* IE 10 and IE 11 */
+  user-select: none; /* Standard syntax */
+  --first-color: #1B262C;
+  --second-color: #0F4C75;
+  --third-color: #3282B8;
+  --fourth-color: #BBE1FA;
+  --ok-color: #2BA646;
+  --nok-color: #A6322B;
+  --white-color: #FFFFFF;
+  --orange-color: #BC9714;
+}
+
 html, body {
 	position: relative;
 	width: 100%;
 	height: 100%;
+	overflow-y: hidden;
+	overflow-x: hidden;
 }
 
 body {

go.mod

@@ -1,33 +1,44 @@
-module changeme
+module dmxconnect
 
-go 1.18
+go 1.21
 
-require github.com/wailsapp/wails/v2 v2.5.1
+toolchain go1.21.3
+
+require (
+	github.com/mattrtaylor/go-rtmidi v0.0.0-20220428034745-af795b1c1a79
+	github.com/pkg/errors v0.9.1
+	github.com/rs/zerolog v1.33.0
+	github.com/wailsapp/wails/v2 v2.9.1
+	gopkg.in/yaml.v2 v2.4.0
+)
 
 require (
 	github.com/bep/debounce v1.2.1 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
-	github.com/google/uuid v1.1.2 // indirect
+	github.com/godbus/dbus/v5 v5.1.0 // indirect
+	github.com/google/uuid v1.3.0 // indirect
 	github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e // indirect
-	github.com/labstack/echo/v4 v4.9.0 // indirect
-	github.com/labstack/gommon v0.3.1 // indirect
-	github.com/leaanthony/go-ansi-parser v1.0.1 // indirect
+	github.com/labstack/echo/v4 v4.10.2 // indirect
+	github.com/labstack/gommon v0.4.0 // indirect
+	github.com/leaanthony/go-ansi-parser v1.6.0 // indirect
 	github.com/leaanthony/gosod v1.0.3 // indirect
-	github.com/leaanthony/slicer v1.5.0 // indirect
-	github.com/mattn/go-colorable v0.1.11 // indirect
-	github.com/mattn/go-isatty v0.0.14 // indirect
-	github.com/pkg/browser v0.0.0-20210706143420-7d21f8c997e2 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
-	github.com/samber/lo v1.27.1 // indirect
-	github.com/tkrajina/go-reflector v0.5.5 // indirect
+	github.com/leaanthony/slicer v1.6.0 // indirect
+	github.com/leaanthony/u v1.1.0 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.19 // indirect
+	github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8 // indirect
+	github.com/rivo/uniseg v0.4.4 // indirect
+	github.com/samber/lo v1.38.1 // indirect
+	github.com/tkrajina/go-reflector v0.5.6 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
-	github.com/valyala/fasttemplate v1.2.1 // indirect
+	github.com/valyala/fasttemplate v1.2.2 // indirect
+	github.com/wailsapp/go-webview2 v1.0.10 // indirect
 	github.com/wailsapp/mimetype v1.4.1 // indirect
-	golang.org/x/crypto v0.1.0 // indirect
-	golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17 // indirect
-	golang.org/x/net v0.7.0 // indirect
-	golang.org/x/sys v0.5.0 // indirect
-	golang.org/x/text v0.7.0 // indirect
+	golang.org/x/crypto v0.23.0 // indirect
+	golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1 // indirect
+	golang.org/x/net v0.25.0 // indirect
+	golang.org/x/sys v0.20.0 // indirect
+	golang.org/x/text v0.15.0 // indirect
 )
 
 // replace github.com/wailsapp/wails/v2 v2.5.1 => /home/dev/go/pkg/mod

go.sum

@@ -1,61 +1,82 @@
 github.com/bep/debounce v1.2.1 h1:v67fRdBA9UQu2NhLFXrSg0Brw7CexQekrBwDMM8bzeY=
 github.com/bep/debounce v1.2.1/go.mod h1:H8yggRPQKLUhUoqrJC1bO2xNya7vanpDl7xR3ISbCJ0=
+github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
-github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y=
-github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk=
+github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e h1:Q3+PugElBCf4PFpxhErSzU3/PY5sFL5Z6rfv4AbGAck=
 github.com/jchv/go-winloader v0.0.0-20210711035445-715c2860da7e/go.mod h1:alcuEEnZsY1WQsagKhZDsoPCRoOijYqhZvPwLG0kzVs=
-github.com/labstack/echo/v4 v4.9.0 h1:wPOF1CE6gvt/kmbMR4dGzWvHMPT+sAEUJOwOTtvITVY=
-github.com/labstack/echo/v4 v4.9.0/go.mod h1:xkCDAdFCIf8jsFQ5NnbK7oqaF/yU1A1X20Ltm0OvSks=
-github.com/labstack/gommon v0.3.1 h1:OomWaJXm7xR6L1HmEtGyQf26TEn7V6X88mktX9kee9o=
-github.com/labstack/gommon v0.3.1/go.mod h1:uW6kP17uPlLJsD3ijUYn3/M5bAxtlZhMI6m3MFxTMTM=
+github.com/labstack/echo/v4 v4.10.2 h1:n1jAhnq/elIFTHr1EYpiYtyKgx4RW9ccVgkqByZaN2M=
+github.com/labstack/echo/v4 v4.10.2/go.mod h1:OEyqf2//K1DFdE57vw2DRgWY0M7s65IVQO2FzvI4J5k=
+github.com/labstack/gommon v0.4.0 h1:y7cvthEAEbU0yHOf4axH8ZG2NH8knB9iNSoTO8dyIk8=
+github.com/labstack/gommon v0.4.0/go.mod h1:uW6kP17uPlLJsD3ijUYn3/M5bAxtlZhMI6m3MFxTMTM=
 github.com/leaanthony/debme v1.2.1 h1:9Tgwf+kjcrbMQ4WnPcEIUcQuIZYqdWftzZkBr+i/oOc=
 github.com/leaanthony/debme v1.2.1/go.mod h1:3V+sCm5tYAgQymvSOfYQ5Xx2JCr+OXiD9Jkw3otUjiA=
-github.com/leaanthony/go-ansi-parser v1.0.1 h1:97v6c5kYppVsbScf4r/VZdXyQ21KQIfeQOk2DgKxGG4=
-github.com/leaanthony/go-ansi-parser v1.0.1/go.mod h1:7arTzgVI47srICYhvgUV4CGd063sGEeoSlych5yeSPM=
+github.com/leaanthony/go-ansi-parser v1.6.0 h1:T8TuMhFB6TUMIUm0oRrSbgJudTFw9csT3ZK09w0t4Pg=
+github.com/leaanthony/go-ansi-parser v1.6.0/go.mod h1:+vva/2y4alzVmmIEpk9QDhA7vLC5zKDTRwfZGOp3IWU=
 github.com/leaanthony/gosod v1.0.3 h1:Fnt+/B6NjQOVuCWOKYRREZnjGyvg+mEhd1nkkA04aTQ=
 github.com/leaanthony/gosod v1.0.3/go.mod h1:BJ2J+oHsQIyIQpnLPjnqFGTMnOZXDbvWtRCSG7jGxs4=
-github.com/leaanthony/slicer v1.5.0 h1:aHYTN8xbCCLxJmkNKiLB6tgcMARl4eWmH9/F+S/0HtY=
 github.com/leaanthony/slicer v1.5.0/go.mod h1:FwrApmf8gOrpzEWM2J/9Lh79tyq8KTX5AzRtwV7m4AY=
+github.com/leaanthony/slicer v1.6.0 h1:1RFP5uiPJvT93TAHi+ipd3NACobkW53yUiBqZheE/Js=
+github.com/leaanthony/slicer v1.6.0/go.mod h1:o/Iz29g7LN0GqH3aMjWAe90381nyZlDNquK+mtH2Fj8=
+github.com/leaanthony/u v1.1.0 h1:2n0d2BwPVXSUq5yhe8lJPHdxevE2qK5G99PMStMZMaI=
+github.com/leaanthony/u v1.1.0/go.mod h1:9+o6hejoRljvZ3BzdYlVL0JYCwtnAsVuN9pVTQcaRfI=
 github.com/matryer/is v1.4.0 h1:sosSmIWwkYITGrxZ25ULNDeKiMNzFSr4V/eqBQP0PeE=
 github.com/matryer/is v1.4.0/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU=
-github.com/mattn/go-colorable v0.1.11 h1:nQ+aFkoE2TMGc0b68U2OKSexC+eq46+XwZzWXHRmPYs=
 github.com/mattn/go-colorable v0.1.11/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
-github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
-github.com/pkg/browser v0.0.0-20210706143420-7d21f8c997e2 h1:acNfDZXmm28D2Yg/c3ALnZStzNaZMSagpbr96vY6Zjc=
-github.com/pkg/browser v0.0.0-20210706143420-7d21f8c997e2/go.mod h1:HKlIX3XHQyzLZPlr7++PzdhaXEj94dEiJgZDTsxEqUI=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattrtaylor/go-rtmidi v0.0.0-20220428034745-af795b1c1a79 h1:CA1UHN3RuY70DlC0RlvgtB1e8h3kYzmvK7s8CFe+Ohw=
+github.com/mattrtaylor/go-rtmidi v0.0.0-20220428034745-af795b1c1a79/go.mod h1:oBuZjmjlKSj9CZKrNhcx/adNhHiiE0hZknECjIP8Z0Q=
+github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8 h1:KoWmjvw+nsYOo29YJK9vDA65RGE3NrOnUtO7a+RF9HU=
+github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8/go.mod h1:HKlIX3XHQyzLZPlr7++PzdhaXEj94dEiJgZDTsxEqUI=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/samber/lo v1.27.1 h1:sTXwkRiIFIQG+G0HeAvOEnGjqWeWtI9cg5/n51KrxPg=
-github.com/samber/lo v1.27.1/go.mod h1:it33p9UtPMS7z72fP4gw/EIfQB2eI8ke7GR2wc6+Rhg=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
+github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
+github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
+github.com/samber/lo v1.38.1 h1:j2XEAqXKb09Am4ebOg31SpvzUTTs6EN3VfgeLUhPdXM=
+github.com/samber/lo v1.38.1/go.mod h1:+m/ZKRl6ClXCE2Lgf3MsQlWfh4bn1bz6CXEOxnEXnEA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
-github.com/thoas/go-funk v0.9.1 h1:O549iLZqPpTUQ10ykd26sZhzD+rmR5pWhuElrhbC20M=
-github.com/tkrajina/go-reflector v0.5.5 h1:gwoQFNye30Kk7NrExj8zm3zFtrGPqOkzFMLuQZg1DtQ=
-github.com/tkrajina/go-reflector v0.5.5/go.mod h1:ECbqLgccecY5kPmPmXg1MrHW585yMcDkVl6IvJe64T4=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/tkrajina/go-reflector v0.5.6 h1:hKQ0gyocG7vgMD2M3dRlYN6WBBOmdoOzJ6njQSepKdE=
+github.com/tkrajina/go-reflector v0.5.6/go.mod h1:ECbqLgccecY5kPmPmXg1MrHW585yMcDkVl6IvJe64T4=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
-github.com/valyala/fasttemplate v1.2.1 h1:TVEnxayobAdVkhQfrfes2IzOB6o+z4roRkPF52WA1u4=
 github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo=
+github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+github.com/wailsapp/go-webview2 v1.0.10 h1:PP5Hug6pnQEAhfRzLCoOh2jJaPdrqeRgJKZhyYyDV/w=
+github.com/wailsapp/go-webview2 v1.0.10/go.mod h1:Uk2BePfCRzttBBjFrBmqKGJd41P6QIHeV9kTgIeOZNo=
 github.com/wailsapp/mimetype v1.4.1 h1:pQN9ycO7uo4vsUUuPeHEYoUkLVkaRntMnHJxVwYhwHs=
 github.com/wailsapp/mimetype v1.4.1/go.mod h1:9aV5k31bBOv5z6u+QP8TltzvNGJPmNJD4XlAL3U+j3o=
-github.com/wailsapp/wails/v2 v2.5.1 h1:mfG+2kWqQXYOwdgI43HEILjOZDXbk5woPYI3jP2b+js=
-github.com/wailsapp/wails/v2 v2.5.1/go.mod h1:jbOZbcr/zm79PxXxAjP8UoVlDd9wLW3uDs+isIthDfs=
-golang.org/x/crypto v0.1.0 h1:MDRAIl0xIo9Io2xV565hzXHw3zVseKrJKodhohM5CjU=
-golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw=
-golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17 h1:3MTrJm4PyNL9NBqvYDSj3DHl46qQakyfqfWo4jgfaEM=
-golang.org/x/exp v0.0.0-20220303212507-bbda1eaf7a17/go.mod h1:lgLbSvA5ygNOMpwM/9anMpWVlVJ7Z+cHWq/eFuinpGE=
+github.com/wailsapp/wails/v2 v2.9.1 h1:irsXnoQrCpeKzKTYZ2SUVlRRyeMR6I0vCO9Q1cvlEdc=
+github.com/wailsapp/wails/v2 v2.9.1/go.mod h1:7maJV2h+Egl11Ak8QZN/jlGLj2wg05bsQS+ywJPT0gI=
+golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
+golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
+golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1 h1:k/i9J1pBpvlfR+9QsetwPyERsqu1GIbi967PQMq3Ivc=
+golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w=
 golang.org/x/net v0.0.0-20210505024714-0287a6fb4125/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g=
-golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
+golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200810151505-1b9f1253b3ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -64,14 +85,21 @@ golang.org/x/sys v0.0.0-20210616045830-e2b7044e8c71/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211103235746-7861aae1554b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

hardware/FTDIFinder.go

@@ -0,0 +1,314 @@
+package hardware
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	goRuntime "runtime"
+	"sync"
+	"time"
+	"unsafe"
+
+	"github.com/rs/zerolog/log"
+	"github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+/*
+#include <stdlib.h>
+#cgo LDFLAGS: -L${SRCDIR}/../build/bin -ldetectFTDI
+#include "cpp/include/detectFTDIBridge.h"
+*/
+import "C"
+
+// FTDIFinder manages all the FTDI peripherals
+type FTDIFinder struct {
+	wg sync.WaitGroup
+	mu sync.Mutex
+
+	saved    map[string]PeripheralInfo  // Peripherals saved in the project
+	detected map[string]*FTDIPeripheral // Detected peripherals
+
+	scanEvery time.Duration // Scans peripherals periodically
+
+	onArrival func(p PeripheralInfo) // When a peripheral arrives
+	onRemoval func(p PeripheralInfo) // When a peripheral goes away
+}
+
+// NewFTDIFinder creates a new FTDI finder
+func NewFTDIFinder(scanEvery time.Duration) *FTDIFinder {
+	log.Trace().Str("file", "FTDIFinder").Msg("FTDI finder created")
+	return &FTDIFinder{
+		scanEvery: scanEvery,
+		saved:     make(map[string]PeripheralInfo),
+		detected:  make(map[string]*FTDIPeripheral),
+	}
+}
+
+// OnArrival is the callback function when a new peripheral arrives
+func (f *FTDIFinder) OnArrival(cb func(p PeripheralInfo)) {
+	f.onArrival = cb
+}
+
+// OnRemoval i the callback when a peripheral goes away
+func (f *FTDIFinder) OnRemoval(cb func(p PeripheralInfo)) {
+	f.onRemoval = cb
+}
+
+// RegisterPeripheral registers a new peripheral
+func (f *FTDIFinder) RegisterPeripheral(ctx context.Context, peripheralData PeripheralInfo) (string, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	f.saved[peripheralData.SerialNumber] = peripheralData
+	runtime.EventsEmit(ctx, string(PeripheralStatusUpdated), peripheralData, PeripheralStatusDisconnected)
+
+	// If already detected, connect it
+	if peripheral, ok := f.detected[peripheralData.SerialNumber]; ok {
+		f.wg.Add(1)
+		go func() {
+			defer f.wg.Done()
+			err := peripheral.Connect(ctx)
+			if err != nil {
+				log.Err(err).Str("file", "FTDIFinder").Str("peripheralSN", peripheralData.SerialNumber).Msg("unable to connect the peripheral")
+				return
+			}
+			// Peripheral connected, activate it
+			err = peripheral.Activate(ctx)
+			if err != nil {
+				log.Err(err).Str("file", "FTDIFinder").Str("peripheralSN", peripheralData.SerialNumber).Msg("unable to activate the FTDI peripheral")
+				return
+			}
+		}()
+	}
+
+	// Emits the event in the hardware
+	runtime.EventsEmit(ctx, "LOAD_PERIPHERAL", peripheralData)
+
+	return peripheralData.SerialNumber, nil
+}
+
+// UnregisterPeripheral unregisters an existing peripheral
+func (f *FTDIFinder) UnregisterPeripheral(ctx context.Context, peripheralData PeripheralInfo) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	if peripheral, detected := f.detected[peripheralData.SerialNumber]; detected {
+		// Deactivating peripheral
+		err := peripheral.Deactivate(ctx)
+		if err != nil {
+			log.Err(err).Str("sn", peripheralData.SerialNumber).Msg("unable to deactivate the peripheral")
+			return nil
+		}
+		// Disconnecting peripheral
+		err = peripheral.Disconnect(ctx)
+		if err != nil {
+			log.Err(err).Str("sn", peripheralData.SerialNumber).Msg("unable to disconnect the peripheral")
+			return nil
+		}
+	}
+	delete(f.saved, peripheralData.SerialNumber)
+	runtime.EventsEmit(ctx, "UNLOAD_PERIPHERAL", peripheralData)
+
+	return nil
+}
+
+// Initialize initializes the FTDI finder
+func (f *FTDIFinder) Initialize() error {
+	// Check platform
+	if goRuntime.GOOS != "windows" {
+		log.Error().Str("file", "FTDIFinder").Str("platform", goRuntime.GOOS).Msg("FTDI finder not compatible with your platform")
+		return fmt.Errorf("the FTDI finder is not compatible with your platform yet (%s)", goRuntime.GOOS)
+	}
+	log.Trace().Str("file", "FTDIFinder").Msg("FTDI finder initialized")
+	return nil
+}
+
+// Start starts the finder and search for peripherals
+func (f *FTDIFinder) Start(ctx context.Context) error {
+	f.wg.Add(1)
+	go func() {
+		ticker := time.NewTicker(f.scanEvery)
+		defer ticker.Stop()
+		defer f.wg.Done()
+
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-ticker.C:
+				// Scan the peripherals
+				err := f.scanPeripherals(ctx)
+				if err != nil {
+					log.Err(err).Str("file", "FTDIFinder").Msg("unable to scan FTDI peripherals")
+				}
+			}
+		}
+	}()
+	return nil
+}
+
+// ForceScan explicitly asks for scanning peripherals
+func (f *FTDIFinder) ForceScan() {
+	// select {
+	// case f.scanChannel <- struct{}{}:
+	// default:
+	// 	// Ignore if the channel is full or if it is closed
+	// }
+}
+
+// GetName returns the name of the driver
+func (f *FTDIFinder) GetName() string {
+	return "FTDI"
+}
+
+// GetPeripheralSettings gets the peripheral settings
+func (f *FTDIFinder) GetPeripheralSettings(peripheralID string) (map[string]interface{}, error) {
+	// Return the specified peripheral
+	peripheral, found := f.detected[peripheralID]
+	if !found {
+		// FTDI not detected, return the last settings saved
+		if savedPeripheral, isFound := f.saved[peripheralID]; isFound {
+			return savedPeripheral.Settings, nil
+		}
+		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.GetSettings(), nil
+}
+
+// SetPeripheralSettings sets the peripheral settings
+func (f *FTDIFinder) SetPeripheralSettings(ctx context.Context, peripheralID string, settings map[string]any) error {
+	// Return the specified peripheral
+	peripheral, found := f.detected[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
+func (f *FTDIFinder) scanPeripherals(ctx context.Context) error {
+	log.Trace().Str("file", "FTDIFinder").Msg("FTDI scan triggered")
+
+	count := int(C.get_peripherals_number())
+
+	log.Info().Int("number", count).Msg("number of FTDI devices connected")
+
+	// Allocating C array
+	size := C.size_t(count) * C.size_t(unsafe.Sizeof(C.FTDIPeripheralC{}))
+	devicesPtr := C.malloc(size)
+	defer C.free(devicesPtr)
+
+	devices := (*[1 << 20]C.FTDIPeripheralC)(devicesPtr)[:count:count]
+
+	C.get_ftdi_devices((*C.FTDIPeripheralC)(devicesPtr), C.int(count))
+
+	currentMap := make(map[string]PeripheralInfo)
+
+	for i := 0; i < count; i++ {
+		d := devices[i]
+
+		sn := C.GoString(d.serialNumber)
+		desc := C.GoString(d.description)
+		// isOpen := d.isOpen != 0
+
+		currentMap[sn] = PeripheralInfo{
+			SerialNumber: sn,
+			Name:         desc,
+			// IsOpen:       isOpen,
+			ProtocolName: "FTDI",
+		}
+
+		// Free C memory
+		C.free_ftdi_device(&d)
+	}
+
+	log.Info().Any("peripherals", currentMap).Msg("available FTDI peripherals")
+
+	// Detect arrivals
+	for sn, peripheralData := range currentMap {
+		if _, known := f.detected[sn]; !known {
+			peripheral := NewFTDIPeripheral(peripheralData)
+			f.detected[sn] = peripheral
+
+			if f.onArrival != nil {
+				f.onArrival(peripheralData)
+			}
+			log.Info().Str("sn", sn).Str("name", peripheralData.Name).Msg("[FTDI] New peripheral detected")
+
+			// If the peripheral is saved in the project => connect
+			if _, saved := f.saved[sn]; saved {
+				f.wg.Add(1)
+				go func(p PeripheralInfo) {
+					defer f.wg.Done()
+					err := peripheral.Connect(ctx)
+					if err != nil {
+						log.Err(err).Str("sn", p.SerialNumber).Msg("unable to connect the FTDI peripheral")
+						return
+					}
+					err = peripheral.Activate(ctx)
+					if err != nil {
+						log.Err(err).Str("sn", p.SerialNumber).Msg("unable to activate the FTDI peripheral")
+						return
+					}
+				}(peripheralData)
+			}
+		}
+	}
+
+	// Detect removals
+	for sn, oldPeripheral := range f.detected {
+		if _, still := currentMap[sn]; !still {
+
+			// Properly clean the DMX device
+			err := oldPeripheral.Deactivate(ctx)
+			if err != nil {
+				log.Err(err).Str("sn", sn).Msg("unable to deactivate the FTDI peripheral after disconnection")
+			}
+			err = oldPeripheral.Disconnect(ctx)
+			if err != nil {
+				log.Err(err).Str("sn", sn).Msg("unable to disconnect the FTDI peripheral after disconnection")
+			}
+
+			// Delete it from the detected list
+			delete(f.detected, sn)
+			log.Info().Str("sn", sn).Str("name", oldPeripheral.GetInfo().Name).Msg("[FTDI] peripheral removed")
+
+			// Execute the removal callback
+			if f.onRemoval != nil {
+				f.onRemoval(oldPeripheral.GetInfo())
+			}
+		}
+	}
+	return nil
+}
+
+// WaitStop stops the finder
+func (f *FTDIFinder) WaitStop() error {
+	log.Trace().Str("file", "FTDIFinder").Msg("stopping the FTDI finder...")
+
+	// Close the channel
+	// close(f.scanChannel)
+
+	// Wait for all the peripherals to close
+	log.Trace().Str("file", "FTDIFinder").Msg("closing all FTDI peripherals")
+	var errs []error
+	for registeredPeripheralSN, registeredPeripheral := range f.detected {
+		err := registeredPeripheral.WaitStop()
+		if err != nil {
+			errs = append(errs, fmt.Errorf("%s: %w", registeredPeripheralSN, err))
+		}
+	}
+
+	// Wait for goroutines to stop
+	f.wg.Wait()
+
+	// Returning errors
+	if len(errs) > 0 {
+		return errors.Join(errs...)
+	}
+	log.Trace().Str("file", "FTDIFinder").Msg("FTDI finder stopped")
+	return nil
+}

hardware/FTDIPeripheral.go

@@ -0,0 +1,171 @@
+package hardware
+
+import (
+	"context"
+	"sync"
+
+	"unsafe"
+
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog/log"
+	"github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+/*
+#include <stdlib.h>
+#cgo LDFLAGS: -L${SRCDIR}/../build/bin -ldmxSender
+#include "cpp/include/dmxSenderBridge.h"
+*/
+import "C"
+
+// FTDIPeripheral contains the data of an FTDI peripheral
+type FTDIPeripheral struct {
+	wg sync.WaitGroup
+
+	info      PeripheralInfo // The peripheral basic data
+	dmxSender unsafe.Pointer // The command object for piloting the DMX ouptut
+}
+
+// NewFTDIPeripheral creates a new FTDI peripheral
+func NewFTDIPeripheral(info PeripheralInfo) *FTDIPeripheral {
+	log.Info().Str("file", "FTDIPeripheral").Str("name", info.Name).Str("s/n", info.SerialNumber).Msg("FTDI peripheral created")
+	return &FTDIPeripheral{
+		info:      info,
+		dmxSender: nil,
+	}
+}
+
+// Connect connects the FTDI peripheral
+func (p *FTDIPeripheral) Connect(ctx context.Context) error {
+	// Check if the device has already been created
+	if p.dmxSender != nil {
+		return errors.Errorf("the DMX device has already been created!")
+	}
+
+	runtime.EventsEmit(ctx, string(PeripheralStatusUpdated), p.GetInfo(), PeripheralStatusConnecting)
+
+	// Create the DMX sender
+	p.dmxSender = C.dmx_create()
+
+	// Connect the FTDI
+	serialNumber := C.CString(p.info.SerialNumber)
+	defer C.free(unsafe.Pointer(serialNumber))
+	if C.dmx_connect(p.dmxSender, serialNumber) != C.DMX_OK {
+		runtime.EventsEmit(ctx, string(PeripheralStatusUpdated), p.GetInfo(), PeripheralStatusDisconnected)
+		log.Error().Str("file", "FTDIPeripheral").Str("s/n", p.info.SerialNumber).Msg("unable to connect the DMX device")
+		return errors.Errorf("unable to connect '%s'", p.info.SerialNumber)
+	}
+
+	p.wg.Add(1)
+	go func() {
+		defer p.wg.Done()
+		<-ctx.Done()
+		_ = p.Disconnect(ctx)
+	}()
+
+	runtime.EventsEmit(ctx, string(PeripheralStatusUpdated), p.GetInfo(), PeripheralStatusDeactivated)
+	log.Trace().Str("file", "FTDIPeripheral").Str("s/n", p.info.SerialNumber).Msg("DMX device connected successfully")
+	return nil
+}
+
+// Disconnect disconnects the FTDI peripheral
+func (p *FTDIPeripheral) Disconnect(ctx context.Context) error {
+	// Check if the device has already been created
+	if p.dmxSender == nil {
+		return errors.Errorf("the DMX device has not been connected!")
+	}
+
+	// Destroy the dmx sender
+	C.dmx_destroy(p.dmxSender)
+
+	// Reset the pointer to the peripheral
+	p.dmxSender = nil
+
+	runtime.EventsEmit(ctx, string(PeripheralStatusUpdated), p.GetInfo(), PeripheralStatusDisconnected)
+	return nil
+}
+
+// Activate activates the FTDI peripheral
+func (p *FTDIPeripheral) Activate(ctx context.Context) error {
+	// Check if the device has already been created
+	if p.dmxSender == nil {
+		return errors.Errorf("the DMX sender has not been created!")
+	}
+
+	log.Trace().Str("file", "FTDIPeripheral").Str("s/n", p.info.SerialNumber).Msg("activating FTDI peripheral...")
+
+	err := C.dmx_activate(p.dmxSender)
+	if err != C.DMX_OK {
+		return errors.Errorf("unable to activate the DMX sender!")
+	}
+
+	// Test only
+	C.dmx_setValue(p.dmxSender, C.uint16_t(1), C.uint8_t(255))
+	C.dmx_setValue(p.dmxSender, C.uint16_t(5), C.uint8_t(255))
+
+	runtime.EventsEmit(ctx, string(PeripheralStatusUpdated), p.GetInfo(), PeripheralStatusActivated)
+
+	log.Trace().Str("file", "FTDIPeripheral").Str("s/n", p.info.SerialNumber).Msg("DMX device activated successfully")
+	return nil
+}
+
+// Deactivate deactivates the FTDI peripheral
+func (p *FTDIPeripheral) Deactivate(ctx context.Context) error {
+	// Check if the device has already been created
+	if p.dmxSender == nil {
+		return errors.Errorf("the DMX device has not been created!")
+	}
+
+	log.Trace().Str("file", "FTDIPeripheral").Str("s/n", p.info.SerialNumber).Msg("deactivating FTDI peripheral...")
+
+	err := C.dmx_deactivate(p.dmxSender)
+	if err != C.DMX_OK {
+		return errors.Errorf("unable to deactivate the DMX sender!")
+	}
+
+	runtime.EventsEmit(ctx, string(PeripheralStatusUpdated), p.GetInfo(), PeripheralStatusDeactivated)
+	log.Trace().Str("file", "FTDIPeripheral").Str("s/n", p.info.SerialNumber).Msg("DMX device deactivated successfully")
+	return nil
+}
+
+// SetSettings sets a specific setting for this peripheral
+func (p *FTDIPeripheral) SetSettings(settings map[string]interface{}) error {
+	return errors.Errorf("unable to set the settings: not implemented")
+}
+
+// SetDeviceProperty sends a command to the specified device
+func (p *FTDIPeripheral) SetDeviceProperty(ctx context.Context, channelNumber uint32, channelValue byte) error {
+	// Check if the device has already been created
+	if p.dmxSender == nil {
+		return errors.Errorf("the DMX device has not been created!")
+	}
+
+	log.Trace().Str("file", "FTDIPeripheral").Str("s/n", p.info.SerialNumber).Msg("setting device property on FTDI peripheral...")
+
+	err := C.dmx_setValue(p.dmxSender, C.uint16_t(channelNumber), C.uint8_t(channelValue))
+	if err != C.DMX_OK {
+		return errors.Errorf("unable to update the channel value!")
+	}
+
+	log.Trace().Str("file", "FTDIPeripheral").Str("s/n", p.info.SerialNumber).Msg("device property set on FTDI peripheral successfully")
+
+	return nil
+}
+
+// GetSettings gets the peripheral settings
+func (p *FTDIPeripheral) GetSettings() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+// GetInfo gets all the peripheral information
+func (p *FTDIPeripheral) GetInfo() PeripheralInfo {
+	return p.info
+}
+
+// WaitStop wait about the peripheral to close
+func (p *FTDIPeripheral) WaitStop() error {
+	log.Info().Str("file", "FTDIPeripheral").Str("s/n", p.info.SerialNumber).Msg("waiting for FTDI peripheral to close...")
+	p.wg.Wait()
+	log.Info().Str("file", "FTDIPeripheral").Str("s/n", p.info.SerialNumber).Msg("FTDI peripheral closed!")
+	return nil
+}

hardware/MIDIFinder.go

@@ -0,0 +1,210 @@
+package hardware
+
+import (
+	"context"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/mattrtaylor/go-rtmidi"
+	"github.com/rs/zerolog/log"
+)
+
+// MIDIFinder represents how the protocol is defined
+type MIDIFinder struct {
+	findTicker            time.Ticker               // Peripherals find ticker
+	registeredPeripherals map[string]MIDIPeripheral // The list of peripherals
+	scanChannel           chan struct{}             // The channel to trigger a scan event
+	goWait                sync.WaitGroup            // Check goroutines execution
+}
+
+// NewMIDIFinder creates a new DMXUSB protocol
+func NewMIDIFinder(findPeriod time.Duration) *MIDIFinder {
+	log.Trace().Str("file", "MIDIFinder").Msg("MIDI finder created")
+	return &MIDIFinder{
+		findTicker:            *time.NewTicker(findPeriod),
+		registeredPeripherals: make(map[string]MIDIPeripheral),
+	}
+}
+
+// Initialize initializes the MIDI driver
+func (f *MIDIFinder) Initialize() error {
+	log.Trace().Str("file", "MIDIFinder").Msg("MIDI finder initialized")
+	return nil
+}
+
+// RegisterPeripheral registers a new peripheral
+func (f *MIDIFinder) RegisterPeripheral(ctx context.Context, peripheralData PeripheralInfo) (string, error) {
+	peripheral, err := NewMIDIPeripheral(peripheralData)
+	if err != nil {
+		return "", fmt.Errorf("unable to create the MIDI peripheral: %v", err)
+	}
+	f.registeredPeripherals[peripheralData.SerialNumber] = *peripheral
+	log.Trace().Any("periph", &peripheral).Str("file", "MIDIFinder").Str("peripheralName", peripheralData.Name).Msg("FTDI peripheral has been created")
+	return peripheralData.SerialNumber, nil
+}
+
+// UnregisterPeripheral unregisters an existing peripheral
+func (f *MIDIFinder) UnregisterPeripheral(peripheralID string) error {
+	peripheral, registered := f.registeredPeripherals[peripheralID]
+	if registered {
+		err := peripheral.Disconnect()
+		if err != nil {
+			return err
+		}
+	}
+	delete(f.registeredPeripherals, peripheralID)
+	return nil
+}
+
+// Start starts the finder and search for peripherals
+func (f *MIDIFinder) Start(ctx context.Context) error {
+	f.goWait.Add(1)
+	go func() {
+		defer f.goWait.Done()
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-f.findTicker.C:
+				// Scan the peripherals
+				err := f.scanPeripherals(ctx)
+				if err != nil {
+					log.Err(err).Str("file", "MIDIFinder").Msg("unable to scan MIDI peripherals")
+				}
+			case <-f.scanChannel:
+				// Scan the peripherals
+				err := f.scanPeripherals(ctx)
+				if err != nil {
+					log.Err(err).Str("file", "MIDIFinder").Msg("unable to scan MIDI peripherals")
+				}
+			}
+		}
+	}()
+	return nil
+}
+
+// Stop stops the finder
+func (f *MIDIFinder) Stop() error {
+	log.Trace().Str("file", "MIDIFinder").Msg("stopping the MIDI finder...")
+	// Wait for goroutines to stop
+	f.goWait.Wait()
+	// Stop the ticker
+	f.findTicker.Stop()
+	log.Trace().Str("file", "MIDIFinder").Msg("MIDI finder stopped")
+	return nil
+}
+
+// GetName returns the name of the driver
+func (f *MIDIFinder) GetName() string {
+	return "MIDI"
+}
+
+// GetPeripheralSettings gets the peripheral settings
+func (f *MIDIFinder) GetPeripheralSettings(peripheralID string) (map[string]interface{}, error) {
+	// Return the specified peripheral
+	peripheral, found := f.registeredPeripherals[peripheralID]
+	if !found {
+		log.Error().Str("file", "MIDIFinder").Str("peripheralID", peripheralID).Msg("unable to get this peripheral from the FTDI finder")
+		return nil, fmt.Errorf("unable to found the peripheral")
+	}
+	log.Debug().Str("file", "MIDIFinder").Str("peripheralID", peripheralID).Msg("peripheral found by the FTDI finder")
+	return peripheral.GetSettings(), nil
+}
+
+// SetPeripheralSettings sets the peripheral settings
+func (f *MIDIFinder) SetPeripheralSettings(peripheralID string, settings map[string]interface{}) error {
+	// Return the specified peripheral
+	peripheral, found := f.registeredPeripherals[peripheralID]
+	if !found {
+		log.Error().Str("file", "MIDIFinder").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", "MIDIFinder").Str("peripheralID", peripheralID).Msg("peripheral found by the FTDI finder")
+	return peripheral.SetSettings(settings)
+}
+
+func splitStringAndNumber(input string) (string, int, error) {
+	// Regular expression to match the text part and the number at the end
+	re := regexp.MustCompile(`^(.*?)(\d+)$`)
+	matches := re.FindStringSubmatch(input)
+
+	// Check if the regex found both a text part and a number
+	if len(matches) == 3 {
+		// matches[1]: text part (might contain trailing spaces)
+		// matches[2]: numeric part as a string
+		textPart := strings.TrimSpace(matches[1]) // Remove any trailing spaces from the text
+		numberPart, err := strconv.Atoi(matches[2])
+		if err != nil {
+			return "", 0, err // Return error if the number conversion fails
+		}
+		return textPart, numberPart, nil
+	}
+
+	// Return an error if no trailing number is found
+	return "", 0, fmt.Errorf("no number found at the end of the string")
+}
+
+// ForceScan explicily asks for scanning peripherals
+func (f *MIDIFinder) ForceScan() {
+	f.scanChannel <- struct{}{}
+}
+
+// scanPeripherals scans the MIDI peripherals
+func (f *MIDIFinder) scanPeripherals(ctx context.Context) error {
+	// midiPeripherals := make(map[string]Peripheral)
+	log.Trace().Str("file", "MIDIFinder").Msg("opening MIDI scanner port...")
+	midiScanner, err := rtmidi.NewMIDIInDefault()
+	if err != nil {
+		log.Err(err).Str("file", "MIDIFinder").Msg("unable to open the MIDI scanner port...")
+		return fmt.Errorf("unable to open the MIDI scanner: %s", err)
+	}
+	defer midiScanner.Close()
+	midiScanner.SetCallback(func(m rtmidi.MIDIIn, b []byte, f float64) {})
+	log.Trace().Str("file", "MIDIFinder").Msg("scanning MIDI peripherals...")
+	devicesCount, err := midiScanner.PortCount()
+	if err != nil {
+		log.Err(err).Str("file", "MIDIFinder").Msg("unable to scan MIDI peripherals...")
+		return fmt.Errorf("unable to scan MIDI peripherals: %s", err)
+	}
+	for i := 0; i < devicesCount; i++ {
+		portName, err := midiScanner.PortName(i)
+		if err != nil {
+			log.Warn().Str("file", "MIDIPeripheral").Msg("found peripheral without a correct name, set it to unknown")
+			portName = "Unknown device 0"
+		}
+		// Separate data
+		name, location, err := splitStringAndNumber(portName)
+		if err != nil {
+			log.Err(err).Str("file", "MIDIFinder").Str("description", portName).Msg("invalid peripheral description")
+			return fmt.Errorf("invalid pripheral description: %s", err)
+		}
+		log.Info().Str("file", "MIDIFinder").Str("name", name).Int("location", location).Msg("MIDI peripheral found")
+		// Add the peripheral to the temporary list
+		// sn := strings.ToLower(strings.Replace(name, " ", "_", -1))
+		// midiPeripherals[sn] = NewMIDIPeripheral(name, location, sn)
+	}
+	// Compare with the current peripherals to detect arrivals/removals
+	// removedList, addedList := comparePeripherals(f.peripherals, midiPeripherals)
+	// Emit the events
+	// emitPeripheralsEvents(ctx, removedList, PeripheralRemoval)
+	log.Info().Str("file", "MIDIFinder").Msg("MIDI remove list emitted to the front")
+	// emitPeripheralsEvents(ctx, addedList, PeripheralArrival)
+	log.Info().Str("file", "MIDIFinder").Msg("MIDI add list emitted to the front")
+	// Store the new peripherals list
+	// f.peripherals = midiPeripherals
+	return nil
+}
+
+// CreatePeripheral is not implemented here
+func (f *MIDIFinder) CreatePeripheral(context.Context) (Peripheral, error) {
+	return nil, nil
+}
+
+// DeletePeripheral is not implemented here
+func (f *MIDIFinder) DeletePeripheral(serialNumber string) error {
+	return nil
+}

hardware/MIDIPeripheral.go

@@ -0,0 +1,64 @@
+package hardware
+
+import (
+	"context"
+
+	"github.com/rs/zerolog/log"
+)
+
+// MIDIPeripheral contains the data of a MIDI peripheral
+type MIDIPeripheral struct {
+	info     PeripheralInfo         // The peripheral info
+	location int                    // The location of the peripheral
+	settings map[string]interface{} // The settings of the peripheral
+}
+
+// NewMIDIPeripheral creates a new MIDI peripheral
+func NewMIDIPeripheral(peripheralData PeripheralInfo) (*MIDIPeripheral, error) {
+	log.Trace().Str("file", "MIDIPeripheral").Str("name", peripheralData.Name).Str("s/n", peripheralData.SerialNumber).Msg("MIDI peripheral created")
+	return &MIDIPeripheral{
+		info:     peripheralData,
+		settings: peripheralData.Settings,
+	}, nil
+}
+
+// Connect connects the MIDI peripheral
+func (p *MIDIPeripheral) Connect(ctx context.Context) error {
+	return nil
+}
+
+// Disconnect disconnects the MIDI peripheral
+func (p *MIDIPeripheral) Disconnect() error {
+	return nil
+}
+
+// Activate activates the MIDI peripheral
+func (p *MIDIPeripheral) Activate(ctx context.Context) error {
+	return nil
+}
+
+// Deactivate deactivates the MIDI peripheral
+func (p *MIDIPeripheral) Deactivate(ctx context.Context) error {
+	return nil
+}
+
+// SetSettings sets a specific setting for this peripheral
+func (p *MIDIPeripheral) SetSettings(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 p.info
+}

hardware/OS2LFinder.go

@@ -0,0 +1,195 @@
+package hardware
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math/rand"
+	"strings"
+	"sync"
+
+	"github.com/rs/zerolog/log"
+	"github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+// OS2LFinder represents how the protocol is defined
+type OS2LFinder struct {
+	wg sync.WaitGroup
+	mu sync.Mutex
+
+	saved map[string]*OS2LPeripheral // The list of saved peripherals
+
+	onArrival func(p PeripheralInfo) // When a peripheral arrives
+	onRemoval func(p PeripheralInfo) // When a peripheral goes away
+}
+
+// NewOS2LFinder creates a new OS2L finder
+func NewOS2LFinder() *OS2LFinder {
+	log.Trace().Str("file", "OS2LFinder").Msg("OS2L finder created")
+	return &OS2LFinder{
+		saved: make(map[string]*OS2LPeripheral),
+	}
+}
+
+// Initialize initializes the finder
+func (f *OS2LFinder) Initialize() error {
+	log.Trace().Str("file", "OS2LFinder").Msg("OS2L finder initialized")
+	return nil
+}
+
+// OnArrival is the callback function when a new peripheral arrives
+func (f *OS2LFinder) OnArrival(cb func(p PeripheralInfo)) {
+	f.onArrival = cb
+}
+
+// OnRemoval i the callback when a peripheral goes away
+func (f *OS2LFinder) OnRemoval(cb func(p PeripheralInfo)) {
+	f.onRemoval = cb
+}
+
+// RegisterPeripheral registers a new peripheral
+func (f *OS2LFinder) RegisterPeripheral(ctx context.Context, peripheralData PeripheralInfo) (string, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	// If the SerialNumber is empty, generate another one
+	if peripheralData.SerialNumber == "" {
+		peripheralData.SerialNumber = strings.ToUpper(fmt.Sprintf("%08x", rand.Intn(1<<32)))
+	}
+
+	// Create a new OS2L peripheral
+	peripheral, err := NewOS2LPeripheral(peripheralData)
+	if err != nil {
+		return "", fmt.Errorf("unable to create the OS2L peripheral: %w", err)
+	}
+	// Set the event callback
+	peripheral.SetEventCallback(func(event any) {
+		runtime.EventsEmit(ctx, string(PeripheralEventEmitted), peripheralData.SerialNumber, event)
+	})
+
+	f.saved[peripheralData.SerialNumber] = peripheral
+	log.Trace().Str("file", "OS2LFinder").Str("serialNumber", peripheralData.SerialNumber).Msg("OS2L peripheral created")
+
+	// New OS2L peripheral has arrived
+	if f.onArrival != nil {
+		f.onArrival(peripheral.GetInfo())
+	}
+
+	f.wg.Add(1)
+	go func() {
+		defer f.wg.Done()
+		// Connect the OS2L peripheral
+		err = peripheral.Connect(ctx)
+		if err != nil {
+			log.Err(err).Str("file", "OS2LFinder").Str("peripheralSN", peripheralData.SerialNumber).Msg("unable to connect the peripheral")
+			return
+		}
+		// Peripheral connected, activate it
+		err = peripheral.Activate(ctx)
+		if err != nil {
+			log.Err(err).Str("file", "OS2LFinder").Str("peripheralSN", peripheralData.SerialNumber).Msg("unable to activate the OS2L peripheral")
+			return
+		}
+	}()
+
+	// Emits the event in the hardware
+	runtime.EventsEmit(ctx, "LOAD_PERIPHERAL", peripheralData)
+
+	return peripheralData.SerialNumber, nil
+}
+
+// UnregisterPeripheral unregisters an existing peripheral
+func (f *OS2LFinder) UnregisterPeripheral(ctx context.Context, peripheralData PeripheralInfo) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	if peripheral, detected := f.saved[peripheralData.SerialNumber]; detected {
+		// Deactivating peripheral
+		err := peripheral.Deactivate(ctx)
+		if err != nil {
+			log.Err(err).Str("sn", peripheralData.SerialNumber).Msg("unable to deactivate the peripheral")
+			return nil
+		}
+		// Disconnecting peripheral
+		err = peripheral.Disconnect(ctx)
+		if err != nil {
+			log.Err(err).Str("sn", peripheralData.SerialNumber).Msg("unable to disconnect the peripheral")
+			return nil
+		}
+	}
+
+	// The OS2L peripheral has gone
+	f.onRemoval(peripheralData)
+
+	delete(f.saved, peripheralData.SerialNumber)
+	runtime.EventsEmit(ctx, "UNLOAD_PERIPHERAL", peripheralData)
+	return nil
+}
+
+// GetName returns the name of the driver
+func (f *OS2LFinder) GetName() string {
+	return "OS2L"
+}
+
+// GetPeripheralSettings gets the peripheral settings
+func (f *OS2LFinder) GetPeripheralSettings(peripheralID string) (map[string]any, error) {
+	// Return the specified peripheral
+	peripheral, found := f.saved[peripheralID]
+	if !found {
+		log.Error().Str("file", "OS2LFinder").Str("peripheralID", peripheralID).Msg("unable to get this peripheral from the OS2L finder")
+		return nil, fmt.Errorf("unable to found the peripheral")
+	}
+	log.Debug().Str("file", "OS2LFinder").Str("peripheralID", peripheralID).Msg("peripheral found by the OS2L finder")
+	return peripheral.GetSettings(), nil
+}
+
+// SetPeripheralSettings sets the peripheral settings
+func (f *OS2LFinder) SetPeripheralSettings(ctx context.Context, peripheralID string, settings map[string]any) error {
+	// Return the specified peripheral
+	peripheral, found := f.saved[peripheralID]
+	if !found {
+		log.Error().Str("file", "OS2LFinder").Str("peripheralID", peripheralID).Msg("unable to get this peripheral from the FTDI finder")
+		return fmt.Errorf("unable to found the peripheral")
+	}
+
+	// Set the peripheral settings
+	return peripheral.SetSettings(ctx, settings)
+}
+
+// Start starts the finder
+func (f *OS2LFinder) Start(ctx context.Context) error {
+	// No peripherals to scan here
+	return nil
+}
+
+// WaitStop stops the finder
+func (f *OS2LFinder) WaitStop() error {
+	log.Trace().Str("file", "OS2LFinder").Msg("stopping the OS2L finder...")
+
+	// Close the channel
+	// close(f.scanChannel)
+
+	// Wait for all the peripherals to close
+	log.Trace().Str("file", "OS2LFinder").Msg("closing all OS2L peripherals")
+	var errs []error
+	for registeredPeripheralSN, registeredPeripheral := range f.saved {
+		err := registeredPeripheral.WaitStop()
+		if err != nil {
+			errs = append(errs, fmt.Errorf("%s: %w", registeredPeripheralSN, err))
+		}
+	}
+
+	// Waiting internal tasks
+	f.wg.Wait()
+
+	// Returning errors
+	if len(errs) > 0 {
+		return errors.Join(errs...)
+	}
+	log.Trace().Str("file", "OS2LFinder").Msg("OS2L finder stopped")
+	return nil
+}
+
+// ForceScan scans the interfaces (not implemented)
+func (f *OS2LFinder) ForceScan() {
+}

hardware/OS2LPeripheral.go

@@ -0,0 +1,286 @@
+package hardware
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/rs/zerolog/log"
+	"github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+// OS2LMessage represents an OS2L message
+type OS2LMessage struct {
+	Event string  `json:"evt"`
+	Name  string  `json:"name"`
+	State string  `json:"state"`
+	ID    int64   `json:"id"`
+	Param float64 `json:"param"`
+}
+
+// OS2LPeripheral contains the data of an OS2L peripheral
+type OS2LPeripheral struct {
+	wg sync.WaitGroup
+
+	info           PeripheralInfo     // The basic info for this peripheral
+	serverIP       string             // OS2L server IP
+	serverPort     int                // OS2L server port
+	listener       net.Listener       // Net listener (TCP)
+	listenerCancel context.CancelFunc // Call this function to cancel the peripheral activation
+
+	eventCallback func(any) // This callback is called for returning events
+}
+
+// NewOS2LPeripheral creates a new OS2L peripheral
+func NewOS2LPeripheral(peripheralData PeripheralInfo) (*OS2LPeripheral, error) {
+	peripheral := &OS2LPeripheral{
+		info:          peripheralData,
+		listener:      nil,
+		eventCallback: nil,
+	}
+	log.Trace().Str("file", "OS2LPeripheral").Str("name", peripheralData.Name).Str("s/n", peripheralData.SerialNumber).Msg("OS2L peripheral created")
+	return peripheral, peripheral.loadSettings(peripheralData.Settings)
+}
+
+// SetEventCallback sets the callback for returning events
+func (p *OS2LPeripheral) SetEventCallback(eventCallback func(any)) {
+	p.eventCallback = eventCallback
+}
+
+// Connect connects the OS2L peripheral
+func (p *OS2LPeripheral) Connect(ctx context.Context) error {
+	runtime.EventsEmit(ctx, string(PeripheralStatusUpdated), p.GetInfo(), PeripheralStatusConnecting)
+
+	var err error
+	addr := net.TCPAddr{Port: p.serverPort, IP: net.ParseIP(p.serverIP)}
+
+	log.Debug().Any("addr", addr).Msg("parametres de connexion à la connexion")
+	p.listener, err = net.ListenTCP("tcp", &addr)
+	if err != nil {
+		runtime.EventsEmit(ctx, string(PeripheralStatusUpdated), p.GetInfo(), PeripheralStatusDisconnected)
+		return fmt.Errorf("unable to set the OS2L TCP listener")
+	}
+
+	runtime.EventsEmit(ctx, string(PeripheralStatusUpdated), p.GetInfo(), PeripheralStatusDeactivated)
+	log.Info().Str("file", "OS2LPeripheral").Msg("OS2L peripheral connected")
+	return nil
+}
+
+// handleMessage handles an OS2L message
+func (p *OS2LPeripheral) handleMessage(raw []byte) error {
+	message := OS2LMessage{}
+	err := json.Unmarshal(raw, &message)
+	if err != nil {
+		return fmt.Errorf("Unable to parse the OS2L message: %w", err)
+	}
+	log.Debug().Str("event", message.Event).Str("name", message.Name).Str("state", message.State).Int("ID", int(message.ID)).Float64("param", message.Param).Msg("OS2L event received")
+	// Return the event to the finder
+	if p.eventCallback != nil {
+		go p.eventCallback(message)
+	}
+	return nil
+}
+
+// loadSettings check and load the settings in the peripheral
+func (p *OS2LPeripheral) loadSettings(settings map[string]any) error {
+	// Check if the IP exists
+	serverIP, found := settings["os2lIp"]
+	if !found {
+		// Set default IP address
+		serverIP = "127.0.0.1"
+	}
+	// 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 {
+		// Set default port
+		serverPort = 9995
+	}
+	switch v := serverPort.(type) {
+	case int:
+		p.serverPort = v
+	case float64:
+		p.serverPort = int(v) // JSON numbers are float64
+	default:
+		return fmt.Errorf("The specified port is not a number, got %T", serverPort)
+	}
+
+	return nil
+}
+
+// Disconnect disconnects the MIDI peripheral
+func (p *OS2LPeripheral) Disconnect(ctx context.Context) error {
+
+	// Close the TCP listener if not null
+	if p.listener != nil {
+		p.listener.Close()
+	}
+
+	runtime.EventsEmit(ctx, string(PeripheralStatusUpdated), p.GetInfo(), PeripheralStatusDisconnected)
+
+	log.Info().Str("file", "OS2LPeripheral").Msg("OS2L peripheral disconnected")
+	return nil
+}
+
+// Activate activates the OS2L peripheral
+func (p *OS2LPeripheral) Activate(ctx context.Context) error {
+	// Create a derived context to handle deactivation
+	var listenerCtx context.Context
+	listenerCtx, p.listenerCancel = context.WithCancel(ctx)
+
+	if p.listener == nil {
+		return fmt.Errorf("the listener isn't defined")
+	}
+
+	p.wg.Add(1)
+	go func() {
+		defer p.wg.Done()
+
+		for {
+			select {
+			case <-listenerCtx.Done():
+				return
+			default:
+				p.listener.(*net.TCPListener).SetDeadline(time.Now().Add(1 * time.Second))
+				conn, err := p.listener.Accept()
+				if err != nil {
+					if ne, ok := err.(net.Error); ok && ne.Timeout() {
+						continue
+					}
+					if strings.Contains(err.Error(), "use of closed network connection") || strings.Contains(err.Error(), "invalid argument") {
+						return
+					}
+					log.Err(err).Str("file", "OS2LPeripheral").Msg("unable to accept the connection")
+					continue
+				}
+
+				// Every client is handled in a dedicated goroutine
+				p.wg.Add(1)
+				go func(c net.Conn) {
+					defer p.wg.Done()
+					defer c.Close()
+
+					buffer := make([]byte, 1024)
+					for {
+						select {
+						case <-listenerCtx.Done():
+							return
+						default:
+							c.SetReadDeadline(time.Now().Add(500 * time.Millisecond))
+							n, err := c.Read(buffer)
+							if err != nil {
+								if ne, ok := err.(net.Error); ok && ne.Timeout() {
+									// Lecture a expiré → vérifier si le contexte est annulé
+									select {
+									case <-listenerCtx.Done():
+										return
+									default:
+										continue // pas annulé → relancer Read
+									}
+								}
+								return // autre erreur ou EOF
+							}
+
+							p.handleMessage(buffer[:n])
+						}
+					}
+				}(conn)
+			}
+		}
+	}()
+	runtime.EventsEmit(ctx, string(PeripheralStatusUpdated), p.GetInfo(), PeripheralStatusActivated)
+
+	log.Info().Str("file", "OS2LPeripheral").Msg("OS2L peripheral activated")
+
+	return nil
+}
+
+// Deactivate deactivates the OS2L peripheral
+func (p *OS2LPeripheral) Deactivate(ctx context.Context) error {
+	if p.listener == nil {
+		return fmt.Errorf("the listener isn't defined")
+	}
+
+	// Cancel listener by context
+	if p.listenerCancel != nil {
+		p.listenerCancel()
+	}
+
+	runtime.EventsEmit(ctx, string(PeripheralStatusUpdated), p.GetInfo(), PeripheralStatusDeactivated)
+
+	log.Info().Str("file", "OS2LPeripheral").Msg("OS2L peripheral deactivated")
+	return nil
+}
+
+// SetSettings sets a specific setting for this peripheral
+func (p *OS2LPeripheral) SetSettings(ctx context.Context, settings map[string]any) error {
+	err := p.loadSettings(settings)
+	if err != nil {
+		return fmt.Errorf("unable to load settings: %w", err)
+	}
+	// Reconnect the peripheral
+	p.wg.Add(1)
+	go func() {
+		defer p.wg.Done()
+		err := p.Deactivate(ctx)
+		if err != nil {
+			log.Err(err).Str("sn", p.GetInfo().SerialNumber).Msg("unable to deactivate")
+			return
+		}
+		err = p.Disconnect(ctx)
+		if err != nil {
+			log.Err(err).Str("sn", p.GetInfo().SerialNumber).Msg("unable to disconnect")
+			return
+		}
+		// Add a sleep to view changes
+		time.Sleep(500 * time.Millisecond)
+		err = p.Connect(ctx)
+		if err != nil {
+			log.Err(err).Str("sn", p.GetInfo().SerialNumber).Msg("unable to connect")
+			return
+		}
+		err = p.Activate(ctx)
+		if err != nil {
+			log.Err(err).Str("sn", p.GetInfo().SerialNumber).Msg("unable to activate")
+			return
+		}
+	}()
+	log.Info().Str("sn", p.GetInfo().SerialNumber).Msg("peripheral settings set")
+	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]any {
+	return map[string]any{
+		"os2lIp":   p.serverIP,
+		"os2lPort": p.serverPort,
+	}
+}
+
+// GetInfo gets the peripheral information
+func (p *OS2LPeripheral) GetInfo() PeripheralInfo {
+	return p.info
+}
+
+// WaitStop stops the peripheral
+func (p *OS2LPeripheral) WaitStop() error {
+	log.Info().Str("file", "OS2LPeripheral").Str("s/n", p.info.SerialNumber).Msg("waiting for OS2L peripheral to close...")
+	p.wg.Wait()
+	log.Info().Str("file", "OS2LPeripheral").Str("s/n", p.info.SerialNumber).Msg("OS2L peripheral closed!")
+	return nil
+}

hardware/cpp/generate.bat

@@ -0,0 +1,22 @@
+@REM windres dmxSender.rc dmxSender.o
+@REM windres detectFTDI.rc detectFTDI.o
+
+@REM g++ -o dmxSender.exe dmxSender.cpp dmxSender.o -I"include" -L"lib" -lftd2xx -mwindows
+@REM g++ -o detectFTDI.exe detectFTDI.cpp detectFTDI.o -I"include" -L"lib" -lftd2xx -mwindows
+
+@REM g++ -o dmxSender.exe dmxSender.cpp -I"include" -L"lib" -lftd2xx
+@REM g++ -o detectFTDI.exe detectFTDI.cpp -I"include" -L"lib" -lftd2xx
+
+@REM g++ -c dmxSender.cpp -o dmxSender.o -I"include" -L"lib" -lftd2xx -mwindows
+
+@REM g++ -c dmxSender_wrapper.cpp -o dmxSender_wrapper.o -I"include" -L"lib" -lftd2xx -mwindows
+
+@REM g++ -shared -o ../../build/bin/libdmxSender.dll src/dmxSender.cpp -fPIC -Wl,--out-implib,../../build/bin/libdmxSender.dll.a -L"lib" -lftd2xx
+
+@REM Compiling DETECTFTDI library
+g++ -shared -o ../../build/bin/libdetectFTDI.dll src/detectFTDI.cpp -fPIC -Wl,--out-implib,../../build/bin/libdetectFTDI.dll.a -L"lib" -lftd2xx -mwindows
+
+@REM Compiling DMXSENDER library
+g++ -shared -o ../../build/bin/libdmxSender.dll src/dmxSender.cpp -fPIC -Wl,--out-implib,../../build/bin/libdmxSender.dll.a -L"lib" -lftd2xx -mwindows
+
+@REM g++ -shared -o libdmxSender.so dmxSender.cpp -fPIC -I"include" -L"lib" -lftd2xx -mwindows

hardware/cpp/include/detectFTDIBridge.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    char* serialNumber;
+    char* description;
+    int isOpen;
+} FTDIPeripheralC;
+
+int get_peripherals_number();
+void get_ftdi_devices(FTDIPeripheralC* devices, int count);
+void free_ftdi_device(FTDIPeripheralC* device);
+
+#ifdef __cplusplus
+}
+#endif

hardware/cpp/include/dmxSenderBridge.h

@@ -0,0 +1,30 @@
+// Declare the C++ function from the shared library
+
+#include <stdint.h>
+
+typedef enum {
+    DMX_OK,
+    DMX_CHANNEL_TOO_LOW_ERROR,
+    DMX_CHANNEL_TOO_HIGH_ERROR,
+    DMX_VALUE_TOO_LOW_ERROR,
+    DMX_VALUE_TOO_HIGH_ERROR,
+    DMX_OPEN_ERROR,
+    DMX_SET_BAUDRATE_ERROR,
+    DMX_SET_DATA_CHARACTERISTICS_ERROR,
+    DMX_SET_FLOW_ERROR,
+    DMX_UNKNOWN_ERROR
+} DMXError;
+
+typedef void DMXDevice;
+
+extern DMXDevice* dmx_create();
+
+extern void* dmx_destroy(DMXDevice* dev);
+
+extern DMXError dmx_connect(DMXDevice* dev, char* serialNumber);
+
+extern DMXError dmx_activate(DMXDevice* dev);
+
+extern DMXError dmx_deactivate(DMXDevice* dev);
+
+extern DMXError dmx_setValue(DMXDevice* dev, uint16_t channel, uint8_t value);

hardware/cpp/src/detectFTDI.cpp

@@ -0,0 +1,91 @@
+#include "../include/detectFTDIBridge.h"
+#include "detectFTDI.h"
+#include <cstring>
+#include <cstdlib>
+#include <algorithm>
+#include <iostream>
+
+int getFTDIPeripheralsNumber() {
+    DWORD numDevs = 0;
+    if (FT_CreateDeviceInfoList(&numDevs) != FT_OK) {
+        std::cerr << "Unable to get FTDI devices: create list error\n";
+    }
+    return numDevs;
+}
+
+std::vector<FTDIPeripheral> scanFTDIPeripherals() {
+    DWORD numDevs = 0;
+    if (FT_CreateDeviceInfoList(&numDevs) != FT_OK) {
+        std::cerr << "Unable to get FTDI devices: create list error\n";
+        return {};
+    }
+
+    if (numDevs == 0) {
+        return {}; 
+    }
+
+    std::vector<FT_DEVICE_LIST_INFO_NODE> devInfo(numDevs);
+    if (FT_GetDeviceInfoList(devInfo.data(), &numDevs) != FT_OK) {
+        std::cerr << "Unable to get FTDI devices: get list error\n";
+        return {};
+    }
+
+    std::vector<FTDIPeripheral> peripherals;
+    peripherals.reserve(numDevs);
+
+    for (const auto& info : devInfo) {
+        if (info.SerialNumber[0] != '\0') {
+            peripherals.push_back({
+                info.SerialNumber,
+                info.Description,
+                static_cast<bool>(info.Flags & FT_FLAGS_OPENED)
+            });
+        }
+    }
+
+    return peripherals;
+}
+
+extern "C" {
+
+int get_peripherals_number() {
+    return getFTDIPeripheralsNumber();
+}
+
+void get_ftdi_devices(FTDIPeripheralC* devices, int count) {
+    if (!devices || count <= 0) {
+        return;
+    }
+
+    auto list = scanFTDIPeripherals();
+    int n = std::min(count, static_cast<int>(list.size()));
+
+    for (int i = 0; i < n; ++i) {
+        const auto& src = list[i];
+        auto& dst = devices[i];
+
+        dst.serialNumber = static_cast<char*>(std::malloc(src.serialNumber.size() + 1));
+        std::strcpy(dst.serialNumber, src.serialNumber.c_str());
+
+        dst.description = static_cast<char*>(std::malloc(src.description.size() + 1));
+        std::strcpy(dst.description, src.description.c_str());
+
+        dst.isOpen = src.isOpen ? 1 : 0;
+    }
+}
+
+void free_ftdi_device(FTDIPeripheralC* device) {
+    if (!device) return;
+
+    if (device->serialNumber) {
+        std::free(device->serialNumber);
+        device->serialNumber = nullptr;
+    }
+
+    if (device->description) {
+        std::free(device->description);
+        device->description = nullptr;
+    }
+}
+
+} // extern "C"

hardware/cpp/src/detectFTDI.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "ftd2xx.h"
+#include <string>
+#include <vector>
+
+struct FTDIPeripheral {
+    std::string serialNumber;
+    std::string description;
+    bool isOpen;
+};
+
+int getFTDIPeripheralsNumber();
+std::vector<FTDIPeripheral> scanFTDIPeripherals();

hardware/cpp/src/dmxSender.cpp

@@ -0,0 +1,225 @@
+//dmxSender.cpp
+
+#include "dmxSender.h"
+#include <iostream>
+
+#define DMX_START_CODE 0x00
+#define BREAK_DURATION_US 110
+#define MAB_DURATION_US 16
+#define DMX_CHANNELS 512
+#define FREQUENCY 44
+#define INTERVAL (1000000 / FREQUENCY) 
+
+// Initialize default values for starting the DMX device
+DMXDevice::DMXDevice(){
+    std::cout << "  [DMXSENDER] " << "Creating a new DMXDevice..." << std::endl;
+    ftHandle = nullptr;
+    isOutputActivated = false;
+    resetChannels();
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    std::cout << "  [DMXSENDER] " << "DMXDevice created!" << std::endl;
+}
+
+// Properly close the DMX device
+DMXDevice::~DMXDevice(){
+    std::cout << "  [DMXSENDER] " << "Removing the DMXDevice..." << std::endl;
+    std::cout << "      [DMXSENDER] " << "Deactivating the DMXDevice..." << std::endl;
+    deactivate();
+    std::cout << "      [DMXSENDER] " << "DMXDevice deactivated!" << std::endl;
+
+    if (ftHandle != nullptr){
+        std::cout << "      [DMXSENDER] " << "ftHandle not null, closing it..." << std::endl;
+        FT_Close(ftHandle);
+        std::cout << "      [DMXSENDER] " << "FT_HANDLE closed!" << std::endl;
+        ftHandle = nullptr;
+    }
+    std::cout << "  [DMXSENDER] " << "DMXDevice removed!" << std::endl;
+}
+
+// Connect the device on a specific port
+DMXError DMXDevice::connect(char* serialNumber){
+    std::cout << "  [DMXSENDER] " << "Connecting the DMXDevice..." << std::endl;
+    ftStatus = FT_OpenEx((PVOID)serialNumber, FT_OPEN_BY_SERIAL_NUMBER, &ftHandle);
+    if (ftStatus != FT_OK) {
+        std::cout << "  [DMXSENDER] " << "Error when connecting the DMXDevice..." << std::endl;
+        return DMX_OPEN_ERROR;
+    }
+
+    std::cout << "      [DMXSENDER] " << "DMXDevice connected, setting up..." << std::endl;
+
+    ftStatus = FT_SetBaudRate(ftHandle, 250000);
+    if (ftStatus != FT_OK) {
+        std::cout << "  [DMXSENDER] " << "Error when setting the baudrate..." << std::endl;
+        FT_Close(ftHandle);
+        return DMX_SET_BAUDRATE_ERROR;
+    }
+    ftStatus |= FT_SetDataCharacteristics(ftHandle, 8, FT_STOP_BITS_2, FT_PARITY_NONE); // 8 bits, no parity, 1 stop bit
+    if (ftStatus != FT_OK) {
+        std::cout << "  [DMXSENDER] " << "Error when setting the data characteristics..." << std::endl;
+        FT_Close(ftHandle);
+        return DMX_SET_DATA_CHARACTERISTICS_ERROR;
+    }
+    ftStatus |= FT_SetFlowControl(ftHandle, FT_FLOW_NONE, 0, 0);
+    if (ftStatus != FT_OK) {
+        std::cout << "      [DMXSENDER] " << "Error when trying to set up the flow control..." << std::endl;
+        FT_Close(ftHandle);
+        return DMX_SET_FLOW_ERROR;
+    }
+
+    std::cout << "  [DMXSENDER] " << "DMXDevice connected!" << std::endl;
+    return DMX_OK;
+}
+
+// Activate the DMX flow
+DMXError DMXDevice::activate(){
+    std::cout << "  [DMXSENDER] " << "Activating the DMXDevice..." << std::endl;
+
+    isOutputActivated.store(true);
+    // Send the DMX frames
+    std::thread updateThread([this]() {
+        this->sendDMX(ftHandle);
+    });
+
+    updateThread.detach();
+
+    std::cout << "  [DMXSENDER] " << "DMXDevice activated!" << std::endl;
+    return DMX_OK;
+}
+
+// Deactivate the DMX flow
+DMXError DMXDevice::deactivate(){
+    std::cout << "  [DMXSENDER] " << "Deactivating the DMXDevice..." << std::endl;
+    std::cout << "      [DMXSENDER] " << "Resetting channels..." << std::endl;
+    resetChannels();
+    std::cout << "      [DMXSENDER] " << "Channels resetted!" << std::endl;
+    isOutputActivated.store(false);
+    std::cout << "  [DMXSENDER] " << "DMXDevice deactivated!" << std::endl;
+    return DMX_OK;
+}
+
+// Set the value of a DMX channel
+DMXError DMXDevice::setValue(uint16_t channel, uint8_t value){
+    std::cout << "  [DMXSENDER] " << "Setting a channel value..." << std::endl;
+    if (channel < 1) {
+        std::cout << "  [DMXSENDER] " << "Unable to set channel value: channel number too low!" << std::endl;
+        return DMX_CHANNEL_TOO_LOW_ERROR;
+    }
+    if (channel > 512) {
+        std::cout << "  [DMXSENDER] " << "Unable to set channel value: channel number too high!" << std::endl;
+        return DMX_CHANNEL_TOO_HIGH_ERROR;
+    }
+    if(value < 0) {
+        std::cout << "  [DMXSENDER] " << "Unable to set channel value: channel value too low!" << std::endl;
+        return DMX_VALUE_TOO_LOW_ERROR;
+    }
+    if(value > 255) {
+        std::cout << "  [DMXSENDER] " << "Unable to set channel value: channel value too high!" << std::endl;
+        return DMX_VALUE_TOO_HIGH_ERROR;
+    }
+    dmxData[channel].store(value);
+    std::cout << "  [DMXSENDER] " << "Channel value set!" << std::endl;
+    return DMX_OK;
+}
+
+// Send a break line
+FT_STATUS DMXDevice::sendBreak(FT_HANDLE ftHandle) {
+    ftStatus = FT_SetBreakOn(ftHandle);  // Set BREAK ON
+    if (ftStatus != FT_OK) {
+        std::cout << "  [DMXSENDER] " << "Unable to put break signal ON!" << std::endl;
+        return ftStatus;
+    }
+    std::this_thread::sleep_for(std::chrono::microseconds(BREAK_DURATION_US));
+    ftStatus = FT_SetBreakOff(ftHandle); // Set BREAK OFF
+    if (ftStatus != FT_OK) {
+        std::cout << "  [DMXSENDER] " << "Unable to put break signal OFF!" << std::endl;
+        return ftStatus;
+    }
+    return ftStatus;
+}
+
+// Continuously send the DMX frame
+void DMXDevice::sendDMX(FT_HANDLE ftHandle) {
+    while (isOutputActivated) {
+        // Send the BREAK
+        ftStatus = sendBreak(ftHandle);
+        if (ftStatus != FT_OK) {
+            std::cout << "  [DMXSENDER] " << "Unable to send break signal! Deactivating output..." << std::endl;
+            deactivate();
+            continue;
+        }
+
+        // Send the MAB
+        std::this_thread::sleep_for(std::chrono::microseconds(MAB_DURATION_US));
+
+        DWORD bytesWritten = 0;
+
+        // Send the DMX frame
+        ftStatus = FT_Write(ftHandle, dmxData, DMX_CHANNELS, &bytesWritten);
+        if (ftStatus != FT_OK || bytesWritten != DMX_CHANNELS) { // Error detected when trying to send the frame. Deactivate the line.
+            std::cout << "  [DMXSENDER] " << "Error when trying to send the DMX frame! Deactivating output..." << std::endl;
+            deactivate();
+            continue;
+        }
+
+        // Wait before sending the next frame
+        std::this_thread::sleep_for(std::chrono::microseconds(INTERVAL - BREAK_DURATION_US - MAB_DURATION_US));
+    }
+}
+
+// Resetting the DMX channels
+void DMXDevice::resetChannels(){
+    for (auto &v : dmxData) {
+        v.store(0);
+    }
+    dmxData[0].store(DMX_START_CODE);
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+}
+
+// Linkable functions from Golang
+extern "C" {
+    // Create a new DMX device
+    DMXDevice* dmx_create() {
+        return new DMXDevice();
+    }
+
+    // Destroy a DMX device
+    void dmx_destroy(DMXDevice* dev) {
+        dev->~DMXDevice();
+    }
+
+    // Connect a DMX device
+    DMXError dmx_connect(DMXDevice* dev, char* serialNumber) {
+        try{
+            return dev->connect(serialNumber);
+        } catch (...) {
+            return DMX_UNKNOWN_ERROR;
+        }
+    }
+
+    // Activate a DMX device
+    DMXError dmx_activate(DMXDevice* dev) {
+        try{
+            return dev->activate();
+        } catch (...) {
+            return DMX_UNKNOWN_ERROR;
+        }
+    }
+
+    // Deactivate a DMX device
+    DMXError dmx_deactivate(DMXDevice* dev) {
+        try{
+            return dev->activate();
+        } catch (...) {
+            return DMX_UNKNOWN_ERROR;
+        }
+    }
+
+    // Set the channel value of a DMX device
+    DMXError dmx_setValue(DMXDevice* dev, int channel, int value) {
+        try {
+            return dev->setValue(channel, value);
+        } catch (...) {
+            return DMX_UNKNOWN_ERROR;
+        }
+    }
+}

hardware/cpp/src/dmxSender.h

@@ -0,0 +1,65 @@
+// dmxSender.h
+
+#pragma once
+
+#include <vector>
+#include <cstdint>
+#include <atomic>
+#include <thread>
+#include "ftd2xx.h"
+
+#define DMX_START_CODE 0x00
+#define BREAK_DURATION_US 110
+#define MAB_DURATION_US 16
+#define DMX_CHANNELS 512
+#define FREQUENCY 44
+#define INTERVAL (1000000 / FREQUENCY) 
+
+typedef enum {
+    DMX_OK,
+    DMX_CHANNEL_TOO_LOW_ERROR,
+    DMX_CHANNEL_TOO_HIGH_ERROR,
+    DMX_VALUE_TOO_LOW_ERROR,
+    DMX_VALUE_TOO_HIGH_ERROR,
+    DMX_OPEN_ERROR,
+    DMX_SET_BAUDRATE_ERROR,
+    DMX_SET_DATA_CHARACTERISTICS_ERROR,
+    DMX_SET_FLOW_ERROR,
+    DMX_UNKNOWN_ERROR
+} DMXError;
+
+class DMXDevice {
+public:
+    // Initialize default values for starting the DMX device
+    DMXDevice();
+
+    // Properly close the DMX device
+    ~DMXDevice();
+
+    // Connect the device on a specific port
+    DMXError connect(char* serialNumber);
+
+    // Activate the DMX flow
+    DMXError activate();
+
+    // Deactivate the DMX flow
+    DMXError deactivate();
+
+    // Set the value of a DMX channel
+    DMXError setValue(uint16_t channel, uint8_t value);
+
+    // Resetting the DMX channels
+    void resetChannels();
+
+private:
+    FT_STATUS ftStatus; // FTDI peripheral status
+    FT_HANDLE ftHandle = nullptr; // FTDI object
+    std::atomic<uint8_t> dmxData[DMX_CHANNELS + 1]; // For storing dynamically the DMX data
+    std::atomic<bool> isOutputActivated = false; // Boolean to start/stop the DMX flow
+
+    // Send a break line
+    FT_STATUS sendBreak(FT_HANDLE ftHandle);
+
+    // Continuously send the DMX frame
+    void sendDMX(FT_HANDLE ftHandle);
+};

hardware/cpp/test/detectFTDI_test.cpp

@@ -0,0 +1,14 @@
+#include "../src/detectFTDI.h"
+#include <iostream>
+
+int main(){
+    int peripheralsNumber = getFTDIPeripheralsNumber();
+
+
+    std::vector<FTDIPeripheral> peripherals = scanFTDIPeripherals();
+
+    // for (const auto& peripheral : peripherals) {
+    //     std::cout << peripheral.serialNumber << " (" << peripheral.description << ") -> IS OPEN: " << peripheral.isOpen << std::endl;
+    // }
+
+}

hardware/cpp/test/dmxSender_test.cpp

@@ -0,0 +1,122 @@
+#include "../src/dmxSender.h"
+
+#include <iostream>
+#include <thread>
+#include <chrono>
+
+int main(){
+    std::cout << "Debugging application DMXSENDER" << std::endl;
+
+    DMXDevice* dev = nullptr;
+    try {
+        dev = new DMXDevice();
+    }
+    catch(const std::exception &e){
+        std::cout << "Unable to create a DMX device: " << e.what() << std::endl;
+    }
+
+    if (!dev) { 
+        std::cout << "Device not created, aborting." << std::endl;
+        return 1;
+    }
+
+    try {
+        bool err = dev->connect(0);
+
+        if (err == true) {
+            delete dev;
+            return 1;
+        }
+    }
+    catch (const std::exception &e){
+        std::cout << "Unable to connect" << e.what() << std::endl;
+        delete dev;
+        return 1;
+    }
+
+    try{
+        dev->activate();
+    }
+    catch(const std::exception &e){
+        std::cout << "Unable to activate" << e.what() << std::endl;
+        delete dev;
+        return 1;
+    }
+
+    try{
+        dev->setValue(1, 100);
+        dev->setValue(2, 255);
+    }
+    catch(const std::exception &e){
+        std::cout << "Unable to activate" << e.what() << std::endl;
+        delete dev;
+        return 1;
+    } 
+
+    Sleep(500);
+
+    try{
+        dev->setValue(2, 127);
+        dev->setValue(3, 255);
+    }
+    catch(const std::exception &e){
+        std::cout << "Unable to activate" << e.what() << std::endl;
+        delete dev;
+        return 1;
+    } 
+
+    Sleep(500);
+
+    try{
+        dev->setValue(3, 127);
+        dev->setValue(4, 255);
+    }
+    catch(const std::exception &e){
+        std::cout << "Unable to activate" << e.what() << std::endl;
+        delete dev;
+        return 1;
+    } 
+
+    Sleep(500);
+
+
+    try{
+        dev->setValue(2, 0);
+        dev->setValue(3, 0);
+        dev->setValue(4, 0);
+        dev->setValue(5, 255);
+    }
+    catch(const std::exception &e){
+        std::cout << "Unable to activate" << e.what() << std::endl;
+        delete dev;
+        return 1;
+    } 
+
+    Sleep(5000);
+
+
+    // try{
+    //     dev->setValue(3, 255);
+    // }
+    // catch(const std::exception &e){
+    //     std::cout << "Unable to activate" << e.what() << std::endl;
+    //     delete dev;
+    //     return 1;
+    // } 
+
+    // Sleep(5000);
+
+    // try{
+    //     dev->setValue(4, 255);
+    // }
+    // catch(const std::exception &e){
+    //     std::cout << "Unable to activate" << e.what() << std::endl;
+    //     delete dev;
+    //     return 1;
+    // } 
+
+    // Sleep(5000);
+
+    delete dev;
+    return 0;
+}

hardware/hardware.go

@@ -0,0 +1,150 @@
+package hardware
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+
+	"github.com/rs/zerolog/log"
+	"github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+// PeripheralEvent is trigger by the finders when the scan is complete
+type PeripheralEvent string
+
+// PeripheralStatus is the peripheral status (DISCONNECTED => CONNECTING => DEACTIVATED => ACTIVATED)
+type PeripheralStatus string
+
+const (
+	// PeripheralArrival is triggerd when a peripheral has been connected to the system
+	PeripheralArrival PeripheralEvent = "PERIPHERAL_ARRIVAL"
+	// PeripheralRemoval is triggered when a peripheral has been disconnected from the system
+	PeripheralRemoval PeripheralEvent = "PERIPHERAL_REMOVAL"
+	// PeripheralStatusUpdated is triggered when a peripheral status has been updated (disconnected - connecting - deactivated - activated)
+	PeripheralStatusUpdated PeripheralEvent = "PERIPHERAL_STATUS"
+	// PeripheralEventEmitted is triggered when a peripheral event is emitted
+	PeripheralEventEmitted PeripheralEvent = "PERIPHERAL_EVENT_EMITTED"
+	// PeripheralStatusDisconnected : peripheral is now disconnected
+	PeripheralStatusDisconnected PeripheralStatus = "PERIPHERAL_DISCONNECTED"
+	// PeripheralStatusConnecting : peripheral is now connecting
+	PeripheralStatusConnecting PeripheralStatus = "PERIPHERAL_CONNECTING"
+	// PeripheralStatusDeactivated : peripheral is now deactivated
+	PeripheralStatusDeactivated PeripheralStatus = "PERIPHERAL_DEACTIVATED"
+	// PeripheralStatusActivated : peripheral is now activated
+	PeripheralStatusActivated PeripheralStatus = "PERIPHERAL_ACTIVATED"
+)
+
+// HardwareManager is the class who manages the hardware
+type HardwareManager struct {
+	wg sync.WaitGroup
+
+	finders                map[string]PeripheralFinder // The map of peripherals finders
+	peripherals            []Peripheral                // The current list of peripherals
+	peripheralsScanTrigger chan struct{}               // Trigger the peripherals scans
+}
+
+// NewHardwareManager creates a new HardwareManager
+func NewHardwareManager() *HardwareManager {
+	log.Trace().Str("package", "hardware").Msg("Hardware instance created")
+	return &HardwareManager{
+		finders:                make(map[string]PeripheralFinder),
+		peripherals:            make([]Peripheral, 0),
+		peripheralsScanTrigger: make(chan struct{}),
+	}
+}
+
+// Start starts to find new peripheral events
+func (h *HardwareManager) Start(ctx context.Context) error {
+	// Initialize all the finders and their callback functions
+	for finderName, finder := range h.finders {
+		err := finder.Initialize()
+		if err != nil {
+			log.Err(err).Str("file", "hardware").Str("finderName", finderName).Msg("unable to initialize finder")
+			return err
+		}
+		finder.OnArrival(func(p PeripheralInfo) {
+			runtime.EventsEmit(ctx, string(PeripheralArrival), p)
+		})
+		finder.OnRemoval(func(p PeripheralInfo) {
+			runtime.EventsEmit(ctx, string(PeripheralRemoval), p)
+		})
+		err = finder.Start(ctx)
+		if err != nil {
+			log.Err(err).Str("file", "hardware").Str("finderName", finderName).Msg("unable to start finder")
+			return err
+		}
+	}
+
+	// Periodically scan all the finders
+	h.wg.Add(1)
+	go func() {
+		defer h.wg.Done()
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-h.peripheralsScanTrigger:
+				for finderName, finder := range h.finders {
+					log.Trace().Str("file", "hardware").Str("finderName", finderName).Msg("force a finder to scan peripherals")
+					finder.ForceScan()
+				}
+			}
+		}
+	}()
+	return nil
+}
+
+// GetFinder returns a register finder
+func (h *HardwareManager) GetFinder(finderName string) (PeripheralFinder, error) {
+	finder, exists := h.finders[finderName]
+	if !exists {
+		log.Error().Str("file", "hardware").Str("finderName", finderName).Msg("unable to get the finder")
+		return nil, fmt.Errorf("unable to locate the '%s' finder", finderName)
+	}
+	log.Debug().Str("file", "hardware").Str("finderName", finderName).Msg("got finder")
+	return finder, nil
+}
+
+// RegisterFinder registers a new peripherals finder
+func (h *HardwareManager) RegisterFinder(finder PeripheralFinder) {
+	h.finders[finder.GetName()] = finder
+	log.Info().Str("file", "hardware").Str("finderName", finder.GetName()).Msg("finder registered")
+}
+
+// Scan scans all the peripherals for the registered finders
+func (h *HardwareManager) Scan() error {
+	select {
+	case h.peripheralsScanTrigger <- struct{}{}:
+		return nil
+	default:
+		return fmt.Errorf("scan trigger not available (manager stopped?)")
+	}
+}
+
+// WaitStop stops the hardware manager
+func (h *HardwareManager) WaitStop() error {
+	log.Trace().Str("file", "hardware").Msg("closing the hardware manager")
+
+	// Closing trigger channel
+	close(h.peripheralsScanTrigger)
+
+	// Stop each finder
+	var errs []error
+	for name, f := range h.finders {
+		if err := f.WaitStop(); err != nil {
+			errs = append(errs, fmt.Errorf("%s: %w", name, err))
+		}
+	}
+
+	// Wait for goroutines to finish
+	h.wg.Wait()
+
+	// Returning errors
+	if len(errs) > 0 {
+		return errors.Join(errs...)
+	}
+	log.Info().Str("file", "hardware").Msg("hardware manager stopped")
+
+	return nil
+}

hardware/interfaces.go

@@ -0,0 +1,41 @@
+package hardware
+
+import "context"
+
+// Peripheral represents the methods used to manage a peripheral (input or output hardware)
+type Peripheral interface {
+	Connect(context.Context) error                         // Connect the peripheral
+	SetEventCallback(func(any))                            // Callback is called when an event is emitted from the peripheral
+	Disconnect(context.Context) error                      // Disconnect the peripheral
+	Activate(context.Context) error                        // Activate the peripheral
+	Deactivate(context.Context) error                      // Deactivate the peripheral
+	SetSettings(context.Context, map[string]any) error     // Set a peripheral setting
+	SetDeviceProperty(context.Context, uint32, byte) error // Update a device property
+	WaitStop() error                                       // Properly close the peripheral
+
+	GetInfo() PeripheralInfo     // Get the peripheral information
+	GetSettings() map[string]any // 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     map[string]any `yaml:"settings"` // Peripheral settings
+}
+
+// PeripheralFinder represents how compatible peripheral drivers are implemented
+type PeripheralFinder interface {
+	Initialize() error                                                   // Initializes the protocol
+	OnArrival(cb func(p PeripheralInfo))                                 // Callback function when a peripheral arrives
+	OnRemoval(cb func(p PeripheralInfo))                                 // Callback function when a peripheral goes away
+	Start(context.Context) error                                         // Start the detection
+	WaitStop() error                                                     // Waiting for finder to close
+	ForceScan()                                                          // Explicitly scans for peripherals
+	RegisterPeripheral(context.Context, PeripheralInfo) (string, error)  // Registers a new peripheral data
+	UnregisterPeripheral(context.Context, PeripheralInfo) error          // Unregisters an existing peripheral
+	GetPeripheralSettings(string) (map[string]any, error)                // Gets the peripheral settings
+	SetPeripheralSettings(context.Context, string, map[string]any) error // Sets the peripheral settings
+	GetName() string                                                     // Get the name of the finder
+}

main.go

@@ -2,8 +2,14 @@ package main
 
 import (
 	"embed"
+	"time"
 
+	"os"
+
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
 	"github.com/wailsapp/wails/v2"
+	"github.com/wailsapp/wails/v2/pkg/logger"
 	"github.com/wailsapp/wails/v2/pkg/options"
 	"github.com/wailsapp/wails/v2/pkg/options/assetserver"
 )
@@ -12,25 +18,38 @@ import (
 var assets embed.FS
 
 func main() {
+	// Configure the logger
+	log.Logger = log.Output(zerolog.ConsoleWriter{
+		Out:        os.Stderr,
+		TimeFormat: "2006-01-02 15:04:05",
+	})
+	zerolog.TimestampFunc = func() time.Time {
+		return time.Now().Local()
+	}
+	zerolog.SetGlobalLevel(zerolog.TraceLevel)
+
 	// Create an instance of the app structure
 	app := NewApp()
 
 	// Create application with options
 	err := wails.Run(&options.App{
-		Title:  "dmxconnect",
-		Width:  1024,
-		Height: 768,
+		Title:            "dmxconnect",
+		Width:            1024,
+		Height:           768,
+		WindowStartState: options.Maximised,
 		AssetServer: &assetserver.Options{
 			Assets: assets,
 		},
-		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
-		OnStartup:        app.startup,
+		OnStartup:  app.onStartup,
+		OnDomReady: app.onReady,
+		OnShutdown: app.onShutdown,
 		Bind: []interface{}{
 			app,
 		},
+		LogLevel: logger.ERROR,
 	})
 
 	if err != nil {
-		println("Error:", err.Error())
+		log.Err(err).Str("file", "main").Msg("unable to start the application")
 	}
 }

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "dmxconnect",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

package.json

@@ -0,0 +1 @@
+{}

peripherals.go

@@ -0,0 +1,126 @@
+package main
+
+import (
+	"dmxconnect/hardware"
+	"fmt"
+
+	"github.com/rs/zerolog/log"
+)
+
+// AddPeripheral adds a peripheral to the project
+func (a *App) AddPeripheral(peripheralData hardware.PeripheralInfo) (string, error) {
+	// Get the peripheral from its finder
+	f, err := a.hardwareManager.GetFinder(peripheralData.ProtocolName)
+	if err != nil {
+		log.Error().Str("file", "peripheral").Str("protocolName", peripheralData.ProtocolName).Msg("unable to found the specified finder")
+		return "", fmt.Errorf("unable to found the peripheral ID '%s'", peripheralData.SerialNumber)
+	}
+	// Register this new peripheral
+	serialNumber, err := f.RegisterPeripheral(a.ctx, peripheralData)
+	if err != nil {
+		return "", fmt.Errorf("unable to register the peripheral '%s': %w", serialNumber, err)
+	}
+	log.Trace().Str("file", "peripheral").Str("protocolName", peripheralData.ProtocolName).Str("periphID", serialNumber).Msg("device registered to the finder")
+
+	// Rewrite the serialnumber for virtual devices
+	peripheralData.SerialNumber = serialNumber
+
+	// Add the peripheral ID to the project
+	if a.projectInfo.PeripheralsInfo == nil {
+		a.projectInfo.PeripheralsInfo = make(map[string]hardware.PeripheralInfo)
+	}
+
+	a.projectInfo.PeripheralsInfo[peripheralData.SerialNumber] = peripheralData
+	log.Info().Str("file", "peripheral").Str("protocolName", peripheralData.ProtocolName).Str("periphID", peripheralData.SerialNumber).Msg("peripheral added to project")
+	return peripheralData.SerialNumber, nil
+}
+
+// GetPeripheralSettings gets the peripheral settings
+func (a *App) GetPeripheralSettings(protocolName, peripheralID string) (map[string]any, error) {
+	// Get the peripheral from its finder
+	f, err := a.hardwareManager.GetFinder(protocolName)
+	if err != nil {
+		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 f.GetPeripheralSettings(peripheralID)
+}
+
+// UpdatePeripheralSettings updates a specific setting of a peripheral
+func (a *App) UpdatePeripheralSettings(protocolName, peripheralID string, settings map[string]any) error {
+	// Sets the settings with the finder
+	f, err := a.hardwareManager.GetFinder(protocolName)
+	if err != nil {
+		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 f.SetPeripheralSettings(a.ctx, peripheralID, pInfo.Settings)
+}
+
+// RemovePeripheral removes a peripheral from the project
+func (a *App) RemovePeripheral(peripheralData hardware.PeripheralInfo) error {
+	// Unregister the peripheral from the finder
+	f, err := a.hardwareManager.GetFinder(peripheralData.ProtocolName)
+	if err != nil {
+		log.Err(err).Str("file", "peripherals").Str("protocolName", peripheralData.ProtocolName).Msg("unable to find the finder")
+		return fmt.Errorf("unable to find the finder")
+	}
+	err = f.UnregisterPeripheral(a.ctx, peripheralData)
+	if err != nil {
+		log.Err(err).Str("file", "peripherals").Str("peripheralID", peripheralData.SerialNumber).Msg("unable to unregister this peripheral")
+		return fmt.Errorf("unable to unregister this peripheral")
+	}
+	// Remove the peripheral ID from the project
+	delete(a.projectInfo.PeripheralsInfo, peripheralData.SerialNumber)
+	log.Info().Str("file", "peripheral").Str("protocolName", peripheralData.ProtocolName).Str("periphID", peripheralData.SerialNumber).Msg("peripheral removed from project")
+	return nil
+}
+
+// FOR TESTING PURPOSE ONLY
+
+// func (a *App) ActivateFTDI() error {
+// 	// Connect the FTDI
+// 	driver, err := a.hardwareManager.GetFinder("FTDI")
+// 	if err != nil {
+// 		return err
+// 	}
+// 	periph, found := driver.GetPeripheral("A50285BI")
+// 	if !found {
+// 		return fmt.Errorf("unable to find the peripheral s/n %s", "A50285BI")
+// 	}
+// 	return periph.Activate(a.ctx)
+// }
+
+// func (a *App) SetDeviceFTDI(channelValue byte) error {
+// 	// Connect the FTDI
+// 	driver, err := a.hardwareManager.GetFinder("FTDI")
+// 	if err != nil {
+// 		return err
+// 	}
+// 	periph, found := driver.GetPeripheral("A50285BI")
+// 	if !found {
+// 		return fmt.Errorf("unable to find the peripheral s/n %s", "A50285BI")
+// 	}
+// 	return periph.SetDeviceProperty(a.ctx, 0, 0, channelValue)
+// }
+
+// func (a *App) DeactivateFTDI() error {
+// 	// Connect the FTDI
+// 	driver, err := a.hardwareManager.GetFinder("FTDI")
+// 	if err != nil {
+// 		return err
+// 	}
+// 	periph, found := driver.GetPeripheral("A50285BI")
+// 	if !found {
+// 		return fmt.Errorf("unable to find the peripheral s/n %s", "A50285BI")
+// 	}
+// 	return periph.Deactivate(a.ctx)
+// }

project.go

@@ -0,0 +1,248 @@
+package main
+
+import (
+	"dmxconnect/hardware"
+	"fmt"
+
+	"github.com/rs/zerolog/log"
+
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/wailsapp/wails/v2/pkg/runtime"
+	"gopkg.in/yaml.v2"
+)
+
+const (
+	projectsDirectory = "projects"        // The directory were are stored all the projects
+	avatarsDirectory  = "frontend/public" // The directory were are stored all the avatars
+	projectExtension  = ".dmxproj"        // The extension of a DMX Connect project
+)
+
+// GetProjects gets all the projects in the projects directory
+func (a *App) GetProjects() ([]ProjectMetaData, error) {
+	projects := []ProjectMetaData{}
+
+	f, err := os.Open(projectsDirectory)
+	if err != nil {
+		log.Err(err).Str("file", "project").Msg("unable to open the projects directory")
+		return nil, fmt.Errorf("unable to open the projects directory: %v", err)
+	}
+	log.Trace().Str("file", "project").Str("projectsDirectory", projectsDirectory).Msg("projects directory opened")
+
+	files, err := f.Readdir(0)
+	if err != nil {
+		log.Err(err).Str("file", "project").Msg("unable to read the projects directory")
+		return nil, fmt.Errorf("unable to read the projects directory: %v", err)
+	}
+	log.Trace().Str("file", "project").Any("projectsFiles", files).Msg("project files got")
+
+	for _, fileInfo := range files {
+		// Open the file and get the show name
+		fileData, err := os.ReadFile(filepath.Join(projectsDirectory, fileInfo.Name()))
+		if err != nil {
+			log.Warn().Str("file", "project").Str("projectFile", fileInfo.Name()).Msg("unable to open the project file")
+			continue
+		}
+		log.Trace().Str("file", "project").Str("projectFile", fileInfo.Name()).Any("fileData", fileData).Msg("project file read")
+
+		projectObject := ProjectInfo{}
+		err = yaml.Unmarshal(fileData, &projectObject)
+		if err != nil {
+			log.Warn().Str("file", "project").Str("projectFile", fileInfo.Name()).Msg("project has invalid format")
+			continue
+		}
+		log.Trace().Str("file", "project").Str("projectFile", fileInfo.Name()).Msg("project file unmarshalled")
+
+		// Add the SaveFile property
+		projects = append(projects, ProjectMetaData{
+			Name: projectObject.ShowInfo.Name,
+			Save: fileInfo.Name(),
+		})
+	}
+	log.Info().Str("file", "project").Any("projectsList", projects).Msg("got the projects list")
+	return projects, nil
+}
+
+// CreateProject creates a new blank project
+func (a *App) CreateProject() error {
+
+	// Create new project information
+	date := time.Now()
+	projectInfo := ProjectInfo{
+		ShowInfo{
+			Name:     "My new show",
+			Date:     fmt.Sprintf("%04d-%02d-%02dT%02d:%02d", date.Year(), date.Month(), date.Day(), date.Hour(), date.Minute()),
+			Avatar:   "appicon.png",
+			Comments: "Write your comments here",
+		},
+		make(map[string]hardware.PeripheralInfo),
+	}
+
+	// The project isn't saved for now
+	a.projectSave = ""
+
+	return a.OpenProject(projectInfo)
+}
+
+// OpenProjectFromDisk opens a project based on its filename
+func (a *App) OpenProjectFromDisk(projectFile string) error {
+	// Open the project file
+	projectPath := filepath.Join(projectsDirectory, projectFile)
+	log.Trace().Str("file", "project").Str("projectPath", projectPath).Msg("project path is created")
+	content, err := os.ReadFile(projectPath)
+	if err != nil {
+		log.Err(err).Str("file", "project").Str("projectFile", projectFile).Msg("Unable to read the project file")
+		return fmt.Errorf("unable to read the project file: %v", err)
+	}
+	log.Trace().Str("file", "project").Str("projectPath", projectPath).Msg("project file read")
+
+	// Import project data structure
+	projectInfo := ProjectInfo{}
+	err = yaml.Unmarshal(content, &projectInfo)
+	if err != nil {
+		log.Err(err).Str("file", "project").Str("projectFile", projectFile).Msg("Unable to get the project information")
+		return fmt.Errorf("unable to get the project information: %v", err)
+	}
+	log.Trace().Str("file", "project").Str("projectPath", projectPath).Msg("project information got")
+
+	// The project is saved
+	a.projectSave = projectFile
+
+	return a.OpenProject(projectInfo)
+}
+
+// OpenProject opens a project based on its information
+func (a *App) OpenProject(projectInfo ProjectInfo) error {
+	// Close the current project
+	err := a.CloseCurrentProject()
+	if err != nil {
+		return fmt.Errorf("unable to close project: %w", err)
+	}
+
+	// Open the project
+	a.projectInfo = projectInfo
+
+	// Send an event with the project data
+	runtime.EventsEmit(a.ctx, "LOAD_PROJECT", projectInfo.ShowInfo)
+
+	// Load all peripherals of the project
+	projectPeripherals := a.projectInfo.PeripheralsInfo
+	for key, value := range projectPeripherals {
+		hostFinder, err := a.hardwareManager.GetFinder(value.ProtocolName)
+		if err != nil {
+			return fmt.Errorf("unable to find the finder '%s': %w", value.ProtocolName, err)
+		}
+		_, err = hostFinder.RegisterPeripheral(a.ctx, value)
+		if err != nil {
+			return fmt.Errorf("unable to register the peripheral S/N '%s': %w", key, err)
+		}
+	}
+	return nil
+}
+
+// CloseCurrentProject closes the current project
+func (a *App) CloseCurrentProject() error {
+	// Unregistrer all peripherals of the project
+	projectPeripherals := a.projectInfo.PeripheralsInfo
+	for key, value := range projectPeripherals {
+		hostFinder, err := a.hardwareManager.GetFinder(value.ProtocolName)
+		if err != nil {
+			return fmt.Errorf("unable to find the finder '%s': %w", value.ProtocolName, err)
+		}
+		err = hostFinder.UnregisterPeripheral(a.ctx, value)
+		if err != nil {
+			return fmt.Errorf("unable to unregister the peripheral S/N '%s': %w", key, err)
+		}
+	}
+
+	// Unload project info in the front
+	return nil
+}
+
+// ChooseAvatarPath opens a filedialog to choose the show avatar
+func (a *App) ChooseAvatarPath() (string, error) {
+	// Open the file dialog box
+	filePath, err := runtime.OpenFileDialog(a.ctx, runtime.OpenDialogOptions{
+		Title: "Choose your show avatar",
+		Filters: []runtime.FileFilter{
+			{
+				DisplayName: "Images",
+				Pattern:     "*.png;*.jpg;*.jpeg",
+			},
+		},
+	})
+	if err != nil {
+		log.Err(err).Str("file", "project").Msg("unable to open the avatar dialog")
+		return "", err
+	}
+	log.Debug().Str("file", "project").Msg("avatar dialog is opened")
+	// Copy the avatar to the application avatars path
+	avatarPath := filepath.Join(avatarsDirectory, filepath.Base(filePath))
+	log.Trace().Str("file", "project").Str("avatarPath", avatarPath).Msg("avatar path is created")
+	_, err = copy(filePath, avatarPath)
+	if err != nil {
+		log.Err(err).Str("file", "project").Str("avatarsDirectory", avatarsDirectory).Str("fileBase", filepath.Base(filePath)).Msg("unable to copy the avatar file")
+		return "", err
+	}
+	log.Info().Str("file", "project").Str("avatarFileName", filepath.Base(filePath)).Msg("got the new avatar file")
+	return filepath.Base(filePath), nil
+}
+
+// UpdateShowInfo updates the show information
+func (a *App) UpdateShowInfo(showInfo ShowInfo) {
+	a.projectInfo.ShowInfo = showInfo
+	log.Info().Str("file", "project").Any("showInfo", showInfo).Msg("show information was updated")
+}
+
+// SaveProject saves the project
+func (a *App) SaveProject() (string, error) {
+	// If there is no save file, create a new one with the show name
+	if a.projectSave == "" {
+		date := time.Now()
+		a.projectSave = fmt.Sprintf("%04d%02d%02d%02d%02d%02d%s", date.Year(), date.Month(), date.Day(), date.Hour(), date.Minute(), date.Second(), projectExtension)
+		log.Debug().Str("file", "project").Str("newProjectSave", a.projectSave).Msg("projectSave is null, getting a new one")
+	}
+	data, err := yaml.Marshal(a.projectInfo)
+	if err != nil {
+		log.Err(err).Str("file", "project").Any("projectInfo", a.projectInfo).Msg("unable to format the project information")
+		return "", err
+	}
+	log.Trace().Str("file", "project").Any("projectInfo", a.projectInfo).Msg("projectInfo has been marshalled")
+	// Create the project directory if not exists
+	err = os.MkdirAll(projectsDirectory, os.ModePerm)
+	if err != nil {
+		log.Err(err).Str("file", "project").Str("projectsDirectory", projectsDirectory).Msg("unable to create the projects directory")
+		return "", err
+	}
+	log.Trace().Str("file", "project").Str("projectsDirectory", projectsDirectory).Msg("projects directory has been created")
+
+	err = os.WriteFile(filepath.Join(projectsDirectory, a.projectSave), data, os.ModePerm)
+	if err != nil {
+		log.Err(err).Str("file", "project").Str("projectsDirectory", projectsDirectory).Str("projectSave", a.projectSave).Msg("unable to save the project")
+		return "", err
+	}
+	log.Info().Str("file", "project").Str("projectFileName", a.projectSave).Msg("project has been saved")
+	return a.projectSave, nil
+}
+
+// ShowInfo defines the information of the show
+type ShowInfo struct {
+	Name     string `yaml:"name"`
+	Date     string `yaml:"date"`
+	Avatar   string `yaml:"avatar"`
+	Comments string `yaml:"comments"`
+}
+
+// ProjectMetaData defines all the minimum information for a lighting project
+type ProjectMetaData struct {
+	Name string // Show name
+	Save string // The save file of the project
+}
+
+// ProjectInfo defines all the information for a lighting project
+type ProjectInfo struct {
+	ShowInfo        ShowInfo                           `yaml:"show"`        // Show information
+	PeripheralsInfo map[string]hardware.PeripheralInfo `yaml:"peripherals"` // Peripherals information
+}

wails.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://wails.io/schemas/config.v2.json",
   "name": "dmxconnect",
-  "outputfilename": "dmxconnect",
+  "outputfilename": "dmxconnect.exe",
   "frontend:install": "npm install",
   "frontend:build": "npm run build",
   "frontend:dev:watcher": "npm run dev",