Esempio n. 1
0
 def testConnectBehavior(self):
     #######################################################################
     # Make sure start and stop can be called without throwing exceptions
     alloc=frontend.createTunerAllocation()
     snk_1 = sb.StreamSink()
     snk_2 = sb.StreamSink()
     self.comp.allocateCapacity(alloc)
     self.comp.connect(snk_1, connectionId='some_connection')
     tuner_status = self.comp.frontend_tuner_status[0]
     alloc_id = alloc['FRONTEND::tuner_allocation']['FRONTEND::tuner_allocation::allocation_id']
     self.assertEquals(tuner_status.allocation_id_csv, alloc_id)
     self.comp.connect(snk_2)
     self.assertEquals(len(self.comp.connectionTable), 2)
     alloc_id = alloc_id + ',' + self.comp.connectionTable[1].connection_id
     self.assertEquals(tuner_status.allocation_id_csv, alloc_id)
     sb.start()
     time.sleep(0.1)
     time.sleep(0.25)
     self.comp.deallocateCapacity(alloc)
     time.sleep(0.1)
     data_1 = snk_1.read(timeout=1)
     self.assertEquals(data_1, None)
     data_2 = snk_2.read(timeout=1)
     self.assertEquals(data_2.streamID, 'my_data')
     self.assertEquals(len(data_2.data), 25)
     self.assertEquals(len(self.comp.connectionTable), 0)
     sb.stop()
Esempio n. 2
0
    def testFloatPort(self):
        #######################################################################
        # Test FLOAT Functionality
        print "\n**TESTING FLOAT PORT"

        # Define test files
        dataFileIn = "./data.in"
        dataFileOut = "./data.out"

        # Create Test Data File if it doesn't exist
        if not os.path.isfile(dataFileIn):
            with open(dataFileIn, "wb") as dataIn:
                dataIn.write(os.urandom(1024))

        # Read in Data from Test File
        size = os.path.getsize(dataFileIn)
        with open(dataFileIn, "rb") as dataIn:
            data = list(struct.unpack("f" * (size / 4), dataIn.read(size)))

        # Create Components and Connections
        comp = sb.launch("../FileWriter.spd.xml")
        comp.destination_uri = dataFileOut
        comp.advanced_properties.existing_file = "TRUNCATE"

        source = sb.DataSource(bytesPerPush=64, dataFormat="32f")
        source.connect(comp, providesPortName="dataFloat_in")

        # Start Components & Push Data
        sb.start()
        source.push(data)
        time.sleep(2)
        sb.stop()

        # Check that the input and output files are the same
        try:
            self.assertEqual(filecmp.cmp(dataFileIn, dataFileOut), True)
        except self.failureException as e:
            # unpacked bytes may be NaN, which could cause test to fail unnecessarily
            size = os.path.getsize(dataFileOut)
            with open(dataFileOut, "rb") as dataOut:
                data2 = list(struct.unpack("f" * (size / 4), dataOut.read(size)))
            for a, b in zip(data, data2):
                if a != b:
                    if a != a and b != b:
                        print "Difference in NaN format, ignoring..."
                    else:
                        print "FAILED:", a, "!=", b
                        raise e

        # Release the components and remove the generated files
        finally:
            comp.releaseObject()
            source.releaseObject()
            os.remove(dataFileIn)
            os.remove(dataFileOut)

        print "........ PASSED\n"
        return
Esempio n. 3
0
    def tearDown(self):
        #######################################################################
        # Simulate regular resource shutdown
        self.comp.releaseObject()

        self.comp.stop()
        sb.reset()
        sb.stop()
        ossie.utils.testing.ScaComponentTestCase.tearDown(self)
 def tearDown(self):
     #######################################################################
     # Simulate regular resource shutdown
     self.comp.releaseObject()
     
     self.comp.stop()
     sb.reset()
     sb.stop()
     ossie.utils.testing.ScaComponentTestCase.tearDown(self);
Esempio n. 5
0
    def testDoublePort(self):
        #######################################################################
        # Test DOUBLE Functionality
        print "\n**TESTING DOUBLE PORT"

        #Define test files
        dataFileIn = './data.in'

        #Create Test Data File if it doesn't exist
        #Floats and Doubles are a special case, as
        #NaNs can be generated randomly and will
        #not equal one another
        if not os.path.isfile(dataFileIn):
            with open(dataFileIn, 'wb') as dataIn:
                for i in range(1024 / 8):
                    doubleNum = struct.unpack('d', os.urandom(8))[0]
                    while isnan(doubleNum):
                        doubleNum = struct.unpack('d', os.urandom(8))[0]
                    dataIn.write(struct.pack('d', doubleNum))

        #Read in Data from Test File
        size = os.path.getsize(dataFileIn)
        with open(dataFileIn, 'rb') as dataIn:
            data = list(struct.unpack('d' * (size / 8), dataIn.read(size)))

        #Create Components and Connections
        comp = sb.launch('../FileReader.spd.xml')
        comp.source_uri = dataFileIn
        comp.file_format = 'DOUBLE'

        sink = sb.DataSink()
        comp.connect(sink, usesPortName='dataDouble_out')

        #Start Components & Push Data
        sb.start()
        comp.playback_state = 'PLAY'
        time.sleep(2)
        readData = sink.getData()
        sb.stop()

        #Check that the input and output files are the same
        try:
            self.assertEqual(data, readData)
        except self.failureException as e:
            comp.releaseObject()
            sink.releaseObject()
            os.remove(dataFileIn)
            raise e

        #Release the components and remove the generated files
        comp.releaseObject()
        sink.releaseObject()
        os.remove(dataFileIn)

        print "........ PASSED\n"
        return
Esempio n. 6
0
    def tearDown(self):
        """ Stops unit test - run after every method that starts with test """
        #######################################################################
        # Simulate regular resource shutdown
        self.comp.releaseObject()

        # stops everything
        self.comp.stop()
        sb.reset()
        sb.stop()
        ossie.utils.testing.ScaComponentTestCase.tearDown(self)
Esempio n. 7
0
    def tearDown(self):
        """ Stops unit test - run after every method that starts with test """
        #######################################################################
        # Simulate regular resource shutdown
        self.comp.releaseObject()

        # stops everything
        self.comp.stop()
        sb.reset()
        sb.stop()
        ossie.utils.testing.ScaComponentTestCase.tearDown(self)
Esempio n. 8
0
    def test_vector(self):
        dsource=sb.DataSource()
        dsink=sb.DataSink()
        test_comp=sb.Component(self.cname)
        data=range(100)
        dsource.connect(test_comp, providesPortName=self.inport )
        test_comp.connect(dsink, providesPortName=self.sink_port_name, usesPortName=self.outport)
        sb.start()
        dsource.push(data,EOS=True)
        dest_data=dsink.getData(eos_block=True)
        sb.stop()

        self.assertEqual(data, dest_data)
Esempio n. 9
0
	def run(self):
		print 'starting benchmark'
		sb.start()
		
		#first sample recorded should be a couple away from the start of BenchmarkGen
		#due to the high output rate to fill up the queue
		lastTP = self.bc.packets_per_time_avg*self.samplesAway
		
		#loop counter
		loopCount = 0
		#run until less than 1%
		while 1:
			timer = 0
			#run until time for benchmark runs out
			while timer <= self.bmTime: 
				#run until next value can be collected
				while self.bc.totalPackets <= lastTP: 
					sleep(.1)
					timer = timer + .1;
				#collect data from benchmark component
				self.samples.append(float(timer + loopCount*self.bmTime))
				self.outputRates.append(float(self.bc.avg_output_rate))
				self.times.append(float(self.bc.time))
				lastTP = lastTP + self.bc.packets_per_time_avg
			#calculating statistics
			N = len(self.samples)
			s = numpy.std(self.outputRates)
			x = numpy.mean(self.outputRates)
			value = 1.96*(s/numpy.sqrt(N))
			lower = x - value
			upper = x + value
			percent = (value / x) * 100
			
			#debug
			if self.debug==1:
				print 'N is: ' + str(int(N))
				print 's is: ' + str(float(s))
				print 'x is: ' + str(float(x))
				print 'value is: ' + str(float(value))
				print '95% confidence level: ' + str(float(lower)) + ' - ' + str(float(upper))
				print 'percent away is: ' + str(float(percent))
			loopCount = loopCount + 1
			if(percent <= 1):
				break;
		
		self.printStats()
		if self.showPlot==1:
			self.plot()
		
		sb.reset()
		sb.stop()
