11-hardware-definition (#17)

- Detection of FTDI and MIDI peripherals
- Creation od OS2L peripherals
- Optimization

Reviewed-on: #17

hardware/FTDIFinder.go

@@ -0,0 +1,231 @@
+package hardware
+
+import (
+	"bufio"
+	"context"
+	_ "embed"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	goRuntime "runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/rs/zerolog/log"
+)
+
+const (
+	ftdiFinderExecutableName = "FTDI_finder.exe"
+	ftdiSenderExecutableName = "FTDI_sender.exe"
+)
+
+// FTDIFinder represents how the protocol is defined
+type FTDIFinder struct {
+	findTicker  time.Ticker           // Peripherals find ticker
+	peripherals map[string]Peripheral // The list of peripherals handled by this finder
+	scanChannel chan struct{}         // The channel to trigger a scan event
+	goWait      sync.WaitGroup        // Check goroutines execution
+}
+
+// NewFTDIFinder creates a new FTDI finder
+func NewFTDIFinder(findPeriod time.Duration) *FTDIFinder {
+	log.Trace().Str("file", "FTDIFinder").Msg("FTDI finder created")
+	return &FTDIFinder{
+		findTicker:  *time.NewTicker(findPeriod),
+		peripherals: make(map[string]Peripheral),
+		scanChannel: make(chan struct{}),
+	}
+}
+
+//go:embed third-party/ftdi/detectFTDI.exe
+var finderExe []byte
+
+//go:embed third-party/ftdi/dmxSender.exe
+var senderExe []byte
+
+// 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)
+	}
+	// Create the FTDI executables
+	err := createExecutable(ftdiFinderExecutableName, finderExe)
+	if err != nil {
+		return err
+	}
+	createExecutable(ftdiSenderExecutableName, senderExe)
+	if err != nil {
+		return err
+	}
+	log.Trace().Str("file", "FTDIFinder").Msg("FTDI finder initialized")
+	return nil
+}
+
+// createExecutable creates and writes an executable to the temporary directory of the system
+func createExecutable(fileName string, storedFile []byte) error {
+	tempFile, err := os.Create(filepath.Join(os.TempDir(), fileName))
+	if err != nil {
+		log.Err(err).Str("file", "FTDIFinder").Str("fileName", fileName).Msg("unable to create an FTDI executable")
+		return err
+	}
+	log.Trace().Str("file", "FTDIFinder").Str("filePath", tempFile.Name()).Msg("FTDI executable created")
+
+	// Write the embedded executable to the temp file
+	if _, err := tempFile.Write(storedFile); err != nil {
+		log.Err(err).Str("file", "FTDIFinder").Str("fileName", fileName).Msg("unable to write the content to an FTDI executable")
+		return err
+	}
+	tempFile.Close()
+	log.Trace().Str("file", "FTDIPeripheral").Str("fileName", fileName).Msg("FTDI executable written")
+	return nil
+}
+
+// Start starts the finder and search for peripherals
+func (f *FTDIFinder) 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", "FTDIFinder").Msg("unable to scan FTDI peripherals")
+				}
+			case <-f.scanChannel:
+				// 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 explicily asks for scanning peripherals
+func (f *FTDIFinder) ForceScan() {
+	f.scanChannel <- struct{}{}
+}
+
+// Stop stops the finder
+func (f *FTDIFinder) Stop() error {
+	log.Trace().Str("file", "FTDIFinder").Msg("stopping the FTDI finder...")
+	// Wait for goroutines to stop
+	f.goWait.Wait()
+	// Stop the ticker
+	f.findTicker.Stop()
+	// Delete the FTDI executable files
+	fileToDelete := filepath.Join(os.TempDir(), ftdiFinderExecutableName)
+	err := os.Remove(fileToDelete)
+	if err != nil {
+		log.Warn().Str("file", "FTDIFinder").Str("fileName", fileToDelete).AnErr("error", err).Msg("unable to remove the executable file")
+	}
+	fileToDelete = filepath.Join(os.TempDir(), ftdiSenderExecutableName)
+	err = os.Remove(fileToDelete)
+	if err != nil {
+		log.Warn().Str("file", "FTDIFinder").Str("fileName", fileToDelete).AnErr("error", err).Msg("unable to remove the executable file")
+	}
+	log.Trace().Str("file", "FTDIFinder").Msg("FTDI finder stopped")
+	return nil
+}
+
+// GetName returns the name of the driver
+func (f *FTDIFinder) GetName() string {
+	return "FTDI"
+}
+
+// GetPeripheral gets the peripheral that correspond to the specified ID
+func (f *FTDIFinder) GetPeripheral(peripheralID string) (Peripheral, bool) {
+	// Return the specified peripheral
+	peripheral := f.peripherals[peripheralID]
+	if peripheral == nil {
+		log.Error().Str("file", "FTDIFinder").Str("peripheralID", peripheralID).Msg("unable to get this peripheral from the FTDI finder")
+		return nil, false
+	}
+	log.Debug().Str("file", "FTDIFinder").Str("peripheralID", peripheralID).Msg("peripheral found by the FTDI finder")
+	return peripheral, true
+}
+
+// scanPeripherals scans the FTDI peripherals
+func (f *FTDIFinder) scanPeripherals(ctx context.Context) error {
+	detectionCtx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	log.Trace().Str("file", "FTDIFinder").Msg("FTDI scan triggered")
+
+	ftdiPeripherals := make(map[string]Peripheral)
+
+	finder := exec.CommandContext(detectionCtx, filepath.Join(os.TempDir(), ftdiFinderExecutableName))
+	log.Trace().Str("file", "FTDIFinder").Msg("has executed the FIND executable")
+
+	stdout, err := finder.StdoutPipe()
+	if err != nil {
+		return fmt.Errorf("unable to create the stdout pipe: %s", err)
+	}
+	defer stdout.Close()
+
+	stderr, err := finder.StderrPipe()
+	if err != nil {
+		return fmt.Errorf("unable to create the stderr pipe: %s", err)
+	}
+	defer stderr.Close()
+
+	err = finder.Start()
+	if err != nil {
+		return fmt.Errorf("unable to find FTDI peripherals: %s", err)
+	}
+
+	scannerErr := bufio.NewScanner(stderr)
+	for scannerErr.Scan() {
+		return fmt.Errorf("unable to find FTDI peripherals: %s", scannerErr.Text())
+	}
+
+	scanner := bufio.NewScanner(stdout)
+	for scanner.Scan() {
+		peripheralString := scanner.Text()
+		// The program output is like '0:1:2' where 0 is the location, 1 is the S/N and 2 is the name
+		peripheralInfo := strings.Split(peripheralString, ":")
+
+		log.Trace().Str("file", "FTDIFinder").Str("scannedString", peripheralString).Str("peripheralName", peripheralInfo[2]).Str("peripheralSN", peripheralInfo[1]).Msg("new FTDI peripheral detected")
+		// Convert the location to an integer
+		location, err := strconv.Atoi(peripheralInfo[0])
+		if err != nil {
+			log.Warn().Str("file", "FTDIFinder").Str("peripheralName", peripheralInfo[2]).Msg("no location provided for this FTDI peripheral")
+			location = -1
+		}
+		// Add the peripheral to the temporary list
+		peripheral, err := NewFTDIPeripheral(peripheralInfo[2], peripheralInfo[1], location)
+		if err != nil {
+			return fmt.Errorf("unable to create the FTDI peripheral: %v", err)
+		}
+		log.Trace().Any("periph", &peripheral).Str("file", "FTDIFinder").Str("peripheralName", peripheralInfo[2]).Msg("has been created")
+
+		ftdiPeripherals[peripheralInfo[1]] = peripheral
+		log.Trace().Any("periph", ftdiPeripherals).Str("file", "FTDIFinder").Str("peripheralName", peripheralInfo[2]).Msg("successfully added the FTDI peripheral to the finder")
+	}
+	// Emit the peripherals changes to the front
+	emitPeripheralsChanges(ctx, f.peripherals, ftdiPeripherals)
+	// Store the new peripherals list
+	f.peripherals = ftdiPeripherals
+	return nil
+}
+
+// CreatePeripheral is not implemented here
+func (f *FTDIFinder) CreatePeripheral(context.Context) (Peripheral, error) {
+	return nil, nil
+}
+
+// DeletePeripheral is not implemented here
+func (f *FTDIFinder) DeletePeripheral(serialNumber string) error {
+	return nil
+}

