mirror of
https://github.com/gnss-sdr/gnss-sdr
synced 2024-06-18 11:09:56 +00:00
Adding new a multichannel file source suitable for multifrequency captures stored in different files to avoid stream synchronization problems in post-processing
This commit is contained in:
Javier Arribas
parent
d49959d264
commit
81ee21f8cf
|
|
@ -129,6 +129,7 @@ endif()
|
|||
|
||||
set(SIGNAL_SOURCE_ADAPTER_SOURCES
|
||||
file_signal_source.cc
|
||||
multichannel_file_signal_source.cc
|
||||
gen_signal_source.cc
|
||||
nsr_file_signal_source.cc
|
||||
spir_file_signal_source.cc
|
||||
|
|
@ -142,6 +143,7 @@ set(SIGNAL_SOURCE_ADAPTER_SOURCES
|
|||
|
||||
set(SIGNAL_SOURCE_ADAPTER_HEADERS
|
||||
file_signal_source.h
|
||||
multichannel_file_signal_source.h
|
||||
gen_signal_source.h
|
||||
nsr_file_signal_source.h
|
||||
spir_file_signal_source.h
|
||||
|
|
|
|||
|
|
@ -0,0 +1,314 @@
|
|||
/*!
|
||||
* \file file_signal_source.cc
|
||||
* \brief Implementation of a class that reads signals samples from a file
|
||||
* and adapts it to a SignalSourceInterface
|
||||
* \author Carlos Aviles, 2010. carlos.avilesr(at)googlemail.com
|
||||
* Javier Arribas, 2011 jarribas(at)cttc.es
|
||||
*
|
||||
* -------------------------------------------------------------------------
|
||||
*
|
||||
* Copyright (C) 2010-2018 (see AUTHORS file for a list of contributors)
|
||||
*
|
||||
* GNSS-SDR is a software defined Global Navigation
|
||||
* Satellite Systems receiver
|
||||
*
|
||||
* This file is part of GNSS-SDR.
|
||||
*
|
||||
* GNSS-SDR is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* GNSS-SDR is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with GNSS-SDR. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
* -------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include "multichannel_file_signal_source.h"
|
||||
#include "configuration_interface.h"
|
||||
#include "gnss_sdr_flags.h"
|
||||
#include "gnss_sdr_valve.h"
|
||||
#include <glog/logging.h>
|
||||
#include <exception>
|
||||
#include <fstream>
|
||||
#include <iomanip>
|
||||
#include <iostream> // for std::cerr
|
||||
#include <utility>
|
||||
|
||||
|
||||
MultichannelFileSignalSource::MultichannelFileSignalSource(ConfigurationInterface* configuration,
|
||||
const std::string& role, unsigned int in_streams, unsigned int out_streams,
|
||||
boost::shared_ptr<gr::msg_queue> queue) : role_(role), in_streams_(in_streams), out_streams_(out_streams), queue_(std::move(queue))
|
||||
{
|
||||
std::string default_filename = "./example_capture.dat";
|
||||
std::string default_item_type = "short";
|
||||
std::string default_dump_filename = "./my_capture.dat";
|
||||
|
||||
double default_seconds_to_skip = 0.0;
|
||||
size_t header_size = 0;
|
||||
samples_ = configuration->property(role + ".samples", 0);
|
||||
sampling_frequency_ = configuration->property(role + ".sampling_frequency", 0);
|
||||
n_channels_ = configuration->property(role + ".total_channels", 1);
|
||||
|
||||
for (unsigned int n = 0; n < n_channels_; n++)
|
||||
{
|
||||
filename_vec_.push_back(configuration->property(role + ".filename" + std::to_string(n), default_filename));
|
||||
}
|
||||
|
||||
item_type_ = configuration->property(role + ".item_type", default_item_type);
|
||||
repeat_ = configuration->property(role + ".repeat", false);
|
||||
enable_throttle_control_ = configuration->property(role + ".enable_throttle_control", false);
|
||||
|
||||
double seconds_to_skip = configuration->property(role + ".seconds_to_skip", default_seconds_to_skip);
|
||||
header_size = configuration->property(role + ".header_size", 0);
|
||||
int64_t samples_to_skip = 0;
|
||||
|
||||
bool is_complex = false;
|
||||
|
||||
if (item_type_ == "gr_complex")
|
||||
{
|
||||
item_size_ = sizeof(gr_complex);
|
||||
}
|
||||
else if (item_type_ == "float")
|
||||
{
|
||||
item_size_ = sizeof(float);
|
||||
}
|
||||
else if (item_type_ == "short")
|
||||
{
|
||||
item_size_ = sizeof(int16_t);
|
||||
}
|
||||
else if (item_type_ == "ishort")
|
||||
{
|
||||
item_size_ = sizeof(int16_t);
|
||||
is_complex = true;
|
||||
}
|
||||
else if (item_type_ == "byte")
|
||||
{
|
||||
item_size_ = sizeof(int8_t);
|
||||
}
|
||||
else if (item_type_ == "ibyte")
|
||||
{
|
||||
item_size_ = sizeof(int8_t);
|
||||
is_complex = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG(WARNING) << item_type_
|
||||
<< " unrecognized item type. Using gr_complex.";
|
||||
item_size_ = sizeof(gr_complex);
|
||||
}
|
||||
try
|
||||
{
|
||||
for (unsigned int n = 0; n < n_channels_; n++)
|
||||
{
|
||||
file_source_vec_.push_back(gr::blocks::file_source::make(item_size_, filename_vec_.at(n).c_str(), repeat_));
|
||||
|
||||
if (seconds_to_skip > 0)
|
||||
{
|
||||
samples_to_skip = static_cast<int64_t>(seconds_to_skip * sampling_frequency_);
|
||||
|
||||
if (is_complex)
|
||||
{
|
||||
samples_to_skip *= 2;
|
||||
}
|
||||
}
|
||||
if (header_size > 0)
|
||||
{
|
||||
samples_to_skip += header_size;
|
||||
}
|
||||
|
||||
if (samples_to_skip > 0)
|
||||
{
|
||||
LOG(INFO) << "Skipping " << samples_to_skip << " samples of the input file #" << n;
|
||||
if (not file_source_vec_.back()->seek(samples_to_skip, SEEK_SET))
|
||||
{
|
||||
LOG(INFO) << "Error skipping bytes!";
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
if (filename_vec_.at(0) == default_filename)
|
||||
{
|
||||
std::cerr
|
||||
<< "The configuration file has not been found."
|
||||
<< std::endl
|
||||
<< "Please create a configuration file based on the examples at the 'conf/' folder "
|
||||
<< std::endl
|
||||
<< "and then generate your own GNSS Software Defined Receiver by doing:"
|
||||
<< std::endl
|
||||
<< "$ gnss-sdr --config_file=/path/to/my_GNSS_SDR_configuration.conf"
|
||||
<< std::endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cerr
|
||||
<< "The receiver was configured to work with a file signal source "
|
||||
<< std::endl
|
||||
<< "but the specified file is unreachable by GNSS-SDR."
|
||||
<< std::endl
|
||||
<< "Please modify your configuration file"
|
||||
<< std::endl
|
||||
<< "and point SignalSource.filename to a valid raw data file. Then:"
|
||||
<< std::endl
|
||||
<< "$ gnss-sdr --config_file=/path/to/my_GNSS_SDR_configuration.conf"
|
||||
<< std::endl
|
||||
<< "Examples of configuration files available at:"
|
||||
<< std::endl
|
||||
<< GNSSSDR_INSTALL_DIR "/share/gnss-sdr/conf/"
|
||||
<< std::endl;
|
||||
}
|
||||
|
||||
LOG(INFO) << "file_signal_source: Unable to open the samples file "
|
||||
<< filename_vec_.at(0).c_str() << ", exiting the program.";
|
||||
throw(e);
|
||||
}
|
||||
|
||||
//todo from here.... add mux demux also
|
||||
if (samples_ == 0) // read all file
|
||||
{
|
||||
/*!
|
||||
* BUG workaround: The GNU Radio file source does not stop the receiver after reaching the End of File.
|
||||
* A possible solution is to compute the file length in samples using file size, excluding the last 100 milliseconds, and enable always the
|
||||
* valve block
|
||||
*/
|
||||
std::ifstream file(filename_vec_.at(0).c_str(), std::ios::in | std::ios::binary | std::ios::ate);
|
||||
std::ifstream::pos_type size;
|
||||
|
||||
if (file.is_open())
|
||||
{
|
||||
size = file.tellg();
|
||||
DLOG(INFO) << "Total samples in the file= " << floor(static_cast<double>(size) / static_cast<double>(item_size()));
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cout << "file_signal_source: Unable to open the samples file " << filename_vec_.at(0).c_str() << std::endl;
|
||||
LOG(ERROR) << "file_signal_source: Unable to open the samples file " << filename_vec_.at(0).c_str();
|
||||
}
|
||||
std::streamsize ss = std::cout.precision();
|
||||
std::cout << std::setprecision(16);
|
||||
std::cout << "Processing file " << filename_vec_.at(0) << ", which contains " << static_cast<double>(size) << " [bytes]" << std::endl;
|
||||
std::cout.precision(ss);
|
||||
|
||||
if (size > 0)
|
||||
{
|
||||
int64_t bytes_to_skip = samples_to_skip * item_size_;
|
||||
int64_t bytes_to_process = static_cast<int64_t>(size) - bytes_to_skip;
|
||||
samples_ = floor(static_cast<double>(bytes_to_process) / static_cast<double>(item_size()) - ceil(0.002 * static_cast<double>(sampling_frequency_))); //process all the samples available in the file excluding at least the last 1 ms
|
||||
}
|
||||
}
|
||||
|
||||
CHECK(samples_ > 0) << "File does not contain enough samples to process.";
|
||||
double signal_duration_s;
|
||||
signal_duration_s = static_cast<double>(samples_) * (1 / static_cast<double>(sampling_frequency_));
|
||||
|
||||
if (is_complex)
|
||||
{
|
||||
signal_duration_s /= 2.0;
|
||||
}
|
||||
|
||||
DLOG(INFO) << "Total number samples to be processed= " << samples_ << " GNSS signal duration= " << signal_duration_s << " [s]";
|
||||
std::cout << "GNSS signal recorded time to be processed: " << signal_duration_s << " [s]" << std::endl;
|
||||
|
||||
valve_ = gnss_sdr_make_valve(item_size_, samples_ * n_channels_, queue_);
|
||||
DLOG(INFO) << "valve(" << valve_->unique_id() << ")";
|
||||
|
||||
|
||||
if (enable_throttle_control_)
|
||||
{
|
||||
for (unsigned int n = 0; n < n_channels_; n++)
|
||||
{
|
||||
throttle_vec_.push_back(gr::blocks::throttle::make(item_size_, sampling_frequency_));
|
||||
}
|
||||
}
|
||||
|
||||
for (unsigned int n = 0; n < n_channels_; n++)
|
||||
{
|
||||
LOG(INFO) << "Multichanne File source filename #" << n << filename_vec_.at(n);
|
||||
}
|
||||
|
||||
DLOG(INFO) << "Samples " << samples_;
|
||||
DLOG(INFO) << "Sampling frequency " << sampling_frequency_;
|
||||
DLOG(INFO) << "Item type " << item_type_;
|
||||
DLOG(INFO) << "Item size " << item_size_;
|
||||
DLOG(INFO) << "Repeat " << repeat_;
|
||||
|
||||
|
||||
if (in_streams_ > 0)
|
||||
{
|
||||
LOG(ERROR) << "A signal source does not have an input stream";
|
||||
}
|
||||
if (out_streams_ > 1)
|
||||
{
|
||||
LOG(ERROR) << "This implementation only supports one output stream";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
MultichannelFileSignalSource::~MultichannelFileSignalSource() = default;
|
||||
|
||||
|
||||
void MultichannelFileSignalSource::connect(gr::top_block_sptr top_block)
|
||||
{
|
||||
if (enable_throttle_control_ == true)
|
||||
{
|
||||
for (unsigned int n = 0; n < n_channels_; n++)
|
||||
{
|
||||
top_block->connect(file_source_vec_.at(n), 0, throttle_vec_.at(n), 0);
|
||||
DLOG(INFO) << "connected file_source #" << n << " to throttle";
|
||||
top_block->connect(throttle_vec_.at(n), 0, valve_, n);
|
||||
DLOG(INFO) << "connected throttle #" << n << " to valve_";
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (unsigned int n = 0; n < n_channels_; n++)
|
||||
{
|
||||
top_block->connect(file_source_vec_.at(n), 0, valve_, n);
|
||||
DLOG(INFO) << "connected file_source #" << n << " to valve_";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void MultichannelFileSignalSource::disconnect(gr::top_block_sptr top_block)
|
||||
{
|
||||
if (enable_throttle_control_ == true)
|
||||
{
|
||||
for (unsigned int n = 0; n < n_channels_; n++)
|
||||
{
|
||||
top_block->disconnect(file_source_vec_.at(n), 0, throttle_vec_.at(n), 0);
|
||||
DLOG(INFO) << "disconnected file_source #" << n << " to throttle";
|
||||
top_block->disconnect(throttle_vec_.at(n), 0, valve_, n);
|
||||
DLOG(INFO) << "disconnected throttle #" << n << " to valve_";
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (unsigned int n = 0; n < n_channels_; n++)
|
||||
{
|
||||
top_block->disconnect(file_source_vec_.at(n), 0, valve_, n);
|
||||
DLOG(INFO) << "disconnected file_source #" << n << " to valve_";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
gr::basic_block_sptr MultichannelFileSignalSource::get_left_block()
|
||||
{
|
||||
LOG(WARNING) << "Left block of a signal source should not be retrieved";
|
||||
return gr::blocks::file_source::sptr();
|
||||
}
|
||||
|
||||
|
||||
gr::basic_block_sptr MultichannelFileSignalSource::get_right_block()
|
||||
{
|
||||
return valve_;
|
||||
}
|
||||
|
|
@ -0,0 +1,131 @@
|
|||
/*!
|
||||
* \file file_signal_source.h
|
||||
* \brief Interface of a class that reads signals samples from a file
|
||||
* and adapts it to a SignalSourceInterface
|
||||
* \author Carlos Aviles, 2010. carlos.avilesr(at)googlemail.com
|
||||
*
|
||||
* This class represents a file signal source. Internally it uses a GNU Radio's
|
||||
* gr_file_source as a connector to the data.
|
||||
*
|
||||
* -------------------------------------------------------------------------
|
||||
*
|
||||
* Copyright (C) 2010-2018 (see AUTHORS file for a list of contributors)
|
||||
*
|
||||
* GNSS-SDR is a software defined Global Navigation
|
||||
* Satellite Systems receiver
|
||||
*
|
||||
* This file is part of GNSS-SDR.
|
||||
*
|
||||
* GNSS-SDR is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* GNSS-SDR is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with GNSS-SDR. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
* -------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#ifndef GNSS_SDR_MULTICHANNEL_FILE_SIGNAL_SOURCE_H_
|
||||
#define GNSS_SDR_MULTICHANNEL_FILE_SIGNAL_SOURCE_H_
|
||||
|
||||
#include "gnss_block_interface.h"
|
||||
#include <gnuradio/blocks/file_sink.h>
|
||||
#include <gnuradio/blocks/file_source.h>
|
||||
#include <gnuradio/blocks/throttle.h>
|
||||
#include <gnuradio/hier_block2.h>
|
||||
#include <gnuradio/msg_queue.h>
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
class ConfigurationInterface;
|
||||
|
||||
/*!
|
||||
* \brief Class that reads signals samples from a file
|
||||
* and adapts it to a SignalSourceInterface
|
||||
*/
|
||||
class MultichannelFileSignalSource : public GNSSBlockInterface
|
||||
{
|
||||
public:
|
||||
MultichannelFileSignalSource(ConfigurationInterface* configuration, const std::string& role,
|
||||
unsigned int in_streams, unsigned int out_streams,
|
||||
boost::shared_ptr<gr::msg_queue> queue);
|
||||
|
||||
virtual ~MultichannelFileSignalSource();
|
||||
|
||||
inline std::string role() override
|
||||
{
|
||||
return role_;
|
||||
}
|
||||
|
||||
/*!
|
||||
* \brief Returns "File_Signal_Source".
|
||||
*/
|
||||
inline std::string implementation() override
|
||||
{
|
||||
return "Multichannel_File_Signal_Source";
|
||||
}
|
||||
|
||||
inline size_t item_size() override
|
||||
{
|
||||
return item_size_;
|
||||
}
|
||||
|
||||
void connect(gr::top_block_sptr top_block) override;
|
||||
void disconnect(gr::top_block_sptr top_block) override;
|
||||
gr::basic_block_sptr get_left_block() override;
|
||||
gr::basic_block_sptr get_right_block() override;
|
||||
|
||||
inline std::string filename() const
|
||||
{
|
||||
return filename_vec_.at(0);
|
||||
}
|
||||
|
||||
inline std::string item_type() const
|
||||
{
|
||||
return item_type_;
|
||||
}
|
||||
|
||||
inline bool repeat() const
|
||||
{
|
||||
return repeat_;
|
||||
}
|
||||
|
||||
inline int64_t sampling_frequency() const
|
||||
{
|
||||
return sampling_frequency_;
|
||||
}
|
||||
|
||||
inline uint64_t samples() const
|
||||
{
|
||||
return samples_;
|
||||
}
|
||||
|
||||
private:
|
||||
uint64_t samples_;
|
||||
int64_t sampling_frequency_;
|
||||
uint32_t n_channels_;
|
||||
std::vector<std::string> filename_vec_;
|
||||
std::string item_type_;
|
||||
bool repeat_;
|
||||
std::string role_;
|
||||
uint32_t in_streams_;
|
||||
uint32_t out_streams_;
|
||||
std::vector<gr::blocks::file_source::sptr> file_source_vec_;
|
||||
boost::shared_ptr<gr::block> valve_;
|
||||
gr::blocks::file_sink::sptr sink_;
|
||||
std::vector<gr::blocks::throttle::sptr> throttle_vec_;
|
||||
boost::shared_ptr<gr::msg_queue> queue_;
|
||||
size_t item_size_;
|
||||
// Throttle control
|
||||
bool enable_throttle_control_;
|
||||
};
|
||||
|
||||
#endif /*GNSS_SDR_MULTICHANNEL_FILE_SIGNAL_SOURCE_H_*/
|
||||
|
|
@ -44,8 +44,8 @@ Gnss_Sdr_Valve::Gnss_Sdr_Valve(size_t sizeof_stream_item,
|
|||
uint64_t nitems,
|
||||
gr::msg_queue::sptr queue,
|
||||
bool stop_flowgraph) : gr::sync_block("valve",
|
||||
gr::io_signature::make(1, 1, sizeof_stream_item),
|
||||
gr::io_signature::make(1, 1, sizeof_stream_item)),
|
||||
gr::io_signature::make(1, 20, sizeof_stream_item),
|
||||
gr::io_signature::make(1, 20, sizeof_stream_item)),
|
||||
d_nitems(nitems),
|
||||
d_ncopied_items(0),
|
||||
d_queue(std::move(queue)),
|
||||
|
|
@ -99,11 +99,17 @@ int Gnss_Sdr_Valve::work(int noutput_items,
|
|||
{
|
||||
return 0;
|
||||
}
|
||||
memcpy(output_items[0], input_items[0], n * input_signature()->sizeof_stream_item(0));
|
||||
//multichannel support
|
||||
for (int ch = 0; ch < output_items.size(); ch++)
|
||||
{
|
||||
memcpy(output_items[ch], input_items[ch], n * input_signature()->sizeof_stream_item(ch));
|
||||
}
|
||||
d_ncopied_items += n;
|
||||
return n;
|
||||
}
|
||||
|
||||
memcpy(output_items[0], input_items[0], noutput_items * input_signature()->sizeof_stream_item(0));
|
||||
for (int ch = 0; ch < output_items.size(); ch++)
|
||||
{
|
||||
memcpy(output_items[ch], input_items[ch], noutput_items * input_signature()->sizeof_stream_item(ch));
|
||||
}
|
||||
return noutput_items;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -97,6 +97,7 @@
|
|||
#include "ishort_to_cshort.h"
|
||||
#include "labsat_signal_source.h"
|
||||
#include "mmse_resampler_conditioner.h"
|
||||
#include "multichannel_file_signal_source.h"
|
||||
#include "notch_filter.h"
|
||||
#include "notch_filter_lite.h"
|
||||
#include "nsr_file_signal_source.h"
|
||||
|
|
@ -1261,6 +1262,21 @@ std::unique_ptr<GNSSBlockInterface> GNSSBlockFactory::GetBlock(
|
|||
block = std::move(block_);
|
||||
}
|
||||
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
std::cout << "GNSS-SDR program ended." << std::endl;
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
else if (implementation == "Multichannel_File_Signal_Source")
|
||||
{
|
||||
try
|
||||
{
|
||||
std::unique_ptr<GNSSBlockInterface> block_(new MultichannelFileSignalSource(configuration.get(), role, in_streams,
|
||||
out_streams, queue));
|
||||
block = std::move(block_);
|
||||
}
|
||||
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
std::cout << "GNSS-SDR program ended." << std::endl;
|
||||
|
|
|
|||
|
|
@ -215,7 +215,7 @@ void GNSSFlowgraph::connect()
|
|||
}
|
||||
|
||||
DLOG(INFO) << "blocks connected internally";
|
||||
// Signal Source (i) > Signal conditioner (i) >
|
||||
// Signal Source (i) > Signal conditioner (i) >
|
||||
#ifndef ENABLE_FPGA
|
||||
int RF_Channels = 0;
|
||||
int signal_conditioner_ID = 0;
|
||||
|
|
@ -249,10 +249,13 @@ void GNSSFlowgraph::connect()
|
|||
DLOG(INFO) << "sig_source_.at(i)->get_right_block()->output_signature()->max_streams()=" << sig_source_.at(i)->get_right_block()->output_signature()->max_streams();
|
||||
DLOG(INFO) << "sig_conditioner_.at(signal_conditioner_ID)->get_left_block()->input_signature()=" << sig_conditioner_.at(signal_conditioner_ID)->get_left_block()->input_signature()->max_streams();
|
||||
|
||||
if (sig_source_.at(i)->get_right_block()->output_signature()->max_streams() > 1)
|
||||
if (sig_source_.at(i)->get_right_block()->output_signature()->max_streams() > 1 or sig_source_.at(i)->get_right_block()->output_signature()->max_streams() == -1)
|
||||
{
|
||||
LOG(INFO) << "connecting sig_source_ " << i << " stream " << j << " to conditioner " << j;
|
||||
top_block_->connect(sig_source_.at(i)->get_right_block(), j, sig_conditioner_.at(signal_conditioner_ID)->get_left_block(), 0);
|
||||
if (sig_conditioner_.size() > signal_conditioner_ID)
|
||||
{
|
||||
LOG(INFO) << "connecting sig_source_ " << i << " stream " << j << " to conditioner " << j;
|
||||
top_block_->connect(sig_source_.at(i)->get_right_block(), j, sig_conditioner_.at(signal_conditioner_ID)->get_left_block(), 0);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -819,7 +822,7 @@ void GNSSFlowgraph::disconnect()
|
|||
|
||||
for (int j = 0; j < RF_Channels; j++)
|
||||
{
|
||||
if (sig_source_.at(i)->get_right_block()->output_signature()->max_streams() > 1)
|
||||
if (sig_source_.at(i)->get_right_block()->output_signature()->max_streams() > 1 or sig_source_.at(i)->get_right_block()->output_signature()->max_streams() == -1)
|
||||
{
|
||||
top_block_->disconnect(sig_source_.at(i)->get_right_block(), j, sig_conditioner_.at(signal_conditioner_ID)->get_left_block(), 0);
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user