From 595f50cc2f0535ea23ae0fdbd9fc6234f7e43c6b Mon Sep 17 00:00:00 2001 From: Joseph Poirier Date: Sun, 25 Oct 2015 22:16:19 -0500 Subject: [PATCH 01/12] UAT and ES mode/hardware handling --- main/sdr.go | 325 +++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 258 insertions(+), 67 deletions(-) diff --git a/main/sdr.go b/main/sdr.go index 67301353..48e5c912 100644 --- a/main/sdr.go +++ b/main/sdr.go @@ -1,133 +1,200 @@ package main import ( + "log" + "os/exec" + "strconv" + "strings" + "sync" + "time" + "../godump978" rtl "github.com/jpoirier/gortlsdr" - "log" - "time" ) -var uatSDR int // Index. -var esSDR int // Index. +type UAT struct { + dev *rtl.Context + indexID int +} + +type ES struct { + dev *rtl.Context + indexID int +} + +var UATDev *UAT +var ESDev *ES + +var uat_shutdown chan int +var uat_wg *sync.WaitGroup = &sync.WaitGroup{} + +var es_shutdown chan int +var es_wg *sync.WaitGroup = &sync.WaitGroup{} var maxSignalStrength int -// Read 978MHz from SDR. -func sdrReader() { - var err error - var dev *rtl.Context - - log.Printf("===== UAT Device name: %s =====\n", rtl.GetDeviceName(uatSDR)) - if dev, err = rtl.Open(uatSDR); err != nil { - log.Printf("\tOpen Failed, exiting\n") - uatSDR = -1 +func (e *ES) read() { + defer es_wg.Done() + log.Println("Entered ES read() ...") + cmd := exec.Command("/usr/bin/dump1090", "--net", "--device-index", strconv.Itoa(e.indexID)) + err := cmd.Start() + if err != nil { + log.Printf("Error executing /usr/bin/dump1090: %s\n", err.Error()) return } - defer dev.Close() - 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.Println("Executed /usr/bin/dump1090 successfully...") + for { + select { + default: + time.Sleep(1 * time.Second) + case _ = <-es_shutdown: + log.Println("ES read(): shutdown msg received, calling cmd.Process.Kill() ...") + cmd.Process.Kill() + log.Println("\t kill successful...") + return + } } - log.Printf("\tGetTunerType: %s\n", dev.GetTunerType()) +} + +func (u *UAT) read() { + defer uat_wg.Done() + // defer u.dev.Close() + log.Println("Entered UAT read() ...") + var buffer = make([]uint8, rtl.DefaultBufLength) + for { + select { + default: + nRead, err := u.dev.ReadSync(buffer, rtl.DefaultBufLength) + if err != nil { + log.Printf("\tReadSync Failed - error: %s\n", err) + break + } + // log.Printf("\tReadSync %d\n", nRead) + if nRead > 0 { + buf := buffer[:nRead] + godump978.InChan <- buf + } + case _ = <-uat_shutdown: + log.Println("UAT read(): shutdown msg received...") + return + } + } +} + +func (e *ES) sdrConfig() (err error) { + return +} + +// Read 978MHz from SDR. +func (u *UAT) sdrConfig() (err error) { + log.Printf("===== UAT Device name: %s =====\n", rtl.GetDeviceName(u.indexID)) + if u.dev, err = rtl.Open(u.indexID); err != nil { + log.Printf("\tUAT Open Failed...\n") + return + } + log.Printf("\tGetTunerType: %s\n", u.dev.GetTunerType()) //---------- Set Tuner Gain ---------- - tgain := 480 - - err = dev.SetTunerGainMode(true) + err = u.dev.SetTunerGainMode(true) if err != nil { + u.dev.Close() log.Printf("\tSetTunerGainMode Failed - error: %s\n", err) + return } else { log.Printf("\tSetTunerGainMode Successful\n") } - err = dev.SetTunerGain(tgain) + tgain := 480 + err = u.dev.SetTunerGain(tgain) if err != nil { + u.dev.Close() log.Printf("\tSetTunerGain Failed - error: %s\n", err) + return } else { log.Printf("\tSetTunerGain Successful\n") } //---------- Get/Set Sample Rate ---------- samplerate := 2083334 - err = dev.SetSampleRate(samplerate) + err = u.dev.SetSampleRate(samplerate) if err != nil { + u.dev.Close() log.Printf("\tSetSampleRate Failed - error: %s\n", err) + return } else { log.Printf("\tSetSampleRate - rate: %d\n", samplerate) } - log.Printf("\tGetSampleRate: %d\n", dev.GetSampleRate()) + log.Printf("\tGetSampleRate: %d\n", u.dev.GetSampleRate()) //---------- Get/Set Xtal Freq ---------- - rtlFreq, tunerFreq, err := dev.GetXtalFreq() + rtlFreq, tunerFreq, err := u.dev.GetXtalFreq() if err != nil { + u.dev.Close() log.Printf("\tGetXtalFreq Failed - error: %s\n", err) + return } else { log.Printf("\tGetXtalFreq - Rtl: %d, Tuner: %d\n", rtlFreq, tunerFreq) } newRTLFreq := 28800000 newTunerFreq := 28800000 - err = dev.SetXtalFreq(newRTLFreq, newTunerFreq) + err = u.dev.SetXtalFreq(newRTLFreq, newTunerFreq) if err != nil { + u.dev.Close() log.Printf("\tSetXtalFreq Failed - error: %s\n", err) + return } else { log.Printf("\tSetXtalFreq - Center freq: %d, Tuner freq: %d\n", newRTLFreq, newTunerFreq) } //---------- Get/Set Center Freq ---------- - err = dev.SetCenterFreq(978000000) + err = u.dev.SetCenterFreq(978000000) if err != nil { + u.dev.Close() log.Printf("\tSetCenterFreq 978MHz Failed, error: %s\n", err) + return } else { log.Printf("\tSetCenterFreq 978MHz Successful\n") } - log.Printf("\tGetCenterFreq: %d\n", dev.GetCenterFreq()) + log.Printf("\tGetCenterFreq: %d\n", u.dev.GetCenterFreq()) //---------- Set Bandwidth ---------- bw := 1000000 log.Printf("\tSetting Bandwidth: %d\n", bw) - if err = dev.SetTunerBw(bw); err != nil { + if err = u.dev.SetTunerBw(bw); err != nil { + u.dev.Close() log.Printf("\tSetTunerBw %d Failed, error: %s\n", bw, err) + return } else { log.Printf("\tSetTunerBw %d Successful\n", bw) } - if err = dev.ResetBuffer(); err == nil { - log.Printf("\tResetBuffer Successful\n") - } else { + if err = u.dev.ResetBuffer(); err != nil { + u.dev.Close() log.Printf("\tResetBuffer Failed - error: %s\n", err) + return + } else { + log.Printf("\tResetBuffer Successful\n") } //---------- Get/Set Freq Correction ---------- - freqCorr := dev.GetFreqCorrection() + freqCorr := u.dev.GetFreqCorrection() log.Printf("\tGetFreqCorrection: %d\n", freqCorr) - err = dev.SetFreqCorrection(globalSettings.PPM) + err = u.dev.SetFreqCorrection(globalSettings.PPM) if err != nil { + u.dev.Close() log.Printf("\tSetFreqCorrection %d Failed, error: %s\n", globalSettings.PPM, err) + return } else { log.Printf("\tSetFreqCorrection %d Successful\n", globalSettings.PPM) } - - for uatSDR != -1 { - var buffer = make([]uint8, rtl.DefaultBufLength) - nRead, err := dev.ReadSync(buffer, rtl.DefaultBufLength) - if err != nil { - log.Printf("\tReadSync Failed - error: %s\n", err) - uatSDR = -1 - break - } else { - // log.Printf("\tReadSync %d\n", nRead) - buf := buffer[:nRead] - godump978.InChan <- buf - } - } + return } // Read from the godump978 channel - on or off. func uatReader() { + log.Println("Entered uatReader() ...") for { uat := <-godump978.OutChan o, msgtype := parseInput(uat) @@ -137,34 +204,158 @@ func uatReader() { } } +func (u *UAT) shutdown() { + log.Println("Entered UAT shutdown() ...") + close(uat_shutdown) // signal to shutdown + log.Println("UAT shutdown(): closing device ...") + // XXX: how to preempt ReadSync? + // the assumption is that calling Close() + // causes ReadSync to return immediately + u.dev.Close() + log.Println("UAT shutdown(): calling uat_wg.Wait() ...") + uat_wg.Wait() // Wait for the goroutine to shutdown + log.Println("UAT shutdown(): uat_wg.Wait() returned...") +} + +func (e *ES) shutdown() { + log.Println("Entered ES shutdown() ...") + close(es_shutdown) // signal to shutdown + log.Println("ES shutdown(): calling es_wg.Wait() ...") + es_wg.Wait() // Wait for the goroutine to shutdown + log.Println("ES shutdown(): es_wg.Wait() returned...") +} + +var devMap = map[int]string{0: "", 1: ""} + // Watch for config/device changes. func sdrWatcher() { - timer := time.NewTicker(1 * time.Second) for { - <-timer.C - // Update device count. - globalStatus.Devices = uint(rtl.GetDeviceCount()) + time.Sleep(1 * time.Second) + count := rtl.GetDeviceCount() + log.Println("DeviceCount...", count) - if uatSDR == -1 && globalSettings.UAT_Enabled { - if globalStatus.Devices == 0 { - log.Printf("No RTL-SDR devices.\n") - continue - } - uatSDR = 0 - go sdrReader() + // support two and only two dongles + if count > 2 { + count = 2 } - if esSDR == -1 && globalSettings.ES_Enabled { - if globalStatus.Devices == 0 || (globalStatus.Devices == 1 && globalSettings.UAT_Enabled) { - log.Printf("Not enough RTL-SDR devices.\n") + + // cleanup if necessary + if count < 1 || (!globalSettings.UAT_Enabled && !globalSettings.ES_Enabled) { + log.Println("doing cleanup...") + if UATDev != nil { + UATDev.shutdown() + UATDev = nil } - esSDR = 1 + 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 { + 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 { + // 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 { + 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 { + 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 { + // 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 { + 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 sdrInit() { - uatSDR = -1 - esSDR = -1 go sdrWatcher() go uatReader() godump978.Dump978Init() From 627353de48556e0b473b2cff4571b1f6fe11bb91 Mon Sep 17 00:00:00 2001 From: Joseph Poirier Date: Thu, 5 Nov 2015 21:54:39 -0600 Subject: [PATCH 02/12] minorcode changes --- main/sdr.go | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/main/sdr.go b/main/sdr.go index 48e5c912..9ac14367 100644 --- a/main/sdr.go +++ b/main/sdr.go @@ -47,7 +47,7 @@ func (e *ES) read() { select { default: time.Sleep(1 * time.Second) - case _ = <-es_shutdown: + case <-es_shutdown: log.Println("ES read(): shutdown msg received, calling cmd.Process.Kill() ...") cmd.Process.Kill() log.Println("\t kill successful...") @@ -58,7 +58,6 @@ func (e *ES) read() { func (u *UAT) read() { defer uat_wg.Done() - // defer u.dev.Close() log.Println("Entered UAT read() ...") var buffer = make([]uint8, rtl.DefaultBufLength) for { @@ -74,7 +73,7 @@ func (u *UAT) read() { buf := buffer[:nRead] godump978.InChan <- buf } - case _ = <-uat_shutdown: + case <-uat_shutdown: log.Println("UAT read(): shutdown msg received...") return } @@ -208,10 +207,7 @@ func (u *UAT) shutdown() { log.Println("Entered UAT shutdown() ...") close(uat_shutdown) // signal to shutdown log.Println("UAT shutdown(): closing device ...") - // XXX: how to preempt ReadSync? - // the assumption is that calling Close() - // causes ReadSync to return immediately - u.dev.Close() + u.dev.Close() // preempt the blocking ReadSync call log.Println("UAT shutdown(): calling uat_wg.Wait() ...") uat_wg.Wait() // Wait for the goroutine to shutdown log.Println("UAT shutdown(): uat_wg.Wait() returned...") From 88ec861fb76962853aca17b65a30c33bcc22c05a Mon Sep 17 00:00:00 2001 From: Joseph Poirier Date: Fri, 6 Nov 2015 21:57:59 -0600 Subject: [PATCH 03/12] put back Devices assignment, change type for atomic store --- main/gen_gdl90.go | 4 ++-- main/sdr.go | 2 ++ 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/main/gen_gdl90.go b/main/gen_gdl90.go index 32ee8d81..3b969e13 100644 --- a/main/gen_gdl90.go +++ b/main/gen_gdl90.go @@ -455,7 +455,7 @@ func cpuTempMonitor() { globalStatus.CPUTemp = float32(tInt) // case where Temp is returned as simple integer } } - } + } } } @@ -708,7 +708,7 @@ type settings struct { type status struct { Version string - Devices uint + Devices uint32 Connected_Users uint UAT_messages_last_minute uint uat_products_last_minute map[string]uint32 diff --git a/main/sdr.go b/main/sdr.go index 9ac14367..09b92fbc 100644 --- a/main/sdr.go +++ b/main/sdr.go @@ -6,6 +6,7 @@ import ( "strconv" "strings" "sync" + "sync/atomic" "time" "../godump978" @@ -228,6 +229,7 @@ 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 From c1932b26cc46d8b159a23fa64eda81caeba30d08 Mon Sep 17 00:00:00 2001 From: Joseph Poirier Date: Fri, 6 Nov 2015 22:32:05 -0600 Subject: [PATCH 04/12] log prints for testing --- main/sdr.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/main/sdr.go b/main/sdr.go index 09b92fbc..e1a0848e 100644 --- a/main/sdr.go +++ b/main/sdr.go @@ -271,6 +271,7 @@ func sdrWatcher() { // 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() @@ -285,6 +286,7 @@ func sdrWatcher() { } if UATDev == nil { + log.Println("\tUATDev == nil") // preference check based on stratux // hardware serial when it exists serial := ids[id] @@ -312,6 +314,7 @@ func sdrWatcher() { // 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 @@ -326,6 +329,7 @@ func sdrWatcher() { } if ESDev == nil { + log.Println("\tESDev == nil") // preference check based on stratux // hardware serial when it exists serial := ids[id] From 18da53d02877d9304b162d885e595da9f6131eea Mon Sep 17 00:00:00 2001 From: Joseph Poirier Date: Fri, 6 Nov 2015 22:50:40 -0600 Subject: [PATCH 05/12] debug prints for testing --- main/sdr.go | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/main/sdr.go b/main/sdr.go index e1a0848e..f3061af5 100644 --- a/main/sdr.go +++ b/main/sdr.go @@ -295,8 +295,12 @@ func sdrWatcher() { } else { UATDev = &UAT{indexID: id} if err := UATDev.sdrConfig(); err != nil { + log.Printf("UATDev = &UAT{indexID: id} failed: %s\n", err) UATDev = nil } else { + if UATDev == nil { + log.Println("XXXXXXX UATDev == nil this shouldn't be nil") + } uat_shutdown = make(chan int) uat_wg.Add(1) go UATDev.read() @@ -338,8 +342,12 @@ func sdrWatcher() { } else { ESDev = &ES{indexID: id} if err := ESDev.sdrConfig(); err != nil { + log.Printf("ESDev = &ES{indexID: id} failed: %s\n", err) ESDev = nil } else { + if ESDev == nil { + log.Println("XXXXXXX ESDev == nil this shouldn't be nil") + } es_shutdown = make(chan int) es_wg.Add(1) go ESDev.read() From 2dab583e8eeef960b339db41ae256e48df3fc76b Mon Sep 17 00:00:00 2001 From: Joseph Poirier Date: Fri, 6 Nov 2015 23:18:15 -0600 Subject: [PATCH 06/12] handle librtlsdr returned error code inconsistencies where dev->corr == PPM when calling SetFreqCorrection --- main/sdr.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/main/sdr.go b/main/sdr.go index f3061af5..2231ec69 100644 --- a/main/sdr.go +++ b/main/sdr.go @@ -182,7 +182,10 @@ func (u *UAT) sdrConfig() (err error) { freqCorr := u.dev.GetFreqCorrection() log.Printf("\tGetFreqCorrection: %d\n", freqCorr) err = u.dev.SetFreqCorrection(globalSettings.PPM) - if err != nil { + // librtlsdr returned error code inconsistencies, i.e. + // error code -2 means the current value is the same as + // the PPM value we sent (dev->corr == PPM) + if err != nil && err != -2 { u.dev.Close() log.Printf("\tSetFreqCorrection %d Failed, error: %s\n", globalSettings.PPM, err) return From c5cf3898d3c4c38fe75175a8acaa646e67739a9b Mon Sep 17 00:00:00 2001 From: Joseph Poirier Date: Fri, 6 Nov 2015 23:35:39 -0600 Subject: [PATCH 07/12] better/fixed error GetFreqCorrection handling --- main/sdr.go | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/main/sdr.go b/main/sdr.go index 2231ec69..fee418f8 100644 --- a/main/sdr.go +++ b/main/sdr.go @@ -181,16 +181,17 @@ func (u *UAT) sdrConfig() (err error) { //---------- Get/Set Freq Correction ---------- freqCorr := u.dev.GetFreqCorrection() log.Printf("\tGetFreqCorrection: %d\n", freqCorr) - err = u.dev.SetFreqCorrection(globalSettings.PPM) - // librtlsdr returned error code inconsistencies, i.e. - // error code -2 means the current value is the same as + // avoid librtlsdr error code inconsistency, i.e. + // error code -2 means the stored value is the same as // the PPM value we sent (dev->corr == PPM) - if err != nil && err != -2 { - u.dev.Close() - log.Printf("\tSetFreqCorrection %d Failed, error: %s\n", globalSettings.PPM, err) - return - } else { - log.Printf("\tSetFreqCorrection %d Successful\n", globalSettings.PPM) + if freqCorr != globalSettings.PPM + err = u.dev.SetFreqCorrection(globalSettings.PPM) + if err != nil{ + // just print a warning + log.Printf("\tSetFreqCorrection %d Failed, error: %s\n", globalSettings.PPM, err) + } else { + log.Printf("\tSetFreqCorrection %d Successful\n", globalSettings.PPM) + } } return } From 07a9349ddf92f34fd29d7185dbd945c7ec99e993 Mon Sep 17 00:00:00 2001 From: Joseph Poirier Date: Fri, 6 Nov 2015 23:37:15 -0600 Subject: [PATCH 08/12] add missing curley brace --- main/sdr.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/main/sdr.go b/main/sdr.go index fee418f8..7c3886d6 100644 --- a/main/sdr.go +++ b/main/sdr.go @@ -184,9 +184,9 @@ func (u *UAT) sdrConfig() (err error) { // avoid librtlsdr error code inconsistency, i.e. // error code -2 means the stored value is the same as // the PPM value we sent (dev->corr == PPM) - if freqCorr != globalSettings.PPM + if freqCorr != globalSettings.PPM { err = u.dev.SetFreqCorrection(globalSettings.PPM) - if err != nil{ + if err != nil { // just print a warning log.Printf("\tSetFreqCorrection %d Failed, error: %s\n", globalSettings.PPM, err) } else { From f357d224c6b4ea78f8a78b93ae3c3085cd8d5d8c Mon Sep 17 00:00:00 2001 From: Joseph Poirier Date: Fri, 6 Nov 2015 23:48:44 -0600 Subject: [PATCH 09/12] debug print cleanup --- main/sdr.go | 14 ++++---------- 1 file changed, 4 insertions(+), 10 deletions(-) diff --git a/main/sdr.go b/main/sdr.go index 7c3886d6..f1df9603 100644 --- a/main/sdr.go +++ b/main/sdr.go @@ -187,7 +187,7 @@ func (u *UAT) sdrConfig() (err error) { if freqCorr != globalSettings.PPM { err = u.dev.SetFreqCorrection(globalSettings.PPM) if err != nil { - // just print a warning + // just a warning log.Printf("\tSetFreqCorrection %d Failed, error: %s\n", globalSettings.PPM, err) } else { log.Printf("\tSetFreqCorrection %d Successful\n", globalSettings.PPM) @@ -243,7 +243,7 @@ func sdrWatcher() { // cleanup if necessary if count < 1 || (!globalSettings.UAT_Enabled && !globalSettings.ES_Enabled) { - log.Println("doing cleanup...") + log.Println("count == 0, doing cleanup if necessary...") if UATDev != nil { UATDev.shutdown() UATDev = nil @@ -290,7 +290,7 @@ func sdrWatcher() { } if UATDev == nil { - log.Println("\tUATDev == nil") + // log.Println("\tUATDev == nil") // preference check based on stratux // hardware serial when it exists serial := ids[id] @@ -302,9 +302,6 @@ func sdrWatcher() { log.Printf("UATDev = &UAT{indexID: id} failed: %s\n", err) UATDev = nil } else { - if UATDev == nil { - log.Println("XXXXXXX UATDev == nil this shouldn't be nil") - } uat_shutdown = make(chan int) uat_wg.Add(1) go UATDev.read() @@ -337,7 +334,7 @@ func sdrWatcher() { } if ESDev == nil { - log.Println("\tESDev == nil") + // log.Println("\tESDev == nil") // preference check based on stratux // hardware serial when it exists serial := ids[id] @@ -349,9 +346,6 @@ func sdrWatcher() { log.Printf("ESDev = &ES{indexID: id} failed: %s\n", err) ESDev = nil } else { - if ESDev == nil { - log.Println("XXXXXXX ESDev == nil this shouldn't be nil") - } es_shutdown = make(chan int) es_wg.Add(1) go ESDev.read() From 76408d5828978cc1402f33428a70a8f179218c9d Mon Sep 17 00:00:00 2001 From: Joseph Poirier Date: Sat, 7 Nov 2015 00:24:56 -0600 Subject: [PATCH 10/12] comment out debug prints --- main/sdr.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/main/sdr.go b/main/sdr.go index f1df9603..e9f7b6c8 100644 --- a/main/sdr.go +++ b/main/sdr.go @@ -275,7 +275,7 @@ func sdrWatcher() { // has enabled both UAT and ES via the web interface. id := 0 if globalSettings.UAT_Enabled { - log.Println("globalSettings.UAT_Enabled == true") + // log.Println("globalSettings.UAT_Enabled == true") if count == 1 { if ESDev != nil { ESDev.shutdown() @@ -319,7 +319,7 @@ func sdrWatcher() { // ES specific handling id = 0 if globalSettings.ES_Enabled { - log.Println("globalSettings.ES_Enabled == true") + // log.Println("globalSettings.ES_Enabled == true") if count == 1 { if globalSettings.UAT_Enabled { // defer to the UAT handler From cb2b1accccde76636e86d047ecbcde3c579a5bc6 Mon Sep 17 00:00:00 2001 From: Joseph Poirier Date: Mon, 9 Nov 2015 09:10:55 -0600 Subject: [PATCH 11/12] remove small hack for freq correction; gortlsdr has been modified to handle -2 error from librtlsdr when requested ppm is the same as current ppm" --- main/sdr.go | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-) diff --git a/main/sdr.go b/main/sdr.go index e9f7b6c8..b7e4ca68 100644 --- a/main/sdr.go +++ b/main/sdr.go @@ -181,17 +181,12 @@ func (u *UAT) sdrConfig() (err error) { //---------- Get/Set Freq Correction ---------- freqCorr := u.dev.GetFreqCorrection() log.Printf("\tGetFreqCorrection: %d\n", freqCorr) - // avoid librtlsdr error code inconsistency, i.e. - // error code -2 means the stored value is the same as - // the PPM value we sent (dev->corr == PPM) - if freqCorr != globalSettings.PPM { - err = u.dev.SetFreqCorrection(globalSettings.PPM) - if err != nil { - // just a warning - log.Printf("\tSetFreqCorrection %d Failed, error: %s\n", globalSettings.PPM, err) - } else { - log.Printf("\tSetFreqCorrection %d Successful\n", globalSettings.PPM) - } + err = u.dev.SetFreqCorrection(globalSettings.PPM) + if err != nil { + // just a warning + log.Printf("\tSetFreqCorrection %d Failed, error: %s\n", globalSettings.PPM, err) + } else { + log.Printf("\tSetFreqCorrection %d Successful\n", globalSettings.PPM) } return } From f7e9991db48e6fad171afc3c02c3c7860d5f90fc Mon Sep 17 00:00:00 2001 From: Joseph Poirier Date: Mon, 9 Nov 2015 09:14:08 -0600 Subject: [PATCH 12/12] consistent error handling for GetFreqCorrection --- main/sdr.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/main/sdr.go b/main/sdr.go index b7e4ca68..1d3872f0 100644 --- a/main/sdr.go +++ b/main/sdr.go @@ -183,8 +183,9 @@ func (u *UAT) sdrConfig() (err error) { log.Printf("\tGetFreqCorrection: %d\n", freqCorr) err = u.dev.SetFreqCorrection(globalSettings.PPM) if err != nil { - // just a warning + u.dev.Close() log.Printf("\tSetFreqCorrection %d Failed, error: %s\n", globalSettings.PPM, err) + return } else { log.Printf("\tSetFreqCorrection %d Successful\n", globalSettings.PPM) }