def createCPUTimestamp(): """ Generates a BULKIO.PrecisionUTCTime object using the current CPU time that you can use in the pushPacket call """ ts = time.time() return BULKIO.PrecisionUTCTime(BULKIO.TCM_CPU, BULKIO.TCS_VALID, 0.0, int(ts), ts - int(ts))
def notSet(): """ Generates a BULKIO.PrecisionUTCTime object with zero time and an invalid flag. This is used by the automatic EOS """ return BULKIO.PrecisionUTCTime(BULKIO.TCM_OFF, BULKIO.TCS_INVALID, 0.0, 0.0, 0.0)
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 _pushData(self, connection, dataString, numBytes, currentSampleTime): # Gather information about the connection arraySrcInst = connection['arraySrcInst'] bytesPerSample = 1 srcPortType = connection['srcPortType'] for i in self.supportedPorts.values(): if i['portType'] == srcPortType: bytesPerSample = i['bytesPerSample'] break outputSize = numBytes / bytesPerSample # Set the byte swap to use if self.byte_swap == 1: byte_swap = bytesPerSample else: byte_swap = self.byte_swap # Perform the byte swap if byte_swap > 1: if byte_swap != bytesPerSample: log.warn("Data size " + str(bytesPerSample) + " is not equal to byte swap size " + str(byte_swap)) output = self._flip(dataString[:numBytes], byte_swap) else: output = dataString[:numBytes] # Convert from a string to a list of # the type expected for the port outputList = self._stringToList(output, bytesPerSample, srcPortType) formattedOutput = _bulkio_helpers.formatData( outputList, BULKIOtype=eval(srcPortType)) EOS = False if len(formattedOutput) == 0: EOS = True T = _BULKIO.PrecisionUTCTime( _BULKIO.TCM_CPU, _BULKIO.TCS_VALID, 0.0, int(currentSampleTime), currentSampleTime - int(currentSampleTime)) if srcPortType != "_BULKIO__POA.dataXML": _bulkio_data_helpers.ArraySource.pushPacket(arraySrcInst, data=formattedOutput, T=T, EOS=EOS, streamID='testing') else: _bulkio_data_helpers.XmlArraySource.pushPacket( arraySrcInst, data=formattedOutput, EOS=EOS, streamID='testing')
def create_cputime_stamp(): """ Generates a PrecisionUTCTime object using the current CPU time. Output: Returns a BULKIO.PrecisionUTCTime object """ ts = time.time() return BULKIO.PrecisionUTCTime(BULKIO.TCM_CPU, BULKIO.TCS_VALID, 0.0, int(ts), ts - int(ts))
def create( whole_secs=-1.0, fractional_secs=-1.0, tsrc=BULKIO.TCM_CPU ): """ Generates a BULKIO.PrecisionUTCTime object using the current CPU time that you can use in the pushPacket call """ wsec = whole_secs; fsec = fractional_secs; if wsec < 0.0 and fsec < 0.0 : ts=time.time() wsec=int(ts) fsec = ts-int(ts) return BULKIO.PrecisionUTCTime(tsrc, BULKIO.TCS_VALID, 0.0, wsec, fsec )
def pushSRI(self, streamId="defaultStreamId", xstart=0.0): sri = bulkio.sri.create(streamId) sri.xstart = xstart ts = time.time() T = BULKIO.PrecisionUTCTime(BULKIO.TCM_CPU, BULKIO.TCS_VALID, 0.0, int(ts), ts - int(ts)) expected_packets = self.source.packets_ingested + 1 inFloatPort = self.source.getPort("dataFloat_in") inFloatPort.pushSRI(sri) inFloatPort.pushPacket(range(1, 100), T, False, streamId) # Wait until we know that the packet and SRI have been processed by the # source; this prevents some tests from reporting spurious failures due # to the appearance of an SRI change versus a new SRI, especially when # running the Python implemenation. self.waitForPacketIngestion(self.source, expected_packets, delay=0.1)
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 testGPSSetter(self): input_parent = self.gps_port_sample() input_parent_2 = self.gps_port_sample() input_port_1 = InGPSPort("input_1", input_parent) output_port = OutGPSPort("output") self.assertEquals(input_parent.get_source_id(), "original") gpsinfo = FRONTEND.GPSInfo( '', '', '', 1L, 1L, 1L, 1.0, 1.0, 1.0, 1.0, 1, 1.0, '', BULKIO.PrecisionUTCTime(1, 1, 1.0, 1.0, 1.0), []) gpsinfo.source_id = "newvalue" output_port._set_gps_info(gpsinfo) self.assertEquals(input_parent.get_source_id(), "original") self.assertRaises(PortCallError, output_port._set_gps_info, gpsinfo, "hello") output_port.connectPort(input_port_1._this(), "hello") output_port._set_gps_info(gpsinfo) self.assertEquals(input_parent.get_source_id(), "newvalue") gpsinfo.source_id = "newvalue_2" output_port._set_gps_info(gpsinfo, "hello") self.assertEquals(input_parent.get_source_id(), "newvalue_2") self.assertRaises(PortCallError, output_port._set_gps_info, gpsinfo, "foo") gpsinfo.source_id = "newvalue_3" input_port_2 = InGPSPort("input_2", input_parent_2) output_port.connectPort(input_port_2._this(), "foo") output_port._set_gps_info(gpsinfo) self.assertEquals(input_parent.get_source_id(), "newvalue_3") self.assertEquals(input_parent_2.get_source_id(), "newvalue_3") gpsinfo.source_id = "newvalue_4" output_port._set_gps_info(gpsinfo, "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_gps_info, gpsinfo, "something") output_port.disconnectPort("hello")
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 get_gps_time_pos(self, port_name): _positioninfo = FRONTEND.PositionInfo(False, 'DATUM_WGS84', 0.0, 0.0, 0.0) _gpstimepos = FRONTEND.GpsTimePos( _positioninfo, BULKIO.PrecisionUTCTime(1, 1, 1.0, 1.0, 1.0)) return _gpstimepos
def get_gps_info(self, port_name): _gpsinfo = FRONTEND.GPSInfo( '', '', '', 1L, 1L, 1L, 1.0, 1.0, 1.0, 1.0, 1, 1.0, '', BULKIO.PrecisionUTCTime(1, 1, 1.0, 1.0, 1.0), []) return _gpsinfo
def run(self, filename, sri=None, pktsize=1024, numpkts=0, startTime=0.0, sampleRate=1.0, complexData=False, streamID=None): """ Pushes the data through the connected port. Each packet of data contains no more than pktsize elements. Once all the elements have been sent, the method sends an empty list with the EOS set to True to indicate the end of the stream. Inputs: <data> A list of elements containing the data to push <sri> SRI to send before pushing data <pktsize> The maximum number of elements to send on each push <numpkts> The maximum number of packets to send <startTime> The time of the first sample <sampleRate> The sample rate of the data used to set xdelta in the SRI <complexData>The mode of the data (real=0(False),complex=1(True)) in the SRI <streamID> The streamID of the data """ # Update SRI based on arguments passed in if sri != None: self.sri = sri else: if sampleRate > 0: self.sri.xdelta = 1/sampleRate if complexData: self.sri.mode = 1 else: self.sri.mode = 0 if streamID != None: self.sri.streamID = streamID if startTime >= 0.0: self.sri.xstart = startTime self.pushSRI(self.sri) run_complete = False self.pkts_sent = 0 if self.file_d == None or self.file_d.closed: self.file_d = open( filename, 'rb' ); self.EOS = False if self.file_d.closed: log.info("file data has been exhausted!") currentSampleTime = self.sri.xstart while not self.EOS and not run_complete: T = BULKIO.PrecisionUTCTime(BULKIO.TCM_CPU, BULKIO.TCS_VALID, 0.0, int(currentSampleTime), currentSampleTime - int(currentSampleTime)) byteData = self.file_d.read(pktsize * self.byte_per_sample) if (len(byteData) < pktsize * self.byte_per_sample): self.EOS = True signalData = byteData if self.structFormat not in ('b', 'B', 'c'): dataSize = len(byteData)/self.byte_per_sample fmt = self._byteswap + str(dataSize) + self.structFormat signalData = struct.unpack(fmt, byteData) else: dataSize = len(byteData) if self.sri.mode == 1: dataSize = dataSize/2 self.pushPacket(signalData,T, False, self.sri.streamID) sampleRate = 1.0/self.sri.xdelta currentSampleTime = currentSampleTime + dataSize/sampleRate self.pkts_sent += 1 if numpkts != 0 and numpkts == self.pkts_sent: run_complete = True if self.EOS: # Send EOS flag = true T = BULKIO.PrecisionUTCTime(BULKIO.TCM_CPU, BULKIO.TCS_VALID, 0.0, int(currentSampleTime), currentSampleTime - int(currentSampleTime)) if self.structFormat not in ('b', 'B', 'c'): self.pushPacket([], T, True, self.sri.streamID) else: self.pushPacket('', T, True, self.sri.streamID) self.file_d.close() else: pass
def run(self, data, sri=None, pktsize=1024, startTime=0.0, sampleRate=1.0, complexData=False, streamID=None): """ Pushes the data through the connected port. Each packet of data contains no more than pktsize elements. Once all the elements have been sent, the method sends an empty list with the EOS set to True to indicate the end of the stream. Inputs: <data> A list of elements containing the data to push <sri> SRI to send before pushing data <pktsize> The maximum number of elements to send on each push <startTime> The time of the first sample <sampleRate> The sample rate of the data used to set xdelta in the SRI <complexData>The mode of the data (real=0(False),complex=1(True)) in the SRI <streamID> The streamID of the data """ start = 0 # stores the start of the packet end = start # stores the end of the packet sz = len(data) self.done = False if sri != None: self.sri = sri else: if sampleRate > 0: self.sri.xdelta = 1/sampleRate if complexData: self.sri.mode = 1 else: self.sri.mode = 0 if streamID != None: self.sri.streamID = streamID if startTime >= 0.0: self.sri.xstart = startTime self.pushSRI(self.sri) currentSampleTime = self.sri.xstart while not self.done: chunk = start + pktsize # if the next chunk is greater than the file, then grab remaining # only, otherwise grab a whole packet size if chunk > sz: end = sz self.done = True else: end = chunk # there are cases when this happens: array has 6 elements and # pktsize = 2 (end = length - 1 = 5 and start = 6) if start > end: self.done = True continue d = data[start:end] start = end T = BULKIO.PrecisionUTCTime(BULKIO.TCM_CPU, BULKIO.TCS_VALID, 0.0, int(currentSampleTime), currentSampleTime - int(currentSampleTime)) self.pushPacket(d, T, False, self.sri.streamID) dataSize = len(d) if self.sri.mode == 1: dataSize = dataSize / 2 currentSampleTime = currentSampleTime + dataSize/sampleRate T = BULKIO.PrecisionUTCTime(BULKIO.TCM_CPU, BULKIO.TCS_VALID, 0.0, int(currentSampleTime), currentSampleTime - int(currentSampleTime)) self.pushPacket([], T, True, self.sri.streamID)
def run(self, infile, pktsize=1024, streamID=None): """ Pushes the data through the connected port. Each packet of data contains no more than pktsize elements. Once all the elements have been sent, the method sends an empty list with the EOS set to True to indicate the end of the stream. Inputs: <infile> The name of the X-Midas file containing the data to push <pktsize> The maximum number of elements to send on each push <streamID> The stream ID to be used, if None, then it defaults to filename """ hdr, data = bluefile.read(infile, list) # generates a new SRI based on the header of the file path, stream_id = os.path.split(infile) if streamID == None: sri = hdr_to_sri(hdr, stream_id) else: sri = hdr_to_sri(hdr, streamID) self.pushSRI(sri) start = 0 # stores the start of the packet end = start # stores the end of the packet if hdr['format'].startswith('C'): data = data.flatten() if hdr['format'].endswith('F'): data = data.view(float32) elif hdr['format'].endswith('D'): data = data.view(float64) sz = len(data) self.done = False # Use midas header timecode to set time of first sample # NOTE: midas time is seconds since Jan. 1 1950 # Redhawk time is seconds since Jan. 1 1970 currentSampleTime = 0.0 if hdr.has_key('timecode'): # Set sample time to seconds since Jan. 1 1970 currentSampleTime = hdr['timecode'] - long(631152000) if currentSampleTime < 0: currentSampleTime = 0.0 while not self.done: chunk = start + pktsize # if the next chunk is greater than the file, then grab remaining # only, otherwise grab a whole packet size if chunk > sz: end = sz self.done = True else: end = chunk dataset = data[start:end] # X-Midas returns an array, so we need to generate a list if hdr['format'].endswith('B'): d = dataset.tostring() else: d = dataset.tolist() start = end T = BULKIO.PrecisionUTCTime( BULKIO.TCM_CPU, BULKIO.TCS_VALID, 0.0, int(currentSampleTime), currentSampleTime - int(currentSampleTime)) self.pushPacket(d, T, False, sri.streamID) dataSize = len(d) sampleRate = 1.0 / sri.xdelta currentSampleTime = currentSampleTime + dataSize / sampleRate T = BULKIO.PrecisionUTCTime(BULKIO.TCM_CPU, BULKIO.TCS_VALID, 0.0, int(currentSampleTime), currentSampleTime - int(currentSampleTime)) if hdr['format'].endswith('B'): self.pushPacket('', T, True, sri.streamID) else: self.pushPacket([], T, True, sri.streamID)
def createTimestamp(wsec, fsec=0.0): return BULKIO.PrecisionUTCTime(BULKIO.TCM_CPU, BULKIO.TCS_VALID, 0.0, wsec, fsec)
try: self.port_digitaltuner_out.setTunerOutputSampleRate(tmp, 1.0) except PortCallError, e: self.set_tuneroutputsamplerate = str(e) self.get_gpsinfo = "ok" try: self.port_gps_out.gps_info() except PortCallError, e: self.get_gpsinfo = str(e) self.set_gpsinfo = "ok" try: _gps = FRONTEND.GPSInfo( '', '', '', 1L, 1L, 1L, 1.0, 1.0, 1.0, 1.0, 1, 1.0, '', BULKIO.PrecisionUTCTime(1, 1, 1.0, 1.0, 1.0), []) self.port_gps_out._set_gps_info(_gps) except PortCallError, e: self.set_gpsinfo = str(e) self.get_gps_timepos = "ok" try: self.port_gps_out.gps_time_pos() except PortCallError, e: self.get_gps_timepos = str(e) self.set_gps_timepos = "ok" try: _positioninfo = FRONTEND.PositionInfo(False, 'DATUM_WGS84', 0.0, 0.0, 0.0) _gps = FRONTEND.GpsTimePos(