1
0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2024-12-15 04:30:33 +00:00

Added Spirent GSS6450 file signal source

This commit is contained in:
Antonio Ramos 2018-01-12 13:15:20 +01:00
parent 6256f15893
commit 29b8643def
6 changed files with 530 additions and 0 deletions

View File

@ -139,6 +139,7 @@ set(SIGNAL_SOURCE_ADAPTER_SOURCES file_signal_source.cc
gen_signal_source.cc gen_signal_source.cc
nsr_file_signal_source.cc nsr_file_signal_source.cc
spir_file_signal_source.cc spir_file_signal_source.cc
spir_gss6450_file_signal_source.cc
rtl_tcp_signal_source.cc rtl_tcp_signal_source.cc
${OPT_DRIVER_SOURCES} ${OPT_DRIVER_SOURCES}
) )

View File

@ -0,0 +1,261 @@
/*!
* \file spir_file_signal_source.cc
* \brief Implementation of a class that reads signals samples from a SPIR file
* and adapts it to a SignalSourceInterface.
* \author Fran Fabra, 2014 fabra(at)ice.csic.es
*
* -------------------------------------------------------------------------
*
* Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors)
*
* GNSS-SDR is a software defined Global Navigation
* Satellite Systems receiver
*
* This file is not 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 <http://www.gnu.org/licenses/>.
*
* -------------------------------------------------------------------------
*/
#include "spir_gss6450_file_signal_source.h"
#include <exception>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <cstdio>
#include <gflags/gflags.h>
#include <glog/logging.h>
#include "configuration_interface.h"
using google::LogMessage;
DEFINE_string(spir_gss6450_signal_source, "-",
"If defined, path to the file containing the Spirent GSS6450 signal samples (overrides the configuration file)");
SpirGSS6450FileSignalSource::SpirGSS6450FileSignalSource(ConfigurationInterface* configuration,
std::string role, unsigned int in_streams, unsigned int out_streams, gr::msg_queue::sptr queue) :
role_(role), in_streams_(in_streams), out_streams_(out_streams), queue_(queue)
{
std::string default_filename = "../data/my_capture.dat";
std::string default_dump_filename = "../data/my_capture_dump.dat";
item_type_ = "int";
samples_ = configuration->property(role + ".samples", 0);
sampling_frequency_ = configuration->property(role + ".sampling_frequency", 0);
filename_ = configuration->property(role + ".filename", default_filename);
// override value with commandline flag, if present
if (FLAGS_spir_gss6450_signal_source.compare("-") != 0) filename_= FLAGS_spir_gss6450_signal_source;
repeat_ = configuration->property(role + ".repeat", false);
dump_ = configuration->property(role + ".dump", false);
dump_filename_ = configuration->property(role + ".dump_filename", default_dump_filename);
enable_throttle_control_ = configuration->property(role + ".enable_throttle_control", false);
adc_bits_ = configuration->property(role + ".adc_bits", 4);
n_channels_ = configuration->property(role + ".RF_channels", 1);
sel_ch_ = configuration->property(role + ".sel_ch", 1);
item_size_ = sizeof(int);
long bytes_seek = 65536;
double sample_size_byte = static_cast<double>(adc_bits_) / 4.0;
int samples_per_item = 16 / adc_bits_;
if(sel_ch_ > n_channels_) { LOG(WARNING) << "Invalid RF channel selection"; }
try
{
file_source_ = gr::blocks::file_source::make(item_size_, filename_.c_str(), repeat_);
file_source_->seek(bytes_seek, SEEK_SET);
unpack_ii_ = gr::blocks::packed_to_unpacked_ii::make(2 * adc_bits_, gr::GR_MSB_FIRST);
unpack_spir_ = make_unpack_spir_gss6450_samples(n_channels_, sel_ch_, item_size_);
}
catch (const std::exception &e)
{
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(WARNING) << "file_signal_source: Unable to open the samples file "
<< filename_.c_str() << ", exiting the program.";
throw(e);
}
DLOG(INFO) << "file_source(" << file_source_->unique_id() << ")";
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_.c_str(), std::ios::in | std::ios::binary | std::ios::ate);
std::ifstream::pos_type size;
if (file.is_open())
{
size = file.tellg();
LOG(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_.c_str() << std::endl;
LOG(ERROR) << "file_signal_source: Unable to open the samples file " << filename_.c_str();
}
std::streamsize ss = std::cout.precision();
std::cout << std::setprecision(16);
std::cout << "Processing file " << filename_ << ", which contains " << size << " [bytes]" << std::endl;
std::cout.precision (ss);
if(size > 0)
{
samples_ = floor(static_cast<double>(size - bytes_seek) / (sample_size_byte * static_cast<double>(n_channels_)));
samples_ = samples_- ceil(0.002 * static_cast<double>(sampling_frequency_)); //process all the samples available in the file excluding the last 2 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_));
LOG(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(sizeof(gr_complex), samples_, queue_);
DLOG(INFO) << "valve(" << valve_->unique_id() << ")";
if (dump_)
{
sink_ = gr::blocks::file_sink::make(sizeof(gr_complex), dump_filename_.c_str());
DLOG(INFO) << "file_sink(" << sink_->unique_id() << ")";
}
if (enable_throttle_control_)
{
throttle_ = gr::blocks::throttle::make(sizeof(gr_complex), sampling_frequency_);
}
DLOG(INFO) << "File source filename " << filename_;
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_;
DLOG(INFO) << "Dump " << dump_;
DLOG(INFO) << "Dump filename " << dump_filename_;
}
SpirGSS6450FileSignalSource::~SpirGSS6450FileSignalSource()
{}
void SpirGSS6450FileSignalSource::connect(gr::top_block_sptr top_block)
{
if (samples_ > 0)
{
if (enable_throttle_control_)
{
top_block->connect(file_source_, 0, unpack_ii_, 0);
top_block->connect(unpack_ii_, 0, unpack_spir_, 0);
top_block->connect(unpack_spir_, 0, throttle_, 0);
top_block->connect(throttle_, 0, valve_, 0);
}
else
{
top_block->connect(file_source_, 0, unpack_ii_, 0);
top_block->connect(unpack_ii_, 0, unpack_spir_, 0);
top_block->connect(unpack_spir_, 0, valve_, 0);
}
if(dump_)
{
top_block->connect(valve_, 0, sink_, 0);
DLOG(INFO) << "connected valve to file sink";
}
}
else
{
LOG(WARNING) << "0 samples to read";
}
}
void SpirGSS6450FileSignalSource::disconnect(gr::top_block_sptr top_block)
{
if (samples_ > 0)
{
if (enable_throttle_control_)
{
top_block->disconnect(file_source_, 0, unpack_ii_, 0);
top_block->disconnect(unpack_ii_, 0, unpack_spir_, 0);
top_block->disconnect(unpack_spir_, 0, throttle_, 0);
top_block->disconnect(throttle_, 0, valve_, 0);
if (dump_)
{
top_block->disconnect(valve_, 0, sink_, 0);
}
}
else
{
top_block->disconnect(file_source_, 0, unpack_ii_, 0);
top_block->disconnect(unpack_ii_, 0, unpack_spir_, 0);
top_block->disconnect(unpack_spir_, 0, valve_, 0);
if (dump_)
{
top_block->disconnect(valve_, 0, sink_, 0);
}
}
}
else
{
LOG(WARNING) << "Nothing to disconnect";
}
}
gr::basic_block_sptr SpirGSS6450FileSignalSource::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 SpirGSS6450FileSignalSource::get_right_block()
{
if(samples_ > 0) { return valve_; }
else
{
if(enable_throttle_control_) { return throttle_; }
else { return unpack_spir_; }
}
}

View File

@ -0,0 +1,130 @@
/*!
* \file spir_file_signal_source.h
* \brief Implementation of a class that reads signals samples from a SPIR file
* and adapts it to a SignalSourceInterface.
* \author Fran Fabra, 2014 fabra(at)ice.csic.es
*
* -------------------------------------------------------------------------
*
* Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors)
*
* GNSS-SDR is a software defined Global Navigation
* Satellite Systems receiver
*
* This file is not 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 <http://www.gnu.org/licenses/>.
*
* -------------------------------------------------------------------------
*/
#ifndef GNSS_SDR_SPIR_GSS6450_FILE_SIGNAL_SOURCE_H_
#define GNSS_SDR_SPIR_GSS6450_FILE_SIGNAL_SOURCE_H_
#include <string>
#include <gnuradio/blocks/file_source.h>
#include <gnuradio/blocks/file_sink.h>
#include <gnuradio/blocks/throttle.h>
#include <gnuradio/blocks/packed_to_unpacked_ii.h>
#include <gnuradio/hier_block2.h>
#include <gnuradio/msg_queue.h>
#include "gnss_block_interface.h"
#include "gnss_sdr_valve.h"
#include "unpack_spir_gss6450_samples.h"
class ConfigurationInterface;
/*!
* \brief Class that reads signals samples from a file
* and adapts it to a SignalSourceInterface
*/
class SpirGSS6450FileSignalSource: public GNSSBlockInterface
{
public:
SpirGSS6450FileSignalSource(ConfigurationInterface* configuration, std::string role,
unsigned int in_streams, unsigned int out_streams, gr::msg_queue::sptr queue);
virtual ~SpirGSS6450FileSignalSource();
inline std::string role() override
{
return role_;
}
inline std::string implementation() override
{
return "Spir_GSS6450_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_;
}
inline std::string item_type() const
{
return item_type_;
}
inline bool repeat() const
{
return repeat_;
}
inline long sampling_frequency() const
{
return sampling_frequency_;
}
inline long samples() const
{
return samples_;
}
private:
unsigned long long samples_;
long sampling_frequency_;
std::string filename_;
bool repeat_;
bool dump_;
std::string dump_filename_;
std::string role_;
std::string item_type_;
unsigned int in_streams_;
unsigned int out_streams_;
unsigned int adc_bits_;
unsigned int n_channels_;
unsigned int sel_ch_;
gr::blocks::file_source::sptr file_source_;
gr::blocks::packed_to_unpacked_ii::sptr unpack_ii_;
unpack_spir_gss6450_samples_sptr unpack_spir_;
boost::shared_ptr<gr::block> valve_;
gr::blocks::file_sink::sptr sink_;
gr::blocks::throttle::sptr throttle_;
gr::msg_queue::sptr queue_;
size_t item_size_;
bool enable_throttle_control_;
};
#endif /*GNSS_SDR_SPIR_GSS6450_FILE_SIGNAL_SOURCE_H_*/

View File

@ -23,6 +23,7 @@ set(SIGNAL_SOURCE_GR_BLOCKS_SOURCES
unpack_intspir_1bit_samples.cc unpack_intspir_1bit_samples.cc
rtl_tcp_signal_source_c.cc rtl_tcp_signal_source_c.cc
unpack_2bit_samples.cc unpack_2bit_samples.cc
unpack_spir_gss6450_samples.cc
) )
include_directories( include_directories(

View File

@ -0,0 +1,75 @@
/*!
* \file unpack_intspir_1bit_samples.cc
*
* \brief Unpacks SPIR int samples to NSR 1 bit samples
* \author Fran Fabra fabra (at) ice.csic.es
* -------------------------------------------------------------------------
*
* Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors)
*
* GNSS-SDR is a software defined Global Navigation
* Satellite Systems receiver
*
* This file is not 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 <http://www.gnu.org/licenses/>.
*
* -------------------------------------------------------------------------
*/
#include "unpack_spir_gss6450_samples.h"
#include <gnuradio/io_signature.h>
unpack_spir_gss6450_samples_sptr make_unpack_spir_gss6450_samples(unsigned int n_chann, unsigned int sel_ch, size_t item_size)
{
return unpack_spir_gss6450_samples_sptr(new unpack_spir_gss6450_samples(n_chann, sel_ch, item_size));
}
unpack_spir_gss6450_samples::unpack_spir_gss6450_samples(
unsigned int n_chann, unsigned int sel_ch, size_t item_size) : gr::block("unpack_spir_gss6450_samples",
gr::io_signature::make(1, 1, sizeof(int)),
gr::io_signature::make(1, 1, sizeof(gr_complex)))
{
d_channels = n_chann;
d_sel_ch = sel_ch;
item_size_ = item_size;
ch_processing = 1;
}
void unpack_spir_gss6450_samples::forecast(int noutput_items, gr_vector_int &ninput_items_required)
{
ninput_items_required[0] = d_channels * noutput_items;
}
unpack_spir_gss6450_samples::~unpack_spir_gss6450_samples()
{}
int unpack_spir_gss6450_samples::general_work(int noutput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items)
{
const int *in = reinterpret_cast<const int *>(input_items[0]);
gr_complex *out = reinterpret_cast<gr_complex*>(output_items[0]);
return noutput_items;
}

View File

@ -0,0 +1,62 @@
/*!
* \file unpack_intspir_1bit_samples.h
*
* \brief Unpacks SPIR int samples to NSR 1 bit samples
* \author Fran Fabra fabra (at) ice.csic.es
* -------------------------------------------------------------------------
*
* Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors)
*
* GNSS-SDR is a software defined Global Navigation
* Satellite Systems receiver
*
* This file is not 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 <http://www.gnu.org/licenses/>.
*
* -------------------------------------------------------------------------
*/
#ifndef GNSS_SDR_UNPACK_SPIR_GSS6450_SAMPLES_H
#define GNSS_SDR_UNPACK_SPIR_GSS6450_SAMPLES_H
#include <gnuradio/block.h>
class unpack_spir_gss6450_samples;
typedef boost::shared_ptr<unpack_spir_gss6450_samples> unpack_spir_gss6450_samples_sptr;
unpack_spir_gss6450_samples_sptr make_unpack_spir_gss6450_samples(unsigned int n_chann, unsigned int sel_ch, size_t item_size);
class unpack_spir_gss6450_samples: public gr::block
{
public:
int general_work (int noutput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items);
void forecast(int noutput_items, gr_vector_int &ninput_items_required);
~unpack_spir_gss6450_samples();
private:
unsigned int d_channels;
unsigned int d_sel_ch;
unsigned int ch_processing;
size_t item_size_;
friend unpack_spir_gss6450_samples_sptr make_unpack_spir_gss6450_samples_sptr(unsigned int n_chann, unsigned int sel_ch, size_t item_size);
unpack_spir_gss6450_samples(unsigned int n_chann, unsigned int sel_ch, size_t item_size);
};
#endif