gnss-sdr代码解读（5）

gnss-sdr代码解读（5）

作者微信公众号：小卫星

 

操作系统： Windows 10

 

这篇是接着上一篇的，但是没有必然联系，上一篇地址：

https://blog.csdn.net/eaglesoars/article/details/81074063

1、Gnss_Synchro

今天看Gnss_Synchro这个类，这个类包含了信号处理模块所共需的一些信息。

这个类在 gnss-sdr/src/core/system_parameters/gnss_synchro.h 中定义：

class Gnss_Synchro
{
public:
    // Satellite and signal info
    char System;       //!< Set by Channel::set_signal(Gnss_Signal gnss_signal)
    char Signal[3];    //!< Set by Channel::set_signal(Gnss_Signal gnss_signal)
    unsigned int PRN;  //!< Set by Channel::set_signal(Gnss_Signal gnss_signal)
    int Channel_ID;    //!< Set by Channel constructor
    // Acquisition
    double Acq_delay_samples;                   //!< Set by Acquisition processing block
    double Acq_doppler_hz;                      //!< Set by Acquisition processing block
    unsigned long int Acq_samplestamp_samples;  //!< Set by Acquisition processing block
    bool Flag_valid_acquisition;                //!< Set by Acquisition processing block
    //Tracking
    long int fs;                                //!< Set by Tracking processing block
    double Prompt_I;                            //!< Set by Tracking processing block
    double Prompt_Q;                            //!< Set by Tracking processing block
    double CN0_dB_hz;                           //!< Set by Tracking processing block
    double Carrier_Doppler_hz;                  //!< Set by Tracking processing block
    double Carrier_phase_rads;                  //!< Set by Tracking processing block
    double Code_phase_samples;                  //!< Set by Tracking processing block
    unsigned long int Tracking_sample_counter;  //!< Set by Tracking processing block

这些参数都在各自的信号处理模块中赋值。

但是这个类最重要的是实现了一个函数：

    template 
    void serialize(Archive& ar, const unsigned int version)
    {
        if (version)
            {
            };
        // Satellite and signal info
        ar& System;
        ar& Signal;
        ar& PRN;
        ar& Channel_ID;
        ar& Acq_delay_samples;
        ar& Acq_doppler_hz;
        ar& Acq_samplestamp_samples;
        ar& Flag_valid_acquisition;
        //Tracking
        ar& fs;
        ar& Prompt_I;
        ar& Prompt_Q;
        ar& CN0_dB_hz;
        ar& Carrier_Doppler_hz;
        ar& Carrier_phase_rads;
        ar& Code_phase_samples;
        ar& Tracking_sample_counter;
        ar& Flag_valid_symbol_output;
        ar& correlation_length_ms;
        //Telemetry Decoder
        ar& Flag_valid_word;
        ar& TOW_at_current_symbol_ms;
        // Observables
        ar& Pseudorange_m;
        ar& RX_time;
        ar& Flag_valid_pseudorange;
        ar& interp_TOW_ms;
    }
};

       同志们，你们发现没，这些参数都是上面那些模块中要附的参数。这里把它记下来，其实就是序列化。

       序列化是为了把一个类的一个对象保存到文件中或者通过网络发出去，可以把它弄成一个二进制字节流，或者其他格式表示等等。

       如何发送呢，在gnss-sdr/src/core/monitor/gnss_synchro_udp_sink.cc中

bool Gnss_Synchro_Udp_Sink::write_gnss_synchro(std::vector stocks)
{
    std::ostringstream archive_stream;
    boost::archive::binary_oarchive oa{archive_stream};
    oa << stocks;
    std::string outbound_data = archive_stream.str();

    for (auto endpoint : endpoints)
        {
            socket.open(endpoint.protocol(), error);
            socket.connect(endpoint, error);

            try
                {
                    socket.send(boost::asio::buffer(outbound_data));
                }
            catch (boost::system::system_error const& e)
                {
                    return false;
                }
        }
    return true;
}

其中的

std::ostringstream archive_stream;
boost::archive::binary_oarchive oa{archive_stream};
oa << stocks;
std::string outbound_data = archive_stream.str();
socket.send(boost::asio::buffer(outbound_data));

都是标准手段，是将stocks类序列化到一个ostringstream流中去了。

那么如何从这个流里恢复数据呢，这里给出标准方法：

std::vector stocks2;
std::istringstream is(content);
boost::archive::binary_iarchive ia(is);
ia >> stocks2;//从一个保存序列化数据的string里面反序列化，从而得到原来的对象。

2、Gnss_Synchro_Udp_Sink

 

这个类的目的就是把Gnss_Synchro记录的参数通过UDP方式发出去。

gnss-sdr/src/core/monitor/gnss_synchro_udp_sink.h

3、gnss_synchro_monitor

在monitor目录中还有一个类，gnss_synchro_monitor，首先，它是一个继承自gr::sync_block的类，血统纯正，根正苗红。

class gnss_synchro_monitor : public gr::sync_block

gr::sync_block继承自gr::block并实现了一个1:1的可选的history。既然知道了输入到输出的速度，某些简化是可能的。从实现者的观点看，定义了一个work()方法，而不是general_work()。

work()省略了ninput_items参数，增加consume_each()供调用。

gnss_synchro_monitor::gnss_synchro_monitor(unsigned int n_channels,
    int output_rate_ms,
    int udp_port,
    std::vector udp_addresses) : gr::sync_block("gnss_synchro_monitor",
                                                  gr::io_signature::make(n_channels, n_channels, sizeof(Gnss_Synchro)),
                                                  gr::io_signature::make(0, 0, 0))
{
    d_output_rate_ms = output_rate_ms;
    d_nchannels = n_channels;

    udp_sink_ptr = std::unique_ptr(new Gnss_Synchro_Udp_Sink(udp_addresses, udp_port));
}

这个类首先弄了一个同步模块，叫“gnss_synchro_monitor”，记住，这里面有个参数是udp_port，然后调用了刚才讲过的Gnss_Synchro_Udp_Sink。

int gnss_synchro_monitor::work(int noutput_items, gr_vector_const_void_star& input_items,
    gr_vector_void_star& output_items __attribute__((unused)))
{
    const Gnss_Synchro** in = reinterpret_cast(&input_items[0]);  // Get the input buffer pointer
    for (int epoch = 0; epoch < noutput_items; epoch++)
        {
            // ############ 1. READ PSEUDORANGES ####
            for (unsigned int i = 0; i < d_nchannels; i++)
                {
                    //if (in[i][epoch].Flag_valid_pseudorange)
                    //    {
                    //    }
                    //todo: send the gnss_synchro objects

                    std::vector stocks;
                    stocks.push_back(in[i][epoch]);
                    udp_sink_ptr->write_gnss_synchro(stocks);
                }
        }
    return noutput_items;
}

这个模块有个work方法，主要是把noutput_items个Gnss_Synchro都通过序列化发出去，其中每个noutput_items中还包含有d_nchannels个通道。

 

可见，这个几个类的关系，

（1）gnss_synchro_monitor是信号处理模块，工程总体；

（2）Gnss_Synchro负责收集信息；

（3）Gnss_Synchro_Udp_Sink把信息序列化发出去。

 

https://www.cnblogs.com/moon1992/p/5424677.html