stratux/main/sdr.go

233 wiersze
5.5 KiB
Go
Czysty Zwykły widok Historia

package main
import (
"../godump978"
2015-09-14 03:38:22 +00:00
rtl "github.com/jpoirier/gortlsdr"
"log"
"time"
"os/exec"
"strconv"
"strings"
)
var uatSDR int // Index.
2015-09-14 03:38:22 +00:00
var esSDR int // Index.
var maxSignalStrength int
func getSDRSerial(dev *rtl.Context) (string, error) {
info, err := dev.GetHwInfo()
if err != nil {
return "", err
}
info.Serial = strings.Replace(info.Serial, "\x00", "", -1)
return info.Serial, nil
}
func setSDRSerial(dev *rtl.Context, info rtl.HwInfo) error {
return dev.SetHwInfo(info)
}
// 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
return
}
defer dev.Close()
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)
}
if err = dev.ResetBuffer(); err == nil {
log.Printf("\tResetBuffer Successful\n")
} else {
log.Printf("\tResetBuffer Failed - error: %s\n", err)
}
2015-09-14 03:38:22 +00:00
//---------- Get/Set Freq Correction ----------
freqCorr := dev.GetFreqCorrection()
log.Printf("\tGetFreqCorrection: %d\n", freqCorr)
2015-09-19 18:19:57 +00:00
err = dev.SetFreqCorrection(globalSettings.PPM)
2015-09-14 03:38:22 +00:00
if err != nil {
2015-09-16 14:09:51 +00:00
log.Printf("\tSetFreqCorrection %d Failed, error: %s\n", globalSettings.PPM, err)
2015-09-14 03:38:22 +00:00
} else {
2015-09-16 14:09:51 +00:00
log.Printf("\tSetFreqCorrection %d Successful\n", globalSettings.PPM)
2015-09-14 03:38:22 +00:00
}
for uatSDR != -1 && globalSettings.UAT_Enabled {
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 {
2015-09-14 03:38:22 +00:00
// log.Printf("\tReadSync %d\n", nRead)
buf := buffer[:nRead]
godump978.InChan <- buf
}
}
esSDR = -1
}
// Read from the godump978 channel - on or off.
func uatReader() {
for {
uat := <-godump978.OutChan
o, msgtype := parseInput(uat)
if o != nil && msgtype != 0 {
relayMessage(msgtype, o)
}
}
}
// 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) && (esSDR != -1 || !globalSettings.ES_Enabled) {
// Nothing to do. All devices are set up and running or not required.
continue
}
// Get the device strings for every device that we can.
devs := make(map[int]string)
for i := 0; i < int(globalStatus.Devices); i++ {
dev, err := rtl.Open(i)
if err != nil {
continue
}
serial, err := getSDRSerial(dev)
if err != nil {
continue
}
devs[i] = serial
dev.Close()
}
if uatSDR == -1 && globalSettings.UAT_Enabled {
for devid, serial := range devs {
if strings.HasPrefix(serial, "stratux:978") {
uatSDR = devid
delete(devs, devid)
break
}
}
if uatSDR == -1 {
for devid, _ := range devs {
uatSDR = devid
break
}
}
if uatSDR != -1 {
log.Printf("UAT SDR: %d\n", uatSDR)
go sdrReader()
} else {
log.Printf("Can't start UAT listening - no available RTL-SDR.\n")
}
}
if esSDR == -1 && globalSettings.ES_Enabled {
for devid, _ := range devs {
esSDR = devid
break
}
if esSDR != -1 {
log.Printf("ES SDR: %d\n", esSDR)
// Assume that this keeps running forever and won't change.
//TODO: esSDR modify, watch if SDR disappears.
err := exec.Command("/usr/bin/dump1090", "--net", "--device-index", strconv.Itoa(esSDR)).Run()
if err != nil {
log.Printf("Error executing /usr/bin/dump1090: %s\n", err.Error())
}
} else {
log.Printf("Can't start ES listening - no available RTL-SDR.\n")
}
}
}
}
func sdrInit() {
godump978.Dump978Init()
uatSDR = -1
esSDR = -1
go sdrWatcher()
go uatReader()
go godump978.ProcessDataFromChannel()
2015-09-14 03:38:22 +00:00
}