code cleaning

src/algorithms/channel/adapters/channel.cc

@@ -48,14 +48,14 @@ Channel::Channel(ConfigurationInterface *configuration, unsigned int channel,
         std::string role, std::string implementation, boost::shared_ptr<gr::msg_queue> queue)
 {
 
-    pass_through_=pass_through;
+    pass_through_ = pass_through;
-    acq_=acq;
+    acq_ = acq;
-    trk_=trk;
+    trk_ = trk;
-    nav_=nav;
+    nav_ = nav;
-    role_=role;
+    role_ = role;
-    implementation_=implementation;
+    implementation_ = implementation;
-    channel_=channel;
+    channel_ = channel;
-    queue_=queue;
+    queue_ = queue;
 
     acq_->set_channel(channel_);
     trk_->set_channel(channel_);
@@ -97,7 +97,7 @@ Channel::Channel(ConfigurationInterface *configuration, unsigned int channel,
 
     gnss_signal_ = Gnss_Signal(implementation_);
 
-    chennel_msg_rx= channel_msg_receiver_make_cc(&channel_fsm_, repeat_);
+    channel_msg_rx = channel_msg_receiver_make_cc(&channel_fsm_, repeat_);
 
 }
 
@@ -128,12 +128,12 @@ void Channel::connect(gr::top_block_sptr top_block)
     DLOG(INFO) << "tracking -> telemetry_decoder";
 
     // Message ports
-    top_block->msg_connect(nav_->get_left_block(),pmt::mp("preamble_timestamp_s"),trk_->get_right_block(),pmt::mp("preamble_timestamp_s"));
+    top_block->msg_connect(nav_->get_left_block(), pmt::mp("preamble_timestamp_s"), trk_->get_right_block(), pmt::mp("preamble_timestamp_s"));
     DLOG(INFO) << "MSG FEEDBACK CHANNEL telemetry_decoder -> tracking";
 
     //std::cout<<"has port: "<<trk_->get_right_block()->has_msg_port(pmt::mp("events"))<<std::endl;
-    top_block->msg_connect(acq_->get_right_block(),pmt::mp("events"), chennel_msg_rx,pmt::mp("events"));
+    top_block->msg_connect(acq_->get_right_block(), pmt::mp("events"), channel_msg_rx, pmt::mp("events"));
-    top_block->msg_connect(trk_->get_right_block(),pmt::mp("events"), chennel_msg_rx,pmt::mp("events"));
+    top_block->msg_connect(trk_->get_right_block(), pmt::mp("events"), channel_msg_rx, pmt::mp("events"));
 
     connected_ = true;
 }
@@ -156,11 +156,13 @@ void Channel::disconnect(gr::top_block_sptr top_block)
     connected_ = false;
 }
 
+
 gr::basic_block_sptr Channel::get_left_block()
 {
     return pass_through_->get_left_block();
 }
 
+
 gr::basic_block_sptr Channel::get_right_block()
 {
     return nav_->get_right_block();
@@ -180,6 +182,7 @@ void Channel::set_signal(const Gnss_Signal& gnss_signal)
     nav_->set_satellite(gnss_signal_.get_satellite());
 }
 