hardware/FTDIPeripheral.go

@@ -0,0 +1,196 @@
+package hardware
+
+import (
+	"bufio"
+	"context"
+	_ "embed"
+	"fmt"
+	"io"
+
+	"github.com/rs/zerolog/log"
+
+	"os"
+	"os/exec"
+)
+
+const (
+	activateCommandString   = 0x01
+	deactivateCommandString = 0x02
+	setCommandString        = 0x03
+)
+
+// FTDIPeripheral contains the data of an FTDI peripheral
+type FTDIPeripheral struct {
+	name            string         // The name of the peripheral
+	serialNumber    string         // The S/N of the FTDI peripheral
+	location        int            // The location of the peripheral
+	universesNumber int            // The number of DMX universes handled by this peripheral
+	programName     string         // The temp file name of the executable
+	dmxSender       *exec.Cmd      // The command to pilot the DMX sender program
+	stdin           io.WriteCloser // For writing in the DMX sender
+	stdout          io.ReadCloser  // For reading from the DMX sender
+	stderr          io.ReadCloser  // For reading the errors
+	disconnectChan  chan struct{}  // Channel to cancel the connection
+	errorsChan      chan error     // Channel to get the errors
+}
+
+// NewFTDIPeripheral creates a new FTDI peripheral
+func NewFTDIPeripheral(name string, serialNumber string, location int) (*FTDIPeripheral, error) {
+	log.Info().Str("file", "FTDIPeripheral").Str("name", name).Str("s/n", serialNumber).Int("location", location).Msg("FTDI peripheral created")
+	return &FTDIPeripheral{
+		name:            name,
+		dmxSender:       nil,
+		serialNumber:    serialNumber,
+		location:        location,
+		universesNumber: 1,
+		disconnectChan:  make(chan struct{}),
+		errorsChan:      make(chan error, 1),
+	}, nil
+}
+
+// Connect connects the FTDI peripheral
+func (p *FTDIPeripheral) Connect(ctx context.Context) error {
+	// Connect if no connection is already running
+	log.Trace().Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("connecting FTDI peripheral...")
+
+	// Check if the connection has already been established
+	if p.dmxSender != nil {
+		log.Warn().Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("dmxSender already initialized")
+		return nil
+	}
+
+	// Initialize the exec.Command for running the process
+	p.dmxSender = exec.Command(p.programName, fmt.Sprintf("%d", p.location))
+	log.Trace().Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("dmxSender instance created")
+
+	// Create the pipes for stdin, stdout, and stderr asynchronously without blocking
+	var err error
+	if p.stdout, err = p.dmxSender.StdoutPipe(); err != nil {
+		log.Err(err).Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("unable to create stdout pipe")
+		return fmt.Errorf("unable to create stdout pipe: %v", err)
+	}
+	if p.stdin, err = p.dmxSender.StdinPipe(); err != nil {
+		log.Err(err).Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("unable to create stdin pipe")
+		return fmt.Errorf("unable to create stdin pipe: %v", err)
+	}
+	if p.stderr, err = p.dmxSender.StderrPipe(); err != nil {
+		log.Err(err).Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("unable to create stderr pipe")
+		return fmt.Errorf("unable to create stderr pipe: %v", err)
+	}
+
+	// Launch a goroutine to read stderr asynchronously
+	go func() {
+		scanner := bufio.NewScanner(p.stderr)
+		for scanner.Scan() {
+			// Process each line read from stderr
+			log.Err(fmt.Errorf(scanner.Text())).Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("error detected in dmx sender")
+		}
+		if err := scanner.Err(); err != nil {
+			log.Err(err).Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("error reading from stderr")
+		}
+	}()
+
+	// Launch the command asynchronously in another goroutine
+	go func() {
+		// Run the command, respecting the context cancellation
+		err := p.dmxSender.Run()
+		select {
+		case <-ctx.Done():
+			// If the context is canceled, handle it gracefully
+			log.Warn().Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("dmxSender was canceled by context")
+			return
+		default:
+			// Handle command exit normally
+			if err != nil {
+				log.Err(err).Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("error while execution of dmx sender")
+				if exitError, ok := err.(*exec.ExitError); ok {
+					log.Warn().Str("file", "FTDIPeripheral").Int("exitCode", exitError.ExitCode()).Str("s/n", p.serialNumber).Msg("dmx sender exited with code")
+				}
+			} else {
+				log.Debug().Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("dmx sender exited successfully")
+			}
+		}
+	}()
+
+	log.Debug().Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("dmxSender process started successfully")
+	return nil
+}
+
+// Disconnect disconnects the FTDI peripheral
+func (p *FTDIPeripheral) Disconnect(ctx context.Context) error {
+	log.Trace().Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("disconnecting FTDI peripheral...")
+	if p.dmxSender != nil {
+		log.Debug().Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("dmxsender is defined for this FTDI")
+		_, err := io.WriteString(p.stdin, string([]byte{0x04, 0x00, 0x00, 0x00}))
+		if err != nil {
+			log.Err(err).Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("unable to write command to sender")
+			return fmt.Errorf("unable to disconnect: %v", err)
+		}
+		p.stdin.Close()
+		p.stdout.Close()
+		p.dmxSender = nil
+		err = os.Remove(p.programName)
+		if err != nil {
+			log.Warn().Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Str("senderPath", p.programName).Msg("unable to delete the dmx sender temporary file")
+			return fmt.Errorf("unable to delete the temporary file: %v", err)
+		}
+		return nil
+	}
+	log.Warn().Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("error while disconnecting: not connected")
+	return fmt.Errorf("unable to disconnect: not connected")
+}
+
+// Activate activates the FTDI peripheral
+func (p *FTDIPeripheral) Activate(ctx context.Context) error {
+	if p.dmxSender != nil {
+		log.Debug().Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("dmxsender is defined for this FTDI")
+		_, err := io.WriteString(p.stdin, string([]byte{0x01, 0x00, 0x00, 0x00}))
+		if err != nil {
+			log.Err(err).Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("unable to write command to sender")
+			return fmt.Errorf("unable to activate: %v", err)
+		}
+		return nil
+	}
+	log.Warn().Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("error while activating: not connected")
+	return fmt.Errorf("unable to activate: not connected")
+}
+
+// Deactivate deactivates the FTDI peripheral
+func (p *FTDIPeripheral) Deactivate(ctx context.Context) error {
+	if p.dmxSender != nil {
+		log.Debug().Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("dmxsender is defined for this FTDI")
+		_, err := io.WriteString(p.stdin, string([]byte{0x02, 0x00, 0x00, 0x00}))
+		if err != nil {
+			log.Err(err).Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("unable to write command to sender")
+			return fmt.Errorf("unable to deactivate: %v", err)
+		}
+		return nil
+	}
+	log.Warn().Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("error while deactivating: not connected")
+	return fmt.Errorf("unable to deactivate: not connected")
+}
+
+// SetDeviceProperty sends a command to the specified device
+func (p *FTDIPeripheral) SetDeviceProperty(ctx context.Context, uint32, channelNumber uint32, channelValue byte) error {
+	if p.dmxSender != nil {
+		log.Debug().Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("dmxsender is defined for this FTDI")
+		commandString := []byte{0x03, 0x01, 0x00, 0xff, 0x03, 0x02, 0x00, channelValue}
+		_, err := io.WriteString(p.stdin, string(commandString))
+		if err != nil {
+			log.Err(err).Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("unable to write command to sender")
+			return fmt.Errorf("unable to set device property: %v", err)
+		}
+		return nil
+	}
+	log.Warn().Str("file", "FTDIPeripheral").Str("s/n", p.serialNumber).Msg("error while setting device property: not connected")
+	return fmt.Errorf("unable to set device property: not connected")
+}
+
+// GetInfo gets all the peripheral information
+func (p *FTDIPeripheral) GetInfo() PeripheralInfo {
+	return PeripheralInfo{
+		Name:         p.name,
+		SerialNumber: p.serialNumber,
+		ProtocolName: "FTDI",
+	}
+}

