예제 #1
0
파일: example.go 프로젝트: jpoirier/kal
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)
}
예제 #2
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")
}
예제 #3
0
// 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 {
			if globalStatus.Devices == 0 {
				log.Printf("No RTL-SDR devices.\n")
				continue
			}
			uatSDR = 0
			go sdrReader()
		}
		if esSDR == -1 && globalSettings.ES_Enabled {
			if globalStatus.Devices == 0 || (globalStatus.Devices == 1 && globalSettings.UAT_Enabled) {
				log.Printf("Not enough RTL-SDR devices.\n")
			}
			esSDR = 1
		}
	}
}
예제 #4
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")
}
예제 #5
0
파일: sdr.go 프로젝트: KingoL/stratux
// Watch for config/device changes.
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
		if count > 2 {
			count = 2
		}

		// cleanup if necessary
		if count < 1 || (!globalSettings.UAT_Enabled && !globalSettings.ES_Enabled) {
			log.Println("count == 0, doing cleanup if necessary...")
			if UATDev != nil {
				UATDev.shutdown()
				UATDev = nil
			}
			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 {
			// log.Println("globalSettings.UAT_Enabled == true")
			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 {
				// log.Println("\tUATDev == 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 {
						log.Printf("UATDev = &UAT{indexID: id} failed: %s\n", err)
						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 {
			// log.Println("globalSettings.ES_Enabled == true")
			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 {
				// log.Println("\tESDev == 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 {
						log.Printf("ESDev = &ES{indexID: id} failed: %s\n", err)
						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:
	}
}
예제 #6
0
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
		}
	}
}
예제 #7
0
파일: sdr.go 프로젝트: ssokol/stratux
// Watch for config/device changes.
func sdrWatcher() {
	prevCount := 0
	prevUATEnabled := false
	prevESEnabled := false

	for {
		time.Sleep(1 * time.Second)
		if sdrShutdown {
			if UATDev != nil {
				UATDev.shutdown()
				UATDev = nil
			}
			if ESDev != nil {
				ESDev.shutdown()
				ESDev = nil
			}
			return
		}

		// true when a ReadSync call fails
		if shutdownUAT {
			if UATDev != nil {
				UATDev.shutdown()
				UATDev = nil
			}
			shutdownUAT = false
		}
		// true when we get stderr output
		if shutdownES {
			if ESDev != nil {
				ESDev.shutdown()
				ESDev = nil
			}
			shutdownES = false
		}

		// capture current state
		esEnabled := globalSettings.ES_Enabled
		uatEnabled := globalSettings.UAT_Enabled
		count := rtl.GetDeviceCount()
		atomic.StoreUint32(&globalStatus.Devices, uint32(count))

		// support up to two dongles
		if count > 2 {
			count = 2
		}

		if count == prevCount && prevESEnabled == esEnabled && prevUATEnabled == uatEnabled {
			continue
		}

		// the device count or the global settings have changed, reconfig
		if UATDev != nil {
			UATDev.shutdown()
			UATDev = nil
		}
		if ESDev != nil {
			ESDev.shutdown()
			ESDev = nil
		}
		configDevices(count, esEnabled, uatEnabled)

		prevCount = count
		prevUATEnabled = uatEnabled
		prevESEnabled = esEnabled
	}
}
예제 #8
0
파일: sdr.go 프로젝트: iposva/stratux
// Watch for config/device changes.
func sdrWatcher() {
	for {
		time.Sleep(1 * time.Second)
		if sdrShutdown {
			if UATDev != nil {
				UATDev.shutdown()
				UATDev = nil
			}
			if ESDev != nil {
				ESDev.shutdown()
				ESDev = nil
			}
			return
		}
		count := rtl.GetDeviceCount()
		atomic.StoreUint32(&globalStatus.Devices, uint32(count))
		// log.Println("DeviceCount...", count)

		// support two and only two dongles
		if count > 2 {
			count = 2
		}

		// cleanup if necessary
		if count < 1 || (!globalSettings.UAT_Enabled && !globalSettings.ES_Enabled) {
			log.Println("count == 0, doing cleanup if necessary...")
			if UATDev != nil {
				UATDev.shutdown()
				UATDev = nil
			}
			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
			}
		}

		// 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 {
			// log.Println("globalSettings.UAT_Enabled == true")
			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 {
				_, _, serial, err := rtl.GetDeviceUsbStrings(id)
				if err != nil {
					serial = ""
				}
				if strings.Compare(serial, "stratux:1090") != 0 {
					UATDev = &UAT{indexID: id, serial: serial}
					if err := UATDev.sdrConfig(); err != nil {
						log.Printf("UATDev = &UAT{indexID: id} failed: %s\n", err)
						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 {
			// log.Println("globalSettings.ES_Enabled == true")
			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 {
				_, _, serial, err := rtl.GetDeviceUsbStrings(id)
				if err != nil {
					serial = ""
				}
				if strings.Compare(serial, "stratux:978") != 0 {
					ESDev = &ES{indexID: id, serial: serial}
					if err := ESDev.sdrConfig(); err != nil {
						log.Printf("ESDev = &ES{indexID: id} failed: %s\n", err)
						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:
	}
}
예제 #9
0
파일: sdr.go 프로젝트: yihchun/stratux
// Watch for config/device changes.
func sdrWatcher() {
	var doSkip bool

	globalStatus.Connected_Devices = 0

	rES, err := regexp.Compile("str?a?t?u?x:1090")
	if err != nil {
		rES = nil
		log.Println("failed to compile ES regexp because %s", err.Error())
	}

	rUAT, err := regexp.Compile("str?a?t?u?x:978")
	if err != nil {
		rUAT = nil
		log.Println("failed to compile UAT regexp because %s", err.Error())
	}

	for {
		time.Sleep(1 * time.Second)
		if sdrShutdown {
			if UATDev != nil {
				UATDev.shutdown()
				UATDev = nil
			}
			if ESDev != nil {
				ESDev.shutdown()
				ESDev = nil
			}
			return
		}
		count := rtl.GetDeviceCount()
		atomic.StoreUint32(&globalStatus.Devices, uint32(count))
		// log.Println("DeviceCount...", count)

		// support two and only two dongles
		if count > 2 {
			count = 2
		}

		// cleanup if necessary
		if count < 1 || (!globalSettings.UAT_Enabled && !globalSettings.ES_Enabled) {
			//			log.Println("count == 0, doing cleanup if necessary...")
			if UATDev != nil {
				UATDev.shutdown()
				UATDev = nil
			}
			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
			}
		}

		// 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 {
			// log.Println("globalSettings.UAT_Enabled == true")
			if count == 1 {
				if ESDev != nil {
					ESDev.shutdown()
					ESDev = nil
				}
			} else { // count == 2
				if UATDev == nil && ESDev != nil {
					if ESDev.indexID == 0 {
						id = 1
					}
				}

				/* Address #275. If both devices are nil, but
				 	 * id 1 matches the rUAT string, we need to
					 * force the UAT to id 1, so that UAT doesn't
					 * consume a flexible id 0 and leave ES bound
					 * to an undesired, fixed 978.
					 * A parallel fix is not installed in the ES
					 * code, because both cases are already handled:
					 * id 0 flex, id 1 1090, then 0 bound to UAT
					 * id 1 flex, id 0 1090, then 0 bound to ES
				*/
				if UATDev == nil && ESDev == nil && rUAT != nil {
					_, _, serial, err := rtl.GetDeviceUsbStrings(1)
					if err == nil && rUAT.MatchString(serial) {
						id = 1
					}
				}
			}

			if UATDev == nil {
				_, _, serial, err := rtl.GetDeviceUsbStrings(id)
				if err != nil {
					serial = ""
				}

				if rES != nil {
					doSkip = rES.MatchString(serial)
				} else {
					doSkip = strings.Compare(serial, "stratux:1090") == 0
				}

				if ESDev != nil || !doSkip {
					UATDev = &UAT{indexID: id, serial: serial}
					if err := UATDev.sdrConfig(); err != nil {
						log.Printf("UATDev = &UAT{indexID: id} failed: %s\n", err)
						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 {
			// log.Println("globalSettings.ES_Enabled == true")
			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 {
				_, _, serial, err := rtl.GetDeviceUsbStrings(id)
				if err != nil {
					serial = ""
				}

				if rUAT != nil {
					doSkip = rUAT.MatchString(serial)
				} else {
					doSkip = strings.Compare(serial, "stratux:978") == 0
				}

				if UATDev != nil || !doSkip {
					ESDev = &ES{indexID: id, serial: serial}
					if err := ESDev.sdrConfig(); err != nil {
						log.Printf("ESDev = &ES{indexID: id} failed: %s\n", err)
						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:
	}
}
예제 #10
0
파일: sdr.go 프로젝트: mondufrea/stratux
// Watch for config/device changes.
func sdrWatcher() {
	stopCheckingUATUntil := time.Time{}

	lastUATCheck := stratuxClock.Time

	for {
		time.Sleep(1 * time.Second)
		if sdrShutdown {
			if UATDev != nil {
				UATDev.shutdown()
				UATDev = nil
			}
			if ESDev != nil {
				ESDev.shutdown()
				ESDev = nil
			}
			return
		}
		count := rtl.GetDeviceCount()
		atomic.StoreUint32(&globalStatus.Devices, uint32(count))
		// log.Println("DeviceCount...", count)

		// support two and only two dongles
		if count > 2 {
			count = 2
		}

		// cleanup if necessary
		if count < 1 || (!globalSettings.UAT_Enabled && !globalSettings.ES_Enabled) {
			log.Println("count == 0, doing cleanup if necessary...")
			if UATDev != nil {
				UATDev.shutdown()
				UATDev = nil
			}
			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
			}
		}

		// UAT specific handling

		// Shutdown UAT for 50 seconds, check every 60 seconds if the count is 0.
		if stratuxClock.Since(lastUATCheck) >= 1*time.Minute {
			if UATDev != nil && globalStatus.UAT_messages_last_minute == 0 {
				log.Printf("Pausing UAT listening for 50 seconds - none received.\n")
				UATDev.shutdown()
				UATDev = nil
				stopCheckingUATUntil = stratuxClock.Time.Add(50 * time.Second)
			}
			lastUATCheck = stratuxClock.Time
		}

		// 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 && stratuxClock.Time.After(stopCheckingUATUntil) {
			// log.Println("globalSettings.UAT_Enabled == true")
			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 {
				// log.Println("\tUATDev == nil")
				// preference check based on stratux
				// hardware serial when it exists.
				// manufact, product, serial, err
				_, _, serial, err := rtl.GetDeviceUsbStrings(id)
				if err != nil {
					serial = ""
				}
				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, serial: serial}
					if err := UATDev.sdrConfig(); err != nil {
						log.Printf("UATDev = &UAT{indexID: id} failed: %s\n", err)
						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 {
			// log.Println("globalSettings.ES_Enabled == true")
			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 {
				// log.Println("\tESDev == nil")
				// preference check based on stratux
				// hardware serial when it exists.
				// manufact, product, serial, err
				_, _, serial, err := rtl.GetDeviceUsbStrings(id)
				if err != nil {
					serial = ""
				}
				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, serial: serial}
					if err := ESDev.sdrConfig(); err != nil {
						log.Printf("ESDev = &ES{indexID: id} failed: %s\n", err)
						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:
	}
}