def acquire_data(self, fc, parent_entry, task_id): tuning_parameters = self.tuning_parameters[fc] self.configure_usrp(fc, **tuning_parameters) # Use the radio's actual reported sample rate instead of requested rate sample_rate = self.usrp.radio.sample_rate # Build global metadata sigmf_md = SigMFFile() sigmf_md.set_global_info(GLOBAL_INFO) sigmf_md.set_global_field("core:sample_rate", sample_rate) sigmf_md.set_global_field("core:description", self.description) sensor_def = capabilities['sensor_definition'] sigmf_md.set_global_field("ntia:sensor_definition", sensor_def) sigmf_md.set_global_field("ntia:sensor_id", settings.FQDN) sigmf_md.set_global_field("scos:version", SCOS_TRANSFER_SPEC_VER) # Acquire data and build per-capture metadata data = np.array([], dtype=np.complex64) nsamps = int(sample_rate * tuning_parameters['duration_ms'] * 1e-3) dt = utils.get_datetime_str_now() acq = self.usrp.radio.acquire_samples(nsamps).astype(np.complex64) data = np.append(data, acq) capture_md = {"core:frequency": fc, "core:datetime": dt} sigmf_md.add_capture(start_index=0, metadata=capture_md) annotation_md = {"applied_scale_factor": self.usrp.radio.scale_factor} sigmf_md.add_annotation(start_index=0, length=nsamps, metadata=annotation_md) return data, sigmf_md
def sigmf_recording(csv_file, data_file): """ Parameters: csv_file --- csv file path where are recorded: #Time,Robot_Number,X,Y,Angle,Start_trame,End_trame,Channel_frequency,Sample_rate data_file --- Sigmf-data file path """ # Initialize SigMF file sigmf_file = SigMFFile(data_file=data_file, global_info=global_info) # Define archive name for SigMF data and metadata files archive_name = csv_file.split('.')[0] with open(csv_file) as csvfile: reader_csv = csv.DictReader(csvfile) offset = 0 for row in reader_csv: sample_rate = int(row['Sample_rate']) len_packet = int(row['End_trame']) - int(row['Start_trame']) frequency = int(row['Channel_frequency']) robot_node = int(row['Robot_node']) latitude = int(row['X']) longitude = int(row['Y']) start_frame = offset end_frame = offset + len_packet add_capture(sigmf_file, start_frame, sample_rate, frequency) add_annotation(sigmf_file, start_frame, end_frame, latitude, longitude, robot_node) offset += len_packet # Dump contents to SigMF archive format archive_path = sigmf_file.archive(archive_name) return archive_path
def test_sigmffile(test_data_file): f = SigMFFile() f.set_global_field("core:datatype", "f32") f.add_annotation(start_index=0, length=len(TEST_FLOAT32_DATA)) f.add_capture(start_index=0) f.set_data_file(test_data_file.name) assert f._metadata == TEST_METADATA return f
def build_sigmf_md(self): logger.debug("Building SigMF metadata file") sigmf_md = SigMFFile() sigmf_md.set_global_field("core:datatype", "rf32_le") sigmf_md.set_global_field("core:sample_rate", self.sample_rate) sigmf_md.set_global_field("core:description", self.description) # get() expects a single object - currently there are none and this fails. # how do I put one in? #sensor_def_obj = SensorDefinition.objects.get() #sensor_def_json = SensorDefinitionSerializer(sensor_def_obj).data #sigmf_md.set_global_field("scos:sensor_definition", sensor_def_json) try: fqdn = settings.ALLOWED_HOSTS[1] except IndexError: fqdn = 'not.set' sigmf_md.set_global_field("scos:sensor_id", fqdn) sigmf_md.set_global_field("scos:version", SCOS_TRANSFER_SPEC_VER) capture_md = { "core:frequency": self.frequency, "core:time": utils.get_datetime_str_now() } sigmf_md.add_capture(start_index=0, metadata=capture_md) # for i, detector in enumerate(M4sDetector): # single_frequency_fft_md = { # "number_of_samples_in_fft": self.fft_size, # "window": "blackman", # "equivalent_noise_bandwidth": self.enbw, # "detector": detector.name + "_power", # "number_of_ffts": self.nffts, # "units": "dBm", # "reference": "not referenced" # } # annotation_md = { # "scos:measurement_type": { # "single_frequency_fft_detection": single_frequency_fft_md, # } # } # sigmf_md.add_annotation( # start_index=(i * self.fft_size), # length=self.fft_size, # metadata=annotation_md # ) return sigmf_md
def build_sigmf_md(self): logger.debug("Building SigMF metadata file") sigmf_md = SigMFFile() sigmf_md.set_global_field("core:datatype", "rf32_le") sigmf_md.set_global_field("core:sample_rate", self.sample_rate) sigmf_md.set_global_field("core:description", self.description) sensor_definition = { "antenna": scos_antenna_obj["scos:antenna"], "data_extraction_unit": data_extract_obj["scos:data_extraction_unit"] } sigmf_md.set_global_field("scos:sensor_definition", sensor_definition) try: fqdn = settings.ALLOWED_HOSTS[1] except IndexError: fqdn = 'not.set' sigmf_md.set_global_field("scos:sensor_id", fqdn) sigmf_md.set_global_field("scos:version", SCOS_TRANSFER_SPEC_VER) capture_md = { "core:frequency": self.frequency, "core:time": get_sigmf_iso8601_datetime_now() } sigmf_md.add_capture(start_index=0, metadata=capture_md) for i, detector in enumerate(M4sDetector): single_frequency_fft_md = { "number_of_samples_in_fft": self.fft_size, "window": "blackman", "equivalent_noise_bandwidth": self.enbw, "detector": detector.name + "_power", "number_of_ffts": self.nffts, "units": "dBm", "reference": "not referenced" } annotation_md = { "scos:measurement_type": { "SingleFrequencyFFTDetection": single_frequency_fft_md } } sigmf_md.add_annotation(start_index=(i * self.fft_size), length=self.fft_size, metadata=annotation_md) return sigmf_md
def build_sigmf_md(self): logger.debug("Building SigMF metadata file") sigmf_md = SigMFFile() sigmf_md.set_global_info(GLOBAL_INFO) sigmf_md.set_global_field("core:sample_rate", self.sample_rate) sigmf_md.set_global_field("core:description", self.description) try: sensor_def_obj = SensorDefinition.objects.get() sensor_def = SensorDefinitionSerializer(sensor_def_obj).data sigmf_md.set_global_field("scos:sensor_definition", sensor_def) except SensorDefinition.DoesNotExist: pass try: fqdn = settings.ALLOWED_HOSTS[1] except IndexError: fqdn = 'not.set' sigmf_md.set_global_field("scos:sensor_id", fqdn) sigmf_md.set_global_field("scos:version", SCOS_TRANSFER_SPEC_VER) capture_md = { "core:frequency": self.frequency, "core:time": utils.get_datetime_str_now() } sigmf_md.add_capture(start_index=0, metadata=capture_md) for i, detector in enumerate(M4sDetector): single_frequency_fft_md = { "number_of_samples_in_fft": self.fft_size, "window": "blackman", "equivalent_noise_bandwidth": self.enbw, "detector": detector.name + "_power", "number_of_ffts": self.nffts, "units": "dBm", "reference": "not referenced" } annotation_md = { "scos:measurement_type": { "single_frequency_fft_detection": single_frequency_fft_md, } } sigmf_md.add_annotation(start_index=(i * self.fft_size), length=self.fft_size, metadata=annotation_md) return sigmf_md
def test_multichannel_seek(): '''assure that seeking is working correctly with multichannel files''' _, temp_path = tempfile.mkstemp() # write some dummy data and read back np.arange(18, dtype=np.uint16).tofile(temp_path) temp_signal = SigMFFile( data_file=temp_path, global_info={ SigMFFile.DATATYPE_KEY: 'cu16_le', SigMFFile.NUM_CHANNELS_KEY: 3, }, ) # read after the first sample temp_samples = temp_signal.read_samples(start_index=1, autoscale=False) # assure samples are in the order we expect assert np.all(temp_samples[:, 0] == np.array([6 + 7j, 12 + 13j]))
def create_sigmf_metafile(self, x_len, dest_data_filename, _file): sigmf_md = SigMFFile(data_file=dest_data_filename) sigmf_md.set_global_field("core:datatype", self.datatype) sigmf_md.set_global_field("core:sample_rate", self.sample_rate) sigmf_md.set_global_field("core:author", self.author) sigmf_md.set_global_field("core:description", self.description) sha = sigmf_md.calculate_hash() print sha start_index = 0 capture_len = x_len capture_md = { "core:time": utils.get_sigmf_iso8601_datetime_now(), "frequency": self.frequency } sigmf_md.add_capture(start_index=start_index, metadata=capture_md) annotation_md = { "genesys:transmitter": { "antenna": { "model": "Ettus VERT2450", "type": "Vertical", "gain": 3, "high_frequency": 2480000000, "low_frequency": 2400000000 }, "model": "Ettus USRP X310 with UBX-160 (10 MHz-6 GHz, 160 MHz BW) Daughterboard" }, "genesys:reciever": { "antenna": { "model": "Ettus VERT2450", "type": "Vertical", "gain": 3, "high_frequency": 2480000000, "low_frequency": 2400000000 }, "model": "Ettus USRP B210" } } sigmf_md.add_annotation(start_index=start_index, length=capture_len, metadata=annotation_md) return sigmf_md
def build_sigmf_md(self): logger.debug("Building SigMF metadata file") sigmf_md = SigMFFile() sigmf_md.set_global_info(GLOBAL_INFO) sigmf_md.set_global_field("core:sample_rate", self.sample_rate) sigmf_md.set_global_field("core:description", self.description) sensor_def = capabilities['sensor_definition'] sigmf_md.set_global_field("ntia:sensor_definition", sensor_def) sigmf_md.set_global_field("ntia:sensor_id", settings.FQDN) sigmf_md.set_global_field("scos:version", SCOS_TRANSFER_SPEC_VER) capture_md = { "core:frequency": self.frequency, "core:time": utils.get_datetime_str_now() } sigmf_md.add_capture(start_index=0, metadata=capture_md) for i, detector in enumerate(M4sDetector): single_frequency_fft_md = { "number_of_samples_in_fft": self.fft_size, "window": "blackman", "equivalent_noise_bandwidth": self.enbw, "detector": detector.name + "_power", "number_of_ffts": self.nffts, "units": "dBm", "reference": "not referenced" } annotation_md = { "scos:measurement_type": { "single_frequency_fft_detection": single_frequency_fft_md, } } sigmf_md.add_annotation(start_index=(i * self.fft_size), length=self.fft_size, metadata=annotation_md) return sigmf_md
def acquire_data(self, parent_entry, task_id): # Build global metadata sigmf_md = SigMFFile() sigmf_md.set_global_info(GLOBAL_INFO) sigmf_md.set_global_field("core:sample_rate", self.sample_rate) sigmf_md.set_global_field("core:description", self.description) try: sensor_def_obj = SensorDefinition.objects.get() sensor_def = SensorDefinitionSerializer(sensor_def_obj).data sigmf_md.set_global_field("scos:sensor_definition", sensor_def) except SensorDefinition.DoesNotExist: pass try: fqdn = settings.ALLOWED_HOSTS[1] except IndexError: fqdn = 'not.set' sigmf_md.set_global_field("scos:sensor_id", fqdn) sigmf_md.set_global_field("scos:version", SCOS_TRANSFER_SPEC_VER) # Acquire data and build per-capture metadata data = np.array([], dtype=np.complex64) nsamps = self.nsamples for idx, fc in enumerate(self.fcs): self.usrp.radio.tune_frequency(fc) dt = utils.get_datetime_str_now() acq = self.usrp.radio.acquire_samples(nsamps).astype(np.complex64) data = np.append(data, acq) start_idx = idx * nsamps capture_md = {"core:frequency": fc, "core:datetime": dt} sigmf_md.add_capture(start_index=start_idx, metadata=capture_md) annotation_md = { "applied_scale_factor": self.usrp.radio.scale_factor } sigmf_md.add_annotation(start_index=start_idx, length=nsamps, metadata=annotation_md) return data, sigmf_md
def test_multichannel_types(): '''check that real & complex for all types is reading multiple channels correctly''' lut = { 'i8': np.int8, 'u8': np.uint8, 'i16': np.int16, 'u16': np.uint16, 'u32': np.uint32, 'i32': np.int32, 'f32': np.float32, } raw_count = 16 _, temp_path = tempfile.mkstemp() for key, dtype in lut.items(): # for each type of storage np.arange(raw_count, dtype=dtype).tofile(temp_path) for num_channels in [1, 8]: # for single or 8 channel for complex_prefix in ['r', 'c']: # for real or complex check_count = raw_count * 1 # deepcopy temp_signal = SigMFFile( data_file=temp_path, global_info={ SigMFFile.DATATYPE_KEY: f'{complex_prefix}{key}_le', SigMFFile.NUM_CHANNELS_KEY: num_channels, }, ) temp_samples = temp_signal.read_samples() if complex_prefix == 'c': # complex data will be half as long check_count //= 2 assert np.all(np.iscomplex(temp_samples)) if num_channels != 1: assert temp_samples.ndim == 2 check_count //= num_channels assert check_count == temp_signal._count_samples()
def build_sigmf_md(self, task_id, data): logger.debug("Building SigMF metadata file") # Use the radio's actual reported sample rate instead of requested rate sample_rate = self.sdr.radio.sample_rate sigmf_md = SigMFFile() sigmf_md.set_global_info(GLOBAL_INFO) sigmf_md.set_global_field("core:sample_rate", sample_rate) sensor_def = capabilities["sensor_definition"] sensor_def["id"] = settings.FQDN sigmf_md.set_global_field("ntia-sensor:sensor", sensor_def) action_def = { "name": self.name, "description": self.description, "type": ["FrequencyDomain"], } sigmf_md.set_global_field("ntia-scos:action", action_def) sigmf_md.set_global_field("ntia-scos:task_id", task_id) capture_md = { "core:frequency": self.sdr.radio.frequency, "core:datetime": utils.get_datetime_str_now(), } sigmf_md.add_capture(start_index=0, metadata=capture_md) for i, detector in enumerate(M4sDetector): frequency_domain_detection_md = { "ntia-core:annotation_type": "FrequencyDomainDetection", "ntia-algorithm:number_of_samples_in_fft": self.measurement_params.fft_size, "ntia-algorithm:window": "flattop", "ntia-algorithm:equivalent_noise_bandwidth": self.enbw, "ntia-algorithm:detector": detector.name + "_power", "ntia-algorithm:number_of_ffts": self.measurement_params.num_ffts, "ntia-algorithm:units": "dBm", "ntia-algorithm:reference": "not referenced", "nita-algorithm:detection_domain": "frequency", } sigmf_md.add_annotation( start_index=(i * self.measurement_params.fft_size), length=self.measurement_params.fft_size, metadata=frequency_domain_detection_md, ) calibration_annotation_md = self.sdr.radio.create_calibration_annotation( ) sigmf_md.add_annotation( start_index=0, length=self.measurement_params.fft_size * len(M4sDetector), metadata=calibration_annotation_md, ) # Recover the sigan overload flag sigan_overload = self.sdr.radio.sigan_overload # Check time domain average power versus calibrated compression flattened_data = data.flatten() time_domain_avg_power = 10 * np.log10( np.mean(np.abs(flattened_data)**2)) time_domain_avg_power += (10 * np.log10(1 / (2 * 50)) + 30 ) # Convert log(V^2) to dBm sensor_overload = ( time_domain_avg_power > self.sdr.radio.sensor_calibration_data["1db_compression_sensor"]) # Create SensorAnnotation and add gain setting and overload indicators sensor_annotation_md = { "ntia-core:annotation_type": "SensorAnnotation", "ntia-sensor:overload_sensor": sensor_overload, "ntia-sensor:overload_sigan": sigan_overload, "ntia-sensor:gain_setting_sigan": self.measurement_params.gain, } location = get_location() if location: sensor_annotation_md["core:latitude"] = (location.latitude, ) sensor_annotation_md["core:longitude"] = location.longitude sigmf_md.add_annotation( start_index=0, length=self.measurement_params.fft_size * len(M4sDetector), metadata=sensor_annotation_md, ) return sigmf_md
def build_sigmf_md( self, task_id, measurement_params, data, schedule_entry, recording_id, start_time, end_time, ): frequency = self.sdr.radio.frequency sample_rate = self.sdr.radio.sample_rate # Build global metadata sigmf_md = SigMFFile() sigmf_md.set_global_info( GLOBAL_INFO.copy() ) # prevent GLOBAL_INFO from being modified by sigmf sigmf_md.set_global_field( "core:datatype", "cf32_le" ) # 2x 32-bit float, Little Endian sigmf_md.set_global_field("core:sample_rate", sample_rate) measurement_object = { "time_start": start_time, "time_stop": end_time, "domain": "Time", "measurement_type": "survey" if self.is_multirecording else "single-frequency", "frequency_tuned_low": frequency, "frequency_tuned_high": frequency, } sigmf_md.set_global_field("ntia-core:measurement", measurement_object) sensor = capabilities["sensor"] sensor["id"] = settings.FQDN get_sensor_location_sigmf(sensor) sigmf_md.set_global_field("ntia-sensor:sensor", sensor) from status.views import get_last_calibration_time sigmf_md.set_global_field( "ntia-sensor:calibration_datetime", get_last_calibration_time() ) action_def = { "name": self.name, "description": self.description, "summary": self.description.splitlines()[0], } sigmf_md.set_global_field("ntia-scos:action", action_def) if self.is_multirecording: sigmf_md.set_global_field("ntia-scos:recording", recording_id) sigmf_md.set_global_field("ntia-scos:task", task_id) from schedule.serializers import ScheduleEntrySerializer serializer = ScheduleEntrySerializer( schedule_entry, context={"request": schedule_entry.request} ) schedule_entry_json = serializer.to_sigmf_json() schedule_entry_json["id"] = schedule_entry.name sigmf_md.set_global_field("ntia-scos:schedule", schedule_entry_json) sigmf_md.set_global_field( "ntia-location:coordinate_system", get_coordinate_system_sigmf() ) num_samples = measurement_params.get_num_samples() capture_md = { "core:frequency": frequency, "core:datetime": self.sdr.radio.capture_time, } sigmf_md.add_capture(start_index=0, metadata=capture_md) calibration_annotation_md = self.sdr.radio.create_calibration_annotation() sigmf_md.add_annotation( start_index=0, length=num_samples, metadata=calibration_annotation_md ) time_domain_detection_md = { "ntia-core:annotation_type": "TimeDomainDetection", "ntia-algorithm:detector": "sample_iq", "ntia-algorithm:number_of_samples": num_samples, "ntia-algorithm:units": "volts", "ntia-algorithm:reference": "preselector input", } sigmf_md.add_annotation( start_index=0, length=num_samples, metadata=time_domain_detection_md ) # Recover the sigan overload flag sigan_overload = self.sdr.radio.sigan_overload # Check time domain average power versus calibrated compression time_domain_avg_power = 10 * np.log10(np.mean(np.abs(data) ** 2)) time_domain_avg_power += ( 10 * np.log10(1 / (2 * 50)) + 30 ) # Convert log(V^2) to dBm sensor_overload = False # explicitly check is not None since 1db compression could be 0 if self.sdr.radio.sensor_calibration_data["1db_compression_sensor"] is not None: sensor_overload = ( time_domain_avg_power > self.sdr.radio.sensor_calibration_data["1db_compression_sensor"] ) # Create SensorAnnotation and add gain setting and overload indicators sensor_annotation_md = { "ntia-core:annotation_type": "SensorAnnotation", "ntia-sensor:overload": sensor_overload or sigan_overload, "ntia-sensor:gain_setting_sigan": measurement_params.gain, } sigmf_md.add_annotation( start_index=0, length=num_samples, metadata=sensor_annotation_md ) return sigmf_md
def test_add_multiple_captures_and_annotations(): f = SigMFFile() for i in range(3): simulate_capture(f, i, 1024)
def test_add_annotation(): f = SigMFFile() f.add_capture(start_index=0) m = {"latitude": 40.0, "longitude": -105.0} f.add_annotation(start_index=0, length=128, metadata=m)
def _run_test(self, config, test): test_name = "{:s}-{:s}-{:n}".format(self.hw, config.file_repr(), self.test_count) test_data_path = os.path.join(self.path, test_name + '.sigmf-data') test_meta_path = os.path.join(self.path, test_name + '.sigmf-meta') self.test_count += 1 capture_meta = { "core:sample_start": 0, "core:frequency": self.capture_freq, "core:datetime": str(datetime.utcnow()), "lora:frequency": config.freq, "lora:frequency_offset": self.frequency_offset, "lora:sf": config.sf, "lora:cr": config.cr, "lora:bw": config.bw, "lora:prlen": config.prlen, "lora:crc": config.crc, "lora:implicit": config.implicit, "test:expected": test.payload, "test:times": test.times, } # Configure transmitter try: #self.lc.set_freq(config.freq) self.lc.set_sf(config.sf) self.lc.set_cr(config.cr) self.lc.set_bw(config.bw / 1e3) self.lc.set_prlen(str(config.prlen)) self.lc.set_crc("on" if config.crc else "off") #self.lc.set_implicit("on" if config.implicit else "off") self.lc.set_pwr(1) except Exception as e: print(e) exit(1) # Build GNU Radio flowgraph tb = gr.top_block() osmosdr_source = osmosdr.source(args="numchan=" + str(1) + " " + '' ) osmosdr_source.set_sample_rate(self.sample_rate) osmosdr_source.set_center_freq(self.capture_freq, 0) osmosdr_source.set_freq_corr(0, 0) osmosdr_source.set_dc_offset_mode(0, 0) osmosdr_source.set_iq_balance_mode(0, 0) osmosdr_source.set_gain_mode(False, 0) osmosdr_source.set_gain(10, 0) osmosdr_source.set_if_gain(20, 0) osmosdr_source.set_bb_gain(20, 0) osmosdr_source.set_antenna('', 0) osmosdr_source.set_bandwidth(0, 0) file_sink = blocks.file_sink(gr.sizeof_gr_complex, test_data_path, False) # Connect blocks tb.connect((osmosdr_source, 0), (file_sink, 0)) # Run print("Running %s" % test_name) tb.start() self.transmit_data(test) tb.stop() tb.wait() # Save metadata file with open(test_meta_path, 'w') as f: test_sigmf = SigMFFile(data_file=test_data_path, global_info=copy.deepcopy(self.global_meta)) test_sigmf.add_capture(0, metadata=capture_meta) test_sigmf.dump(f, pretty=True)
def build_sigmf_md(self, task_id, measurement_params, data): # Build global metadata sigmf_md = SigMFFile() sigmf_md.set_global_info(GLOBAL_INFO) sample_rate = self.sdr.radio.sample_rate sigmf_md.set_global_field("core:sample_rate", sample_rate) sensor_def = capabilities["sensor_definition"] sensor_def["id"] = settings.FQDN sigmf_md.set_global_field("ntia-sensor:sensor", sensor_def) action_def = { "name": self.name, "description": self.description, "type": ["TimeDomain"], } sigmf_md.set_global_field("ntia-scos:action", action_def) sigmf_md.set_global_field("ntia-scos:task_id", task_id) dt = utils.get_datetime_str_now() num_samples = measurement_params.get_num_samples() capture_md = { "core:frequency": self.sdr.radio.frequency, "core:datetime": dt } sigmf_md.add_capture(start_index=0, metadata=capture_md) calibration_annotation_md = self.sdr.radio.create_calibration_annotation( ) sigmf_md.add_annotation(start_index=0, length=num_samples, metadata=calibration_annotation_md) time_domain_detection_md = { "ntia-core:annotation_type": "TimeDomainDetection", "ntia-algorithm:detector": "sample_iq", "ntia-algorithm:detection_domain": "time", "ntia-algorithm:number_of_samples": num_samples, "ntia-algorithm:units": "volts", "ntia-algorithm:reference": "not referenced", } sigmf_md.add_annotation(start_index=0, length=num_samples, metadata=time_domain_detection_md) # Recover the sigan overload flag sigan_overload = self.sdr.radio.sigan_overload # Check time domain average power versus calibrated compression time_domain_avg_power = 10 * np.log10(np.mean(np.abs(data)**2)) time_domain_avg_power += (10 * np.log10(1 / (2 * 50)) + 30 ) # Convert log(V^2) to dBm sensor_overload = ( time_domain_avg_power > self.sdr.radio.sensor_calibration_data["1db_compression_sensor"]) # Create SensorAnnotation and add gain setting and overload indicators sensor_annotation_md = { "ntia-core:annotation_type": "SensorAnnotation", "ntia-sensor:overload_sensor": sensor_overload, "ntia-sensor:overload_sigan": sigan_overload, "ntia-sensor:gain_setting_sigan": measurement_params.gain, } location = get_location() if location: sensor_annotation_md["core:latitude"] = (location.latitude, ) sensor_annotation_md["core:longitude"] = location.longitude sigmf_md.add_annotation(start_index=0, length=num_samples, metadata=sensor_annotation_md) return sigmf_md
def test_add_multiple_captures_and_annotations(): sigf = SigMFFile() for idx in range(3): simulate_capture(sigf, idx, 1024)
def test_ordered_metadata(): '''check to make sure the metadata is sorted as expected''' sigf = SigMFFile() top_sort_order = ['global', 'captures', 'annotations'] for kdx, key in enumerate(sigf.ordered_metadata()): assert kdx == top_sort_order.index(key)
def test_invalid_capture_seq(): assert not SigMFFile(MD_INVALID_SEQUENCE_CAP).validate() assert not SigMFFile(MD_INVALID_SEQUENCE_ANN).validate()
def create_sigmf_metafile(self, x_len, dest_data_filename, _file): sigmf_md = SigMFFile(data_file=dest_data_filename) sigmf_md.set_global_field("core:datatype", self.datatype) sigmf_md.set_global_field("core:sample_rate", self.sample_rate) sigmf_md.set_global_field("core:author", self.author) sigmf_md.set_global_field("core:version", self.version) pattern = '(\d+)ft' distance = re.findall(pattern, _file) print 'distance', distance #--description "SigMF IQ samples recording of demodulated data derived from over-the-cable WiFi transmissions collected by a fixed USRP B210 as a receiver. The transmitter emitted IEEE 802.11a standards compliant frames generated via a MATLAB WLAN System toolbox. Using UHD software, a controlled level of IQ imbalance is introduced at the runtime such that the demodulated symbols acquire unique characteristics." self.description = "SigMF IQ samples recording of over-the-air WiFi transmissions collected by a fixed USRP B210 as a receiver. The data is collected in indoor environmnet of Kostas Research Institute (KRI), at Northeastern University, with a transmitter-receiver separation distance of " + distance[ 0] + "ft. The transmitter emitted IEEE 802.11a standards compliant frames generated via a MATLAB WLAN System toolbox." sigmf_md.set_global_field("core:description", self.description) sha = sigmf_md.calculate_hash() print sha start_index = 0 capture_len = x_len capture_md = { "core:time": utils.get_sigmf_iso8601_datetime_now(), "frequency": self.frequency } sigmf_md.add_capture(start_index=start_index, metadata=capture_md) # annotation_md = { # "core:latitude": 40.0 + 0.0001 * 0, # "core:longitude": -105.0 + 0.0001 * 0, # } print sigmf_md annotation_md = { "genesys:transmitter": { "antenna": { "model": "Ettus VERT2450", "type": "Vertical", "gain": 3, "high_frequency": 2480000000, "low_frequency": 2400000000 }, "model": "Ettus USRP X310 with UBX-160 (10 MHz-6 GHz, 160 MHz BW) Daughterboard" }, "genesys:reciever": { "antenna": { "model": "Ettus VERT2450", "type": "Vertical", "gain": 3, "high_frequency": 2480000000, "low_frequency": 2400000000 }, "model": "Ettus USRP B210" } } # annotation_md = { # "genesys:transmitter_identification": 'hello', # "genesys:receiver_identification": 'hello', # } sigmf_md.add_annotation(start_index=start_index, length=capture_len, metadata=annotation_md) #print "Hello" #sigmf_md.set_annotations("genesys:transmitter_identification","Hello") return sigmf_md
def build_sigmf_md(self, task_id, data, schedule_entry, start_time, end_time): logger.debug("Building SigMF metadata file") # Use the radio's actual reported sample rate instead of requested rate sample_rate = self.sdr.radio.sample_rate frequency = self.sdr.radio.frequency sigmf_md = SigMFFile() sigmf_md.set_global_info(GLOBAL_INFO.copy( )) # prevent GLOBAL_INFO from being modified by sigmf sigmf_md.set_global_field("core:datatype", "rf32_le") # 32-bit float, Little Endian sigmf_md.set_global_field("core:sample_rate", sample_rate) measurement_object = { "time_start": start_time, "time_stop": end_time, "domain": "Frequency", "measurement_type": "single-frequency", "frequency_tuned_low": frequency, "frequency_tuned_high": frequency, } sigmf_md.set_global_field("ntia-core:measurement", measurement_object) sensor = capabilities["sensor"] sensor["id"] = settings.FQDN get_sensor_location_sigmf(sensor) sigmf_md.set_global_field("ntia-sensor:sensor", sensor) from status.views import get_last_calibration_time sigmf_md.set_global_field("ntia-sensor:calibration_datetime", get_last_calibration_time()) sigmf_md.set_global_field("ntia-scos:task", task_id) action_def = { "name": self.name, "description": self.description, "summary": self.description.splitlines()[0], } sigmf_md.set_global_field("ntia-scos:action", action_def) from schedule.serializers import ScheduleEntrySerializer serializer = ScheduleEntrySerializer( schedule_entry, context={"request": schedule_entry.request}) schedule_entry_json = serializer.to_sigmf_json() schedule_entry_json["id"] = schedule_entry.name sigmf_md.set_global_field("ntia-scos:schedule", schedule_entry_json) sigmf_md.set_global_field("ntia-location:coordinate_system", get_coordinate_system_sigmf()) capture_md = { "core:frequency": frequency, "core:datetime": self.sdr.radio.capture_time, } sigmf_md.add_capture(start_index=0, metadata=capture_md) frequencies = get_fft_frequencies(self.measurement_params.fft_size, sample_rate, frequency).tolist() for i, detector in enumerate(M4sDetector): frequency_domain_detection_md = { "ntia-core:annotation_type": "FrequencyDomainDetection", "ntia-algorithm:number_of_samples_in_fft": self.measurement_params.fft_size, "ntia-algorithm:window": "flattop", "ntia-algorithm:equivalent_noise_bandwidth": self.enbw, "ntia-algorithm:detector": "fft_" + detector.name + "_power", "ntia-algorithm:number_of_ffts": self.measurement_params.num_ffts, "ntia-algorithm:units": "dBm", "ntia-algorithm:reference": "preselector input", "ntia-algorithm:frequency_start": frequencies[0], "ntia-algorithm:frequency_stop": frequencies[-1], "ntia-algorithm:frequency_step": frequencies[1] - frequencies[0], } sigmf_md.add_annotation( start_index=(i * self.measurement_params.fft_size), length=self.measurement_params.fft_size, metadata=frequency_domain_detection_md, ) calibration_annotation_md = self.sdr.radio.create_calibration_annotation( ) sigmf_md.add_annotation( start_index=0, length=self.measurement_params.fft_size * len(M4sDetector), metadata=calibration_annotation_md, ) # Recover the sigan overload flag sigan_overload = self.sdr.radio.sigan_overload # Check time domain average power versus calibrated compression flattened_data = data.flatten() time_domain_avg_power = 10 * np.log10( np.mean(np.abs(flattened_data)**2)) time_domain_avg_power += (10 * np.log10(1 / (2 * 50)) + 30 ) # Convert log(V^2) to dBm sensor_overload = False # explicitly check is not None since 1db compression could be 0 if self.sdr.radio.sensor_calibration_data[ "1db_compression_sensor"] is not None: sensor_overload = ( time_domain_avg_power > self.sdr.radio. sensor_calibration_data["1db_compression_sensor"]) # Create SensorAnnotation and add gain setting and overload indicators sensor_annotation_md = { "ntia-core:annotation_type": "SensorAnnotation", "ntia-sensor:overload": sensor_overload or sigan_overload, "ntia-sensor:gain_setting_sigan": self.measurement_params.gain, } sigmf_md.add_annotation( start_index=0, length=self.measurement_params.fft_size * len(M4sDetector), metadata=sensor_annotation_md, ) return sigmf_md
def test_default_constructor(): SigMFFile()
def test_set_non_required_global_field(): f = SigMFFile() f.set_global_field('this_is:not_in_the_schema', None)
def test_valid_data(): assert SigMFFile(MD_VALID).validate()
def test_add_capture(): f = SigMFFile() f.add_capture(start_index=0, metadata={})
def run(self, suites_to_run, pause=False, write_output=True): for test_suite in self.test_suites: # Skip test suites that we don't want to run if suites_to_run != [] and (not test_suite in suites_to_run): continue print("[+] Testing suite: '%s'" % test_suite) summary = TestSummary(suite=test_suite, pause=pause) # Get all metadata files associated with the suite get_mtime = lambda f: os.stat( os.path.join(self.test_suites_directory, test_suite, f) ).st_mtime metadata_files = [ os.path.join(self.test_suites_directory, test_suite, x) for x in sorted(os.listdir( os.path.join(self.test_suites_directory, test_suite)), key=get_mtime) if x.endswith('.sigmf-meta') ] # Parse metadata files for metadata_file in metadata_files: print("[+] %s" % metadata_file) data_file = os.path.splitext(metadata_file)[0] + '.sigmf-data' # Load sigmf data TODO abstract f = open(metadata_file, 'r') sigmf = SigMFFile(metadata=f.read()) if not sigmf.validate(): raise Exception("Invalid SigMF format") global_meta = sigmf.get_global_info() capture_meta = sigmf.get_capture_info(0) f.close() # Initialize test parameters sample_rate = global_meta["core:sample_rate"] # Get LoRa configuration capture_freq = capture_meta["core:frequency"] if "lora:frequency_offset" in capture_meta: frequency_offset = capture_meta["lora:frequency_offset"] else: frequency_offset = 0 transmit_freq = capture_meta["lora:frequency"] sf = capture_meta["lora:sf"] cr = capture_meta["lora:cr"] bw = int(capture_meta["lora:bw"]) prlen = capture_meta["lora:prlen"] crc = capture_meta["lora:crc"] implicit = capture_meta["lora:implicit"] lora_config = LoRaConfig(transmit_freq, sf, cr, bw, prlen, crc, implicit) # Get test case configuration payload = capture_meta["test:expected"] times = capture_meta["test:times"] test = Test(payload, times) # Build flowgraph tb = gr.top_block() file_source = blocks.file_source(gr.sizeof_gr_complex, data_file, False) lora_receiver = lora.lora_receiver(sample_rate, capture_freq, [868100000], bw, sf, False, 4, True, reduced_rate=False, decimation=1) throttle = blocks.throttle(gr.sizeof_gr_complex, sample_rate, True) message_socket_sink = lora.message_socket_sink( "127.0.0.1", 40868, 2) freq_xlating_fir_filter = filter.freq_xlating_fir_filter_ccc( 1, (firdes.low_pass(1, sample_rate, 200000, 100000, firdes.WIN_HAMMING, 6.67)), frequency_offset, sample_rate) # Make connections tb.connect((file_source, 0), (throttle, 0)) tb.connect((throttle, 0), (freq_xlating_fir_filter, 0)) tb.connect((freq_xlating_fir_filter, 0), (lora_receiver, 0)) tb.msg_connect((lora_receiver, 'frames'), (message_socket_sink, 'in')) tb.start() tb.wait() decoded_data = self.server.get_payloads( times) # Output from the flowgraph summary.add(TestResult(decoded_data=decoded_data, lora_config=lora_config, test=test), print_intermediate=True) # Finally, export the result for the suite summary.export_summary(path=self.reports_directory, write_output=write_output)
def run_gui(): window_input = WindowInput() capture_data_input = CaptureData() capture_text_blocks = dict() window_text_blocks = dict() f = SigMFFile() capture_selector_dict = dict() layout = [ [ Text('This is the APL SIGMF tool to archive RF datasets', size=(80, 1)) ], [ Text('Enter your data and signal captures below. You must include', auto_size_text=True), Text('required', text_color='red', font=DEFAULT_FONT + ('italic', ), auto_size_text=True), Text('fields.', size=(50, 1), auto_size_text=True) ], [Text('_' * 150, auto_size_text=True)] ] layout.append([Text('Global Data', font=('Arial', 12, 'bold'))]) num_components = 0 line = [] for el in window_input.iter_core(): size = (30, 1) if len(line) == 0 else (None, None) auto_size = True if len(line) == 0 else (10, 1) line.extend([ Text(el, justification='right', size=size, text_color='red' if el in window_input.req_tags else None, auto_size_text=auto_size) ]) if el in window_input.el_multiline: window_text_blocks.update({ el: Multiline(window_input.el_text.get(el, ''), key=el, tooltip=window_input.el_tooltips.get(el, None), size=(30, 2)) }) elif el in window_input.el_selector: window_text_blocks.update({ el: Combo(values=window_input.el_selector[el], key=el, size=window_input.el_size.get(el, (None, None))) }) elif el in window_input.el_checkbox: window_text_blocks.update({ el: Checkbox(window_input.el_text.get(el, ''), key=el, size=window_input.el_size.get(el, (None, None))) }) else: window_text_blocks.update({ el: InputText(window_input.el_text.get(el, ''), key=el, tooltip=window_input.el_tooltips.get(el, None)) }) line.append(window_text_blocks[el]) if el in window_input.el_units: line.append(Text(window_input.el_units[el])) num_components += 1 if num_components < window_input.first_line_size: continue layout.append(line) line = [] for el1, el2 in window_input.iter_x_secondary(2): line = [] for el, size in zip([el1, el2], [30, 22]): if el is None: continue color = 'red' if el in window_input.req_tags else None window_text_blocks.update({ el: InputText(window_input.el_text.get(el, ''), key=el, tooltip=window_input.el_tooltips.get(el, None)) }) line.extend([ Text(el, justification='right', size=(size, 1), text_color=color), window_text_blocks[el] ]) if el in window_input.el_units: line.append(Text(window_input.el_units[el], size=(5, 1))) else: line.append(Text('', size=(5, 1))) layout.append(line) layout.extend( [[Text('_' * 150, auto_size_text=True)], [Text('Individual Capture Data', font=('Arial', 12, 'bold'))], [ Text('Capture Selector', auto_size_text=True), combo_button, Text('', size=(10, 1)), Button('Add Capture', enable_events=True), Button('Remove Capture', enable_events=True, size=(15, 1)), Button('Clear Capture', enable_events=True, size=(15, 1)) ]]) for el1, el2, el3 in capture_data_input.iter_x(3): line = [] for el in [el1, el2, el3]: if el is None: continue capture_text_blocks.update({ el: InputText(key=el, tooltip=capture_data_input.el_tooltips.get(el, None)) }) color = 'red' if el in capture_data_input.req_tags else None line.extend([ Text(el, justification='right', size=(20, 1), text_color=color), capture_text_blocks[el] ]) if el in capture_data_input.el_units: line.append(Text(capture_data_input.el_units[el], size=(5, 1))) else: line.append(Text('', size=(5, 1))) layout.append(line) window_text_blocks.update( {WindowInput.DATA_FILE: InputText('', key=WindowInput.DATA_FILE)}) layout.extend([[Text('_' * 150, auto_size_text=True)], [Text('Data Location', font=('Arial', 12, 'bold'))], [ Text(WindowInput.DATA_FILE, size=(30, 1), justification='right', text_color='red'), window_text_blocks[WindowInput.DATA_FILE], FileBrowse() ], [ Text(WindowInput.OUTPUT_FOLDER, size=(30, 1), justification='right'), InputText('', key=WindowInput.OUTPUT_FOLDER), FolderBrowse(), submit_button ], [ Text(WindowInput.LOAD_PATH, size=(30, 1), justification='right'), InputText('', key=WindowInput.LOAD_PATH), FileBrowse(file_types=(("Archive Files", "*.sigmf"), )), load_button ], [validate_button, Button('View Data')]]) window = Window('APL SigMF Archive Creator', auto_size_buttons=False, default_element_size=(20, 1), auto_size_text=False, default_button_element_size=(10, 1)).Layout(layout) while True: validate_button.Update(text='Update') load_button.Update(text='Load') submit_button.Update(text='Save Archive') window.Refresh() event, values = window.Read() print(event, values) if event == 'Load Archive': load_path = values[WindowInput.LOAD_PATH] if load_path == '': show_error('No archive file provided') continue load_button.Update(text='Loading...') window.Refresh() print('reading from ', values[WindowInput.LOAD_PATH]) f = fromarchive(values[WindowInput.LOAD_PATH]) update_global_screen(window_input, window_text_blocks, f.get_global_info(), f) capture_selector_dict = {} for capture in f.get_captures(): add_capture(capture_data_input, capture, capture_selector_dict, f, from_archive=True) elif event == 'Data Type Help': PopupOK( 'Format: <TypeCharacters><ElementBitSize>_<Endianness>\n\n' '\tTypeCharacters:\n' '\t\tUnsigned data: \"u\"\n' '\t\tComplex data: \"c\"\n' '\t\tFixedpoint data: \"f\"\n' '\tElementBitSize:\n' '\t\t32 bits, 16 bits, or 8 bits\n' '\tEndianness:\n' '\t\tl: Little Endian\n' '\t\tb: Big Endian\n\n\n\n' 'Example: \"uc32_l\"\n' 'Unsigned complex data where each element is 32 bits, or 64 bits total, formatted in little endian.', title='Data Type Help') elif event == 'Update': validate_button.Update(text='Validating...') window.Refresh() window_data_type_dict = {} added = True for el in window_input.iter(): req_field = True if el in window_input.req_tags else False el_type = window_input.el_types.get(el, None) el_unit = window_input.el_units.get(el, None) if el in window_input.partial_component_list: added = added and add_sigmf_field(update_dictionary, values, el, window_data_type_dict, window_input.get_tag(el), required=req_field, type=el_type, unit=el_unit) else: added = added and add_sigmf_field( SigMFFile.set_global_field, values, el, f, window_input.get_tag(el), required=req_field, type=el_type, unit=el_unit) data_type_str = '' data_type_str += 'c' if bool( window_data_type_dict[WindowInput.DATA_TYPE_COMPLEX]) else '' data_type_str += 'f' if not bool(window_data_type_dict[ WindowInput.DATA_TYPE_FIXEDPOINT]) else '' data_type_str += 'u' if bool( window_data_type_dict[WindowInput.DATA_TYPE_UNSIGNED]) else '' data_type_str += str( window_data_type_dict[WindowInput.DATA_SAMPLE_SIZE]) + '_' data_type_str += 'l' if window_data_type_dict[ WindowInput.DATA_BYTE_ORDER] == 'little endian' else 'b' data_type_dict = {SigMFFile.DATATYPE_KEY: data_type_str} added = added and add_sigmf_field(SigMFFile.set_global_field, data_type_dict, SigMFFile.DATATYPE_KEY, f, SigMFFile.DATATYPE_KEY, required=True) print('HERE: ', window_data_type_dict) added = added and add_sigmf_field(SigMFFile.set_data_file, values, WindowInput.DATA_FILE, f, required=True) and added if not added: # requirement not given continue if validate_data(f): submit_button.Update(disabled=False, button_color=DEFAULT_BUTTON_COLOR) elif event == 'Capture Combo': capture_dict = capture_selector_dict[values['Capture Combo']] update_capture_screen(capture_data_input, capture_text_blocks, capture_dict) elif event == 'Add Capture': add_capture(capture_data_input, values, capture_selector_dict, f) elif event == 'Remove Capture': capture_dict = dict() added = add_sigmf_field(update_dictionary, values, CaptureData.START_INDEX, capture_dict, SigMFFile.START_INDEX_KEY, required=True, type=int) if not added: # requirement not given continue captures = [] for capture in f._metadata[SigMFFile.CAPTURE_KEY]: if capture[SigMFFile.START_INDEX_KEY] != capture_dict[ SigMFFile.START_INDEX_KEY]: captures.append(capture) f._metadata[SigMFFile.CAPTURE_KEY] = captures annotations = [] for annotation in f._metadata[SigMFFile.ANNOTATION_KEY]: if annotation[SigMFFile.START_INDEX_KEY] != capture_dict[ SigMFFile.START_INDEX_KEY]: annotations.append(annotation) f._metadata[SigMFFile.ANNOTATION_KEY] = annotations new_values = list(combo_button.Values) rm_val = 'Capture {}'.format( capture_dict[SigMFFile.START_INDEX_KEY]) if rm_val in capture_selector_dict: capture_selector_dict.pop(rm_val) if rm_val in new_values: new_values.remove(rm_val) combo_button.Update(values=new_values, set_to_index=0) capture_dict = capture_selector_dict.get( combo_button.DefaultValue, None) update_capture_screen(capture_data_input, capture_text_blocks, capture_dict) elif event == 'Clear Capture': update_capture_screen(capture_data_input, capture_text_blocks, None) elif event == 'View Data': PopupOK('Current data:\n', f.dumps(pretty=True), title='') elif event == 'Save Archive': output_folder = values[WindowInput.OUTPUT_FOLDER] if output_folder == '': show_error('No output folder provided') continue elif len(capture_selector_dict.keys()) == 0: show_error('No capture data specified') submit_button.Update(text='Saving...') window.Refresh() archive_file = output_folder + '/' + os.path.basename( f.data_file).split('.')[0] + SIGMF_ARCHIVE_EXT f.archive(archive_file) PopupOK('Saved archive as \n', archive_file, title='') elif event in ['Cancel', None, 'Exit']: window.Close() break window.Close()