hardware/MIDIFinder.go

@@ -0,0 +1,174 @@
+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
+	peripherals map[string]Peripheral // 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),
+		peripherals: make(map[string]Peripheral),
+	}
+}
+
+// Initialize initializes the MIDI driver
+func (f *MIDIFinder) Initialize() error {
+	log.Trace().Str("file", "MIDIFinder").Msg("MIDI finder initialized")
+	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"
+}
+
+// GetPeripheral gets the peripheral that correspond to the specified ID
+func (f *MIDIFinder) GetPeripheral(peripheralID string) (Peripheral, bool) {
+	// Return the specified peripheral
+	peripheral, found := f.peripherals[peripheralID]
+	if !found {
+		log.Error().Str("file", "MIDIFinder").Str("peripheralID", peripheralID).Msg("unable to get this peripheral in the MIDI finder")
+		return nil, false
+	}
+	log.Trace().Str("file", "MIDIFinder").Str("peripheralID", peripheralID).Msg("MIDI peripheral found in the driver")
+	return peripheral, true
+}
+
+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,58 @@
+package hardware
+
+import (
+	"context"
+
+	"github.com/rs/zerolog/log"
+)
+
+// MIDIPeripheral contains the data of a MIDI peripheral
+type MIDIPeripheral struct {
+	name         string // The name of the peripheral
+	location     int    // The location of the peripheral
+	serialNumber string // The S/N of the peripheral
+}
+
+// NewMIDIPeripheral creates a new MIDI peripheral
+func NewMIDIPeripheral(name string, location int, serialNumber string) *MIDIPeripheral {
+	log.Trace().Str("file", "MIDIPeripheral").Str("name", name).Str("s/n", serialNumber).Int("location", location).Msg("MIDI peripheral created")
+	return &MIDIPeripheral{
+		name:         name,
+		location:     location,
+		serialNumber: serialNumber,
+	}
+}
+
+// Connect connects the MIDI peripheral
+func (p *MIDIPeripheral) Connect(ctx context.Context) error {
+	return nil
+}
+
+// Disconnect disconnects the MIDI peripheral
+func (p *MIDIPeripheral) Disconnect(ctx context.Context) 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
+}
+
+// SetDeviceProperty - not implemented for this kind of peripheral
+func (p *MIDIPeripheral) SetDeviceProperty(context.Context, uint32, uint32, byte) error {
+	return nil
+}
+
+// GetInfo gets the peripheral information
+func (p *MIDIPeripheral) GetInfo() PeripheralInfo {
+	return PeripheralInfo{
+		Name:         p.name,
+		ProtocolName: "MIDI",
+		SerialNumber: p.serialNumber,
+	}
+}