Esempio n. 10
0
    def testCharPort(self):
        #######################################################################
        # Test Char Functionality
        print "\n**TESTING CHAR PORT"

        # Define test files
        dataFileIn = "./data.in"
        dataFileOut = "./data.out"

        # Create Test Data File if it doesn't exist
        if not os.path.isfile(dataFileIn):
            with open(dataFileIn, "wb") as dataIn:
                dataIn.write(os.urandom(1024))

        # Read in Data from Test File
        size = os.path.getsize(dataFileIn)
        with open(dataFileIn, "rb") as dataIn:
            data = list(struct.unpack("b" * size, dataIn.read(size)))

        # Create Components and Connections
        comp = sb.launch("../FileWriter.spd.xml")
        comp.destination_uri = dataFileOut
        comp.advanced_properties.existing_file = "TRUNCATE"

        source = sb.DataSource(bytesPerPush=64, dataFormat="8t")
        source.connect(comp, providesPortName="dataChar_in")

        # Start Components & Push Data
        sb.start()
        source.push(data)
        time.sleep(2)
        sb.stop()

        # Check that the input and output files are the same
        try:
            self.assertEqual(filecmp.cmp(dataFileIn, dataFileOut), True)
        except self.failureException as e:
            comp.releaseObject()
            source.releaseObject()
            os.remove(dataFileIn)
            os.remove(dataFileOut)
            raise e

        # Release the components and remove the generated files
        comp.releaseObject()
        source.releaseObject()
        os.remove(dataFileIn)
        os.remove(dataFileOut)

        print "........ PASSED\n"
        return
Esempio n. 11
0
    def ntestUShortPort(self):
        #######################################################################
        # Test USHORT Functionality
        print "\n**TESTING USHORT PORT"

        #Define test files
        dataFileIn = './data.in'

        #Create Test Data File if it doesn't exist
        if not os.path.isfile(dataFileIn):
            with open(dataFileIn, 'wb') as dataIn:
                dataIn.write(os.urandom(1024))

        #Read in Data from Test File
        size = os.path.getsize(dataFileIn)
        with open(dataFileIn, 'rb') as dataIn:
            data = list(struct.unpack('H' * (size / 2), dataIn.read(size)))

        #Create Components and Connections
        comp = sb.launch('../FileReader.spd.xml')
        comp.source_uri = dataFileIn
        comp.file_format = 'USHORT'

        sink = sb.DataSink()
        comp.connect(sink, usesPortName='dataUshort_out')

        #Start Components & Push Data
        sb.start()
        comp.playback_state = 'PLAY'
        time.sleep(2)
        readData = sink.getData()
        sb.stop()

        #Check that the input and output files are the same
        try:
            self.assertEqual(data, readData)
        except self.failureException as e:
            comp.releaseObject()
            sink.releaseObject()
            os.remove(dataFileIn)
            raise e

        #Release the components and remove the generated files
        comp.releaseObject()
        sink.releaseObject()
        os.remove(dataFileIn)

        print "........ PASSED\n"
        return
Esempio n. 12
0
    def testBPSOverride(self):
        self.source = sb.StreamSource(self.id(), 'octet')
        self.source.connect(self.comp, usesPortName='octetOut')
        self.comp.override_sdds_header.enabled = True

        for bps in range(32):
            time.sleep(0.1)
            self.comp.override_sdds_header.bps = bps
            sb.start()
            fakeData = 1024 * [1]
            self.source.write(fakeData)
            rcv = self.getPacket()
            sdds_header = self.getHeader(rcv)
            self.assertEqual(bps, sum(sdds_header.bps),
                             "Received BPS that did not match expected")
            sb.stop()
Esempio n. 13
0
 def addRTL(self):
     listOfRTL = []
     # determine which rtl is new 
     for myDev in [self.dom.devices][0]:
         if myDev.name == "rtl_sdr_device":
             listOfRTL.append(myDev)
     
     for rtl in listOfRTL:
         if rtl._get_identifier() not in self.rtl_list:
             rtlObject = rtl
             #break
 
     # populate gui
     newBox = gtk.HBox(False, 0)
     rtlBox = gtk.VBox(False, 0)
     rtlBox = self.addLabel(rtlBox, "RTL " + str(len(self.rtl_list)))
     
     rtlBox, rtl_freq = self.addDouble(rtlBox, 
                                                 "Frequency:   ", 
                                                 10, 
                                                 "462637500")
     rtlBox, rtl_samp   = self.addDouble(rtlBox, 
                                                 "Sample Rate: ",
                                                 5, 
                                                 "200")
     newBox.pack_start(rtlBox)
     
     self.table.attach(newBox, len(self.rtl_list)+1, len(self.rtl_list)+2, 0, 1)
     self.window.show_all()
     
     sb.stop()
     
     redhawk.Device
     myDemod   = sb.launch("AmFmPmBasebandDemod")
     #plot = sb.LinePSD()
     rtlObject.connect(myDemod)
     #myDemod.connect(plot, usesPortName="fm_dataFloat_out")
     sb.start()
     sb.show()
     
     self.box_list.append(newBox)
     self.rtl_list.append(rtlObject._get_identifier())
     self.demod_list.append(myDemod)
     self.freq_list.append(rtl_freq)
     self.samp_list.append(rtl_samp)
Esempio n. 14
0
    def testCxOverride(self):
        self.octetConnect()
        self.comp.override_sdds_header.enabled = True

        for cx in range(2):
            time.sleep(0.1)
            self.comp.override_sdds_header.cx = cx
            sb.start()
            fakeData = 1024 * [1]
            self.source.push(fakeData,
                             EOS=False,
                             streamID=self.id(),
                             sampleRate=1.0,
                             complexData=False,
                             loop=False)
            rcv = self.getPacket()
            self.assertEqual(self.getCx(rcv), cx,
                             "Received CX that did not match expected")
            sb.stop()
Esempio n. 15
0
    def testStandardFormat(self):
        self.octetConnect()

        for sf in range(2):
            time.sleep(0.1)
            self.comp.sdds_settings.standard_format = sf
            sb.start()
            fakeData = 1024 * [1]
            self.source.push(fakeData,
                             EOS=False,
                             streamID=self.id(),
                             sampleRate=1.0,
                             complexData=False,
                             loop=False)
            rcv = self.getPacket()
            sdds_header = self.getHeader(rcv)
            self.assertEqual(sdds_header.SF, sf,
                             "Received SF that did not match expected")
            sb.stop()
Esempio n. 16
0
    def testSpectralSense(self):
        self.octetConnect()

        for ss in range(2):
            time.sleep(0.1)
            self.comp.sdds_settings.spectral_sense = ss
            sb.start()
            fakeData = 1024 * [1]
            self.source.push(fakeData,
                             EOS=False,
                             streamID=self.id(),
                             sampleRate=1.0,
                             complexData=False,
                             loop=False)
            rcv = self.getPacket()
            sdds_header = self.getHeader(rcv)
            self.assertEqual(sdds_header.SS, ss,
                             "Received SS that did not match expected")
            sb.stop()
Esempio n. 17
0
    def testXmlPort(self):
        #######################################################################
        # Test XML Functionality
        print "\n**TESTING XML PORT"

        dataFileIn = './data.xml'

        with open(dataFileIn, 'rb') as file:
            data = file.read()

        #Set up FileReader
        comp = sb.launch('../FileReader.spd.xml')
        comp.source_uri = dataFileIn
        comp.file_format = 'XML'

        sink = sb.DataSink()
        comp.connect(sink, usesPortName='dataXML_out')

        #Start Components & Push Data
        sb.start()
        comp.playback_state = 'PLAY'
        time.sleep(2)
        readData = sink.getData()
        sb.stop()

        #Convert list of strings into a string
        readData = readData[0]

        #Check that the input and output files are the same
        try:
            self.assertEqual(data, readData)
        except self.failureException as e:
            comp.releaseObject()
            sink.releaseObject()
            raise e

        #Release the components and remove the generated files
        comp.releaseObject()
        sink.releaseObject()

        print "........ PASSED\n"
        return
Esempio n. 18
0
    def testOriginalFormat(self):
        self.octetConnect()
        sink = sb.DataSinkSDDS()

        for of in range(2):
            time.sleep(0.1)
            self.comp.sdds_settings.original_format = of
            sb.start()
            fakeData = 1024 * [1]
            self.source.push(fakeData,
                             EOS=False,
                             streamID=self.id(),
                             sampleRate=1.0,
                             complexData=False,
                             loop=False)
            rcv = self.getPacket()
            sdds_header = self.getHeader(rcv)
            self.assertEqual(sdds_header.OF, of,
                             "Received OF that did not match expected")
            sb.stop()
