dmxconnect/hardware/FTDIPeripheral.go

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
}