hardware/OS2LFinder.go

@@ -0,0 +1,78 @@
+package hardware
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+	"strings"
+
+	"github.com/rs/zerolog/log"
+)
+
+// OS2LFinder represents how the protocol is defined
+type OS2LFinder struct {
+	peripherals map[string]Peripheral // The list of peripherals
+}
+
+// NewOS2LFinder creates a new OS2L finder
+func NewOS2LFinder() *OS2LFinder {
+	log.Trace().Str("file", "OS2LFinder").Msg("OS2L finder created")
+	return &OS2LFinder{
+		peripherals: make(map[string]Peripheral),
+	}
+}
+
+// Initialize initializes the finder
+func (f *OS2LFinder) Initialize() error {
+	log.Trace().Str("file", "OS2LFinder").Msg("OS2L finder initialized")
+	return nil
+}
+
+// CreatePeripheral creates a new OS2L peripheral
+func (f *OS2LFinder) CreatePeripheral(ctx context.Context) (Peripheral, error) {
+	// Create a random serial number for this peripheral
+	randomSerialNumber := strings.ToUpper(fmt.Sprintf("%08x", rand.Intn(1<<32)))
+	log.Trace().Str("file", "OS2LFinder").Str("serialNumber", randomSerialNumber).Msg("OS2L peripheral created")
+	peripheral := NewOS2LPeripheral("OS2L", randomSerialNumber)
+	f.peripherals[randomSerialNumber] = peripheral
+	log.Info().Str("file", "OS2LFinder").Str("serialNumber", randomSerialNumber).Msg("OS2L peripheral created and registered")
+	return peripheral, nil
+}
+
+// DeletePeripheral removes an OS2L peripheral
+func (f *OS2LFinder) DeletePeripheral(serialNumber string) error {
+	delete(f.peripherals, serialNumber)
+	log.Info().Str("file", "OS2LFinder").Str("serialNumber", serialNumber).Msg("OS2L peripheral removed")
+	return nil
+}
+
+// GetName returns the name of the driver
+func (f *OS2LFinder) GetName() string {
+	return "OS2L"
+}
+
+// GetPeripheral gets the peripheral that correspond to the specified ID
+func (f *OS2LFinder) GetPeripheral(peripheralID string) (Peripheral, bool) {
+	// Return the specified peripheral
+	peripheral, found := f.peripherals[peripheralID]
+	if !found {
+		log.Error().Str("file", "OS2LFinder").Str("peripheralID", peripheralID).Msg("unable to get this peripheral in the OS2L finder")
+		return nil, false
+	}
+	log.Trace().Str("file", "OS2LFinder").Str("peripheralID", peripheralID).Msg("OS2L peripheral found in the finder")
+	return peripheral, true
+}
+
+// Start starts the finder
+func (f *OS2LFinder) Start(ctx context.Context) error {
+	return nil
+}
+
+// Stop stops this finder
+func (f *OS2LFinder) Stop() error {
+	return nil
+}
+
+// ForceScan scans the interfaces (not implemented)
+func (f *OS2LFinder) ForceScan() {
+}