Esempio n. 19
0
    def testFrequencyOverride(self):
        self.octetConnect()
        self.comp.override_sdds_header.enabled = True

        for freq in [x * .1 for x in range(10)]:
            time.sleep(0.1)
            self.comp.override_sdds_header.frequency = freq
            sb.start()
            fakeData = 1024 * [1]
            self.source.push(fakeData,
                             EOS=False,
                             streamID=self.id(),
                             sampleRate=1.0,
                             complexData=False,
                             loop=False)
            rcv = self.getPacket()
            sdds_header = self.getHeader(rcv)
            self.assertEqual(sdds_header.freq, int(73786976294.838211 * freq),
                             "Received freq that did not match expected")
            sb.stop()
Esempio n. 20
0
    def testDfdtOverride(self):
        self.octetConnect()
        self.comp.override_sdds_header.enabled = True

        for dfdt in [x * .1 for x in range(10)]:
            time.sleep(0.1)
            self.comp.override_sdds_header.dfdt = dfdt
            sb.start()
            fakeData = 1024 * [1]
            self.source.push(fakeData,
                             EOS=False,
                             streamID=self.id(),
                             sampleRate=1.0,
                             complexData=False,
                             loop=False)
            rcv = self.getPacket()
            sdds_header = self.getHeader(rcv)
            self.assertEqual(sdds_header.dfdt, int(1073741824 * dfdt),
                             "Received MSdelta that did not match expected")
            sb.stop()
Esempio n. 21
0
    def testXmlPort(self):
        #######################################################################
        # Test XML Functionality
        print "\n**TESTING XML PORT"

        # Create Test Data
        dataFileOut = "./data.out"

        with open("data.xml", "rb") as file:
            inputData = file.read()

        # Connect DataSource to FileWriter
        comp = sb.launch("../FileWriter.spd.xml")
        comp.destination_uri = dataFileOut
        comp.advanced_properties.existing_file = "TRUNCATE"

        source = sb.DataSource(bytesPerPush=64, dataFormat="xml")
        source.connect(comp, providesPortName="dataXML_in")

        # Start Components & Push Data
        sb.start()
        source.push(inputData)
        time.sleep(2)
        sb.stop()

        # Check that the input and output files are the same
        try:
            self.assertEqual(filecmp.cmp("./data.xml", dataFileOut), True)
        except self.failureException as e:
            comp.releaseObject()
            source.releaseObject()
            os.remove(dataFileOut)
            raise e

        # Release the components and remove the generated files
        comp.releaseObject()
        source.releaseObject()
        os.remove(dataFileOut)

        print "........ PASSED\n"
        return
Esempio n. 22
0
    def testBPSOverride(self):
        self.octetConnect()
        sink = sb.DataSinkSDDS()
        self.comp.override_sdds_header.enabled = True

        for bps in range(32):
            time.sleep(0.1)
            self.comp.override_sdds_header.bps = bps
            sb.start()
            fakeData = 1024 * [1]
            self.source.push(fakeData,
                             EOS=False,
                             streamID=self.id(),
                             sampleRate=1.0,
                             complexData=False,
                             loop=False)
            rcv = self.getPacket()
            sdds_header = self.getHeader(rcv)
            self.assertEqual(bps, sum(sdds_header.bps),
                             "Received BPS that did not match expected")
            sb.stop()
 def testOne(self):
     outData = []
     count = 0
     while True:
         outData = self.sink.getData()
         if outData:
             break
         if count == 100:
             break
         sleep(.1)
         count += 1
     sb.stop()
     sleep(.5)
     for x in outData:
         print "%i " % x,
     print ""
     complexData = []
     for x in xrange(len(outData) / 2):
         complexData.append(complex(outData[2 * x], outData[x * 2 + 1]))
     complexData = [x + 0.1 * random.random() for x in complexData]
     plotFFT(complexData)
Esempio n. 24
0
    def testMsdelOverride(self):
        self.octetConnect()
        self.comp.override_sdds_header.enabled = True

        for i in range(10):
            msdel = random.randint(0, 65535)
            time.sleep(0.1)
            self.comp.override_sdds_header.msdel = msdel
            sb.start()
            fakeData = 1024 * [1]
            self.source.push(fakeData,
                             EOS=False,
                             streamID=self.id(),
                             sampleRate=1.0,
                             complexData=False,
                             loop=False)
            rcv = self.getPacket()
            sdds_header = self.getHeader(rcv)
            self.assertEqual(sdds_header.timeCode1msDelta, msdel,
                             "Received MSdelta that did not match expected")
            sb.stop()
Esempio n. 25
0
 def testOne(self):
     outData = []
     count = 0
     while True:
         outData = self.sink.getData()
         if outData:
             break
         if count == 100:
             break
         sleep(.1)
         count+=1
     sb.stop()
     sleep(.5)
     for x in outData:
         print "%i " %x,
     print ""
     complexData = []
     for x in xrange(len(outData)/2):
         complexData.append(complex(outData[2*x], outData[x*2+1]))
     complexData = [x + 0.1*random.random() for x in complexData]
     plotFFT(complexData)
Esempio n. 26
0
    def testMsptrOverride(self):
        self.octetConnect()
        self.comp.override_sdds_header.enabled = True

        for i in range(10):
            msptr = random.randint(0, 2047)
            time.sleep(0.1)
            self.comp.override_sdds_header.msptr = msptr
            sb.start()
            fakeData = 1024 * [1]
            self.source.push(fakeData,
                             EOS=False,
                             streamID=self.id(),
                             sampleRate=1.0,
                             complexData=False,
                             loop=False)
            rcv = self.getPacket()
            rcv_msptr = self.getMsptr(rcv)
            self.assertEqual(rcv_msptr, msptr,
                             "Received msptr that did not match expected")
            sb.stop()
    def test_push_packet(self):
        ##print self.ctx
        dsource=sb.DataSource()
        dsink=sb.DataSink()
        c_spd_xml = test_dir + self.c_dir + '/' + self.c_name + '/' + self.c_name + '.spd.xml'
	print c_spd_xml
        test_comp=sb.launch( c_spd_xml, execparams=self.execparams)
        if self.seq:
            data=self.seq

        cmp_data = data
        if self.cmpData:
            cmp_data = self.cmpData

        dsource.connect(test_comp, providesPortName=self.c_inport )
        test_comp.connect(dsink, providesPortName=self.sink_inport, usesPortName=self.c_outport)
        sb.start()
        dsource.push(data,EOS=True)
        dest_data=dsink.getData(eos_block=True)
        sb.stop()
        self.assertEqual(data, dest_data)
Esempio n. 28
0
    def test_bpsk_decode(self):
        nbits = 6000
        samples_per_symbol = 4

        # Generate random bit sequence and convert to BPSK symbols
        bits_in = [random.randint(0,1) for x in range(nbits)]
        samples_in = symbols_to_samples(bits_to_symbols(bits_in), samples_per_symbol)

        # Add Gaussian noise and a slow rotation to the symbols
        sig_in = apply_rotation(add_noise(samples_in, 0.10), 0.01)

        # Convert from a list of complex pairs to a single list of floats
        sig_in = expand_complex(sig_in)

        source = sb.DataSource()
        sink = sb.DataSink()

        # FLL
        fll_ntaps = 55
        freq_recov = sb.Component('../components/fll_band_edge_cc_4o/fll_band_edge_cc_4o.spd.xml',execparams=execparams)
        freq_recov.samples_per_symbol = samples_per_symbol
        freq_recov.rolloff = 0.35
        freq_recov.filter_size = fll_ntaps
        freq_recov.bandwidth = 2.0*math.pi/100.0

        # Timing recovery
        nfilts = 32
        time_recov = sb.Component('../components/pfb_clock_sync_ccf_4o/pfb_clock_sync_ccf_4o.spd.xml', execparams=execparams)
        time_recov.sps = samples_per_symbol
        time_recov.loop_bw = 2*math.pi/100.0
        # Note: taps are hard-coded
        time_recov.taps = list(bpsk_taps.taps)
        time_recov.filter_size = nfilts
        time_recov.init_phase = nfilts/2
        time_recov.max_rate_deviation = 1.5
        time_recov.osps = 1

        # BPSK symbol decode
        receiver = sb.Component('../components/psk_demod_cb/psk_demod_cb.spd.xml', execparams=execparams)
        receiver.constellation = 1
        receiver.loop_bw = 2*math.pi/100.0
        receiver.fmin = -0.25
        receiver.fmax = 0.25

        # Connect components
        source.connect(freq_recov)
        freq_recov.connect(time_recov, usesPortName='data_complex_out')
        time_recov.connect(receiver, usesPortName='data_complex_out')
        receiver.connect(sink)

        # Push data through components, waiting for completion
        sb.start()
        source.push(sig_in, EOS=True, complexData=True)
        sym_out = sink.getData(eos_block=True)
        sb.stop()

        # The symbol is equivalent to the bit value; unpack from a char to
        # a number.
        bits_out = map(lambda x: struct.unpack('b', x)[0], sym_out)

        # The output data is delayed by 34 samples
        delay = 34

        # Verify that our delayed output data matches the input
        bit_errors = 0
        for ii in range(len(bits_out)-delay):
            if bits_out[ii+delay] != bits_in[ii]:
                bit_errors += 1

        self.failUnless(bit_errors == 0, '%d bit errors' % (bit_errors,))
