func main() {
var err error
var dev *rtl.Context
//---------- Device Check ----------
if c := rtl.GetDeviceCount(); c == 0 {
log.Fatal("No devices found, exiting.\n")
} else {
for i := 0; i < c; i++ {
m, p, s, err := rtl.GetDeviceUsbStrings(i)
if err == nil {
err = errors.New("")
}
log.Printf("GetDeviceUsbStrings %s - %s %s %s\n",
err, m, p, s)
}
}
log.Printf("===== Device name: %s =====\n", rtl.GetDeviceName(0))
log.Printf("===== Running tests using device indx: 0 =====\n")
//---------- Open Device ----------
if dev, err = rtl.Open(0); err != nil {
log.Fatal("\tOpen Failed, exiting\n")
}
defer dev.Close()
//---------- Device Strings ----------
m, p, s, err := dev.GetUsbStrings()
if err != nil {
log.Printf("\tGetUsbStrings Failed - error: %s\n", err)
} else {
log.Printf("\tGetUsbStrings - %s %s %s\n", m, p, s)
}
log.Printf("\tGetTunerType: %s\n", dev.GetTunerType())
//---------- Device Info ----------
info, err := dev.GetHwInfo()
if err != nil {
log.Printf("\tGetHwInfo Failed - error: %s\n", err)
} else {
log.Printf("\tVendor ID : 0x%X\n", info.VendorID)
log.Printf("\tProduct ID : 0x%X\n", info.ProductID)
log.Println("\tManufacturer : ", info.Manufact)
log.Println("\tProduct : ", info.Product)
log.Println("\tSerial : ", info.Serial)
log.Println("\tHave Serial : ", info.HaveSerial)
log.Println("\tEnable IR : ", info.EnableIR)
log.Println("\tRemote Wakeup : ", info.RemoteWakeup)
}
ppm, err := kal.Kal((*kal.Context)(dev), kal.GSM850)
log.Printf("PPM: %d\n", ppm)
log.Printf("err: %s\n", err)
}
func main() {
var err error
var dev *rtl.Context
if c := rtl.GetDeviceCount(); c == 0 {
log.Fatal("No devices found, exiting.\n")
}
if dev, err = rtl.Open(0); err != nil {
log.Fatal("\tOpen Failed, existing\n")
}
//defer pushes a function onto a list that will be invoked
//after the surrounding function returns (in this case main)
defer dev.Close()
go sig_abort(dev)
//Set to 1090Mhz
dev.SetSampleRate(2000000) //from rtl_adsb.c
dev.SetTunerGainMode(false)
err = dev.SetCenterFreq(1090000000)
if err != nil {
log.Printf("\tSetCenterFreq 1090Mhz Failed, error: %s\n", err)
}
//dev.SetTestMode(true)
dev.ResetBuffer()
IQch := make(chan bool)
var userctx rtl.UserCtx = IQch
err = dev.ReadAsync(rtlsdr_cb, &userctx, rtl.DefaultAsyncBufNumber, 512)
if err == nil {
log.Printf("\tReadAsync Successful\n")
} else {
log.Printf("\rReadAsync FAILED - error: %s\n", err)
}
/*
var buffer []byte = make([]uint8, rtl.DefaultBufLength)
//var hexbuf []byte = make([]uint8, rtl.DefaultBufLength)
n_read, err := dev.ReadSync(buffer, rtl.DefaultBufLength)
if err != nil {
log.Printf("\tReadSynch Failed - error %s\n", err)
} else {
//hex.Decode(hexbuf, buffer)
log.Printf("\tReadSync %d\n", n_read)
//log.Printf("\t%X\n", hexbuf)
}
if err == nil && n_read < rtl.DefaultBufLength {
log.Printf("ReadSynch short read, %d samples lost\n", rtl.DefaultBufLength-n_read)
}
*/
log.Printf("Exiting...\n")
}
// Watch for config/device changes.
func sdrWatcher() {
timer := time.NewTicker(1 * time.Second)
for {
<-timer.C
// Update device count.
globalStatus.Devices = uint(rtl.GetDeviceCount())
if uatSDR == -1 && globalSettings.UAT_Enabled {
if globalStatus.Devices == 0 {
log.Printf("No RTL-SDR devices.\n")
continue
}
uatSDR = 0
go sdrReader()
}
if esSDR == -1 && globalSettings.ES_Enabled {
if globalStatus.Devices == 0 || (globalStatus.Devices == 1 && globalSettings.UAT_Enabled) {
log.Printf("Not enough RTL-SDR devices.\n")
}
esSDR = 1
}
}
}
func main() {
runtime.GOMAXPROCS(3)
var status int
var dev *rtl.Context
if c := rtl.GetDeviceCount(); c == 0 {
log.Fatal("No devices found, exiting.\n")
} else {
for i := 0; i < c; i++ {
m, p, s, status := rtl.GetDeviceUsbStrings(i)
log.Printf("GetDeviceUsbStrings %s - %s %s %s\n",
rtl.Status[status], m, p, s)
}
}
log.Printf("===== Device name: %s =====\n", rtl.GetDeviceName(0))
log.Printf("===== Running tests using device indx: %d =====\n", 0)
if dev, status = rtl.Open(0); status != rtl.Success {
log.Fatal("\tOpen Failed, exiting\n")
}
defer dev.Close()
go sig_abort(dev)
m, p, s, status := dev.GetUsbStrings()
log.Printf("\tGetUsbStrings %s - %s %s %s\n", rtl.Status[status], m, p, s)
g, status := dev.GetTunerGains()
log.Printf("\tGetTunerGains %s\n", rtl.Status[status])
if status == rtl.Success {
fmt.Printf("\tGains: ")
for _, j := range g {
fmt.Printf("%d ", j)
}
fmt.Printf("\n")
}
log.Printf("\tSetSampleRate %s - rate: %d\n",
rtl.Status[dev.SetSampleRate(rtl.DefaultSampleRate)], rtl.DefaultSampleRate)
log.Printf("\tGetSampleRate: %d\n", dev.GetSampleRate())
// status = dev.SetXtalFreq(rtl_freq, tuner_freq)
// log.Printf("\tSetXtalFreq %s - Center freq: %d, Tuner freq: %d\n",
// rtl.Status[status], rtl_freq, tuner_freq)
rtl_freq, tuner_freq, status := dev.GetXtalFreq()
log.Printf("\tGetXtalFreq %s - Rtl: %d, Tuner: %d\n",
rtl.Status[status], rtl_freq, tuner_freq)
status = dev.SetCenterFreq(850000000)
if status < 0 {
log.Println("\tSetCenterFreq 850MHz Failed, error code: %d\n", status)
} else {
log.Println("\tSetCenterFreq 850MHz Successful")
}
log.Printf("\tGetCenterFreq: %d\n", dev.GetCenterFreq())
log.Printf("\tGetFreqCorrection: %d\n", dev.GetFreqCorrection())
log.Printf("\tGetTunerType: %s\n", rtl.TunerType[dev.GetTunerType()])
log.Printf("\tSetTunerGainMode: %s\n", rtl.TunerType[dev.SetTunerGainMode(rtl.GainAuto)])
log.Printf("\tGetTunerGain: %d\n", dev.GetTunerGain())
/*
func (c *Context) SetFreqCorrection(ppm int) (err int)
func (c *Context) SetTunerGain(gain int) (err int)
func (c *Context) SetTunerIfGain(stage, gain int) (err int)
func (c *Context) SetAgcMode(on int) (err int)
func (c *Context) SetDirectSampling(on int) (err int)
*/
if status = dev.SetTestMode(1); status < 1 {
log.Printf("\tSetTestMode 'On' Failed - error code: %d\n", status)
} else {
log.Printf("\tSetTestMode 'On' Successful\n")
}
log.Printf("\tResetBuffer %s\n", rtl.Status[dev.ResetBuffer()])
var buffer []byte = make([]uint8, rtl.DefaultBufLength)
n_read, status := dev.ReadSync(buffer, rtl.DefaultBufLength)
log.Printf("\tReadSync %s\n", rtl.Status[status])
if status == rtl.Success && n_read < rtl.DefaultBufLength {
log.Println("ReadSync short read, %d samples lost\n", rtl.DefaultBufLength-n_read)
}
if status = dev.SetTestMode(1); status < 1 {
log.Printf("\tSetTestMode 'Off' Fail - error code: %d\n", status)
} else {
log.Printf("\tSetTestMode 'Off' Success\n")
}
// Note, ReadAsync blocks until CancelAsync is called, so spawn
// a goroutine running in its own system thread that'll wait
// for the async-read callback to signal when it's done.
IQch := make(chan bool)
go async_stop(dev, IQch)
var userctx rtl.UserCtx = IQch
status = dev.ReadAsync(rtlsdr_cb, &userctx, rtl.DefaultAsyncBufNumber, rtl.DefaultBufLength)
log.Printf("\tReadAsync %s\n", rtl.Status[status])
log.Printf("Exiting...\n")
}
// Watch for config/device changes.
func sdrWatcher() {
for {
time.Sleep(1 * time.Second)
count := rtl.GetDeviceCount()
atomic.StoreUint32(&globalStatus.Devices, uint32(count))
log.Println("DeviceCount...", count)
// support two and only two dongles
if count > 2 {
count = 2
}
// cleanup if necessary
if count < 1 || (!globalSettings.UAT_Enabled && !globalSettings.ES_Enabled) {
log.Println("count == 0, doing cleanup if necessary...")
if UATDev != nil {
UATDev.shutdown()
UATDev = nil
}
if ESDev != nil {
ESDev.shutdown()
ESDev = nil
}
continue
}
if count == 1 {
if UATDev != nil && ESDev == nil {
UATDev.indexID = 0
} else if UATDev == nil && ESDev != nil {
ESDev.indexID = 0
}
}
ids := []string{"", ""}
for i := 0; i < count; i++ {
// manufact, product, serial, err
_, _, s, _ := rtl.GetDeviceUsbStrings(i)
ids[i] = s
}
// UAT specific handling
// When count is one, favor UAT in the case where the user
// has enabled both UAT and ES via the web interface.
id := 0
if globalSettings.UAT_Enabled {
// log.Println("globalSettings.UAT_Enabled == true")
if count == 1 {
if ESDev != nil {
ESDev.shutdown()
ESDev = nil
}
} else { // count == 2
if UATDev == nil && ESDev != nil {
if ESDev.indexID == 0 {
id = 1
}
}
}
if UATDev == nil {
// log.Println("\tUATDev == nil")
// preference check based on stratux
// hardware serial when it exists
serial := ids[id]
if strings.HasPrefix(serial, "stratux:1090") {
log.Println("Settings conflict: 978UAT set via WebUI but hardware serial says stratux:1090")
} else {
UATDev = &UAT{indexID: id}
if err := UATDev.sdrConfig(); err != nil {
log.Printf("UATDev = &UAT{indexID: id} failed: %s\n", err)
UATDev = nil
} else {
uat_shutdown = make(chan int)
uat_wg.Add(1)
go UATDev.read()
}
}
}
} else if UATDev != nil {
UATDev.shutdown()
UATDev = nil
if count == 1 && ESDev != nil {
ESDev.indexID = 0
}
}
// ES specific handling
id = 0
if globalSettings.ES_Enabled {
// log.Println("globalSettings.ES_Enabled == true")
if count == 1 {
if globalSettings.UAT_Enabled {
// defer to the UAT handler
goto End
}
} else { // count == 2
if ESDev == nil && UATDev != nil {
if UATDev.indexID == 0 {
id = 1
}
}
}
if ESDev == nil {
// log.Println("\tESDev == nil")
// preference check based on stratux
// hardware serial when it exists
serial := ids[id]
if strings.HasPrefix(serial, "stratux:978") {
log.Println("Settings conflict: 1090ES set via WebUI but hardware serial says stratux:978")
} else {
ESDev = &ES{indexID: id}
if err := ESDev.sdrConfig(); err != nil {
log.Printf("ESDev = &ES{indexID: id} failed: %s\n", err)
ESDev = nil
} else {
es_shutdown = make(chan int)
es_wg.Add(1)
go ESDev.read()
}
}
}
} else if ESDev != nil {
ESDev.shutdown()
ESDev = nil
if count == 1 && UATDev != nil {
UATDev.indexID = 0
}
}
End:
}
}
func main() {
var err error
var dev *rtl.Context
//---------- Device Check ----------
if c := rtl.GetDeviceCount(); c == 0 {
log.Fatal("No devices found, exiting.\n")
} else {
for i := 0; i < c; i++ {
m, p, s, err := rtl.GetDeviceUsbStrings(i)
if err == nil {
err = errors.New("")
}
log.Printf("GetDeviceUsbStrings %s - %s %s %s\n",
err, m, p, s)
}
}
log.Printf("===== Device name: %s =====\n", rtl.GetDeviceName(0))
log.Printf("===== Running tests using device indx: 0 =====\n")
//---------- Open Device ----------
if dev, err = rtl.Open(0); err != nil {
log.Fatal("\tOpen Failed, exiting\n")
}
defer dev.Close()
go sigAbort(dev)
//---------- Device Strings ----------
m, p, s, err := dev.GetUsbStrings()
if err != nil {
log.Printf("\tGetUsbStrings Failed - error: %s\n", err)
} else {
log.Printf("\tGetUsbStrings - %s %s %s\n", m, p, s)
}
log.Printf("\tGetTunerType: %s\n", dev.GetTunerType())
//---------- Set Tuner Gain ----------
tgain := 480
err = dev.SetTunerGainMode(true)
if err != nil {
log.Printf("\tSetTunerGainMode Failed - error: %s\n", err)
} else {
log.Printf("\tSetTunerGainMode Successful\n")
}
err = dev.SetTunerGain(tgain)
if err != nil {
log.Printf("\tSetTunerGain Failed - error: %s\n", err)
} else {
log.Printf("\tSetTunerGain Successful\n")
}
//---------- Get/Set Sample Rate ----------
samplerate := 2083334
err = dev.SetSampleRate(samplerate)
if err != nil {
log.Printf("\tSetSampleRate Failed - error: %s\n", err)
} else {
log.Printf("\tSetSampleRate - rate: %d\n", samplerate)
}
log.Printf("\tGetSampleRate: %d\n", dev.GetSampleRate())
//---------- Get/Set Xtal Freq ----------
rtlFreq, tunerFreq, err := dev.GetXtalFreq()
if err != nil {
log.Printf("\tGetXtalFreq Failed - error: %s\n", err)
} else {
log.Printf("\tGetXtalFreq - Rtl: %d, Tuner: %d\n", rtlFreq, tunerFreq)
}
newRTLFreq := 28800000
newTunerFreq := 28800000
err = dev.SetXtalFreq(newRTLFreq, newTunerFreq)
if err != nil {
log.Printf("\tSetXtalFreq Failed - error: %s\n", err)
} else {
log.Printf("\tSetXtalFreq - Center freq: %d, Tuner freq: %d\n",
newRTLFreq, newTunerFreq)
}
//---------- Get/Set Center Freq ----------
err = dev.SetCenterFreq(978000000)
if err != nil {
log.Printf("\tSetCenterFreq 978MHz Failed, error: %s\n", err)
} else {
log.Printf("\tSetCenterFreq 978MHz Successful\n")
}
log.Printf("\tGetCenterFreq: %d\n", dev.GetCenterFreq())
//---------- Set Bandwidth ----------
bw := 1000000
log.Printf("\tSetting Bandwidth: %d\n", bw)
if err = dev.SetTunerBw(bw); err != nil {
log.Printf("\tSetTunerBw %d Failed, error: %s\n", bw, err)
} else {
log.Printf("\tSetTunerBw %d Successful\n", bw)
}
/*
//---------- Get/Set Freq Correction ----------
freqCorr := dev.GetFreqCorrection()
log.Printf("\tGetFreqCorrection: %d\n", freqCorr)
err = dev.SetFreqCorrection(0) // 10ppm
if err != nil {
log.Printf("\tSetFreqCorrection %d Failed, error: %s\n", 0, err)
} else {
log.Printf("\tSetFreqCorrection %d Successful\n", 0)
}
//---------- Get/Set AGC Mode ----------
if err = dev.SetAgcMode(false); err == nil {
log.Printf("\tSetAgcMode off Successful\n")
} else {
log.Printf("\tSetAgcMode Failed, error: %s\n", err)
}
//---------- Get/Set Direct Sampling ----------
if mode, err := dev.GetDirectSampling(); err == nil {
log.Printf("\tGetDirectSampling Successful, mode: %s\n",
rtl.SamplingModes[mode])
} else {
log.Printf("\tSetTestMode 'On' Failed - error: %s\n", err)
}
if err = dev.SetDirectSampling(rtl.SamplingNone); err == nil {
log.Printf("\tSetDirectSampling 'On' Successful\n")
} else {
log.Printf("\tSetDirectSampling 'On' Failed - error: %s\n", err)
}
*/
//---------- Get/Set Tuner IF Gain ----------
// if err = SetTunerIfGain(stage, gain: int); err == nil {
// log.Printf("\SetTunerIfGain Successful\n")
// } else {
// log.Printf("\tSetTunerIfGain Failed - error: %s\n", err)
// }
/*
//---------- Get/Set test mode ----------
if err = dev.SetTestMode(true); err == nil {
log.Printf("\tSetTestMode 'On' Successful\n")
} else {
log.Printf("\tSetTestMode 'On' Failed - error: %s\n", err)
}
if err = dev.SetTestMode(false); err == nil {
log.Printf("\tSetTestMode 'Off' Successful\n")
} else {
log.Printf("\tSetTestMode 'Off' Fail - error: %s\n", err)
}
*/
//---------- Get/Set misc. streaming ----------
godump978.Dump978Init()
go printUAT()
go godump978.ProcessDataFromChannel()
if err = dev.ResetBuffer(); err == nil {
log.Printf("\tResetBuffer Successful\n")
} else {
log.Printf("\tResetBuffer Failed - error: %s\n", err)
}
for {
var buffer = make([]uint8, rtl.DefaultBufLength)
nRead, err := dev.ReadSync(buffer, rtl.DefaultBufLength)
if err != nil {
log.Printf("\tReadSync Failed - error: %s\n", err)
} else {
log.Printf("\tReadSync %d\n", nRead)
// buf := buffer[:nRead]
// godump978.InChan <- buf
}
}
}
// Watch for config/device changes.
func sdrWatcher() {
prevCount := 0
prevUATEnabled := false
prevESEnabled := false
for {
time.Sleep(1 * time.Second)
if sdrShutdown {
if UATDev != nil {
UATDev.shutdown()
UATDev = nil
}
if ESDev != nil {
ESDev.shutdown()
ESDev = nil
}
return
}
// true when a ReadSync call fails
if shutdownUAT {
if UATDev != nil {
UATDev.shutdown()
UATDev = nil
}
shutdownUAT = false
}
// true when we get stderr output
if shutdownES {
if ESDev != nil {
ESDev.shutdown()
ESDev = nil
}
shutdownES = false
}
// capture current state
esEnabled := globalSettings.ES_Enabled
uatEnabled := globalSettings.UAT_Enabled
count := rtl.GetDeviceCount()
atomic.StoreUint32(&globalStatus.Devices, uint32(count))
// support up to two dongles
if count > 2 {
count = 2
}
if count == prevCount && prevESEnabled == esEnabled && prevUATEnabled == uatEnabled {
continue
}
// the device count or the global settings have changed, reconfig
if UATDev != nil {
UATDev.shutdown()
UATDev = nil
}
if ESDev != nil {
ESDev.shutdown()
ESDev = nil
}
configDevices(count, esEnabled, uatEnabled)
prevCount = count
prevUATEnabled = uatEnabled
prevESEnabled = esEnabled
}
}
// Watch for config/device changes.
func sdrWatcher() {
for {
time.Sleep(1 * time.Second)
if sdrShutdown {
if UATDev != nil {
UATDev.shutdown()
UATDev = nil
}
if ESDev != nil {
ESDev.shutdown()
ESDev = nil
}
return
}
count := rtl.GetDeviceCount()
atomic.StoreUint32(&globalStatus.Devices, uint32(count))
// log.Println("DeviceCount...", count)
// support two and only two dongles
if count > 2 {
count = 2
}
// cleanup if necessary
if count < 1 || (!globalSettings.UAT_Enabled && !globalSettings.ES_Enabled) {
log.Println("count == 0, doing cleanup if necessary...")
if UATDev != nil {
UATDev.shutdown()
UATDev = nil
}
if ESDev != nil {
ESDev.shutdown()
ESDev = nil
}
continue
}
if count == 1 {
if UATDev != nil && ESDev == nil {
UATDev.indexID = 0
} else if UATDev == nil && ESDev != nil {
ESDev.indexID = 0
}
}
// UAT specific handling
// When count is one, favor UAT in the case where the user
// has enabled both UAT and ES via the web interface.
id := 0
if globalSettings.UAT_Enabled {
// log.Println("globalSettings.UAT_Enabled == true")
if count == 1 {
if ESDev != nil {
ESDev.shutdown()
ESDev = nil
}
} else { // count == 2
if UATDev == nil && ESDev != nil {
if ESDev.indexID == 0 {
id = 1
}
}
}
if UATDev == nil {
_, _, serial, err := rtl.GetDeviceUsbStrings(id)
if err != nil {
serial = ""
}
if strings.Compare(serial, "stratux:1090") != 0 {
UATDev = &UAT{indexID: id, serial: serial}
if err := UATDev.sdrConfig(); err != nil {
log.Printf("UATDev = &UAT{indexID: id} failed: %s\n", err)
UATDev = nil
} else {
uat_shutdown = make(chan int)
uat_wg.Add(1)
go UATDev.read()
}
}
}
} else if UATDev != nil {
UATDev.shutdown()
UATDev = nil
if count == 1 && ESDev != nil {
ESDev.indexID = 0
}
}
// ES specific handling
id = 0
if globalSettings.ES_Enabled {
// log.Println("globalSettings.ES_Enabled == true")
if count == 1 {
if globalSettings.UAT_Enabled {
// defer to the UAT handler
goto End
}
} else { // count == 2
if ESDev == nil && UATDev != nil {
if UATDev.indexID == 0 {
id = 1
}
}
}
if ESDev == nil {
_, _, serial, err := rtl.GetDeviceUsbStrings(id)
if err != nil {
serial = ""
}
if strings.Compare(serial, "stratux:978") != 0 {
ESDev = &ES{indexID: id, serial: serial}
if err := ESDev.sdrConfig(); err != nil {
log.Printf("ESDev = &ES{indexID: id} failed: %s\n", err)
ESDev = nil
} else {
es_shutdown = make(chan int)
es_wg.Add(1)
go ESDev.read()
}
}
}
} else if ESDev != nil {
ESDev.shutdown()
ESDev = nil
if count == 1 && UATDev != nil {
UATDev.indexID = 0
}
}
End:
}
}
// Watch for config/device changes.
func sdrWatcher() {
var doSkip bool
globalStatus.Connected_Devices = 0
rES, err := regexp.Compile("str?a?t?u?x:1090")
if err != nil {
rES = nil
log.Println("failed to compile ES regexp because %s", err.Error())
}
rUAT, err := regexp.Compile("str?a?t?u?x:978")
if err != nil {
rUAT = nil
log.Println("failed to compile UAT regexp because %s", err.Error())
}
for {
time.Sleep(1 * time.Second)
if sdrShutdown {
if UATDev != nil {
UATDev.shutdown()
UATDev = nil
}
if ESDev != nil {
ESDev.shutdown()
ESDev = nil
}
return
}
count := rtl.GetDeviceCount()
atomic.StoreUint32(&globalStatus.Devices, uint32(count))
// log.Println("DeviceCount...", count)
// support two and only two dongles
if count > 2 {
count = 2
}
// cleanup if necessary
if count < 1 || (!globalSettings.UAT_Enabled && !globalSettings.ES_Enabled) {
// log.Println("count == 0, doing cleanup if necessary...")
if UATDev != nil {
UATDev.shutdown()
UATDev = nil
}
if ESDev != nil {
ESDev.shutdown()
ESDev = nil
}
continue
}
if count == 1 {
if UATDev != nil && ESDev == nil {
UATDev.indexID = 0
} else if UATDev == nil && ESDev != nil {
ESDev.indexID = 0
}
}
// UAT specific handling
// When count is one, favor UAT in the case where the user
// has enabled both UAT and ES via the web interface.
id := 0
if globalSettings.UAT_Enabled {
// log.Println("globalSettings.UAT_Enabled == true")
if count == 1 {
if ESDev != nil {
ESDev.shutdown()
ESDev = nil
}
} else { // count == 2
if UATDev == nil && ESDev != nil {
if ESDev.indexID == 0 {
id = 1
}
}
/* Address #275. If both devices are nil, but
* id 1 matches the rUAT string, we need to
* force the UAT to id 1, so that UAT doesn't
* consume a flexible id 0 and leave ES bound
* to an undesired, fixed 978.
* A parallel fix is not installed in the ES
* code, because both cases are already handled:
* id 0 flex, id 1 1090, then 0 bound to UAT
* id 1 flex, id 0 1090, then 0 bound to ES
*/
if UATDev == nil && ESDev == nil && rUAT != nil {
_, _, serial, err := rtl.GetDeviceUsbStrings(1)
if err == nil && rUAT.MatchString(serial) {
id = 1
}
}
}
if UATDev == nil {
_, _, serial, err := rtl.GetDeviceUsbStrings(id)
if err != nil {
serial = ""
}
if rES != nil {
doSkip = rES.MatchString(serial)
} else {
doSkip = strings.Compare(serial, "stratux:1090") == 0
}
if ESDev != nil || !doSkip {
UATDev = &UAT{indexID: id, serial: serial}
if err := UATDev.sdrConfig(); err != nil {
log.Printf("UATDev = &UAT{indexID: id} failed: %s\n", err)
UATDev = nil
} else {
uat_shutdown = make(chan int)
uat_wg.Add(1)
go UATDev.read()
}
}
}
} else if UATDev != nil {
UATDev.shutdown()
UATDev = nil
if count == 1 && ESDev != nil {
ESDev.indexID = 0
}
}
// ES specific handling
id = 0
if globalSettings.ES_Enabled {
// log.Println("globalSettings.ES_Enabled == true")
if count == 1 {
if globalSettings.UAT_Enabled {
// defer to the UAT handler
goto End
}
} else { // count == 2
if ESDev == nil && UATDev != nil {
if UATDev.indexID == 0 {
id = 1
}
}
}
if ESDev == nil {
_, _, serial, err := rtl.GetDeviceUsbStrings(id)
if err != nil {
serial = ""
}
if rUAT != nil {
doSkip = rUAT.MatchString(serial)
} else {
doSkip = strings.Compare(serial, "stratux:978") == 0
}
if UATDev != nil || !doSkip {
ESDev = &ES{indexID: id, serial: serial}
if err := ESDev.sdrConfig(); err != nil {
log.Printf("ESDev = &ES{indexID: id} failed: %s\n", err)
ESDev = nil
} else {
es_shutdown = make(chan int)
es_wg.Add(1)
go ESDev.read()
}
}
}
} else if ESDev != nil {
ESDev.shutdown()
ESDev = nil
if count == 1 && UATDev != nil {
UATDev.indexID = 0
}
}
End:
}
}
// Watch for config/device changes.
func sdrWatcher() {
stopCheckingUATUntil := time.Time{}
lastUATCheck := stratuxClock.Time
for {
time.Sleep(1 * time.Second)
if sdrShutdown {
if UATDev != nil {
UATDev.shutdown()
UATDev = nil
}
if ESDev != nil {
ESDev.shutdown()
ESDev = nil
}
return
}
count := rtl.GetDeviceCount()
atomic.StoreUint32(&globalStatus.Devices, uint32(count))
// log.Println("DeviceCount...", count)
// support two and only two dongles
if count > 2 {
count = 2
}
// cleanup if necessary
if count < 1 || (!globalSettings.UAT_Enabled && !globalSettings.ES_Enabled) {
log.Println("count == 0, doing cleanup if necessary...")
if UATDev != nil {
UATDev.shutdown()
UATDev = nil
}
if ESDev != nil {
ESDev.shutdown()
ESDev = nil
}
continue
}
if count == 1 {
if UATDev != nil && ESDev == nil {
UATDev.indexID = 0
} else if UATDev == nil && ESDev != nil {
ESDev.indexID = 0
}
}
// UAT specific handling
// Shutdown UAT for 50 seconds, check every 60 seconds if the count is 0.
if stratuxClock.Since(lastUATCheck) >= 1*time.Minute {
if UATDev != nil && globalStatus.UAT_messages_last_minute == 0 {
log.Printf("Pausing UAT listening for 50 seconds - none received.\n")
UATDev.shutdown()
UATDev = nil
stopCheckingUATUntil = stratuxClock.Time.Add(50 * time.Second)
}
lastUATCheck = stratuxClock.Time
}
// When count is one, favor UAT in the case where the user
// has enabled both UAT and ES via the web interface.
id := 0
if globalSettings.UAT_Enabled && stratuxClock.Time.After(stopCheckingUATUntil) {
// log.Println("globalSettings.UAT_Enabled == true")
if count == 1 {
if ESDev != nil {
ESDev.shutdown()
ESDev = nil
}
} else { // count == 2
if UATDev == nil && ESDev != nil {
if ESDev.indexID == 0 {
id = 1
}
}
}
if UATDev == nil {
// log.Println("\tUATDev == nil")
// preference check based on stratux
// hardware serial when it exists.
// manufact, product, serial, err
_, _, serial, err := rtl.GetDeviceUsbStrings(id)
if err != nil {
serial = ""
}
if strings.HasPrefix(serial, "stratux:1090") {
log.Println("Settings conflict: 978UAT set via WebUI but hardware serial says stratux:1090")
} else {
UATDev = &UAT{indexID: id, serial: serial}
if err := UATDev.sdrConfig(); err != nil {
log.Printf("UATDev = &UAT{indexID: id} failed: %s\n", err)
UATDev = nil
} else {
uat_shutdown = make(chan int)
uat_wg.Add(1)
go UATDev.read()
}
}
}
} else if UATDev != nil {
UATDev.shutdown()
UATDev = nil
if count == 1 && ESDev != nil {
ESDev.indexID = 0
}
}
// ES specific handling
id = 0
if globalSettings.ES_Enabled {
// log.Println("globalSettings.ES_Enabled == true")
if count == 1 {
if globalSettings.UAT_Enabled {
// defer to the UAT handler
goto End
}
} else { // count == 2
if ESDev == nil && UATDev != nil {
if UATDev.indexID == 0 {
id = 1
}
}
}
if ESDev == nil {
// log.Println("\tESDev == nil")
// preference check based on stratux
// hardware serial when it exists.
// manufact, product, serial, err
_, _, serial, err := rtl.GetDeviceUsbStrings(id)
if err != nil {
serial = ""
}
if strings.HasPrefix(serial, "stratux:978") {
log.Println("Settings conflict: 1090ES set via WebUI but hardware serial says stratux:978")
} else {
ESDev = &ES{indexID: id, serial: serial}
if err := ESDev.sdrConfig(); err != nil {
log.Printf("ESDev = &ES{indexID: id} failed: %s\n", err)
ESDev = nil
} else {
es_shutdown = make(chan int)
es_wg.Add(1)
go ESDev.read()
}
}
}
} else if ESDev != nil {
ESDev.shutdown()
ESDev = nil
if count == 1 && UATDev != nil {
UATDev.indexID = 0
}
}
End:
}
}