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")
}
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")
}
// 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 ----------
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")
}
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 = 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", u.dev.GetSampleRate())
//---------- Get/Set Xtal Freq ----------
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 = 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 = 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", u.dev.GetCenterFreq())
//---------- Set Bandwidth ----------
bw := 1000000
log.Printf("\tSetting Bandwidth: %d\n", bw)
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 = 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 := u.dev.GetFreqCorrection()
log.Printf("\tGetFreqCorrection: %d\n", freqCorr)
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)
}
return
}
func main() {
var err error
flag.IntVar(&dongle.devIndex, "d", 0, "dongle device index")
flag.Var(&controller.freqs, "f", "frequency or range of frequencies, and step e.g 92.9M:100.1M:25k")
flag.IntVar(&demod.squelchLevel, "l", 0, "squelch level")
rateStr := flag.String("s", "24k", "sample rate")
flag.IntVar(&dongle.ppmError, "p", 0, "ppm error")
flag.IntVar(&dongle.gain, "g", autoGain, "gain level (defaults to autogain)")
flag.BoolVar(&demod.agcEnable, "agc", false, "Software AGC")
flag.BoolVar(&output.pad, "pad", false, "pad output gaps with zeros")
demodMode := flag.String("M", "am", "demodulation mode [fm, wbfm, am]")
flag.Parse()
if *rateStr != "" {
var rateIn uint32
rateIn, err = freqHz(*rateStr)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to parse sample rate %s\n", err)
return
}
demod.rateIn = int(rateIn)
demod.rateOut = int(rateIn)
}
switch *demodMode {
case "fm":
demod.modeDemod = fmDemod
case "wbfm":
controller.wbMode = true
demod.modeDemod = fmDemod
demod.rateIn = 170000
demod.rateOut = 170000
demod.rateOut2 = 32000
output.rate = 32000
demod.customAtan = 1
//demod.post_downsample = 4;
demod.deemph = true
demod.squelchLevel = 0
default:
demod.modeDemod = amDemod
}
if len(controller.freqs) == 0 {
fmt.Fprintln(os.Stderr, "Please specify a frequency.")
return
}
if len(controller.freqs) >= frequenciesLimit {
fmt.Fprintf(os.Stderr, "Too many channels, maximum %d.\n", frequenciesLimit)
return
}
if len(controller.freqs) > 1 && demod.squelchLevel == 0 {
fmt.Fprintln(os.Stderr, "Please specify a squelch level. Required for scanning multiple frequencies.")
return
}
// quadruple sample_rate to limit to Δθ to ±π/2
demod.rateIn *= demod.postDownsample
if output.rate == 0 {
output.rate = demod.rateOut
}
if flag.Arg(0) != "" {
output.filename = flag.Arg(0)
} else {
output.filename = ""
}
dongle.dev, err = rtl.Open(dongle.devIndex)
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to open dongle, '%s', exiting\n", err)
return
}
defer dongle.dev.Close()
if demod.deemph {
demod.deemphA = int(
//round(1.0/(1.0-math.Exp(-1.0/(float64(demod.rateOut)*75e-6))), 0),
round(1.0 / (1.0 - math.Exp(-1.0/(float64(demod.rateOut)*75e-6)))),
)
fmt.Fprintf(os.Stderr, "Deempha %d\n", demod.deemphA)
}
// Set the tuner gain
if dongle.gain == autoGain {
fmt.Fprintf(os.Stderr, "Setting auto gain\n")
err = dongle.dev.SetTunerGainMode(false)
if err != nil {
fmt.Fprintf(os.Stderr, "Error setting tuner auto-gain: %s\n", err)
return
}
} else {
dongle.gain *= 10
dongle.gain, err = nearestGain(dongle.dev, dongle.gain)
if err != nil {
fmt.Fprintf(os.Stderr, "Error getting nearest gain to %d: %s\n", dongle.gain, err)
return
}
err = dongle.dev.SetTunerGain(dongle.gain)
if err != nil {
fmt.Fprintf(os.Stderr, "Error setting tuner manual gain to %d: %s\n", dongle.gain)
return
}
}
if dongle.ppmError > 0 {
err = dongle.dev.SetFreqCorrection(dongle.ppmError)
if err != nil {
fmt.Fprintf(os.Stderr, "Error setting frequency correction to %d: %s\n", dongle.ppmError, err)
return
}
fmt.Fprintf(os.Stderr, "Tuner error set to %i ppm.\n", dongle.ppmError)
}
if output.filename == "" {
output.file = os.Stdout
} else {
output.file, err = os.Create(output.filename)
if err != nil {
fmt.Fprintln(os.Stderr, err)
return
}
defer output.file.Close()
}
// Reset endpoint before we start reading from it (mandatory)
err = dongle.dev.ResetBuffer()
if err != nil {
fmt.Fprintln(os.Stderr, err)
return
}
signalChan := make(chan os.Signal, 1)
quit := make(exitChan)
signal.Notify(signalChan, os.Interrupt)
go func() {
for _ = range signalChan {
fmt.Fprintln(os.Stderr, "\nReceived an interrupt, stopping services...")
close(quit)
return
}
}()
var wg sync.WaitGroup
wg.Add(4)
go controllerRoutine(&wg)
go outputRoutine(&wg)
go demodRoutine(&wg)
go dongleRoutine(&wg)
controller.hopChan <- true
<-quit
fmt.Fprintf(os.Stderr, "rtlsdr CancelAsync()\n")
if err := dongle.dev.CancelAsync(); err != nil {
fmt.Fprintf(os.Stderr, "Error canceling async %s\n", err)
}
fmt.Fprintf(os.Stderr, "Waiting for goroutines to finish...\n")
wg.Wait()
fmt.Fprintf(os.Stderr, "Exiting...\n")
}
// 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()
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)
}
if err = dev.ResetBuffer(); err == nil {
log.Printf("\tResetBuffer Successful\n")
} else {
log.Printf("\tResetBuffer Failed - error: %s\n", err)
}
//---------- Get/Set Freq Correction ----------
freqCorr := dev.GetFreqCorrection()
log.Printf("\tGetFreqCorrection: %d\n", freqCorr)
err = dev.SetFreqCorrection(globalSettings.PPM)
if err != nil {
log.Printf("\tSetFreqCorrection %d Failed, error: %s\n", globalSettings.PPM, err)
} 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
}
}
}
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
}
}
}
func (u *UAT) sdrConfig() (err error) {
log.Printf("===== UAT Device Name : %s =====\n", rtl.GetDeviceName(u.indexID))
log.Printf("===== UAT Device Serial: %s=====\n", u.serial)
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 ----------
err = u.dev.SetTunerGainMode(true)
if err != nil {
u.dev.Close()
log.Printf("\tSetTunerGainMode Failed - error: %s\n", err)
return
}
log.Printf("\tSetTunerGainMode Successful\n")
err = u.dev.SetTunerGain(TunerGain)
if err != nil {
u.dev.Close()
log.Printf("\tSetTunerGain Failed - error: %s\n", err)
return
}
log.Printf("\tSetTunerGain Successful\n")
tgain := u.dev.GetTunerGain()
log.Printf("\tGetTunerGain: %d\n", tgain)
//---------- Get/Set Sample Rate ----------
err = u.dev.SetSampleRate(SampleRate)
if err != nil {
u.dev.Close()
log.Printf("\tSetSampleRate Failed - error: %s\n", err)
return
}
log.Printf("\tSetSampleRate - rate: %d\n", SampleRate)
log.Printf("\tGetSampleRate: %d\n", u.dev.GetSampleRate())
//---------- Get/Set Xtal Freq ----------
rtlFreq, tunerFreq, err := u.dev.GetXtalFreq()
if err != nil {
u.dev.Close()
log.Printf("\tGetXtalFreq Failed - error: %s\n", err)
return
}
log.Printf("\tGetXtalFreq - Rtl: %d, Tuner: %d\n", rtlFreq, tunerFreq)
err = u.dev.SetXtalFreq(NewRTLFreq, NewTunerFreq)
if err != nil {
u.dev.Close()
log.Printf("\tSetXtalFreq Failed - error: %s\n", err)
return
}
log.Printf("\tSetXtalFreq - Center freq: %d, Tuner freq: %d\n",
NewRTLFreq, NewTunerFreq)
//---------- Get/Set Center Freq ----------
err = u.dev.SetCenterFreq(CenterFreq)
if err != nil {
u.dev.Close()
log.Printf("\tSetCenterFreq 978MHz Failed, error: %s\n", err)
return
}
log.Printf("\tSetCenterFreq 978MHz Successful\n")
log.Printf("\tGetCenterFreq: %d\n", u.dev.GetCenterFreq())
//---------- Set Bandwidth ----------
log.Printf("\tSetting Bandwidth: %d\n", Bandwidth)
if err = u.dev.SetTunerBw(Bandwidth); err != nil {
u.dev.Close()
log.Printf("\tSetTunerBw %d Failed, error: %s\n", Bandwidth, err)
return
}
log.Printf("\tSetTunerBw %d Successful\n", Bandwidth)
if err = u.dev.ResetBuffer(); err != nil {
u.dev.Close()
log.Printf("\tResetBuffer Failed - error: %s\n", err)
return
}
log.Printf("\tResetBuffer Successful\n")
//---------- Get/Set Freq Correction ----------
freqCorr := u.dev.GetFreqCorrection()
log.Printf("\tGetFreqCorrection: %d\n", freqCorr)
u.ppm = getPPM(u.serial)
err = u.dev.SetFreqCorrection(u.ppm)
if err != nil {
u.dev.Close()
log.Printf("\tSetFreqCorrection %d Failed, error: %s\n", u.ppm, err)
return
}
log.Printf("\tSetFreqCorrection %d Successful\n", u.ppm)
return
}
// sdrConfig configures the device to 978 MHz UAT channel.
func (u *UAT) sdrConfig(indexID int) (err error) {
if u.dev, err = rtl.Open(indexID); err != nil {
log.Printf("\tUAT Open Failed...\n")
return
}
log.Printf("\tGetTunerType: %s\n", u.dev.GetTunerType())
//---------- Set Tuner Gain ----------
err = u.dev.SetTunerGainMode(true)
if err != nil {
u.dev.Close()
log.Printf("\tSetTunerGainMode Failed - error: %s\n", err)
return
}
log.Printf("\tSetTunerGainMode Successful\n")
tgain := 0
gains, err := u.dev.GetTunerGains()
if err != nil {
log.Printf("\tGetTunerGains Failed - error: %s\n", err)
} else if len(gains) > 0 {
log.Printf("Gains: %v", gains)
tgain = int(gains[0])
}
err = u.dev.SetTunerGain(tgain)
if err != nil {
u.dev.Close()
log.Printf("\tSetTunerGain Failed - error: %s\n", err)
return
}
log.Printf("\tSetTunerGain Successful. Gain: %d\n", tgain)
//---------- Get/Set Sample Rate ----------
samplerate := 2048000 // 2000000 // 2083334
err = u.dev.SetSampleRate(samplerate)
if err != nil {
u.dev.Close()
log.Printf("\tSetSampleRate Failed - error: %s\n", err)
return
}
log.Printf("\tSetSampleRate - rate: %d\n", samplerate)
log.Printf("\tGetSampleRate: %d\n", u.dev.GetSampleRate())
//---------- Get/Set Xtal Freq ----------
rtlFreq, tunerFreq, err := u.dev.GetXtalFreq()
if err != nil {
u.dev.Close()
log.Printf("\tGetXtalFreq Failed - error: %s\n", err)
return
}
log.Printf("\tGetXtalFreq - Rtl: %d, Tuner: %d\n", rtlFreq, tunerFreq)
newRTLFreq := 28800000
newTunerFreq := 28800000
err = u.dev.SetXtalFreq(newRTLFreq, newTunerFreq)
if err != nil {
u.dev.Close()
log.Printf("\tSetXtalFreq Failed - error: %s\n", err)
return
}
log.Printf("\tSetXtalFreq - Center freq: %d, Tuner freq: %d\n",
newRTLFreq, newTunerFreq)
//---------- Get/Set Center Freq ----------
err = u.dev.SetCenterFreq(978000000)
if err != nil {
u.dev.Close()
log.Printf("\tSetCenterFreq 978MHz Failed, error: %s\n", err)
return
}
log.Printf("\tSetCenterFreq 978MHz Successful\n")
log.Printf("\tGetCenterFreq: %d\n", u.dev.GetCenterFreq())
//---------- Set Bandwidth ----------
bw := 1000000
log.Printf("\tSetting Bandwidth: %d\n", bw)
if err = u.dev.SetTunerBw(bw); err != nil {
u.dev.Close()
log.Printf("\tSetTunerBw %d Failed, error: %s\n", bw, err)
return
}
log.Printf("\tSetTunerBw %d Successful\n", bw)
if err = u.dev.ResetBuffer(); err != nil {
u.dev.Close()
log.Printf("\tResetBuffer Failed - error: %s\n", err)
return
}
log.Printf("\tResetBuffer Successful\n")
//---------- Get/Set Freq Correction ----------
freqCorr := u.dev.GetFreqCorrection()
log.Printf("\tGetFreqCorrection: %d\n", freqCorr)
err = u.dev.SetFreqCorrection(freqCorr)
if err != nil {
u.dev.Close()
log.Printf("\tSetFreqCorrection %d Failed, error: %s\n", freqCorr, err)
return
}
log.Printf("\tSetFreqCorrection %d Successful\n", freqCorr)
return
}