Esempio n. 29
0
def main():
    f = open('unit_test.log', 'w')

    display(f, "*********************************")
    display(f, "******** BPSK Unit Test *********")
    display(f, "*********************************")

    # Launch the component and the input sources and output sink
    display(f, "\n******* Creating Component ******")
    test_component = sb.launch('../BPSK.spd.xml',
                               execparams={'DEBUG_LEVEL': 5})
    clockSource = sb.DataSource()
    dataSource = sb.DataSource()
    dataSink = sb.DataSink()

    # Connect the output of the clock source and the data source
    # to the inputs of the BPSK.  Connect the output of the BPSK
    # to the input of the data sink
    display(f, "\n****** Creating Connections *****")
    clockSource.connect(test_component, providesPortName='clockFloat_in')
    dataSource.connect(test_component, providesPortName='dataFloat_in')
    test_component.connect(dataSink, providesPortName='shortIn')
    display(f, "Connections created")

    display(f, "\n******** Generating Data ********")
    # Generate a simple sine wave for use as the clock and the
    # data
    convenient_time_data = linspace(0, 48 * pi, 2400)
    clock = sin(convenient_time_data).tolist()

    display(f, "Single Packet Case...")
    # Use 24 bits to generate a BPSK modulated signal
    single_packet_data = [
        0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1
    ]
    single_packet_keyed_data = []
    i = 0
    for j in single_packet_data:
        for k in range(i, i + 100):
            if j == 1:
                single_packet_keyed_data.append(clock[k])
            else:
                single_packet_keyed_data.append(-clock[k])

        i += 100

    display(f, "Two Packet Case...")
    # Use a 16 bit packet and an 8 bit packet to generate two
    # BPSK modulated signals using the same clock
    two_packet_data1 = [0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1]
    two_packet_data2 = [0, 1, 0, 1, 0, 1, 1, 1]
    two_packet_keyed_data1 = []
    two_packet_keyed_data2 = []
    i = 0
    for j in two_packet_data1:
        for k in range(i, i + 100):
            if j == 1:
                two_packet_keyed_data1.append(clock[k])
            else:
                two_packet_keyed_data1.append(-clock[k])

        i += 100

    for j in two_packet_data2:
        for k in range(i, i + 100):
            if j == 1:
                two_packet_keyed_data2.append(clock[k])
            else:
                two_packet_keyed_data2.append(-clock[k])

        i += 100

    display(f, "Two Packets, Unaligned Case...")
    # Reuse the one packet from above, but send it as two
    # that aren't lined up on the period boundary
    two_packet_unaligned_keyed_data1 = []
    two_packet_unaligned_keyed_data2 = []
    i = 0
    for j in single_packet_data[:14]:
        for k in range(i, i + 100):
            if j == 1:
                two_packet_unaligned_keyed_data1.append(clock[k])
            else:
                two_packet_unaligned_keyed_data1.append(-clock[k])

        i += 100

    for k in range(i, i + 100):
        # Put the first 27 samples into the first packet and the next
        # 73 into the second packet
        if k < (i + 27):
            if single_packet_data[14] == 1:
                two_packet_unaligned_keyed_data1.append(clock[k])
            else:
                two_packet_unaligned_keyed_data1.append(-clock[k])
        else:
            if single_packet_data[14] == 1:
                two_packet_unaligned_keyed_data2.append(clock[k])
            else:
                two_packet_unaligned_keyed_data2.append(-clock[k])

    i += 100

    for j in single_packet_data[15:]:
        for k in range(i, i + 100):
            if j == 1:
                two_packet_unaligned_keyed_data2.append(clock[k])
            else:
                two_packet_unaligned_keyed_data2.append(-clock[k])

        i += 100

    display(f, "\n******* Starting Components ******")
    sb.start()
    display(f, "Component started")
    display(f, "** Testing Single Packet Case **")
    # For now, the only accepted output rate of the BPSK is
    # 1187.5 bps.  Since 100 samples of the clock represents
    # a period, this will force the output to be one bit per
    # period
    clockSource.push(clock, False, 'Test', (100 * 1187.5), False, [], None)
    dataSource.push(single_packet_keyed_data, False, 'Test', (100 * 1187.5),
                    False, [], None)
    time.sleep(1)

    received_data = dataSink.getData()
    passed_test_1 = True
    test_1_message = ""

    displayList(f, "Received Data:  ", received_data)
    displayList(f, "Original Data:  ", single_packet_data)

    # Make sure that the received data and original data
    # are of the same length and that they match
    if len(received_data) == len(single_packet_data):
        for i in range(0, len(received_data)):
            if received_data[i] != single_packet_data[i]:
                passed_test_1 = False
                test_1_message = "received_data[" + str(
                    i) + "] != original_data[" + str(i) + "]"
                break
    else:
        passed_test_1 = False
        test_1_message = "len(received_data) != len(original_data)"

    #******************************************************
    display(f, "\n*** Testing Two Packet Case ****")

    clockSource.push(clock[:len(two_packet_keyed_data1)], False, 'Test',
                     (100 * 1187.5), False, [], None)
    dataSource.push(two_packet_keyed_data1, False, 'Test', (100 * 1187.5),
                    False, [], None)
    time.sleep(1)

    received_data = dataSink.getData()

    clockSource.push(clock[len(two_packet_keyed_data1):], False, 'Test',
                     (100 * 1187.5), False, [], None)
    dataSource.push(two_packet_keyed_data2, False, 'Test', (100 * 1187.5),
                    False, [], None)
    time.sleep(1)

    received_data += dataSink.getData()
    passed_test_2 = True
    test_2_message = ""

    displayList(f, "Received Data:  ", received_data)
    displayList(f, "Original Data1: ", two_packet_data1)
    displayList(f, "Original Data2: ", two_packet_data2)

    # Make sure that the received data and original data
    # are of the same length and that they match
    if len(received_data) == (len(two_packet_data1) + len(two_packet_data2)):
        for i in range(0, len(received_data)):
            if i < len(two_packet_data1):
                if received_data[i] != two_packet_data1[i]:
                    passed_test_2 = False
                    test_2_message = "received_data[" + str(
                        i) + "] != original_data1[" + str(i) + "]"
                    break
            else:
                if received_data[i] != two_packet_data2[i -
                                                        len(two_packet_data1)]:
                    passed_test_2 = False
                    test_2_message = "received_data[" + str(
                        i) + "] != original_data2[" + str(
                            i - len(two_packet_data1)) + "]"
    else:
        passed_test_2 = False
        test_2_message = "len(received_data) != len(original_data1) + len(original_data2)"

    #******************************************************
    display(f, "\n** Testing Two Packet, Unaligned Case **")
    clockSource.push(clock[:len(two_packet_unaligned_keyed_data1)], False,
                     'Test', (100 * 1187.5), False, [], None)
    dataSource.push(two_packet_unaligned_keyed_data1, False, 'Test',
                    (100 * 1187.5), False, [], None)
    time.sleep(1)

    received_data = dataSink.getData()

    clockSource.push(clock[len(two_packet_unaligned_keyed_data1):], False,
                     'Test', (100 * 1187.5), False, [], None)
    dataSource.push(two_packet_unaligned_keyed_data2, False, 'Test',
                    (100 * 1187.5), False, [], None)
    time.sleep(1)

    received_data += dataSink.getData()
    passed_test_3 = True
    test_3_message = ""

    displayList(f, "Received Data:  ", received_data)
    displayList(f, "Original Data:  ", single_packet_data)

    # Make sure that the received data and original data
    # are of the same length and that they match
    if len(received_data) == len(single_packet_data):
        for i in range(0, len(received_data)):
            if received_data[i] != single_packet_data[i]:
                passed_test_3 = False
                test_3_message = "received_data[" + str(
                    i) + "] != original_data[" + str(i) + "]"
                break
    else:
        passed_test_3 = False
        test_3_message = "len(received_data) != len(original_data1) + len(original_data2)"

    display(f, "\n******* Stopping Components ******")
    sb.stop()
    display(f, "Components stopped")

    # Display the results of the unit test
    if passed_test_1:
        display(
            f, "\nSingle Packet Test ...................." +
            u'\u2714'.encode('utf8'))
    else:
        display(
            f, "\nSingle Packet Test ...................." +
            u'\u2718'.encode('utf8') + '\t' + test_1_message)

    if passed_test_2:
        display(
            f, "Two Packet Test ......................." +
            u'\u2714'.encode('utf8'))
    else:
        display(
            f, "Two Packet Test ......................." +
            u'\u2718'.encode('utf8') + '\t' + test_2_message)

    if passed_test_3:
        display(
            f, "Two Packet, Unaligned Test ............" +
            u'\u2714'.encode('utf8'))
    else:
        display(
            f, "Two Packet, Unaligned Test ............" +
            u'\u2718'.encode('utf8') + '\t' + test_3_message)

    display(f, '\n')
    display(f, "Unit Test Complete")

    f.close()