+
 void Channel::start_acquisition()
 {
     channel_fsm_.Event_start_acquisition();

src/algorithms/channel/adapters/channel.h

@@ -87,7 +87,7 @@ public:
 
 
 private:
-    channel_msg_receiver_cc_sptr chennel_msg_rx;
+    channel_msg_receiver_cc_sptr channel_msg_rx;
     GNSSBlockInterface *pass_through_;
     AcquisitionInterface *acq_;
     TrackingInterface *trk_;

src/algorithms/channel/libs/channel_msg_receiver_cc.cc

@@ -1,6 +1,6 @@
 /*!
  * \file channel_msg_receiver_cc.cc
- * \brief GNURadio block that receives asynchronous channel messages from acquisition and tracking blocks
+ * \brief GNU Radio block that receives asynchronous channel messages from acquisition and tracking blocks
  * \author Javier Arribas, 2016. jarribas(at)cttc.es
  *
  * -------------------------------------------------------------------------
@@ -44,51 +44,54 @@ channel_msg_receiver_cc_sptr channel_msg_receiver_make_cc(ChannelFsm* channel_fs
 
 void channel_msg_receiver_cc::msg_handler_events(pmt::pmt_t msg)
 {
-    try {
+    try
-        long int message=pmt::to_long(msg);
-        switch (message)
-        {
-        case 1: //positive acquisition
-            //DLOG(INFO) << "Channel " << channel_ << " ACQ SUCCESS satellite " <<
-            //    gnss_synchro_.System << " " << gnss_synchro_.PRN;
-            d_channel_fsm->Event_valid_acquisition();
-            break;
-        case 2: //negative acquisition
-            //DLOG(INFO) << "Channel " << channel_
-            //    << " ACQ FAILED satellite " << gnss_synchro_.System << " " << gnss_synchro_.PRN;
-            if (d_repeat == true)
-                {
-                    d_channel_fsm->Event_failed_acquisition_repeat();
-                }
-            else
-                {
-                    d_channel_fsm->Event_failed_acquisition_no_repeat();
-                }
-            break;
-        case 3: // tracking loss of lock event
-            d_channel_fsm->Event_failed_tracking_standby();
-            break;
-        default:
-            LOG(WARNING) << "Default case, invalid message.";
-            break;
-        }
-    }catch(boost::bad_any_cast& e)
     {
-            LOG(WARNING) << "msg_handler_telemetry Bad any cast!\n";
+            long int message = pmt::to_long(msg);
+            switch (message)
+            {
+            case 1: //positive acquisition
+                //DLOG(INFO) << "Channel " << channel_ << " ACQ SUCCESS satellite " <<
+                //    gnss_synchro_.System << " " << gnss_synchro_.PRN;
+                d_channel_fsm->Event_valid_acquisition();
+                break;
+            case 2: //negative acquisition
+                //DLOG(INFO) << "Channel " << channel_
+                //    << " ACQ FAILED satellite " << gnss_synchro_.System << " " << gnss_synchro_.PRN;
+                if (d_repeat == true)
+                    {
+                        d_channel_fsm->Event_failed_acquisition_repeat();
+                    }
+                else
+                    {
+                        d_channel_fsm->Event_failed_acquisition_no_repeat();
+                    }
+                break;
+            case 3: // tracking loss of lock event
+                d_channel_fsm->Event_failed_tracking_standby();
+                break;
+            default:
+                LOG(WARNING) << "Default case, invalid message.";
+                break;
+            }
+    }
+    catch(boost::bad_any_cast& e)
+    {
+            LOG(WARNING) << "msg_handler_telemetry Bad any cast!";
     }
 }
 
+
 channel_msg_receiver_cc::channel_msg_receiver_cc(ChannelFsm* channel_fsm, bool repeat) :
     gr::block("channel_msg_receiver_cc", gr::io_signature::make(0, 0, 0), gr::io_signature::make(0, 0, 0))
 {
-
     this->message_port_register_in(pmt::mp("events"));
     this->set_msg_handler(pmt::mp("events"), boost::bind(&channel_msg_receiver_cc::msg_handler_events, this, _1));
 
-    d_channel_fsm=channel_fsm;
+    d_channel_fsm = channel_fsm;
-    d_repeat=repeat;
+    d_repeat = repeat;
 }
 
+
 channel_msg_receiver_cc::~channel_msg_receiver_cc()
 {}
 

src/algorithms/channel/libs/channel_msg_receiver_cc.h

@@ -1,6 +1,6 @@
 /*!
  * \file channel_msg_receiver_cc.h
- * \brief GNURadio block that receives asynchronous channel messages from acquisition and tracking blocks
+ * \brief GNU Radio block that receives asynchronous channel messages from acquisition and tracking blocks
  * \author Javier Arribas, 2016. jarribas(at)cttc.es
  *
  * -------------------------------------------------------------------------
@@ -41,7 +41,7 @@ typedef boost::shared_ptr<channel_msg_receiver_cc> channel_msg_receiver_cc_sptr;
 channel_msg_receiver_cc_sptr channel_msg_receiver_make_cc(ChannelFsm* channel_fsm, bool repeat);
 
 /*!
- * \brief This class implements a block that computes the PVT solution with Galileo E1 signals
+ * \brief GNU Radio block that receives asynchronous channel messages from acquisition and tracking blocks
  */
 class channel_msg_receiver_cc : public gr::block
 {