124 lines
3.0 KiB
Go
124 lines
3.0 KiB
Go
package services
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log/slog"
|
|
"sync/atomic"
|
|
|
|
"esdi/devices"
|
|
"esdi/devices/cdashdisplay"
|
|
"esdi/telemetry"
|
|
)
|
|
|
|
// DeviceService will handle sending the data from the telemetry service to the
|
|
// actual devices
|
|
// NOTE: create a virtual device and make it be the output window or something so
|
|
// we can just add it as a device or whatever instead of being a custom made thing
|
|
// that would be pretty cool I think
|
|
type DeviceService struct {
|
|
Logger *slog.Logger
|
|
Devices map[string]devices.Device
|
|
// Strem handling
|
|
streamCancel context.CancelFunc
|
|
TelemCh <-chan telemetry.TelemetryData
|
|
// Output
|
|
Messages chan string
|
|
}
|
|
|
|
func NewDeviceService(logger *slog.Logger) *DeviceService {
|
|
sharedChannel := make(chan string, 10)
|
|
return &DeviceService{
|
|
Devices: make(map[string]devices.Device),
|
|
Logger: logger,
|
|
Messages: sharedChannel,
|
|
}
|
|
}
|
|
|
|
func (ds *DeviceService) FindDevices() {
|
|
// Need to define a list of devices to search for
|
|
// For now lets just try to find our cdashdisplay - will think about the rest later
|
|
|
|
// Find CDashDisplay
|
|
{
|
|
ds.Messages <- "looking for " + cdashdisplay.Name + "...\n"
|
|
ds.Logger.Info("Looking for " + cdashdisplay.Name)
|
|
|
|
cdashdisplay.SetLogger(ds.Logger.With("[device]", cdashdisplay.Name))
|
|
|
|
// Create a cdashdisplay
|
|
display, err := cdashdisplay.Discover()
|
|
if err == nil {
|
|
ds.Devices[cdashdisplay.Name] = display
|
|
ds.Logger.Info("found " + cdashdisplay.Name + " on: " + display.WT.Cfg.Name)
|
|
ds.Messages <- "found " + cdashdisplay.Name + " on: " + display.WT.Cfg.Name + "\n"
|
|
return
|
|
}
|
|
|
|
ds.Logger.Info("didn't find " + cdashdisplay.Name)
|
|
ds.Messages <- "didn't find " + cdashdisplay.Name + "\n"
|
|
// No CDashDisplay available for one reason or another, so we don't set the
|
|
// key
|
|
}
|
|
}
|
|
|
|
func (ds *DeviceService) GetDevice(name string) (devices.Device, error) {
|
|
val, ok := ds.Devices[name]
|
|
if !ok {
|
|
return nil, fmt.Errorf("device `%s` couldn't be found", name)
|
|
}
|
|
|
|
return val, nil
|
|
}
|
|
|
|
func (ds *DeviceService) StartStream() {
|
|
// NOTE: i'm using this pattern a whole lot. Maybe I can create a struct to handle this
|
|
var ctx context.Context
|
|
ctx, ds.streamCancel = context.WithCancel(context.Background())
|
|
|
|
go ds.transmit(ctx)
|
|
}
|
|
|
|
func (ds *DeviceService) StopStream() {
|
|
if ds.streamCancel == nil {
|
|
return
|
|
}
|
|
|
|
ds.streamCancel()
|
|
ds.streamCancel = nil
|
|
}
|
|
|
|
// SetTelemetryChannel sets the TelemCh to the passed channel
|
|
func (ds *DeviceService) SetTelemetryChannel(ch <-chan telemetry.TelemetryData) {
|
|
ds.TelemCh = ch
|
|
}
|
|
|
|
// transmit will send the data to the devices themselves
|
|
func (ds *DeviceService) transmit(ctx context.Context) {
|
|
var isSending atomic.Bool
|
|
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case data, ok := <-ds.TelemCh:
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
if isSending.Load() {
|
|
continue
|
|
}
|
|
|
|
isSending.Store(true)
|
|
|
|
// TODO: make a copy of the data and send that copy instead of keeping
|
|
// the data locked
|
|
for _, dev := range ds.Devices {
|
|
dev.SendData(&data)
|
|
}
|
|
isSending.Store(false)
|
|
}
|
|
}
|
|
}
|