def main(argv):
    sadfile = ''
    inputfile = ''
    dataformat = ''
    samplerate = ''
    iscomplex = False
    outputfile = ''
    try:
        opts, args = getopt.getopt(argv, "hs:i:f:r:co:", [
            "sadfile=", "ifile=", "dataformat=", "samplerate=", "complex",
            "ofile="
        ])
    except getopt.GetoptError:
        print 'runWaveform.py -s <sadfile> -i <inputfile> -f <dataFormat> -r <sampleRate> -c -o <outputfile>'
        sys.exit(2)
    for opt, arg in opts:
        #print 'evaluating opt - ',opt,' arg - ',arg
        if opt == '-h':
            print 'runWaveform.py -s <sadfile> -i <inputfile> -f <dataFormat> -r <sampleRate> -c o <outputfile>'
            sys.exit()
        elif opt in ("-s", "--sadfile"):
            sadfile = arg
        elif opt in ("-i", "--ifile"):
            inputfile = arg
        elif opt in ("-f", "--dataformat"):
            dataformat = arg
        elif opt in ("-r", "--samplerate"):
            samplerate = arg
        elif opt in ("-c", "--complex"):
            iscomplex = True
        elif opt in ("-o", "--ofile"):
            outputfile = arg
            print 'setting outputfile', outputfile
    print 'Processing ', inputfile, " through waveform - ", sadfile
    sadFile = open(sadfile)
    sadFileString = sadFile.read()
    usesPort = ''
    usesComponent = ''
    providesPort = ''
    providesComponent = ''
    sadXML = parsers.sad.parseString(sadFileString)
    if sadXML.get_externalports():
        for port in sadXML.get_externalports().get_port():
            if port.get_usesidentifier():
                usesPort = port.get_usesidentifier()
                usesComponent = port.get_componentinstantiationref()
            elif port.get_providesidentifier():
                providesPort = port.get_providesidentifier()
                providesComponent = port.get_componentinstantiationref()
        if not usesPort and not providesPort:
            print 'Need uses and provides external ports'
            sys.exit()
    else:
        print 'No external ports'
        sys.exit()
    print usesPort, providesPort
    if not usesPort or not providesPort:
        print 'Require external uses & provides port'
        sys.exit()
    sb.loadSADFile(sadfile)
    fileSource = sb.FileSource(filename=inputfile,
                               dataFormat=dataformat,
                               sampleRate=samplerate)
    fileSink = sb.FileSink(filename=outputfile)
    #FIXME check file type matches external port
    fileSource.connect(sb.getComponent(providesComponent.get_refid()),
                       providesPortName=providesPort)
    sb.getComponent(usesComponent.get_refid()).connect(fileSink,
                                                       usesPortName=usesPort)
    sb.start()
    fileSink.waitForEOS()
    sb.stop()
    sb.release()
Esempio n. 31
0
    def test_bpsk_decode(self):
        nbits = 6000
        samples_per_symbol = 4

        # Generate random bit sequence and convert to BPSK symbols
        bits_in = [random.randint(0, 1) for x in range(nbits)]
        samples_in = symbols_to_samples(bits_to_symbols(bits_in),
                                        samples_per_symbol)

        # Add Gaussian noise and a slow rotation to the symbols
        sig_in = apply_rotation(add_noise(samples_in, 0.10), 0.01)

        # Convert from a list of complex pairs to a single list of floats
        sig_in = expand_complex(sig_in)

        source = sb.DataSource()
        sink = sb.DataSink()

        # FLL
        fll_ntaps = 55
        freq_recov = sb.Component(
            '../components/fll_band_edge_cc_4o/fll_band_edge_cc_4o.spd.xml',
            execparams=execparams)
        freq_recov.samples_per_symbol = samples_per_symbol
        freq_recov.rolloff = 0.35
        freq_recov.filter_size = fll_ntaps
        freq_recov.bandwidth = 2.0 * math.pi / 100.0

        # Timing recovery
        nfilts = 32
        time_recov = sb.Component(
            '../components/pfb_clock_sync_ccf_4o/pfb_clock_sync_ccf_4o.spd.xml',
            execparams=execparams)
        time_recov.sps = samples_per_symbol
        time_recov.loop_bw = 2 * math.pi / 100.0
        # Note: taps are hard-coded
        time_recov.taps = list(bpsk_taps.taps)
        time_recov.filter_size = nfilts
        time_recov.init_phase = nfilts / 2
        time_recov.max_rate_deviation = 1.5
        time_recov.osps = 1

        # BPSK symbol decode
        receiver = sb.Component(
            '../components/psk_demod_cb/psk_demod_cb.spd.xml',
            execparams=execparams)
        receiver.constellation = 1
        receiver.loop_bw = 2 * math.pi / 100.0
        receiver.fmin = -0.25
        receiver.fmax = 0.25

        # Connect components
        source.connect(freq_recov)
        freq_recov.connect(time_recov, usesPortName='data_complex_out')
        time_recov.connect(receiver, usesPortName='data_complex_out')
        receiver.connect(sink)

        # Push data through components, waiting for completion
        sb.start()
        source.push(sig_in, EOS=True, complexData=True)
        sym_out = sink.getData(eos_block=True)
        sb.stop()

        # The symbol is equivalent to the bit value; unpack from a char to
        # a number.
        bits_out = map(lambda x: struct.unpack('b', x)[0], sym_out)

        # The output data is delayed by 34 samples
        delay = 34

        # Verify that our delayed output data matches the input
        bit_errors = 0
        for ii in range(len(bits_out) - delay):
            if bits_out[ii + delay] != bits_in[ii]:
                bit_errors += 1

        self.failUnless(bit_errors == 0, '%d bit errors' % (bit_errors, ))
Esempio n. 32
0
 def stop(self):
     # TODO: consider removing this
     sb.stop()
	#figure(2)
	#title('Input Signal Time Plot')
	#plot(t, signal, 'y')
	#
	#figure(3)
	#title('Component & NumPy Output Plot')
	#plot(t_dec, py_dec, 'b')
	#plot(t_dec, received_data, 'g')
	#		
	#grid(True)
	#show()

#------------------------------------------------
# Stop Component
#------------------------------------------------
sb.stop()


#########################################################################################
#							UNIT TEST 2 - Bandpass - Real Data							#
#########################################################################################

display(f,'****************************************************************************\n')
display(f,'******************** Unit Test 2 - Bandpass - Real Data ********************\n')
display(f,'****************************************************************************\n\n')

#------------------------------------------------
# Create components and connections
#------------------------------------------------
display(f,'* Creating Components and Connections\n')
filt = sb.launch('../FilterDecimate.spd.xml',execparams={"DEBUG_LEVEL":3})
Esempio n. 34
0
 def tearDown(self):
     """Finish the unit test - this is run after every method that starts with test"""
     sb.stop()
     self.comp.releaseObject()
     ossie.utils.testing.ScaComponentTestCase.tearDown(self)
Esempio n. 35
0
 def stop(self):
     sb.stop()
