def connect(self, top_block): "" assert isinstance(top_block, gr_top_block) if self.samples_ > 0: if self.enable_throttle_control_: top_block.connect(self.file_source_, 0, self.throttle_, 0) DLOG.INFO("connected file source to throttle") top_block.connect(self.throttle_, 0, self.valve_, 0) DLOG.INFO("connected throttle to valve") if self.dump_: assert False else: top_block.connect(self.file_source_, 0, self.valve_, 0) DLOG.INFO("connected file source to valve") if self.dump_: assert False else: if self.enable_throttle_control_: top_block.connect(self.file_source_, 0, self.throttle_, 0) DLOG.INFO("connected file source to throttle") if self.dump_: assert False else: if self.dump_: assert False
def __init__(self, configuration, role, in_streams, out_streams): "" # .h self.config_ = self.conjugate_cc_ = \ self.dump_ = self.dump_filename_ = \ self.file_sink_ = \ self.gr_interleaved_short_to_complex_ = \ self.in_streams_ = self.input_item_type_ = None self.inverted_spectrum = None ## BIZARRE, pas de _ final self.out_streams_ = self.output_item_type_ = \ self.role_ = None # .cc self.config_ = configuration self.role_ = role self.in_streams_ = in_streams self.out_streams_ = out_streams default_input_item_type = "short" default_output_item_type = "gr_complex" default_dump_filename = "../data/input_filter.dat" DLOG.INFO("role " + self.role_) self.input_item_type_ = self.config_.get( self.role_ + ".input_item_type", default_input_item_type) self.dump_ = self.config_.get(self.role_ + ".dump", False) self.dump_filename_ = self.config_.get(self.role_ + ".dump_filename", default_dump_filename) self.inverted_spectrum = configuration.get(role + ".inverted_spectrum", False) item_size = 8 # sizeof(gr_complex); self.gr_interleaved_short_to_complex_ = gr_blocks_interleaved_short_to_complex( ) # DLOG.INFO("data_type_adapter_(" + self.gr_interleaved_short_to_complex_->unique_id() + ")") assert self.inverted_spectrum is False assert self.dump_ is False assert self.in_streams_ <= 1 assert self.out_streams_ <= 1
def connect(self): """ Connects the defined blocks in the flow graph Signal Source > Signal conditioner > Channels >> Observables >> PVT > Output filter """ LOG.INFO("Connecting flowgraph") assert not self.connected_ #ifndef ENABLE_FPGA for ss in self.sig_source_: if self.configuration_.get(ss.role_ + ".enable_FPGA", False) == False: ss.connect(self.top_block_) for sc in self.sig_conditioner_: if self.configuration_.get(sc.role_ + ".enable_FPGA", False) == False: sc.connect(self.top_block_) #endif for ch in self.channels_: ch.connect(self.top_block_) self.observables_.connect(self.top_block_) self.pvt_.connect(self.top_block_) DLOG.INFO("blocks connected internally") #ifndef ENABLE_FPGA RF_Channels = 0 signal_conditioner_ID = 0 for i, ss in enumerate(self.sig_source_): if ss.implementation() == "Raw_Array_Signal_Source": assert False else: RF_Channels = self.configuration_.get( ss.role_ + ".RF_channels", 1) for j in range(RF_Channels): # if ss.get_right_block().output_signature( )[1] > 1 or ss.get_right_block().output_signature( )[1] == -1: if len(self.sig_conditioner_) > signal_conditioner_ID: LOG.INFO("connecting sig_source_ " + str(i) + " stream " + str(j) + " to conditioner " + str(j)) self.top_block_.connect( ss.get_right_block(), j, self.sig_conditioner_[signal_conditioner_ID]. get_left_block(), 0) else: assert False _ = 2 + 2 assert False
def connect(self, top_block): "" if not self.flag_enable_fpga: self.acq_.connect(top_block) self.trk_.connect(top_block) self.nav_.connect(top_block) # Synchronous ports top_block.connect(self.trk_.get_right_block(), 0, self.nav_.get_left_block(), 0) # Message ports top_block.msg_connect(self.nav_.get_left_block(), "telemetry_to_trk", self.trk_.get_right_block(), "telemetry_to_trk") DLOG.INFO("tracking -> telemetry_decoder") # Message ports if not self.flag_enable_fpga: top_block.msg_connect(self.acq_.get_right_block(), "events", self.channel_msg_rx, "events") top_block.msg_connect(self.trk_.get_right_block(), "events", self.channel_msg_rx, "events") self.connected_ = True
def __init__(self, configuration, role, in_streams, out_streams): "" # .h self.dump_ = \ self.dump_filename_ = \ self.dump_mat_ = \ self.in_streams_ = \ self.observables_ = \ self.out_streams_ = \ self.role_ = None # .cc self.role_ = role self.in_streams_ = in_streams self.out_streams_ = out_streams default_dump_filename = "./observables.dat" DLOG.INFO("role " + role) self.dump_ = configuration.get(role + ".dump", False) self.dump_mat_ = configuration.get(role + ".dump_mat", True) self.dump_filename_ = configuration.get(role + ".dump_filename", default_dump_filename) self.observables_ = hybrid_observables_gs(self.in_streams_, self.out_streams_, self.dump_, self.dump_mat_, self.dump_filename_)
def connect(self, top_block): "" assert self.dump_ is False assert self.inverted_spectrum is False DLOG.INFO("Nothing to connect internally")
def __init__(self, configuration, queue): "" # .h self.acq_channels_count_ = None self.acq_resamplers_ = {} self.available_xx_signals_ = [[] for _ in range(10)] self.channels_ = [] self.ch_out_sample_counter = None # BIZARRE : pas de _ terminal self.channels_count_ = None # int self.channels_state_ = [] self.channels_status_ = None self.config_file_ = None # string self.configuration_ = None self.connected_ = None self.enable_monitor_ = None self.GnssSynchroMonitor_ = None self.mapStringValues_ = {} self.max_acq_channels_ = None self.null_sinks_ = [] self.observables_ = None self.pvt_ = None self.queue_ = None self.running_ = None self.sig_conditioner_ = [] # vector GNSSBlockInterface self.sig_source_ = [] # vector GNSSBlockInterface self.signal_list_mutex = None self.sources_count_ = None self.top_block_ = None # .c self.configuration_ = configuration self.queue_ = queue self.block_factory_ = GNSSBlockFactory() self.channels_status_ = channel_status_msg_receiver() self.sources_count_ = self.configuration_.get("Receiver.sources_count", 1) RF_Channels = 0 signal_conditioner_ID = 0 if self.sources_count_ > 1: assert False else: self.sig_source_.append( self.block_factory_.GetSignalSource(self.configuration_, self.queue_, -1)) RF_Channels = self.configuration_.get( self.sig_source_[0].role_ + ".RF_channels", 0) if RF_Channels != 0: assert False else: self.sig_conditioner_.append( self.block_factory_.GetSignalConditioner( self.configuration_, -1)) self.observables_ = self.block_factory_.GetObservables( self.configuration_) default_str = "Default" obs_implementation = self.configuration_.get( "Observables.implementation", default_str) if obs_implementation in ("GPS_L1_CA_Observables", "GPS_L2C_Observables", "Galileo_E1B_Observables", "Galileo_E5A_Observables"): assert False self.pvt_ = self.block_factory_.GetPVT(self.configuration_) pvt_implementation = self.configuration_.get("PVT.implementation", default_str) if pvt_implementation in ("GPS_L1_CA_PVT", "Galileo_E1_PVT", "Hybrid_PVT"): assert False channels = self.block_factory_.GetChannels(self.configuration_, self.queue_) self.channels_count_ = len(channels) self.channels_.extend(channels) self.top_block_ = gr_top_block("GNSSFlowgraph") # self.mapStringValues_["1C"] = GNSSFlowgraph.evGPS_1C # self.mapStringValues_["2S"] = GNSSFlowgraph.evGPS_2S # self.mapStringValues_["L5"] = GNSSFlowgraph.evGPS_L5 # self.mapStringValues_["1B"] = GNSSFlowgraph.evGAL_1B # self.mapStringValues_["5X"] = GNSSFlowgraph.evGAL_5X # self.mapStringValues_["1G"] = GNSSFlowgraph.evGLO_1G # self.mapStringValues_["2G"] = GNSSFlowgraph.evGLO_2G # self.mapStringValues_["B1"] = GNSSFlowgraph.evBDS_B1 # self.mapStringValues_["B3"] = GNSSFlowgraph.evBDS_B3 self.mapStringValues_ = jld_channels.cid # fill the signals queue with the satellites ID's to be searched by the acquisition self.set_signals_list() self.set_channels_state() DLOG.INFO("Blocks instantiated. " + str(self.channels_count_) + " channels.") # Instantiate the receiver monitor block, if required self.enable_monitor_ = self.configuration_.get( "Monitor.enable_monitor", False) assert not self.enable_monitor_ ### JLD assert self.sources_count_ == len(self.sig_source_) assert self.channels_count_ == len(self.channels_)
def connect(self, top_block): "" DLOG.INFO("nothing to connect internally")
def __init__(self, configuration, role, in_streams, out_streams): "" # .h self.acq_parameters_ = { 'it_size': 1, 'resampler_ratio': 1.0 } # Acq_Conf ### tous les autres a 0/false # .cc self.role_ = role self.in_streams_ = in_streams self.out_streams_ = out_streams self.configuration_ = configuration default_item_type = "gr_complex" default_dump_filename = "./acquisition.mat" DLOG.INFO("role " + role) self.item_type_ = configuration.get(role + ".item_type", default_item_type) fs_in_deprecated = configuration.get("GNSS-SDR.internal_fs_hz", 2048000) # int64_t self.acq_parameters_['fs_in'] = self.fs_in_ = configuration.get( "GNSS-SDR.internal_fs_sps", fs_in_deprecated) self.acq_parameters_['dump'] = self.dump_ = configuration.get( role + ".dump", False) self.acq_parameters_['dump_channel'] = configuration.get( role + ".dump_channel", 0) self.acq_parameters_['blocking'] = self.blocking_ = configuration.get( role + ".blocking", True) self.acq_parameters_[ 'doppler_max'] = self.doppler_max_ = configuration.get( role + ".doppler_max", 5000) self.acq_parameters_[ 'sampled_ms'] = self.sampled_ms_ = configuration.get( role + ".coherent_integration_time_ms", 1) self.acq_parameters_['ms_per_code'] = 1 self.acq_parameters_[ 'bit_transition_flag'] = self.bit_transition_flag_ = configuration.get( role + ".bit_transition_flag", False) self.acq_parameters_[ 'use_CFAR_algorithm_flag'] = self.use_CFAR_algorithm_flag_ = configuration.get( role + ".use_CFAR_algorithm", True) # will be false in future versions self.acq_parameters_[ 'max_dwells'] = self.max_dwells_ = configuration.get( role + ".max_dwells", 1) self.acq_parameters_[ 'dump_filename'] = self.dump_filename_ = configuration.get( role + ".dump_filename", default_dump_filename) self.acq_parameters_['num_doppler_bins_step2'] = configuration.get( role + ".second_nbins", 4) self.acq_parameters_['doppler_step2'] = configuration.get( role + ".second_doppler_step", 125.0) self.acq_parameters_['make_2_steps'] = configuration.get( role + ".make_two_steps", False) self.acq_parameters_['use_automatic_resampler'] = configuration.get( "GNSS-SDR.use_acquisition_resampler", False) if self.acq_parameters_[ 'use_automatic_resampler'] and self.item_type_ != "gr_complex": assert False if self.acq_parameters_['use_automatic_resampler']: if self.acq_parameters_['fs_in'] > GPS.L1.CA.OPT_ACQ_FS_HZ: 2 + 2 assert False else: self.acq_parameters_['resampled_fs'] = self.fs_in_ #--- Find number of samples per spreading code ------------------------- self.code_length_ = int( math.floor( self.fs_in_ / (GPS.L1.CA.CODE_RATE_HZ / GPS.L1.CA.CODE_LENGTH_CHIPS))) self.acq_parameters_['samples_per_ms'] = self.fs_in_ * 0.001 self.acq_parameters_['samples_per_chip'] = int( math.ceil(GPS.L1.CA.CHIP_PERIOD * float(self.acq_parameters_['fs_in']))) """ if (acq_parameters_.use_automatic_resampler == true and item_type_ != "gr_complex") { LOG(WARNING) << "GPS L1 CA acquisition disabled the automatic resampler feature because its item_type is not set to gr_complex"; acq_parameters_.use_automatic_resampler = false; } if (acq_parameters_.use_automatic_resampler) { if (acq_parameters_.fs_in > GPS_L1_CA_OPT_ACQ_FS_HZ) { acq_parameters_.resampler_ratio = floor(static_cast<float>(acq_parameters_.fs_in) / GPS_L1_CA_OPT_ACQ_FS_HZ); uint32_t decimation = acq_parameters_.fs_in / GPS_L1_CA_OPT_ACQ_FS_HZ; while (acq_parameters_.fs_in % decimation > 0) { decimation--; }; acq_parameters_.resampler_ratio = decimation; acq_parameters_.resampled_fs = acq_parameters_.fs_in / static_cast<int>(acq_parameters_.resampler_ratio); } //--- Find number of samples per spreading code ------------------------- code_length_ = static_cast<unsigned int>(std::floor(static_cast<double>(acq_parameters_.resampled_fs) / (GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS))); acq_parameters_.samples_per_ms = static_cast<float>(acq_parameters_.resampled_fs) * 0.001; acq_parameters_.samples_per_chip = static_cast<unsigned int>(ceil(GPS_L1_CA_CHIP_PERIOD * static_cast<float>(acq_parameters_.resampled_fs))); } else { acq_parameters_.resampled_fs = fs_in_; //--- Find number of samples per spreading code ------------------------- code_length_ = static_cast<unsigned int>(std::floor(static_cast<double>(fs_in_) / (GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS))); acq_parameters_.samples_per_ms = static_cast<float>(fs_in_) * 0.001; acq_parameters_.samples_per_chip = static_cast<unsigned int>(ceil(GPS_L1_CA_CHIP_PERIOD * static_cast<float>(acq_parameters_.fs_in))); } """ self.acq_parameters_['samples_per_code'] = self.acq_parameters_[ 'samples_per_ms'] * float(GPS.L1.CA.CODE_PERIOD * 1000.0) tmp = math.floor( self.acq_parameters_['sampled_ms'] * self.acq_parameters_['samples_per_ms']) * ( 2 if self.acq_parameters_['bit_transition_flag'] else 1) self.vector_length_ = int(math.floor(tmp + 0.5)) assert abs(self.vector_length_ - tmp) < 1e-5 self.code_ = np.zeros(self.vector_length_, dtype=np.complex64) if self.item_type_ == "cshort": assert False # item_size_ = sizeof(lv_16sc_t); else: self.item_size_ = gr_complex.sizeof self.acq_parameters_['it_size'] = self.item_size_ self.acq_parameters_['blocking_on_standby'] = configuration.get( role + ".blocking_on_standby", False) self.acquisition_ = pcps_acquisition(self.acq_parameters_) DLOG.INFO("acquisition(" + str(self.acquisition_.unique_id()) + ")")
def connect(self, top_block): "" assert self.dump_ is False DLOG.INFO("nothing to connect internally")