def setTunerCenterFrequency(self, allocation_id, freq): idx = self.getTunerMapping(allocation_id) if idx < 0: raise FRONTEND.FrontendException("Invalid allocation id") if allocation_id != self.getControlAllocationId(idx): raise FRONTEND.FrontendException( ("ID " + str(allocation_id) + " does not have authorization to modify the tuner")) if freq < 0: raise FRONTEND.BadParameterException("Bad CF") # set hardware to new value. Raise an exception if it's not possible #Check Frequency again min/max Range #Convert CF based on RFInfo. tuneFreq = self.convert_rf_to_if(freq) # Check the CF if not (validateRequestSingle(self.MINFREQ, self.MAXFREQ, tuneFreq)): self._log.debug("Center Freq Does not fit %s, %s, %s" % (tuneFreq, self.MINFREQ, self.MAXFREQ)) raise FRONTEND.BadParameterException( "Radio Center Freq of %s Does not fit in %s, %s" % (tuneFreq, self.MINFREQ, self.MAXFREQ)) #set tuner new freq self.datagenerators[idx].cf = tuneFreq self.datagenerators[idx].keyword_dict['COL_RF'] = freq self.datagenerators[idx].keyword_dict['CHAN_RF'] = freq self.datagenerators[idx].updateandPushSRI() self.frontend_tuner_status[idx].center_frequency = freq
def testRFInfo(self): _port = None for port in self.comp.ports: if port.name == 'RFInfo_in': _port = port break _antennainfo = FRONTEND.AntennaInfo('testAnt', 'testType', 'testSize', 'testDescription') _freqrange = FRONTEND.FreqRange(0, 100, [1]) _feedinfo = FRONTEND.FeedInfo('testFeed', 'testPol', _freqrange) _sensorinfo = FRONTEND.SensorInfo('testMission', 'testCollector', 'testRX', _antennainfo, _feedinfo) _pathdelays = [ FRONTEND.PathDelay(100, 200), FRONTEND.PathDelay(300, 400) ] _rfcapabilities = FRONTEND.RFCapabilities(FRONTEND.FreqRange(1, 2, []), FRONTEND.FreqRange(3, 4, [])) _additionalinfo = [ CF.DataType(id='a', value=any.to_any(1)), CF.DataType(id='b', value=any.to_any(2)), CF.DataType(id='c', value=any.to_any(3)) ] _rfinfopkt = FRONTEND.RFInfoPkt('TestID', 256.0, 101.0, 412.0, False, _sensorinfo, _pathdelays, _rfcapabilities, _additionalinfo) _port.ref._set_rfinfo_pkt(_rfinfopkt)
def setTunerEnable(self, allocation_id, enable): idx = self.getTunerMapping(allocation_id) if idx < 0: raise FRONTEND.FrontendException("Invalid allocation id") if allocation_id != self.getControlAllocationId(idx): raise FRONTEND.FrontendException( ("ID " + str(allocation_id) + " does not have authorization to modify the tuner")) # set hardware to new value. Raise an exception if it's not possible self.frontend_tuner_status[idx].enabled = enable
def fe_setTunerEnable(self, alloc_id, enable): tuner_id = self.getTunerMapping(alloc_id) if tuner_id < 0: raise FRONTEND.FrontendException("ERROR: ID: %s IS NOT ASSOCIATED WITH ANY TUNER!"%(alloc_id)) if alloc_id != self.tunerChannels[tuner_id].control_allocation_id: raise FRONTEND.FrontendException("ERROR: ID: %s DOES NOT HAVE AUTHORIZATION TO MODIFY TUNER!"%(alloc_id)) try: self.enableTuner(tuner_id, enable) except Exception, e: raise FRONTEND.FrontendException("WARNING: Exception Caught during enableTuner: %s"%(e))
def setTunerGain(self, allocation_id, gain): idx = self.getTunerMapping(allocation_id) if idx < 0: raise FRONTEND.FrontendException("Invalid allocation id") if allocation_id != self.getControlAllocationId(idx): raise FRONTEND.FrontendException( ("ID " + str(allocation_id) + " does not have authorization to modify the tuner")) if (gain < 0 or gain > 10): raise FRONTEND.BadParameterException("Invalid Gain") gain = round(gain, 1) # magnitude on data generators is 100+gain*10 self.datagenerators[idx].magnitude = 100 + gain * 10 self.frontend_tuner_status[idx].gain = gain
def validateRequestVsDevice(request, upstream_sri, max_device_frame_rate): # check if request can be satisfied using the available upstream data if not validateRequestVsSRI(request, upstream_sri): raise FRONTEND.BadParameterException( "INVALID REQUEST -- falls outside of input data stream") # check device constraints # check vs. device frame rate capability (ensure 0 <= request <= max device capability) if not validateRequest(0, max_device_sample_rate, request.fps): raise FRONTEND.BadParameterException( "INVALID REQUEST -- device capabilities cannot support fr request") return True
def fe_getTunerDeviceControl(self, alloc_id): tuner_id = self.getTunerMapping(alloc_id) if tuner_id < 0: raise FRONTEND.FrontendException("ERROR: ID: %s IS NOT ASSOCIATED WITH ANY TUNER!"%(alloc_id)) if alloc_id == self.tunerChannels[tuner_id].control_allocation_id: return True return False
def testBasicBehavior(self): ####################################################################### # Make sure start and stop can be called without throwing exceptions _antennainfo = FRONTEND.AntennaInfo('', '', '', '') _freqrange = FRONTEND.FreqRange(0, 0, []) _feedinfo = FRONTEND.FeedInfo('', '', _freqrange) _sensorinfo = FRONTEND.SensorInfo('', '', '', _antennainfo, _feedinfo) _rfcapabilities = FRONTEND.RFCapabilities(_freqrange, _freqrange) rf_center_freq = 1e7 rf_bandwidth = 3e5 if_center_freq = 1e6 pkt_str = FRONTEND.RFInfoPkt('my_flow', rf_center_freq, rf_bandwidth, if_center_freq, False, _sensorinfo, [], _rfcapabilities, []) request_cf = 9.95e6 request_bw = 2e5 alloc = frontend.createTunerAllocation(allocation_id='foo', center_frequency=request_cf, bandwidth=request_bw, sample_rate=0.0) port = self.comp.ports[1] port.ref._set_rfinfo_pkt(pkt_str) self.comp.max_dev_if_cf = 1e6 self.assertTrue(self.comp.allocateCapacity(alloc)) self.comp.deallocateCapacity(alloc) pkt_inv = FRONTEND.RFInfoPkt('my_flow', rf_center_freq, rf_bandwidth, if_center_freq, True, _sensorinfo, [], _rfcapabilities, []) port.ref._set_rfinfo_pkt(pkt_inv) self.assertFalse(self.comp.allocateCapacity(alloc)) self.comp.max_dev_if_cf = 1.15e6 self.assertTrue(self.comp.allocateCapacity(alloc)) self.comp.deallocateCapacity(alloc)
def validateRequestVsDevice(request, max_device_frame_rate): # check device constraints # check vs. device frame rate capability (ensure 0 <= request <= max device capability) if not validateRequest(0, max_device_frame_rate, request.fps): raise FRONTEND.BadParameterException( "INVALID REQUEST -- device capabilities cannot support fr request") return True
def setTunerBandwidth(self, allocation_id, bw): idx = self.getTunerMapping(allocation_id) if idx < 0: raise FRONTEND.FrontendException("Invalid allocation id") if allocation_id != self.getControlAllocationId(idx): raise FRONTEND.FrontendException( ("ID " + str(allocation_id) + " does not have authorization to modify the tuner")) if bw < 0: raise FRONTEND.BadParameterException("Invalid BW") newbw, newsr, decimation = self.findBestBWSR(bw, 0) if not newbw: self._log.debug("Can't Satisfy BW and SR request") raise FRONTEND.BadParameterException( "Can't Satisfy BW and SR request") # set hardware to new value. Raise an exception if it's not possible self.datagenerators[idx].keyword_dict['FRONTEND::BANDWIDTH'] = newbw self.datagenerators[idx].updateandPushSRI() self.frontend_tuner_status[idx].bandwidth = newsr self.frontend_tuner_status[idx].bandwidth = newbw self.frontend_tuner_status[idx].decimation = decimation
def fe_setTunerOutputSampleRate(self, alloc_id, sr): tuner_id = self.getTunerMapping(alloc_id) if tuner_id < 0: raise FRONTEND.FrontendException("ERROR: ID: %s IS NOT ASSOCIATED WITH ANY TUNER!"%(alloc_id)) if alloc_id != self.tunerChannels[tuner_id].control_allocation_id: raise FRONTEND.FrontendException("ERROR: ID: %s DOES NOT HAVE AUTHORIZATION TO MODIFY TUNER!"%(alloc_id)) try: self.tunerChannels[tuner_id].lock.acquire() try: if not self._valid_sample_rate(sr,tuner_id): # TODO: add log message raise FRONTEND.BadParameterException("INVALID SAMPLE RATE") try: self._dev_set_sample_rate(sr,tuner_id) except: #TODO: add back log messages raise FRONTEND.FrontendException("WARNING: failed when configuring device hardware") try: self.tunerChannels[tuner_id].frontend_status.sample_rate = self._dev_get_sample_rate(tuner_id) except: #TODO: add back log messages raise FRONTEND.FrontendException("WARNING: failed when querying device hardware") finally: self.tunerChannels[tuner_id].lock.release() except Exception, e: raise FRONTEND.FrontendException("WARNING: %s"%(e))
def fe_setTunerCenterFrequency(self, alloc_id, freq): tuner_id = self.getTunerMapping(alloc_id) if tuner_id < 0: raise FRONTEND.FrontendException("ERROR: ID: %s IS NOT ASSOCIATED WITH ANY TUNER!"%(alloc_id)) if alloc_id != self.tunerChannels[tuner_id].control_allocation_id: raise FRONTEND.FrontendException("ERROR: ID: %s DOES NOT HAVE AUTHORIZATION TO MODIFY TUNER!"%(alloc_id)) try: # If the freq has changed (change in stream) or the tuner is disabled, then set it as disabled isTunerEnabled = self.tunerChannels[tuner_id].frontend_status.enabled if not isTunerEnabled or self.tunerChannels[tuner_id].frontend_status.center_frequency != freq: self.enableTuner(tuner_id, False) # TODO: is this a generic thing we can assume is desired when changing any tuner device? self.tunerChannels[tuner_id].lock.acquire() try: if not self._valid_center_frequency(freq,tuner_id): # TODO: add log message raise FRONTEND.BadParameterException("INVALID FREQUENCY") try: self._dev_set_center_frequency(freq,tuner_id) except: #TODO: add back log messages raise FRONTEND.FrontendException("WARNING: failed when configuring device hardware") try: self.tunerChannels[tuner_id].frontend_status.center_frequency = self._dev_get_center_frequency(tuner_id) except: #TODO: add back log messages raise FRONTEND.FrontendException("WARNING: failed when querying device hardware") finally: self.tunerChannels[tuner_id].lock.release() if isTunerEnabled: self.enableTuner(tuner_id, True) except Exception, e: raise FRONTEND.FrontendException("WARNING: %s"%(e))
def testNavSetter(self): input_parent = self.nav_port_sample() input_parent_2 = self.nav_port_sample() input_port_1 = InNavDataPort("input_1", input_parent) output_port = OutNavDataPort("output") self.assertEquals(input_parent.get_source_id(), "original") _time = BULKIO.PrecisionUTCTime(1, 1, 1.0, 1.0, 1.0) _positioninfo = FRONTEND.PositionInfo(False, 'DATUM_WGS84', 0.0, 0.0, 0.0) _cartesianpos = FRONTEND.CartesianPositionInfo(False, 'DATUM_WGS84', 0.0, 0.0, 0.0) _velocityinfo = FRONTEND.VelocityInfo(False, 'DATUM_WGS84', '', 0.0, 0.0, 0.0) _accelerationinfo = FRONTEND.AccelerationInfo(False, 'DATUM_WGS84', '', 0.0, 0.0, 0.0) _attitudeinfo = FRONTEND.AttitudeInfo(False, 0.0, 0.0, 0.0) navpacket = FRONTEND.NavigationPacket('', '', _positioninfo, _cartesianpos, _velocityinfo, _accelerationinfo, _attitudeinfo, _time, []) navpacket.source_id = "newvalue" output_port._set_nav_packet(navpacket) self.assertEquals(input_parent.get_source_id(), "original") self.assertRaises(PortCallError, output_port._set_nav_packet, navpacket, "hello") output_port.connectPort(input_port_1._this(), "hello") output_port._set_nav_packet(navpacket) self.assertEquals(input_parent.get_source_id(), "newvalue") navpacket.source_id = "newvalue_2" output_port._set_nav_packet(navpacket, "hello") self.assertEquals(input_parent.get_source_id(), "newvalue_2") self.assertRaises(PortCallError, output_port._set_nav_packet, navpacket, "foo") navpacket.source_id = "newvalue_3" input_port_2 = InNavDataPort("input_2", input_parent_2) output_port.connectPort(input_port_2._this(), "foo") output_port._set_nav_packet(navpacket) self.assertEquals(input_parent.get_source_id(), "newvalue_3") self.assertEquals(input_parent_2.get_source_id(), "newvalue_3") navpacket.source_id = "newvalue_4" output_port._set_nav_packet(navpacket, "hello") self.assertEquals(input_parent.get_source_id(), "newvalue_4") self.assertEquals(input_parent_2.get_source_id(), "newvalue_3") self.assertRaises(PortCallError, output_port._set_nav_packet, navpacket, "something") output_port.disconnectPort("hello")
def setTunerOutputSampleRate(self, allocation_id, sr): idx = self.getTunerMapping(allocation_id) if idx < 0: raise FRONTEND.FrontendException("Invalid allocation id") if allocation_id != self.getControlAllocationId(idx): raise FRONTEND.FrontendException( ("ID " + str(allocation_id) + " does not have authorization to modify the tuner")) if sr < 0: raise FRONTEND.BadParameterException("Invalid SR") newbw, newsr, decimation = self.findBestBWSR(0, sr) if not newbw: self._log.debug("Can't Satisfy BW and SR request") raise FRONTEND.BadParameterException( "Can't Satisfy BW and SR request") self._log.debug("Setting BW and Sample Rate %s, %s " % (newbw, newsr)) #set new SR self.datagenerators[idx].sr = sr self.datagenerators[idx].keyword_dict['FRONTEND::BANDWIDTH'] = newbw self.datagenerators[idx].updateandPushSRI() self.frontend_tuner_status[idx].sample_rate = newsr self.frontend_tuner_status[idx].bandwidth = newbw self.frontend_tuner_status[idx].decimation = decimation
def _createEmptyRFInfo(self): _antennainfo = FRONTEND.AntennaInfo('', '', '', '') _freqrange = FRONTEND.FreqRange(0, 0, []) _feedinfo = FRONTEND.FeedInfo('', '', _freqrange) _sensorinfo = FRONTEND.SensorInfo('', '', '', _antennainfo, _feedinfo) _rfcapabilities = FRONTEND.RFCapabilities(_freqrange, _freqrange) _rfinfopkt = FRONTEND.RFInfoPkt('', 0.0, 0.0, 0.0, False, _sensorinfo, [], _rfcapabilities, []) return _rfinfopkt
def get_current_rf_input(self, port_name): _antennainfo = FRONTEND.AntennaInfo('', '', '', '') _freqrange = FRONTEND.FreqRange(0, 0, []) _feedinfo = FRONTEND.FeedInfo('', '', _freqrange) _sensorinfo = FRONTEND.SensorInfo('', '', '', _antennainfo, _feedinfo) _rfcapabilities = FRONTEND.RFCapabilities(_freqrange, _freqrange) _rfinfopkt = FRONTEND.RFInfoPkt('', 0.0, 0.0, 0.0, False, _sensorinfo, [], _rfcapabilities, []) return _rfinfopkt
def validateRequestVsSRI(request, upstream_sri): # check if the upstream sample rate falls within the requested tolerable frame rate upstream_sr = 1 / upstream_sri.xdelta upstream_frame_rate = upstream_sr / ( request.frame_height * request.frame_width * request.channels) min_requested_sample_rate = request.sample_rate max_requested_sample_rate = request.sample_rate + request.sample_rate * request.sample_rate_tolerance / 100.0 if not validateRequest(min_requested_sample_rate, max_requested_sample_rate, upstream_frame_rate): raise FRONTEND.BadParameterException( "INVALID REQUEST -- input data stream cannot support fr request") return True
def _generateRFInfoPkt(self,rf_freq=1e9,rf_bw=1e9,if_freq=0,spec_inverted=False,rf_flow_id="testflowID"): antenna_info = FRONTEND.AntennaInfo("antenna_name","antenna_type","antenna.size","description") freqRange= FRONTEND.FreqRange(0,1e12,[] ) feed_info = FRONTEND.FeedInfo("feed_name", "polarization",freqRange) sensor_info = FRONTEND.SensorInfo("msn_name", "collector_name", "receiver_name",antenna_info,feed_info) delays = []; cap = FRONTEND.RFCapabilities(freqRange,freqRange); add_props = []; rf_info_pkt = FRONTEND.RFInfoPkt(rf_flow_id,rf_freq, rf_bw, if_freq, spec_inverted, sensor_info, delays, cap, add_props) return rf_info_pkt
def testRFSourceSetter(self): input_parent = self.rfsource_port_sample() input_parent_2 = self.rfsource_port_sample() input_port_1 = InRFSourcePort("input_1", input_parent) output_port = OutRFSourcePort("output") self.assertEquals(input_parent.get_rf_flow_id(), "original") _antennainfo = FRONTEND.AntennaInfo('', '', '', '') _freqrange = FRONTEND.FreqRange(0, 0, []) _feedinfo = FRONTEND.FeedInfo('', '', _freqrange) _sensorinfo = FRONTEND.SensorInfo('', '', '', _antennainfo, _feedinfo) _rfcapabilities = FRONTEND.RFCapabilities(_freqrange, _freqrange) rfsource = FRONTEND.RFInfoPkt('', 0.0, 0.0, 0.0, False, _sensorinfo, [], _rfcapabilities, []) rfsource.rf_flow_id = "newvalue" output_port._set_current_rf_input(rfsource) self.assertEquals(input_parent.get_rf_flow_id(), "original") self.assertRaises(PortCallError, output_port._set_current_rf_input, rfsource, "hello") output_port.connectPort(input_port_1._this(), "hello") output_port._set_current_rf_input(rfsource) self.assertEquals(input_parent.get_rf_flow_id(), "newvalue") rfsource.rf_flow_id = "newvalue_2" output_port._set_current_rf_input(rfsource, "hello") self.assertEquals(input_parent.get_rf_flow_id(), "newvalue_2") self.assertRaises(PortCallError, output_port._set_current_rf_input, rfsource, "foo") rfsource.rf_flow_id = "newvalue_3" input_port_2 = InRFSourcePort("input_2", input_parent_2) output_port.connectPort(input_port_2._this(), "foo") output_port._set_current_rf_input(rfsource) self.assertEquals(input_parent.get_rf_flow_id(), "newvalue_3") self.assertEquals(input_parent_2.get_rf_flow_id(), "newvalue_3") rfsource.rf_flow_id = "newvalue_4" output_port._set_current_rf_input(rfsource, "hello") self.assertEquals(input_parent.get_rf_flow_id(), "newvalue_4") self.assertEquals(input_parent_2.get_rf_flow_id(), "newvalue_3") self.assertRaises(PortCallError, output_port._set_current_rf_input, rfsource, "something") output_port.disconnectPort("hello")
def get_nav_packet(self, port_name): _time = BULKIO.PrecisionUTCTime(1, 1, 1.0, 1.0, 1.0) _positioninfo = FRONTEND.PositionInfo(False, 'DATUM_WGS84', 0.0, 0.0, 0.0) _cartesianpos = FRONTEND.CartesianPositionInfo(False, 'DATUM_WGS84', 0.0, 0.0, 0.0) _velocityinfo = FRONTEND.VelocityInfo(False, 'DATUM_WGS84', '', 0.0, 0.0, 0.0) _accelerationinfo = FRONTEND.AccelerationInfo(False, 'DATUM_WGS84', '', 0.0, 0.0, 0.0) _attitudeinfo = FRONTEND.AttitudeInfo(False, 0.0, 0.0, 0.0) _navpacket = FRONTEND.NavigationPacket('', '', _positioninfo, _cartesianpos, _velocityinfo, _accelerationinfo, _attitudeinfo, _time, []) return _navpacket
def getTunerEnable(self, id): raise FRONTEND.NotSupportedException("getTunerEnable not supported")
def setTunerEnable(self, id, enable): raise FRONTEND.NotSupportedException("setTunerEnable not supported")
def getTunerReferenceSource(self, id): raise FRONTEND.NotSupportedException( "getTunerReferenceSource not supported")
def getTunerGain(self, id): raise FRONTEND.NotSupportedException("getTunerGain not supported")
def setTunerGain(self, id, gain): raise FRONTEND.NotSupportedException("setTunerGain not supported")
def getTunerBandwidth(self, id): raise FRONTEND.NotSupportedException("getTunerBandwidth not supported")
def getTunerCenterFrequency(self, id): raise FRONTEND.NotSupportedException( "getTunerCenterFrequency not supported")
def getTunerOutputSampleRate(self, id): raise FRONTEND.NotSupportedException( "getTunerOutputSampleRate not supported")
def testBasicBehavior(self): self.assertEquals(self.got_logmsg, False) ####################################################################### # Make sure start and stop can be called without throwing exceptions exc_src = sb.launch('./build/fei_exception_through/tests/fei_exc_src/fei_exc_src.spd.xml') self.comp.connect(exc_src,usesPortName='DigitalTuner_out') self.comp.connect(exc_src,usesPortName='RFInfo_out') self.comp.connect(exc_src,usesPortName='GPS_out') self.comp.connect(exc_src,usesPortName='NavData_out') self.comp.connect(exc_src,usesPortName='RFSource_out') for port in self.comp.ports: if port.name == 'DigitalTuner_in': DigitalTuner_in = port if port.name == 'RFInfo_in': RFInfo_in = port if port.name == 'GPS_in': GPS_in = port if port.name == 'NavData_in': NavData_in = port if port.name == 'RFSource_in': RFSource_in = port _time = BULKIO.PrecisionUTCTime(1,1,1.0,1.0,1.0) _gpsinfo = FRONTEND.GPSInfo('','','',1L,1L,1L,1.0,1.0,1.0,1.0,1,1.0,'',_time,[]) _positioninfo = FRONTEND.PositionInfo(False,'DATUM_WGS84',0.0,0.0,0.0) _gpstimepos = FRONTEND.GpsTimePos(_positioninfo,_time) _cartesianpos=FRONTEND.CartesianPositionInfo(False,'DATUM_WGS84',0.0,0.0,0.0) _velocityinfo=FRONTEND.VelocityInfo(False,'DATUM_WGS84','',0.0,0.0,0.0) _accelerationinfo=FRONTEND.AccelerationInfo(False,'DATUM_WGS84','',0.0,0.0,0.0) _attitudeinfo=FRONTEND.AttitudeInfo(False,0.0,0.0,0.0) _navpacket=FRONTEND.NavigationPacket('','',_positioninfo,_cartesianpos,_velocityinfo,_accelerationinfo,_attitudeinfo,_time,[]) _antennainfo=FRONTEND.AntennaInfo('','','','') _freqrange=FRONTEND.FreqRange(0,0,[]) _feedinfo=FRONTEND.FeedInfo('','',_freqrange) _sensorinfo=FRONTEND.SensorInfo('','','',_antennainfo,_feedinfo) _rfcapabilities=FRONTEND.RFCapabilities(_freqrange,_freqrange) _rfinfopkt=FRONTEND.RFInfoPkt('',0.0,0.0,0.0,False,_sensorinfo,[],_rfcapabilities,[]) _strat = FRONTEND.ScanningTuner.ScanStrategy(FRONTEND.ScanningTuner.DISCRETE_SCAN, FRONTEND.ScanningTuner.ScanModeDefinition(discrete_freq_list=[]), FRONTEND.ScanningTuner.TIME_BASED, 0.1) DigitalTuner_in.ref.getScanStatus('hello') DigitalTuner_in.ref.setScanStartTime('hello', _time) DigitalTuner_in.ref.setScanStrategy('hello', _strat) DigitalTuner_in.ref.getTunerType('hello') DigitalTuner_in.ref.getTunerDeviceControl('hello') DigitalTuner_in.ref.getTunerGroupId('hello') DigitalTuner_in.ref.getTunerRfFlowId('hello') DigitalTuner_in.ref.setTunerCenterFrequency('hello', 1.0) DigitalTuner_in.ref.getTunerCenterFrequency('hello') DigitalTuner_in.ref.setTunerBandwidth('hello', 1.0) DigitalTuner_in.ref.getTunerBandwidth('hello') DigitalTuner_in.ref.setTunerAgcEnable('hello', True) DigitalTuner_in.ref.getTunerAgcEnable('hello') DigitalTuner_in.ref.setTunerGain('hello', 1.0) DigitalTuner_in.ref.getTunerGain('hello') DigitalTuner_in.ref.setTunerReferenceSource('hello', 1L) DigitalTuner_in.ref.getTunerReferenceSource('hello') DigitalTuner_in.ref.setTunerEnable('hello', True) DigitalTuner_in.ref.getTunerEnable('hello') DigitalTuner_in.ref.setTunerOutputSampleRate('hello', 1.0) DigitalTuner_in.ref.getTunerOutputSampleRate('hello') GPS_in.ref._get_gps_info() GPS_in.ref._set_gps_info(_gpsinfo) GPS_in.ref._get_gps_time_pos() GPS_in.ref._set_gps_time_pos(_gpstimepos) NavData_in.ref._get_nav_packet() NavData_in.ref._set_nav_packet(_navpacket) RFInfo_in.ref._get_rf_flow_id() RFInfo_in.ref._set_rf_flow_id('rf_flow') RFInfo_in.ref._get_rfinfo_pkt() RFInfo_in.ref._set_rfinfo_pkt(_rfinfopkt) os.killpg(exc_src._pid, 9) while True: try: os.kill(exc_src._pid, 0) time.sleep(0.1) except: break exception = (CORBA.COMM_FAILURE, CORBA.TRANSIENT) self.assertRaises(exception, DigitalTuner_in.ref.getScanStatus, 'hello') self.assertRaises(exception, DigitalTuner_in.ref.setScanStartTime, 'hello', _time) self.assertRaises(exception, DigitalTuner_in.ref.setScanStrategy, 'hello', _strat) self.assertRaises(exception, DigitalTuner_in.ref.getTunerType, 'hello') self.assertRaises(exception, DigitalTuner_in.ref.getTunerDeviceControl, 'hello') self.assertRaises(exception, DigitalTuner_in.ref.getTunerGroupId, 'hello') self.assertRaises(exception, DigitalTuner_in.ref.getTunerRfFlowId, 'hello') self.assertRaises(exception, DigitalTuner_in.ref.setTunerCenterFrequency, 'hello', 1.0) self.assertRaises(exception, DigitalTuner_in.ref.getTunerCenterFrequency, 'hello') self.assertRaises(exception, DigitalTuner_in.ref.setTunerBandwidth, 'hello', 1.0) self.assertRaises(exception, DigitalTuner_in.ref.getTunerBandwidth, 'hello') self.assertRaises(exception, DigitalTuner_in.ref.setTunerAgcEnable, 'hello', True) self.assertRaises(exception, DigitalTuner_in.ref.getTunerAgcEnable, 'hello') self.assertRaises(exception, DigitalTuner_in.ref.setTunerGain, 'hello', 1.0) self.assertRaises(exception, DigitalTuner_in.ref.getTunerGain, 'hello') self.assertRaises(exception, DigitalTuner_in.ref.setTunerReferenceSource, 'hello', 1L) self.assertRaises(exception, DigitalTuner_in.ref.getTunerReferenceSource, 'hello') self.assertRaises(exception, DigitalTuner_in.ref.setTunerEnable, 'hello', True) self.assertRaises(exception, DigitalTuner_in.ref.getTunerEnable, 'hello') self.assertRaises(exception, DigitalTuner_in.ref.setTunerOutputSampleRate, 'hello', 1.0) self.assertRaises(exception, DigitalTuner_in.ref.getTunerOutputSampleRate, 'hello') self.assertRaises(exception, GPS_in.ref._get_gps_info) self.assertRaises(exception, GPS_in.ref._set_gps_info, _gpsinfo) self.assertRaises(exception, GPS_in.ref._get_gps_time_pos) self.assertRaises(exception, GPS_in.ref._set_gps_time_pos, _gpstimepos) self.assertRaises(exception, NavData_in.ref._get_nav_packet) self.assertRaises(exception, NavData_in.ref._set_nav_packet, _navpacket) self.assertRaises(exception, RFInfo_in.ref._get_rf_flow_id) self.assertRaises(exception, RFInfo_in.ref._set_rf_flow_id, 'rf_flow') self.assertRaises(exception, RFInfo_in.ref._get_rfinfo_pkt) self.assertRaises(exception, RFInfo_in.ref._set_rfinfo_pkt, _rfinfopkt)
def setTunerBandwidth(self, bw): raise FRONTEND.NotSupportedException("setTunerBandwidth not supported")