hardware/OS2LPeripheral.go

@@ -0,0 +1,60 @@
+package hardware
+
+import (
+	"context"
+
+	"github.com/rs/zerolog/log"
+)
+
+// OS2LPeripheral contains the data of an OS2L peripheral
+type OS2LPeripheral struct {
+	name         string // The name of the peripheral
+	serialNumber string // The serial number of the peripheral
+}
+
+// NewOS2LPeripheral creates a new OS2L peripheral
+func NewOS2LPeripheral(name string, serialNumber string) *OS2LPeripheral {
+	log.Trace().Str("file", "OS2LPeripheral").Str("name", name).Str("s/n", serialNumber).Msg("OS2L peripheral created")
+	return &OS2LPeripheral{
+		name:         name,
+		serialNumber: serialNumber,
+	}
+}
+
+// Connect connects the MIDI peripheral
+func (p *OS2LPeripheral) Connect(ctx context.Context) error {
+	log.Info().Str("file", "OS2LPeripheral").Msg("OS2L peripheral connected")
+	return nil
+}
+
+// Disconnect disconnects the MIDI peripheral
+func (p *OS2LPeripheral) Disconnect(ctx context.Context) error {
+	log.Info().Str("file", "OS2LPeripheral").Msg("OS2L peripheral disconnected")
+	return nil
+}
+
+// Activate activates the MIDI peripheral
+func (p *OS2LPeripheral) Activate(ctx context.Context) error {
+	log.Info().Str("file", "OS2LPeripheral").Msg("OS2L peripheral activated")
+	return nil
+}
+
+// Deactivate deactivates the MIDI peripheral
+func (p *OS2LPeripheral) Deactivate(ctx context.Context) error {
+	log.Info().Str("file", "OS2LPeripheral").Msg("OS2L peripheral deactivated")
+	return nil
+}
+
+// SetDeviceProperty - not implemented for this kind of peripheral
+func (p *OS2LPeripheral) SetDeviceProperty(context.Context, uint32, uint32, byte) error {
+	return nil
+}
+
+// GetInfo gets the peripheral information
+func (p *OS2LPeripheral) GetInfo() PeripheralInfo {
+	return PeripheralInfo{
+		Name:         p.name,
+		SerialNumber: p.serialNumber,
+		ProtocolName: "OS2L",
+	}
+}