Esempio n. 36
0
    def testBaseUri(self):
        #######################################################################
        # Test base uri w/ keyword substitution
        print "\n**TESTING URI w/ KW Substitution"

        # Define test files
        dataFileIn = "./data.in"
        STREAMID = "baseuritest"
        COL_RF = 1.2e6
        CHAN_RF1 = 1.25e6
        CHAN_RF2 = 1.15e6
        COLRF_HZ = "1200000Hz"
        CF_HZ1 = CHANRF_HZ1 = "1250000Hz"
        CF_HZ2 = CHANRF_HZ2 = "1150000Hz"
        MY_KEYWORD = "customkw"
        dataFileOut_template = "./%s.%s.%s.%s.%s.out"
        dataFileOut1 = dataFileOut_template % (STREAMID, CF_HZ1, COLRF_HZ, CHANRF_HZ1, MY_KEYWORD)
        dataFileOut2 = dataFileOut_template % (STREAMID, CF_HZ2, COLRF_HZ, CHANRF_HZ2, MY_KEYWORD)

        keywords1 = [
            sb.io_helpers.SRIKeyword("COL_RF", COL_RF, "double"),
            sb.io_helpers.SRIKeyword("CHAN_RF", CHAN_RF1, "double"),
            sb.io_helpers.SRIKeyword("MY_KEYWORD", MY_KEYWORD, "string"),
        ]

        keywords2 = [
            sb.io_helpers.SRIKeyword("COL_RF", COL_RF, "double"),
            sb.io_helpers.SRIKeyword("CHAN_RF", CHAN_RF2, "double"),
            sb.io_helpers.SRIKeyword("MY_KEYWORD", MY_KEYWORD, "string"),
        ]

        # Create Test Data File if it doesn't exist
        if not os.path.isfile(dataFileIn):
            with open(dataFileIn, "wb") as dataIn:
                dataIn.write(os.urandom(1024))

        # Read in Data from Test File
        size = os.path.getsize(dataFileIn)
        with open(dataFileIn, "rb") as dataIn:
            data = list(struct.unpack("f" * (size / 4), dataIn.read(size)))

        # Create Components and Connections
        comp = sb.launch("../FileWriter.spd.xml")
        comp.destination_uri = dataFileOut_template % (
            "%STREAMID%",
            "%CF_HZ%",
            "%COLRF_HZ%",
            "%CHANRF_HZ%",
            "%MY_KEYWORD%",
        )
        comp.advanced_properties.existing_file = "TRUNCATE"

        source = sb.DataSource(bytesPerPush=64, dataFormat="32f")
        source.connect(comp, providesPortName="dataFloat_in")

        # Start Components & Push Data
        sb.start()
        source.push(data, streamID=STREAMID, SRIKeywords=keywords1)
        time.sleep(2)
        source.push(data, streamID=STREAMID, SRIKeywords=keywords2)
        time.sleep(2)
        sb.stop()

        # Check that the input and output files are the same
        try:
            dataFileOut = dataFileOut1
            self.assertEqual(filecmp.cmp(dataFileIn, dataFileOut), True)
            dataFileOut = dataFileOut2
            self.assertEqual(filecmp.cmp(dataFileIn, dataFileOut), True)
        except self.failureException as e:
            # unpacked bytes may be NaN, which could cause test to fail unnecessarily
            size = os.path.getsize(dataFileOut)
            with open(dataFileOut, "rb") as dataOut:
                data2 = list(struct.unpack("f" * (size / 4), dataOut.read(size)))
            for a, b in zip(data, data2):
                if a != b:
                    if a != a and b != b:
                        print "Difference in NaN format, ignoring..."
                    else:
                        print "FAILED:", a, "!=", b
                        raise e

        # Release the components and remove the generated files
        finally:
            comp.releaseObject()
            source.releaseObject()
            os.remove(dataFileIn)
            os.remove(dataFileOut1)
            os.remove(dataFileOut2)

        print "........ PASSED\n"
        return
Esempio n. 37
0
    def timerTests(self, pkt_ts=False):
        #######################################################################
        # Test multiple recording timers

        # Define test files
        dataFileIn = "./data.in"
        dataFileOut = "./data.out"
        resultsFileOut = "./results.out"
        sample_rate = 128.0
        start_delay = 0.5
        stop_delay = 2.0

        # Create Test Data File if it doesn't exist
        if not os.path.isfile(dataFileIn):
            with open(dataFileIn, "wb") as dataIn:
                dataIn.write(os.urandom(1024))

        # Read in Data from Test File
        size = os.path.getsize(dataFileIn)
        with open(dataFileIn, "rb") as dataIn:
            data = list(struct.unpack("f" * (size / 4), dataIn.read(size)))

        # Create Components and Connections
        comp = sb.launch("../FileWriter.spd.xml")
        comp.destination_uri = dataFileOut
        comp.recording_enabled = False

        # Create timers
        ts_start = bulkio.bulkio_helpers.createCPUTimestamp()
        start1_wsec = ts_start.twsec + 2.0
        stop1_wsec = start1_wsec + 2.0
        start2_wsec = stop1_wsec + 2.0
        stop2_wsec = start2_wsec + 2.0
        timers = [
            {"recording_enable": True, "use_pkt_timestamp": pkt_ts, "twsec": start1_wsec, "tfsec": ts_start.tfsec},
            {"recording_enable": False, "use_pkt_timestamp": pkt_ts, "twsec": stop1_wsec, "tfsec": ts_start.tfsec},
            {"recording_enable": True, "use_pkt_timestamp": pkt_ts, "twsec": start2_wsec, "tfsec": ts_start.tfsec},
            {"recording_enable": False, "use_pkt_timestamp": pkt_ts, "twsec": stop2_wsec, "tfsec": ts_start.tfsec},
        ]
        # print timers
        comp.recording_timer = timers

        source = sb.DataSource(
            bytesPerPush=64.0, dataFormat="32f", startTime=ts_start.twsec + ts_start.tfsec + start_delay
        )
        source.connect(comp, providesPortName="dataFloat_in")

        # results will be shifted due to start_delay
        results_offset = int((start1_wsec - ts_start.twsec - start_delay) * sample_rate)

        # Start Components & Push Data
        sb.start()
        if pkt_ts:
            source.push(data * 5, sampleRate=sample_rate)  # 5*256 samples per push
            time.sleep(2)
        else:
            # meter to actual sample rate since based on cpu time
            end_ws = stop2_wsec + stop_delay
            num_samps = 16
            loop_delay = num_samps / sample_rate
            idx = results_offset  # necessary to achieve same results as pkt_ts, accounting for start_delay
            ts_now = bulkio.bulkio_helpers.createCPUTimestamp()
            while ts_now.twsec < end_ws:
                source.push(data[idx : idx + num_samps], sampleRate=sample_rate)  # 256 samples per push
                idx = (idx + num_samps) % len(data)
                time.sleep(loop_delay)
                ts_now = bulkio.bulkio_helpers.createCPUTimestamp()
        sb.stop()

        # Create Test Results Files
        results = data[results_offset:] + data[:results_offset]
        with open(resultsFileOut, "wb") as dataIn:
            dataIn.write(struct.pack("f" * len(results), *results))

        # Check that the input and output files are the same
        try:
            try:
                self.assertEqual(filecmp.cmp(resultsFileOut, dataFileOut), True)
            except self.failureException as e:
                # unpacked bytes may be NaN, which could cause test to fail unnecessarily
                size1 = os.path.getsize(dataFileOut)
                with open(dataFileOut, "rb") as dataOut1:
                    data1 = list(struct.unpack("f" * (size1 / 4), dataOut1.read(size1)))

                offset1 = results.index(max(results)) - data1.index(max(data1))
                # print 'offset1 is', offset1
                if offset1 != 0:
                    if abs(offset1) > num_samps:  # allow it to be off by one data push
                        print "FAILED: offset1 =", offset1
                        raise e
                    shifted_res1 = results[offset1:] + results[:offset1]
                else:
                    shifted_res1 = results
                for a, b in zip(shifted_res1, data1):
                    if a != b:
                        if a != a and b != b:
                            print "Difference in NaN format, ignoring..."
                        else:
                            print "1st FAILED:", a, "!=", b
                            raise e
            try:
                self.assertEqual(filecmp.cmp(resultsFileOut, dataFileOut + "-1"), True)
            except self.failureException as e:
                # unpacked bytes may be NaN, which could cause test to fail unnecessarily
                size2 = os.path.getsize(dataFileOut + "-1")
                with open(dataFileOut + "-1", "rb") as dataOut:
                    data2 = list(struct.unpack("f" * (size2 / 4), dataOut.read(size2)))

                offset2 = results.index(max(results)) - data2.index(max(data2))
                # print 'offset2 is', offset2
                if offset2 != 0:
                    if abs(offset2) > num_samps:  # allow it to be off by one data push
                        print "FAILED: offset2 =", offset2
                        raise e
                    shifted_res2 = results[offset2:] + results[:offset2]
                else:
                    shifted_res2 = results
                for a, b in zip(shifted_res2, data2):
                    if a != b:
                        if a != a and b != b:
                            print "Difference in NaN format, ignoring..."
                        else:
                            print "2nd FAILED:", a, "!=", b
                            raise e
        except:
            raise e
        # Release the components and remove the generated files
        finally:
            comp.releaseObject()
            source.releaseObject()
            os.remove(dataFileIn)
            os.remove(dataFileOut)
            os.remove(dataFileOut + "-1")
            os.remove(resultsFileOut)

        # TODO - validate timestamps, perhaps using BLUEFILEs

        print "........ PASSED\n"
        return
