mirror
/
stratux
kopia lustrzana https://github.com/cyoung/stratux
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

cleanup and idiomatic code in prep for #239

pull/274/head
Joseph Poirier 2016-02-21 10:40:14 -06:00
rodzic cebb1ba103
commit e9221e5097
2 zmienionych plików z 87 dodań i 96 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

2
main/gen_gdl90.go
Wyświetl plik

@ -73,6 +73,8 @@ const (
TRACK_RESOLUTION = float32(360.0 / 256.0) TRACK_RESOLUTION = float32(360.0 / 256.0)
) )
var maxSignalStrength int
var uatReplayLog string var uatReplayLog string
var esReplayLog string var esReplayLog string
var gpsReplayLog string var gpsReplayLog string

169
main/sdr.go
Wyświetl plik

@ -24,30 +24,18 @@ import (
rtl "github.com/jpoirier/gortlsdr" rtl "github.com/jpoirier/gortlsdr"
) )
type UAT struct { type Device struct {
dev *rtl.Context dev *rtl.Context
wg *sync.WaitGroup
closeCh chan int
indexID int indexID int
ppm int ppm int
serial string serial string
hasID bool
} }
type ES struct { var UATDev *Device
dev *rtl.Context var ESDev *Device
indexID int
ppm int
serial string
}
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
func readToChan(fp io.ReadCloser, ch chan []byte) { func readToChan(fp io.ReadCloser, ch chan []byte) {
for { for {
@ -62,7 +50,7 @@ func readToChan(fp io.ReadCloser, ch chan []byte) {
} }
func (e *ES) read() { func (e *ES) read() {
defer es_wg.Done() defer e.wg.Done()
log.Println("Entered ES read() ...") log.Println("Entered ES read() ...")
cmd := exec.Command("/usr/bin/dump1090", "--net", "--device-index", strconv.Itoa(e.indexID), "--ppm", strconv.Itoa(e.ppm)) cmd := exec.Command("/usr/bin/dump1090", "--net", "--device-index", strconv.Itoa(e.indexID), "--ppm", strconv.Itoa(e.ppm))
stdout, _ := cmd.StdoutPipe() stdout, _ := cmd.StdoutPipe()
@ -84,8 +72,7 @@ func (e *ES) read() {
select { select {
case buf := <-outputChan: case buf := <-outputChan:
replayLog(string(buf), MSGCLASS_DUMP1090) replayLog(string(buf), MSGCLASS_DUMP1090)
case <-e.closeCh:
case <-es_shutdown:
log.Println("ES read(): shutdown msg received, calling cmd.Process.Kill() ...") log.Println("ES read(): shutdown msg received, calling cmd.Process.Kill() ...")
err := cmd.Process.Kill() err := cmd.Process.Kill()
if err != nil { if err != nil {
@ -97,13 +84,12 @@ func (e *ES) read() {
return return
default: default:
time.Sleep(1 * time.Second) time.Sleep(1 * time.Second)
} }
} }
} }
func (u *UAT) read() { func (u *UAT) read() {
defer uat_wg.Done() defer u.wg.Done()
log.Println("Entered UAT read() ...") log.Println("Entered UAT read() ...")
var buffer = make([]uint8, rtl.DefaultBufLength) var buffer = make([]uint8, rtl.DefaultBufLength)
@ -120,7 +106,7 @@ func (u *UAT) read() {
buf := buffer[:nRead] buf := buffer[:nRead]
godump978.InChan <- buf godump978.InChan <- buf
} }
case <-uat_shutdown: case <-u.closeCh:
log.Println("UAT read(): shutdown msg received...") log.Println("UAT read(): shutdown msg received...")
return return
} }
@ -128,12 +114,12 @@ func (u *UAT) read() {
} }
func getPPM(serial string) int { func getPPM(serial string) int {
r, err := regexp.Compile("str?a?t?u?x:\\d+:?(-?\\d*)"); r, err := regexp.Compile("str?a?t?u?x:\\d+:?(-?\\d*)")
if err != nil { if err != nil {
return globalSettings.PPM return globalSettings.PPM
} }
arr := r.FindStringSubmatch(serial); arr := r.FindStringSubmatch(serial)
if arr == nil { if arr == nil {
return globalSettings.PPM return globalSettings.PPM
} }
@ -150,9 +136,17 @@ func (e *ES) sdrConfig() (err error) {
return return
} }
const (
TunerGain = 480
SampleRate = 2083334
NewRTLFreq = 28800000
NewTunerFreq = 28800000
CenterFreq = 978000000
Bandwidth = 1000000
)
func (u *UAT) sdrConfig() (err error) { func (u *UAT) sdrConfig() (err error) {
log.Printf("===== UAT Device name: %s =====\n", rtl.GetDeviceName(u.indexID)) log.Printf("===== UAT Device name: %s =====\n", rtl.GetDeviceName(u.indexID))
u.ppm = getPPM(u.serial)
if u.dev, err = rtl.Open(u.indexID); err != nil { if u.dev, err = rtl.Open(u.indexID); err != nil {
log.Printf("\tUAT Open Failed...\n") log.Printf("\tUAT Open Failed...\n")
@ -170,8 +164,7 @@ func (u *UAT) sdrConfig() (err error) {
log.Printf("\tSetTunerGainMode Successful\n") log.Printf("\tSetTunerGainMode Successful\n")
} }
tgain := 480 err = u.dev.SetTunerGain(TunerGain)
err = u.dev.SetTunerGain(tgain)
if err != nil { if err != nil {
u.dev.Close() u.dev.Close()
log.Printf("\tSetTunerGain Failed - error: %s\n", err) log.Printf("\tSetTunerGain Failed - error: %s\n", err)
@ -181,14 +174,13 @@ func (u *UAT) sdrConfig() (err error) {
} }
//---------- Get/Set Sample Rate ---------- //---------- Get/Set Sample Rate ----------
samplerate := 2083334 err = u.dev.SetSampleRate(SampleRate)
err = u.dev.SetSampleRate(samplerate)
if err != nil { if err != nil {
u.dev.Close() u.dev.Close()
log.Printf("\tSetSampleRate Failed - error: %s\n", err) log.Printf("\tSetSampleRate Failed - error: %s\n", err)
return return
} else { } else {
log.Printf("\tSetSampleRate - rate: %d\n", samplerate) log.Printf("\tSetSampleRate - rate: %d\n", SampleRate)
} }
log.Printf("\tGetSampleRate: %d\n", u.dev.GetSampleRate()) log.Printf("\tGetSampleRate: %d\n", u.dev.GetSampleRate())
@ -202,20 +194,18 @@ func (u *UAT) sdrConfig() (err error) {
log.Printf("\tGetXtalFreq - Rtl: %d, Tuner: %d\n", rtlFreq, tunerFreq) log.Printf("\tGetXtalFreq - Rtl: %d, Tuner: %d\n", rtlFreq, tunerFreq)
} }
newRTLFreq := 28800000 err = u.dev.SetXtalFreq(NewRTLFreq, NewTunerFreq)
newTunerFreq := 28800000
err = u.dev.SetXtalFreq(newRTLFreq, newTunerFreq)
if err != nil { if err != nil {
u.dev.Close() u.dev.Close()
log.Printf("\tSetXtalFreq Failed - error: %s\n", err) log.Printf("\tSetXtalFreq Failed - error: %s\n", err)
return return
} else { } else {
log.Printf("\tSetXtalFreq - Center freq: %d, Tuner freq: %d\n", log.Printf("\tSetXtalFreq - Center freq: %d, Tuner freq: %d\n",
newRTLFreq, newTunerFreq) NewRTLFreq, NewTunerFreq)
} }
//---------- Get/Set Center Freq ---------- //---------- Get/Set Center Freq ----------
err = u.dev.SetCenterFreq(978000000) err = u.dev.SetCenterFreq(CenterFreq)
if err != nil { if err != nil {
u.dev.Close() u.dev.Close()
log.Printf("\tSetCenterFreq 978MHz Failed, error: %s\n", err) log.Printf("\tSetCenterFreq 978MHz Failed, error: %s\n", err)
@ -227,14 +217,13 @@ func (u *UAT) sdrConfig() (err error) {
log.Printf("\tGetCenterFreq: %d\n", u.dev.GetCenterFreq()) log.Printf("\tGetCenterFreq: %d\n", u.dev.GetCenterFreq())
//---------- Set Bandwidth ---------- //---------- Set Bandwidth ----------
bw := 1000000 log.Printf("\tSetting Bandwidth: %d\n", Bandwidth)
log.Printf("\tSetting Bandwidth: %d\n", bw) if err = u.dev.SetTunerBw(Bandwidth); err != nil {
if err = u.dev.SetTunerBw(bw); err != nil {
u.dev.Close() u.dev.Close()
log.Printf("\tSetTunerBw %d Failed, error: %s\n", bw, err) log.Printf("\tSetTunerBw %d Failed, error: %s\n", Bandwidth, err)
return return
} else { } else {
log.Printf("\tSetTunerBw %d Successful\n", bw) log.Printf("\tSetTunerBw %d Successful\n", Bandwidth)
} }
if err = u.dev.ResetBuffer(); err != nil { if err = u.dev.ResetBuffer(); err != nil {
@ -244,9 +233,11 @@ func (u *UAT) sdrConfig() (err error) {
} else { } else {
log.Printf("\tResetBuffer Successful\n") log.Printf("\tResetBuffer Successful\n")
} }
//---------- Get/Set Freq Correction ---------- //---------- Get/Set Freq Correction ----------
freqCorr := u.dev.GetFreqCorrection() freqCorr := u.dev.GetFreqCorrection()
log.Printf("\tGetFreqCorrection: %d\n", freqCorr) log.Printf("\tGetFreqCorrection: %d\n", freqCorr)
u.ppm = getPPM(u.serial)
err = u.dev.SetFreqCorrection(u.ppm) err = u.dev.SetFreqCorrection(u.ppm)
if err != nil { if err != nil {
u.dev.Close() u.dev.Close()
@ -290,24 +281,22 @@ func (e *ES) writeID() error {
func (u *UAT) shutdown() { func (u *UAT) shutdown() {
log.Println("Entered UAT shutdown() ...") log.Println("Entered UAT shutdown() ...")
close(uat_shutdown) // signal to shutdown close(u.closeCh) // signal to shutdown
log.Println("UAT shutdown(): calling uat_wg.Wait() ...") log.Println("UAT shutdown(): calling u.wg.Wait() ...")
uat_wg.Wait() // Wait for the goroutine to shutdown u.wg.Wait() // Wait for the goroutine to shutdown
log.Println("UAT shutdown(): uat_wg.Wait() returned...") log.Println("UAT shutdown(): u.wg.Wait() returned...")
log.Println("UAT shutdown(): closing device ...") log.Println("UAT shutdown(): closing device ...")
u.dev.Close() // preempt the blocking ReadSync call u.dev.Close() // preempt the blocking ReadSync call
} }
func (e *ES) shutdown() { func (e *ES) shutdown() {
log.Println("Entered ES shutdown() ...") log.Println("Entered ES shutdown() ...")
close(es_shutdown) // signal to shutdown close(e.closeCh) // signal to shutdown
log.Println("ES shutdown(): calling es_wg.Wait() ...") log.Println("ES shutdown(): calling e.wg.Wait() ...")
es_wg.Wait() // Wait for the goroutine to shutdown e.wg.Wait() // Wait for the goroutine to shutdown
log.Println("ES shutdown(): es_wg.Wait() returned...") log.Println("ES shutdown(): e.wg.Wait() returned...")
} }
var devMap = map[int]string{0: "", 1: ""}
var sdrShutdown bool var sdrShutdown bool
func sdrKill() { func sdrKill() {
@ -319,20 +308,30 @@ func sdrKill() {
} }
} }
// Watch for config/device changes. type rUAT regexp.Regexp
func sdrWatcher() {
var doSkip bool func (r *rUAT) hasID(serial string) bool {
rES, err := regexp.Compile("str?a?t?u?x:1090") if r == nil {
if err != nil { return !strings.HasPrefix(serial, "stratux:978")
rES = nil }
log.Println("failed to compile ES regexp because %s", err.Error()) return r.MatchString(serial)
} }
rUAT, err := regexp.Compile("str?a?t?u?x:978") type rES regexp.Regexp
if err != nil {
rUAT = nil func (r *rES) hasID(serial string) bool {
log.Println("failed to compile UAT regexp because %s", err.Error()) if r == nil {
return strings.HasPrefix(serial, "stratux:1090")
} }
return r.MatchString(serial)
}
// Watch for config/device changes.
func sdrWatcher() {
// Compile returns a nil pointer when it fails and
// we do the nil check in the hasID method
rES, _ = regexp.Compile("str?a?t?u?x:1090")
rUAT, _ = regexp.Compile("str?a?t?u?x:978")
for { for {
time.Sleep(1 * time.Second) time.Sleep(1 * time.Second)
@ -349,7 +348,6 @@ func sdrWatcher() {
} }
count := rtl.GetDeviceCount() count := rtl.GetDeviceCount()
atomic.StoreUint32(&globalStatus.Devices, uint32(count)) atomic.StoreUint32(&globalStatus.Devices, uint32(count))
// log.Println("DeviceCount...", count)
// support two and only two dongles // support two and only two dongles
if count > 2 { if count > 2 {
@ -358,7 +356,6 @@ func sdrWatcher() {
// cleanup if necessary // cleanup if necessary
if count < 1 || (!globalSettings.UAT_Enabled && !globalSettings.ES_Enabled) { if count < 1 || (!globalSettings.UAT_Enabled && !globalSettings.ES_Enabled) {
// log.Println("count == 0, doing cleanup if necessary...")
if UATDev != nil { if UATDev != nil {
UATDev.shutdown() UATDev.shutdown()
UATDev = nil UATDev = nil
@ -371,7 +368,13 @@ func sdrWatcher() {
} }
if count == 1 { if count == 1 {
if UATDev != nil && ESDev == nil { if UATDev != nil && ESDev != nil {
// this is a bit heavy handed but we shouldn't be in this state
ESDev.shutdown()
ESDev = nil
UATDev.shutdown()
UATDev = nil
} else if UATDev != nil && ESDev == nil {
UATDev.indexID = 0 UATDev.indexID = 0
} else if UATDev == nil && ESDev != nil { } else if UATDev == nil && ESDev != nil {
ESDev.indexID = 0 ESDev.indexID = 0
@ -381,9 +384,8 @@ func sdrWatcher() {
// UAT specific handling // UAT specific handling
// When count is one, favor UAT in the case where the user // When count is one, favor UAT in the case where the user
// has enabled both UAT and ES via the web interface. // has enabled both UAT and ES via the web interface.
id := 0
if globalSettings.UAT_Enabled { if globalSettings.UAT_Enabled {
// log.Println("globalSettings.UAT_Enabled == true") id := 0
if count == 1 { if count == 1 {
if ESDev != nil { if ESDev != nil {
ESDev.shutdown() ESDev.shutdown()
@ -403,20 +405,14 @@ func sdrWatcher() {
serial = "" serial = ""
} }
if (rES != nil) { if !!rES.hasID(serial) {
doSkip = rES.MatchString(serial) UATDev = &Device{indexID: id, serial: serial, wg: &sync.WaitGroup{}}
} else {
doSkip = strings.Compare(serial, "stratux:1090") == 0
}
if !doSkip {
UATDev = &UAT{indexID: id, serial: serial}
if err := UATDev.sdrConfig(); err != nil { if err := UATDev.sdrConfig(); err != nil {
log.Printf("UATDev = &UAT{indexID: id} failed: %s\n", err) log.Printf("UATDev = &UAT{indexID: id} failed: %s\n", err)
UATDev = nil UATDev = nil
} else { } else {
uat_shutdown = make(chan int) UATDev.closeCh = make(chan int)
uat_wg.Add(1) UATDev.wg.Add(1)
go UATDev.read() go UATDev.read()
} }
} }
@ -430,9 +426,8 @@ func sdrWatcher() {
} }
// ES specific handling // ES specific handling
id = 0
if globalSettings.ES_Enabled { if globalSettings.ES_Enabled {
// log.Println("globalSettings.ES_Enabled == true") id := 0
if count == 1 { if count == 1 {
if globalSettings.UAT_Enabled { if globalSettings.UAT_Enabled {
// defer to the UAT handler // defer to the UAT handler
@ -452,20 +447,14 @@ func sdrWatcher() {
serial = "" serial = ""
} }
if (rUAT != nil) { if !!rUAT.hasID(serial) {
doSkip = rUAT.MatchString(serial) ESDev = &Device{indexID: id, serial: serial, wg: &sync.WaitGroup{}}
} else {
doSkip = strings.Compare(serial, "stratux:978") == 0
}
if !doSkip {
ESDev = &ES{indexID: id, serial: serial}
if err := ESDev.sdrConfig(); err != nil { if err := ESDev.sdrConfig(); err != nil {
log.Printf("ESDev = &ES{indexID: id} failed: %s\n", err) log.Printf("ESDev = &ES{indexID: id} failed: %s\n", err)
ESDev = nil ESDev = nil
} else { } else {
es_shutdown = make(chan int) ESDev.closeCh = make(chan int)
es_wg.Add(1) ESDev.wg.Add(1)
go ESDev.read() go ESDev.read()
} }
} }