hardware/hardware.go

@@ -0,0 +1,151 @@
+package hardware
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"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
+
+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"
+	// debounceDuration                  = 500 * time.Millisecond
+)
+
+var (
+	debounceTimer *time.Timer
+)
+
+// HardwareManager is the class who manages the hardware
+type HardwareManager struct {
+	finders                map[string]PeripheralFinder // The map of peripherals finders
+	peripherals            []Peripheral                // The current list of peripherals
+	peripheralsScanTrigger chan struct{}               // Trigger the peripherals scans
+	goWait                 sync.WaitGroup              // Wait for goroutines to terminate
+}
+
+// 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 {
+	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
+		}
+		err = finder.Start(ctx)
+		if err != nil {
+			log.Err(err).Str("file", "hardware").Str("finderName", finderName).Msg("unable to start finder")
+			return err
+		}
+	}
+	h.goWait.Add(1)
+	go func() {
+		defer h.goWait.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")
+}
+
+// GetPeripheral gets the peripheral object from the parent finder
+func (h *HardwareManager) GetPeripheral(finderName string, peripheralID string) (Peripheral, bool) {
+	// Get the finder
+	parentFinder, found := h.finders[finderName]
+	// If no finder found, return false
+	if !found {
+		log.Error().Str("file", "hardware").Str("finderName", finderName).Msg("unable to get the finder")
+		return nil, false
+	}
+	log.Trace().Str("file", "hardware").Str("finderName", parentFinder.GetName()).Msg("finder got")
+	// Contact the finder to get the peripheral
+	return parentFinder.GetPeripheral(peripheralID)
+}
+
+// Scan scans all the peripherals for the registered finders
+func (h *HardwareManager) Scan() error {
+	h.peripheralsScanTrigger <- struct{}{}
+	return nil
+}
+
+// Stop stops the hardware manager
+func (h *HardwareManager) Stop() error {
+	log.Trace().Str("file", "hardware").Msg("closing the hardware manager")
+	// Stop each finder
+	for finderName, finder := range h.finders {
+		err := finder.Stop()
+		if err != nil {
+			log.Err(err).Str("file", "hardware").Str("finderName", finderName).Msg("unable to stop the finder")
+		}
+	}
+	// Wait for goroutines to finish
+	h.goWait.Wait()
+	log.Info().Str("file", "hardware").Msg("hardware manager stopped")
+	return nil
+}
+
+// emitPeripheralsChanges compares the old and new peripherals to determine which ones have been added or removed.
+func emitPeripheralsChanges(ctx context.Context, oldPeripherals map[string]Peripheral, newPeripherals map[string]Peripheral) {
+	log.Trace().Any("oldList", oldPeripherals).Any("newList", newPeripherals).Msg("emitting peripherals changes to the front")
+
+	// Identify removed peripherals: present in the old list but not in the new list
+	for oldPeriphName := range oldPeripherals {
+		if _, exists := newPeripherals[oldPeriphName]; !exists {
+			runtime.EventsEmit(ctx, string(PeripheralRemoval), oldPeripherals[oldPeriphName].GetInfo())
+			log.Trace().Str("file", "hardware").Str("event", string(PeripheralRemoval)).Msg("emit peripheral removal event")
+		}
+	}
+
+	// Identify added peripherals: present in the new list but not in the old list
+	for newPeriphName := range newPeripherals {
+		if _, exists := oldPeripherals[newPeriphName]; !exists {
+			runtime.EventsEmit(ctx, string(PeripheralArrival), newPeripherals[newPeriphName].GetInfo())
+			log.Trace().Str("file", "hardware").Str("event", string(PeripheralArrival)).Msg("emit peripheral arrival event")
+		}
+	}
+}

