示例#1
0
文件: test.go 项目: Tanis8472/goadsb
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")
}
示例#2
0
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")
}