123 lines
2.6 KiB
Go
123 lines
2.6 KiB
Go
package device
|
|
|
|
import "sync"
|
|
|
|
// DeviceState holds the simulated device state with thread-safe access
|
|
type DeviceState struct {
|
|
mu sync.RWMutex
|
|
|
|
progMode bool
|
|
caliMode bool
|
|
alarmActive bool
|
|
|
|
// Parameters from docs.toon
|
|
// W1=1200 (Min Threshold), W2=4000 (Max Threshold), W3=2 (Pulse Count),
|
|
// W4=40 (Time Window), W20=128 (Gain)
|
|
params map[int]int
|
|
|
|
sensorValue int // Default 2067 (ideal rest value)
|
|
}
|
|
|
|
// NewDeviceState creates a new DeviceState with default values
|
|
func NewDeviceState() *DeviceState {
|
|
return &DeviceState{
|
|
progMode: false,
|
|
caliMode: false,
|
|
alarmActive: false,
|
|
params: map[int]int{
|
|
1: 1200, // W1 - Min Threshold
|
|
2: 4000, // W2 - Max Threshold
|
|
3: 2, // W3 - Pulse Count
|
|
4: 40, // W4 - Time Window
|
|
11: 0, // W11 - Min Pulse Duration (reserved)
|
|
12: 0, // W12 - Max Pulse Duration (reserved)
|
|
20: 128, // W20 - Gain (Wiper)
|
|
},
|
|
sensorValue: 2067,
|
|
}
|
|
}
|
|
|
|
// GetProgMode returns whether programming mode is active
|
|
func (s *DeviceState) GetProgMode() bool {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
return s.progMode
|
|
}
|
|
|
|
// SetProgMode sets the programming mode
|
|
func (s *DeviceState) SetProgMode(enabled bool) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
s.progMode = enabled
|
|
}
|
|
|
|
// GetCaliMode returns whether calibration mode is active
|
|
func (s *DeviceState) GetCaliMode() bool {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
return s.caliMode
|
|
}
|
|
|
|
// ToggleCaliMode toggles the calibration mode
|
|
func (s *DeviceState) ToggleCaliMode() bool {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
s.caliMode = !s.caliMode
|
|
return s.caliMode
|
|
}
|
|
|
|
// GetAlarmActive returns whether the alarm is active
|
|
func (s *DeviceState) GetAlarmActive() bool {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
return s.alarmActive
|
|
}
|
|
|
|
// ResetAlarm resets the alarm state
|
|
func (s *DeviceState) ResetAlarm() {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
s.alarmActive = false
|
|
}
|
|
|
|
// GetParam returns a parameter value by ID
|
|
func (s *DeviceState) GetParam(id int) (int, bool) {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
val, ok := s.params[id]
|
|
return val, ok
|
|
}
|
|
|
|
// SetParam sets a parameter value by ID
|
|
func (s *DeviceState) SetParam(id, value int) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
s.params[id] = value
|
|
}
|
|
|
|
// GetSensorValue returns the current sensor value
|
|
func (s *DeviceState) GetSensorValue() int {
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
return s.sensorValue
|
|
}
|
|
|
|
// ResetToDefaults resets all parameters to factory defaults
|
|
func (s *DeviceState) ResetToDefaults() {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
s.progMode = false
|
|
s.caliMode = false
|
|
s.alarmActive = false
|
|
s.params = map[int]int{
|
|
1: 1200,
|
|
2: 4000,
|
|
3: 2,
|
|
4: 40,
|
|
11: 0,
|
|
12: 0,
|
|
20: 128,
|
|
}
|
|
s.sensorValue = 2067
|
|
}
|