hardware/interfaces.go

@@ -0,0 +1,34 @@
+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
+	Disconnect(context.Context) error                              // Disconnect the peripheral
+	Activate(context.Context) error                                // Activate the peripheral
+	Deactivate(context.Context) error                              // Deactivate the peripheral
+	SetDeviceProperty(context.Context, uint32, uint32, byte) error // Update a device property
+
+	GetInfo() PeripheralInfo // Get the peripheral information
+}
+
+// PeripheralInfo represents a peripheral information
+type PeripheralInfo struct {
+	Name         string        `yaml:"name"`     // Name of the peripheral
+	SerialNumber string        `yaml:"sn"`       // S/N of the peripheral
+	ProtocolName string        `yaml:"protocol"` // Protocol name of the peripheral
+	Settings     []interface{} `yaml:"settings"` // Number of DMX universes handled by the peripheral
+}
+
+// PeripheralFinder represents how compatible peripheral drivers are implemented
+type PeripheralFinder interface {
+	Initialize() error                                        // Initializes the protocol
+	Start(context.Context) error                              // Start the detection
+	Stop() error                                              // Stop the detection
+	ForceScan()                                               // Explicitly scans for peripherals
+	CreatePeripheral(ctx context.Context) (Peripheral, error) // Creates a new peripheral
+	DeletePeripheral(serialNumber string) error               // Removes a peripheral
+	GetName() string                                          // Get the name of the finder
+	GetPeripheral(string) (Peripheral, bool)                  // Get the peripheral
+}

hardware/third-party/ftdi/detectFTDI.cpp

@@ -0,0 +1,35 @@
+#include <iostream>
+#include <vector>
+#include <thread>
+#include "ftd2xx.h"
+
+int main() {
+    FT_STATUS ftStatus;
+    FT_HANDLE ftHandle = nullptr;
+    FT_DEVICE_LIST_INFO_NODE *devInfo;
+    DWORD numDevs;
+    
+    // create the device information list
+    ftStatus = FT_CreateDeviceInfoList(&numDevs);
+    if (ftStatus != FT_OK) {
+        std::cerr << "Unable to get the FTDI devices : create list error" << std::endl;
+        return 1;
+    }
+    if (numDevs > 0) {
+        // allocate storage for list based on numDevs
+        devInfo =
+        (FT_DEVICE_LIST_INFO_NODE*)malloc(sizeof(FT_DEVICE_LIST_INFO_NODE)*numDevs);
+        // get the device information list
+        ftStatus = FT_GetDeviceInfoList(devInfo, &numDevs);
+        if (ftStatus != FT_OK) {
+            std::cerr << "Unable to get the FTDI devices : get list error" << std::endl;
+            return 1;
+        }
+
+        for (int i = 0; i < numDevs; i++) {
+            if (devInfo[i].SerialNumber[0] != '\0') {
+                std::cout << i << ":" << devInfo[i].SerialNumber << ":" << devInfo[i].Description << std::endl;
+            }
+        }
+    }
+}

hardware/third-party/ftdi/detectFTDI.manifest

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+    <assemblyIdentity version="1.0.0.0" processorArchitecture="*" name="DMXSender" type="win32"/>
+    <description>Detect FTDI</description>
+    <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+        <security>
+            <requestedPrivileges>
+                <requestedExecutionLevel level="requireAdministrator" uiAccess="false"/>
+            </requestedPrivileges>
+        </security>
+    </trustInfo>
+</assembly>

hardware/third-party/ftdi/dmxSender.cpp

