mirror of
https://github.com/gnss-sdr/gnss-sdr
synced 2024-06-25 22:43:14 +00:00
179 lines
6.0 KiB
C++
179 lines
6.0 KiB
C++
/*!
|
|
* \filei fmcomms2_signal_source.cc
|
|
* \brief signal source for sdr hardware from analog devices based on
|
|
* fmcomms2 evaluation board.
|
|
* \author Rodrigo Muñoz, 2017, rmunozl(at)inacap.cl
|
|
*
|
|
* -------------------------------------------------------------------------
|
|
*
|
|
* 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 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 "fmcomms2_signal_source.h"
|
|
#include <cstdio>
|
|
#include <iostream>
|
|
#include <boost/format.hpp>
|
|
#include <glog/logging.h>
|
|
#include <gnuradio/blocks/file_sink.h>
|
|
#include "configuration_interface.h"
|
|
#include "gnss_sdr_valve.h"
|
|
#include "GPS_L1_CA.h"
|
|
|
|
using google::LogMessage;
|
|
|
|
Fmcomms2SignalSource::Fmcomms2SignalSource(ConfigurationInterface* configuration,
|
|
std::string role, unsigned int in_stream, unsigned int out_stream,
|
|
boost::shared_ptr<gr::msg_queue> queue) :
|
|
role_(role), in_stream_(in_stream), out_stream_(out_stream),
|
|
queue_(queue)
|
|
{
|
|
std::string default_item_type="gr_complex";
|
|
std::string default_dump_file="./data/signal_source.dat";
|
|
uri_= configuration->property(role+".device_address",std::string("192.168.2.1"));
|
|
freq_= configuration->property(role+".freq",GPS_L1_FREQ_HZ);
|
|
sample_rate_=configuration->property(role+".sampling_frequency",2600000);
|
|
bandwidth_= configuration->property(role+".bandwidth",2000000);
|
|
rx1_en_=configuration->property(role+".rx1_enable",true);
|
|
rx2_en_=configuration->property(role+".rx2_enable",false);
|
|
buffer_size_=configuration->property(role+".buffer_size",0xA0000);
|
|
decimation_=configuration->property(role+".decimation",1);
|
|
quadrature_=configuration->property(role+".quadrature",true);
|
|
rf_dc_=configuration->property(role+".rf_dc",true);
|
|
bb_dc_=configuration->property(role+".bb_dc",true);
|
|
gain_mode_rx1_=configuration->property(role+".gain_mode_rx1",std::string("manual"));
|
|
gain_mode_rx2_=configuration->property(role+".gain_mode_rx2",std::string("manual"));
|
|
rf_gain_rx1_=configuration->property(role+".gain_rx1",64.0);
|
|
rf_gain_rx2_=configuration->property(role+".gain_rx2",64.0);
|
|
rf_port_select_=configuration->property(role+".rf_port_select",std::string("A_BALANCED"));
|
|
filter_file_=configuration->property(role+".filter_file",std::string(""));
|
|
filter_auto_=configuration->property(role+".filter_auto",true);
|
|
item_type_=configuration->property(role+".item_type",default_item_type);
|
|
samples_=configuration->property(role+".samples",0);
|
|
dump_=configuration->property(role+".dump",false);
|
|
dump_filename_=configuration->property(role+".dump_filename",default_dump_file);
|
|
|
|
item_size_=sizeof(gr_complex);
|
|
|
|
std::cout<<"device address: "<<uri_<<std::endl;
|
|
std::cout<<"LO frequency : "<<freq_<<"Hz"<<std::endl;
|
|
std::cout<<"sample rate: "<<sample_rate_<<"Hz"<<std::endl;
|
|
|
|
if(item_type_.compare("gr_complex")==0)
|
|
{
|
|
fmcomms2_source_f32c_ = gr::iio::fmcomms2_source_f32c::make(
|
|
uri_.c_str(), freq_, sample_rate_,
|
|
decimation_, bandwidth_,
|
|
rx1_en_, rx2_en_,
|
|
buffer_size_, quadrature_, rf_dc_,
|
|
bb_dc_, gain_mode_rx1_.c_str(), rf_gain_rx1_,
|
|
gain_mode_rx2_.c_str(), rf_gain_rx2_,
|
|
rf_port_select_.c_str(), filter_file_.c_str(),
|
|
filter_auto_);
|
|
}
|
|
else
|
|
{
|
|
LOG(FATAL) <<"Exception: item type "<<item_type_<<" not suported!";
|
|
}
|
|
|
|
if (samples_ != 0)
|
|
{
|
|
DLOG(INFO) << "Send STOP signal after " << samples_ << " samples";
|
|
valve_ = gnss_sdr_make_valve(item_size_, samples_, queue_);
|
|
DLOG(INFO) << "valve(" << valve_->unique_id() << ")";
|
|
}
|
|
|
|
if (dump_)
|
|
{
|
|
DLOG(INFO) << "Dumping output into file " << dump_filename_;
|
|
file_sink_ = gr::blocks::file_sink::make(item_size_, dump_filename_.c_str());
|
|
DLOG(INFO) << "file_sink(" << file_sink_->unique_id() << ")";
|
|
}
|
|
}
|
|
|
|
Fmcomms2SignalSource::~Fmcomms2SignalSource()
|
|
{
|
|
}
|
|
|
|
void Fmcomms2SignalSource::connect(gr::top_block_sptr top_block)
|
|
{
|
|
if (samples_ != 0)
|
|
{
|
|
top_block->connect(fmcomms2_source_f32c_, 0, valve_, 0);
|
|
DLOG(INFO) << "connected fmcomms2 source to valve";
|
|
if (dump_)
|
|
{
|
|
top_block->connect(valve_, 0, file_sink_, 0);
|
|
DLOG(INFO) << "connected valve to file sink";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (dump_)
|
|
{
|
|
|
|
top_block->connect(fmcomms2_source_f32c_ , 0, file_sink_, 0);
|
|
DLOG(INFO) << "connected fmcomms2 source to file sink";
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Fmcomms2SignalSource::disconnect(gr::top_block_sptr top_block)
|
|
{
|
|
if (samples_ != 0)
|
|
{
|
|
top_block->disconnect(fmcomms2_source_f32c_, 0, valve_, 0);
|
|
if (dump_)
|
|
{
|
|
top_block->disconnect(valve_, 0, file_sink_, 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (dump_)
|
|
{
|
|
top_block->disconnect(fmcomms2_source_f32c_, 0, file_sink_, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
gr::basic_block_sptr Fmcomms2SignalSource::get_left_block()
|
|
{
|
|
LOG(WARNING) << "Trying to get signal source left block.";
|
|
return gr::basic_block_sptr();
|
|
}
|
|
|
|
|
|
gr::basic_block_sptr Fmcomms2SignalSource::get_right_block()
|
|
{
|
|
if (samples_ != 0)
|
|
{
|
|
return valve_;
|
|
}
|
|
else
|
|
{
|
|
return (fmcomms2_source_f32c_);
|
|
}
|
|
}
|