Esempio n. 38
0
 def startFlow(self):
     sb.start()
     self.comp.playback_state = 'PLAY'
     time.sleep(2)
     sb.stop()
     return self.sink.getData()
data1 = [0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0]
data2 = [0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1]

print 'Pushing data'
#Send data across the wave
#Do two pushes to verify that we are storing the last bit of each packet
src.push(data1)
time.sleep(.05)
received_data = sink.getData()
src.push(data2)
time.sleep(.05)
received_data.extend(sink.getData())

print '\n*********** Stopping Sandbox ************'
#Stop sandbox env
sb.stop()
print 'Components stopped'

#Check expected values against the received values
expected = [
    1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1,
    1, 1, 1, 1, 0, 1
]
passed = True
for i in xrange(len(received_data)):
    if received_data[i] != expected[i]:
        passed = False

print '\n************** Results ****************'
if passed:
    print "Unit Test 1 .........................", u'\u2714'
Esempio n. 40
0
def load_and_run_scenario(json_file, time_inc=1, wfm=""):
    """Load a scenario and run

    Parameters
    ----------
    json_file : str, dict
        The path to a JSON specifying the scenario.  This should include
        "components", "connections", "simulation"

    time_inc : float
        Time increment to run simulation.  After each increment, check
        the debug (throughput)

    wfm : str
        Specify a file to save the scenario to waveform.
        Don't save if empty string
    """
    if isinstance(json_file, str):
        settings = json.load(open(json_file), encoding='ascii')
        settings = convert_dict(settings)
    elif isinstance(json_file, dict):
        settings = json_file
    else:
        raise ValueError("Expecting a string json filepath or dict")

    # extract from dictionary (verify keys exist)
    comp_specs = settings.get("components", {})
    wave_specs = settings.get("waveforms", {})
    domain_specs = settings.get("domains", {})
    conns = settings["connections"]
    simm = settings["simulation"]
    debug = settings.get("debug", {})

    if domain_specs:
        setup_domains(domain_specs)

    # ---------------------------  load components  -------------------------
    comp_dict = component_helper.launch_components(sb, comp_specs)

    # --------------------------  load waveforms  ---------------------------
    wfm_dict = waveform_helper.launch_waveforms(wave_specs)

    # ----------------------  connect message sinks  ------------------------
    msg_sinks, msg_store = message_helper.connect_msg_sinks(
        sb, comp_dict, wfm_dict, debug)

    # -------------------------  setup connections  -------------------------
    for conn in conns:
        try:
            obj_1 = get_instance(conn[0], comp_dict, wfm_dict)
            port_1 = obj_1.getPort(str(conn[1]))
            obj_2 = get_instance(conn[2], comp_dict, wfm_dict)
            port_2 = obj_2.getPort(str(conn[3]))
            port_1.connectPort(port_2,
                "conn_%s_to_%s_"%(str(conn[0]), str(conn[2]))\
                + str(uuid.uuid1()))
        except Exception as e:
            print("Error running connection %s" % str(conn))
            raise
    # ---------------------------  setup debug  ---------------------------
    throughput_ports = throughput_helper.setup_throughput(debug.get(
        "throughput", []),
                                                          comp_dict=comp_dict,
                                                          wfm_dict=wfm_dict)

    # --------------------------  save waveform  ----------------------------
    if wfm:
        raise NotImplementedError("Waveform Generation is not working")
        # NOTE: Generated waveform does not track component settings

        with open(wfm + ".sad.xml", "w") as fid:
            fid.write(sb.generateSADXML(wfm))

    # --------------------------  run simulation  ---------------------------
    if simm["type"].lower() in ["time"]:
        print("In time simulation")
        waveform_helper.start_waveforms(wfm_dict)
        component_helper.start_in_reverse_order(comp_dict)

        tic = time.time()
        while time.time() - tic < simm["value"]["duration"]:
            # show message being passed
            message_helper.show_messages(msg_sinks, msg_store)

            # show port throughput statistics
            throughput_helper.show_throughput(throughput_ports)

            # sleep a little
            time.sleep(time_inc)

        component_helper.stop_in_order(comp_dict)
        waveform_helper.stop_waveforms(wfm_dict)
        #sb.stop()

    elif simm["type"].lower() in ["user"]:
        # run till user hits enter
        sb.start()
        resp = user_prompt("Hit enter to exit")
        sb.stop()

    else:
        raise RuntimeError("Unexpected type of simulation")

    # save messages
    if msg_store:
        message_helper.save_messages(msg_store)

    # TODO: release components/waveforms/devices/domains
    waveform_helper.release_waveforms(wfm_dict)
    throughput_helper.close(throughput_ports)
Esempio n. 41
0
    def testBlueShortPortSwapped(self):
        #######################################################################
        # Test Bluefile Swapped SHORT Functionality
        print "\n**TESTING BLUEFILE Swapped + SHORT PORT"

        #Define test files
        dataFileIn = './bluefile.in'
        dataFileInSwap = './bluefile.in.swap'

        #Create Test Data File if it doesn't exist
        if not os.path.isfile(dataFileIn):
            tmpSink = bluefile_helpers.BlueFileWriter(dataFileIn,
                                                      BULKIO__POA.dataShort)
            tmpSink.start()
            tmpSri = createSri('bluefileShortSwapped', 5000)
            #kwVal = 1234
            #kwSwap = swap([kwVal], 'long')[0]
            #tmpSri.keywords = props_from_dict({'TEST_KW':kwSwap})
            tmpSri.keywords = props_from_dict({'TEST_KW': 1234})
            tmpSink.pushSRI(tmpSri)
            tmpTs = createTs()
            #tmpSink.pushPacket(swap(range(1024),'short'), tmpTs, True, 'bluefileShortSwapped')
            tmpSink.pushPacket(range(1024), tmpTs, True,
                               'bluefileShortSwapped')

        #Read in Data from Test File, modify header, and rewrite
        hdr, d = bluefile.read(dataFileIn, dict)
        hdr['file_name'] = dataFileInSwap
        hdr['head_rep'] = 'IEEE'
        hdr['data_rep'] = 'IEEE'
        bluefile.write(dataFileInSwap, hdr, d)

        #Read in Data from Swapped Test File
        hdr, d = bluefile.read(dataFileInSwap, dict)
        data = list(d)
        keywords = hdr['ext_header']

        #Create Components and Connections
        comp = sb.launch('../FileReader.spd.xml')
        comp.source_uri = dataFileInSwap
        comp.file_format = 'BLUEFILE'

        sink = sb.DataSink()
        comp.connect(sink, usesPortName='dataShort_out')

        #Start Components & Push Data
        sb.start()
        comp.playback_state = 'PLAY'
        time.sleep(2)
        readData = sink.getData()
        readKeywords = props_to_dict(sink.sri().keywords)
        sb.stop()

        #Check that the input and output files are the same
        try:
            self.assertEqual(data, readData)
        except self.failureException as e:
            comp.releaseObject()
            sink.releaseObject()
            os.remove(dataFileIn)
            os.remove(dataFileInSwap)
            raise e

        #Check that the keywords are the same
        try:
            self.assertEqual(keywords, readKeywords)
        except self.failureException as e:
            comp.releaseObject()
            sink.releaseObject()
            os.remove(dataFileIn)
            os.remove(dataFileInSwap)
            raise e

        #Release the components and remove the generated files
        comp.releaseObject()
        sink.releaseObject()
        os.remove(dataFileIn)
        os.remove(dataFileInSwap)

        print "........ PASSED\n"
        return
 def stop(self):
     # TODO: consider removing this
     sb.stop()