@@ -0,0 +1,142 @@
+#include <cstring>
+#include <errno.h>
+#include <fcntl.h>
+#include <iostream>
+#include <unistd.h>
+#include <fstream>
+#include <windows.h>
+#include <string>
+#include <math.h>
+#include <chrono>
+#include <thread>
+#include <cstdint>
+#include <vector>
+#include <atomic>
+#include <fcntl.h>
+#include <io.h>
+#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) 
+
+std::atomic<unsigned char> dmxData[DMX_CHANNELS + 1];
+std::atomic<bool> isOutputActivated = false;
+
+using namespace std;
+
+void sendBreak(FT_HANDLE ftHandle) {
+    FT_SetBreakOn(ftHandle);  // Envoie le signal de BREAK
+    std::this_thread::sleep_for(std::chrono::microseconds(BREAK_DURATION_US));
+    FT_SetBreakOff(ftHandle); // Arrête le signal de BREAK
+}
+
+void sendDMX(FT_HANDLE ftHandle) {
+    while (true) {
+        if(isOutputActivated){
+            // Envoi du BREAK suivi du MAB
+            sendBreak(ftHandle);
+            std::this_thread::sleep_for(std::chrono::microseconds(MAB_DURATION_US));
+
+            // Envoi de la trame DMX512
+            DWORD bytesWritten = 0;
+
+            // Envoyer la trame DMX512
+            FT_STATUS status = FT_Write(ftHandle, dmxData, DMX_CHANNELS, &bytesWritten);
+            if (status != FT_OK || bytesWritten != DMX_CHANNELS) {
+                std::cerr << "Unable to send the DMX frame" << std::endl;
+                FT_Close(ftHandle);
+                return;
+            }
+
+            // Attendre avant d'envoyer la prochaine trame
+            std::this_thread::sleep_for(std::chrono::microseconds(INTERVAL - BREAK_DURATION_US - MAB_DURATION_US));
+        }
+    }
+}
+
+void processCommand(const char* buffer) {
+    if (buffer[0] == 0x01) {
+        // Activate the DMX512
+        isOutputActivated.store(true);
+    } else if(buffer[0] == 0x02) {
+        // Deactivate the DMX512
+        isOutputActivated.store(false);
+    } else if(buffer[0] == 0x03) {
+        // Get the channel number
+        uint16_t channelNumber = (static_cast<unsigned char>(buffer[1]) |
+                            (static_cast<unsigned char>(buffer[2]) << 8));
+        // Get the channel value
+        uint8_t channelValue = static_cast<unsigned char>(buffer[3]);
+        // // Update the DMX array
+        dmxData[channelNumber].store(channelValue);
+    } else if(buffer[0] == 0x04) {
+        // Close this sender
+        exit(0);
+    } else {
+        std::cerr << "Unknown command" << endl;
+    }
+}
+
+// Entry point
+int main(int argc, char* argv[]) {
+    #ifdef _WIN32
+        _setmode(_fileno(stdin), _O_BINARY);
+    #endif
+
+    FT_STATUS ftStatus;
+    FT_HANDLE ftHandle = nullptr;
+
+    // Check if the serial port is specified
+    if (argc != 2) {
+        std::cerr << "Invalid call to DMX sender" << std::endl;
+        return 1;
+    }
+
+    // Connect the serial port
+    int deviceDev;
+    try {
+        deviceDev = std::stoi(argv[1]);
+    }catch(const std::exception& e){
+        std::cerr << "Invalid call to DMX sender" << std::endl;
+        return 1;
+    }
+    
+    ftStatus = FT_Open(deviceDev, &ftHandle);
+    if (ftStatus != FT_OK) {
+        std::cerr << "Unable to open the FTDI device" << std::endl;
+        return 1;
+    }
+
+    ftStatus = FT_SetBaudRate(ftHandle, 250000);
+    ftStatus |= FT_SetDataCharacteristics(ftHandle, 8, FT_STOP_BITS_2, FT_PARITY_NONE); // 8 bits, pas de parité, 1 bit de stop
+    ftStatus |= FT_SetFlowControl(ftHandle, FT_FLOW_NONE, 0, 0);
+    if (ftStatus != FT_OK) {
+        std::cerr << "Unable to configure the FTDI device" << std::endl;
+        FT_Close(ftHandle);
+        return 1;
+    }
+
+    // Send the DMX frames
+    std::thread updateThread(sendDMX, ftHandle);
+
+    // Intercept commands from the GO program
+    char buffer[4]; // Tampon pour stocker les 4 octets d'une commande
+
+    while (true) {
+        std::cin.read(buffer, 4); // Attente bloquante jusqu'à ce que 4 octets soient lus
+        if (std::cin.gcount() == 4) { // Vérifier que 4 octets ont été lus
+            processCommand(buffer);
+        } else if (std::cin.eof()) {
+            std::cerr << "Fin de l'entrée standard (EOF)" << std::endl;
+            break;
+        } else if (std::cin.fail()) {
+            std::cerr << "Erreur de lecture sur stdin" << std::endl;
+            break;
+        }
+    }
+    return 0;
+}

hardware/third-party/ftdi/dmxSender.manifest

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+    <assemblyIdentity version="1.0.0.0" processorArchitecture="*" name="DMXSender" type="win32"/>
+    <description>DMXSender</description>
+    <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+        <security>
+            <requestedPrivileges>
+                <requestedExecutionLevel level="requireAdministrator" uiAccess="false"/>
+            </requestedPrivileges>
+        </security>
+    </trustInfo>
+</assembly>

hardware/third-party/ftdi/generate.bat

@@ -0,0 +1,8 @@
+windres dmxSender.rc dmxSender.o
+windres detectFTDI.rc detectFTDI.o
+
+g++ -o dmxSender.exe dmxSender.cpp dmxSender.o -I"include" -L"lib" -lftd2xx -mwindows
+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