Esempio n. 43
0
def main():
	f = open('unit_test.log', 'w')

	display(f, "*********************************")
	display(f, "******** BPSK Unit Test *********")
	display(f, "*********************************")

	# Launch the component and the input sources and output sink
	display(f, "\n******* Creating Component ******")
	test_component = sb.launch('../BPSK.spd.xml', execparams={'DEBUG_LEVEL':5})
	clockSource = sb.DataSource()
	dataSource = sb.DataSource()
	dataSink = sb.DataSink()

	# Connect the output of the clock source and the data source
	# to the inputs of the BPSK.  Connect the output of the BPSK
	# to the input of the data sink
	display(f, "\n****** Creating Connections *****")
	clockSource.connect(test_component, providesPortName='clockFloat_in')
	dataSource.connect(test_component, providesPortName='dataFloat_in')
	test_component.connect(dataSink, providesPortName='shortIn')
	display(f, "Connections created")

	display(f, "\n******** Generating Data ********")
	# Generate a simple sine wave for use as the clock and the
	# data
	convenient_time_data = linspace(0, 48*pi, 2400)
	clock = sin(convenient_time_data).tolist()

	display(f, "Single Packet Case...")
	# Use 24 bits to generate a BPSK modulated signal
	single_packet_data = [0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,1,0,1,0,1,0,1,1,1]
	single_packet_keyed_data = []
	i = 0
	for j in single_packet_data:
		for k in range(i, i+100):
			if j == 1:
				single_packet_keyed_data.append(clock[k])
			else:
				single_packet_keyed_data.append(-clock[k])
	
		i += 100

	display(f, "Two Packet Case...")
	# Use a 16 bit packet and an 8 bit packet to generate two
	# BPSK modulated signals using the same clock
	two_packet_data1 = [0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,1]
	two_packet_data2 = [0,1,0,1,0,1,1,1]
	two_packet_keyed_data1 = []
	two_packet_keyed_data2 = []
	i = 0
	for j in two_packet_data1:
		for k in range(i, i+100):
			if j == 1:
				two_packet_keyed_data1.append(clock[k])
			else:
				two_packet_keyed_data1.append(-clock[k])

		i += 100

	for j in two_packet_data2:
		for k in range(i, i+100):
			if j == 1:
				two_packet_keyed_data2.append(clock[k])
			else:
				two_packet_keyed_data2.append(-clock[k])
	
		i += 100

	display(f, "Two Packets, Unaligned Case...")
	# Reuse the one packet from above, but send it as two
	# that aren't lined up on the period boundary
	two_packet_unaligned_keyed_data1 = []
	two_packet_unaligned_keyed_data2 = []
	i = 0
	for j in single_packet_data[:14]:
		for k in range(i, i+100):
			if j == 1:
				two_packet_unaligned_keyed_data1.append(clock[k])
			else:
				two_packet_unaligned_keyed_data1.append(-clock[k])
		
		i += 100
	
	for k in range(i, i+100):
		# Put the first 27 samples into the first packet and the next
		# 73 into the second packet
		if k < (i+27):
			if single_packet_data[14] == 1:
				two_packet_unaligned_keyed_data1.append(clock[k])
			else:
				two_packet_unaligned_keyed_data1.append(-clock[k])
		else:
			if single_packet_data[14] == 1:
				two_packet_unaligned_keyed_data2.append(clock[k])
			else:
				two_packet_unaligned_keyed_data2.append(-clock[k])

	i += 100

	for j in single_packet_data[15:]:
                for k in range(i, i+100):
                        if j == 1:
                                two_packet_unaligned_keyed_data2.append(clock[k])
                        else:
                                two_packet_unaligned_keyed_data2.append(-clock[k])

                i += 100

	display(f, "\n******* Starting Components ******")
	sb.start()
	display(f, "Component started")
	display(f, "** Testing Single Packet Case **")
	# For now, the only accepted output rate of the BPSK is
	# 1187.5 bps.  Since 100 samples of the clock represents
	# a period, this will force the output to be one bit per
	# period
	clockSource.push(clock, False, 'Test', (100 * 1187.5), False, [], None)
	dataSource.push(single_packet_keyed_data, False, 'Test', (100 * 1187.5), False, [], None)
	time.sleep(1)
	
	received_data = dataSink.getData()
	passed_test_1 = True
	test_1_message = ""

	displayList(f, "Received Data:  ",received_data)
        displayList(f, "Original Data:  ", single_packet_data)
	
	# Make sure that the received data and original data
	# are of the same length and that they match
	if len(received_data) == len(single_packet_data):
		for i in range(0, len(received_data)):
			if received_data[i] != single_packet_data[i]:
				passed_test_1 = False
				test_1_message = "received_data[" + str(i) + "] != original_data[" + str(i) + "]"
				break
	else:
		passed_test_1 = False
		test_1_message = "len(received_data) != len(original_data)"

	#******************************************************
	display(f, "\n*** Testing Two Packet Case ****")

	clockSource.push(clock[:len(two_packet_keyed_data1)], False, 'Test', (100 * 1187.5), False, [], None)
	dataSource.push(two_packet_keyed_data1, False, 'Test', (100 * 1187.5), False, [], None)
	time.sleep(1)
	
	received_data = dataSink.getData()
	
	clockSource.push(clock[len(two_packet_keyed_data1):], False, 'Test', (100 * 1187.5), False, [], None)
	dataSource.push(two_packet_keyed_data2, False, 'Test', (100 * 1187.5), False, [], None)
	time.sleep(1)
	
	received_data += dataSink.getData()
	passed_test_2 = True
	test_2_message = ""

	displayList(f, "Received Data:  ", received_data)
	displayList(f, "Original Data1: ", two_packet_data1)
	displayList(f, "Original Data2: ", two_packet_data2)
	
	# Make sure that the received data and original data
        # are of the same length and that they match
	if len(received_data) == (len(two_packet_data1) + len(two_packet_data2)):
		for i in range(0, len(received_data)):
			if i < len(two_packet_data1):
				if received_data[i] != two_packet_data1[i]:
					passed_test_2 = False
					test_2_message = "received_data[" + str(i) + "] != original_data1[" + str(i) + "]"
					break
			else:
				if received_data[i] != two_packet_data2[i-len(two_packet_data1)]:
					passed_test_2 = False
					test_2_message = "received_data[" + str(i) + "] != original_data2[" + str(i - len(two_packet_data1)) + "]"
	else:
		passed_test_2 = False
		test_2_message = "len(received_data) != len(original_data1) + len(original_data2)"

	#******************************************************
	display(f, "\n** Testing Two Packet, Unaligned Case **")
	clockSource.push(clock[:len(two_packet_unaligned_keyed_data1)], False, 'Test', (100 * 1187.5), False, [], None)
	dataSource.push(two_packet_unaligned_keyed_data1, False, 'Test', (100 * 1187.5), False, [], None)
	time.sleep(1)

	received_data = dataSink.getData()

	clockSource.push(clock[len(two_packet_unaligned_keyed_data1):], False, 'Test', (100 * 1187.5), False, [], None)
	dataSource.push(two_packet_unaligned_keyed_data2, False, 'Test', (100 * 1187.5), False, [], None)
	time.sleep(1)

	received_data += dataSink.getData()
	passed_test_3 = True
	test_3_message = ""

	displayList(f, "Received Data:  ", received_data)
	displayList(f, "Original Data:  ", single_packet_data)

	# Make sure that the received data and original data
	# are of the same length and that they match
	if len(received_data) == len(single_packet_data):
		for i in range(0, len(received_data)):
                	if received_data[i] != single_packet_data[i]:
                        	passed_test_3 = False
                                test_3_message = "received_data[" + str(i) + "] != original_data[" + str(i) + "]"
                                break
        else:
                passed_test_3 = False
                test_3_message = "len(received_data) != len(original_data1) + len(original_data2)"

	display(f, "\n******* Stopping Components ******")
	sb.stop()
	display(f, "Components stopped")

	# Display the results of the unit test
	if passed_test_1:
		display(f, "\nSingle Packet Test ...................." + u'\u2714'.encode('utf8'))
	else:
	        display(f, "\nSingle Packet Test ...................." + u'\u2718'.encode('utf8') + '\t' + test_1_message)
	
	if passed_test_2:
		display(f, "Two Packet Test ......................." + u'\u2714'.encode('utf8'))
	else:
		display(f, "Two Packet Test ......................." + u'\u2718'.encode('utf8') + '\t' + test_2_message)
	
	if passed_test_3:
		display(f, "Two Packet, Unaligned Test ............" + u'\u2714'.encode('utf8'))
	else:
		display(f, "Two Packet, Unaligned Test ............" + u'\u2718'.encode('utf8') + '\t' + test_3_message)

	display(f, '\n')
	display(f, "Unit Test Complete")

	f.close()