From b873c75e3aa74c2c4e8ff17127c89ba06a19aba0 Mon Sep 17 00:00:00 2001
From: Piotr Krysik <perper@o2.pl>
Date: Thu, 11 Jun 2009 12:13:19 +0200
Subject: doxygen coments - start, changes to sch search process

---
 src/lib/Assert.h           |   2 +-
 src/lib/gsm_receiver_cf.cc |  27 +++++-----
 src/lib/gsm_receiver_cf.h  | 132 ++++++++++++++++++++++++++++++++++++++-------
 3 files changed, 129 insertions(+), 32 deletions(-)

(limited to 'src')

diff --git a/src/lib/Assert.h b/src/lib/Assert.h
index acfb3f7..dd222b0 100644
--- a/src/lib/Assert.h
+++ b/src/lib/Assert.h
@@ -26,7 +26,7 @@
 #include "stdio.h"
 #include <iostream>
 
-#define NDEBUG
+// #define NDEBUG
 
 /**@name Macros for standard messages. */
 //@{
diff --git a/src/lib/gsm_receiver_cf.cc b/src/lib/gsm_receiver_cf.cc
index 3f8602a..827c600 100644
--- a/src/lib/gsm_receiver_cf.cc
+++ b/src/lib/gsm_receiver_cf.cc
@@ -113,8 +113,8 @@ gsm_receiver_cf::gsm_receiver_cf(gr_feval_dd *tuner, int osr)
     d_OSR(osr),
     d_chan_imp_length(CHAN_IMP_RESP_LENGTH),
     d_tuner(tuner),
-    d_counter(0),
-    d_fcch_start_pos(0),
+    d_samples_counter(0),
+//     d_fcch_start_pos(0),
     d_freq_offset(0),
     d_burst_nr(osr),
     d_state(first_fcch_search)
@@ -166,9 +166,10 @@ gsm_receiver_cf::general_work(int noutput_items,
     case next_fcch_search:
       prev_freq_offset = d_freq_offset;
       if (find_fcch_burst(in, ninput_items[0])) {
-        if (abs(d_freq_offset) > 100) {
+        if (abs(d_freq_offset) > 100.0) {
           set_frequency(d_freq_offset);
         }
+        d_samples_counter = 0;
         produced_out = 0;
         d_state = sch_search;
       } else {
@@ -389,10 +390,11 @@ bool gsm_receiver_cf::find_fcch_burst(const gr_complex *in, const int nitems)
         break;
 
       case fcch_found:
-        DCOUT("fcch found on position: " << d_counter + start_pos);
+//         DCOUT("fcch found on position: " << d_samples_counter + start_pos);
+        DCOUT("fcch found on position: " << start_pos);
         to_consume = start_pos + FCCH_HITS_NEEDED * d_OSR + 1;
 
-        d_fcch_start_pos = d_counter + start_pos;
+//         d_fcch_start_pos = d_samples_counter + start_pos;
         freq_offset = compute_freq_offset(best_sum, FCCH_HITS_NEEDED);
         d_freq_offset -= freq_offset;
         DCOUT("freq_offset: " << d_freq_offset);
@@ -408,7 +410,7 @@ bool gsm_receiver_cf::find_fcch_burst(const gr_complex *in, const int nitems)
     }
   }
 
-  d_counter += to_consume;
+//   d_samples_counter += to_consume;
   consume_each(to_consume);
 
   return result;
@@ -438,8 +440,9 @@ bool gsm_receiver_cf::find_sch_burst(const gr_complex *in, const int nitems , fl
   int to_consume = 0;
   bool end = false;
   bool result = false;
-  unsigned sample_nr_near_sch_start = d_fcch_start_pos + (FRAME_BITS - SAFETY_MARGIN) * d_OSR;
-
+//   unsigned sample_nr_near_sch_start = d_fcch_start_pos + (FRAME_BITS - SAFETY_MARGIN) * d_OSR;
+  const unsigned sample_nr_near_sch_start = (FRAME_BITS - SAFETY_MARGIN + TS_BITS) * d_OSR;
+  
   enum states {
     start, reach_sch, search_not_finished, sch_found
   } sch_search_state;
@@ -450,7 +453,7 @@ bool gsm_receiver_cf::find_sch_burst(const gr_complex *in, const int nitems , fl
     switch (sch_search_state) {
 
       case start:
-        if (d_counter < sample_nr_near_sch_start) {
+        if (d_samples_counter < sample_nr_near_sch_start) {
           sch_search_state = reach_sch;
         } else {
           sch_search_state = sch_found;
@@ -458,8 +461,8 @@ bool gsm_receiver_cf::find_sch_burst(const gr_complex *in, const int nitems , fl
         break;
 
       case reach_sch:
-        if (d_counter + nitems >= sample_nr_near_sch_start) {
-          to_consume = sample_nr_near_sch_start - d_counter;
+        if (d_samples_counter + nitems >= sample_nr_near_sch_start) {
+          to_consume = sample_nr_near_sch_start - d_samples_counter;
         } else {
           to_consume = nitems;
         }
@@ -479,7 +482,7 @@ bool gsm_receiver_cf::find_sch_burst(const gr_complex *in, const int nitems , fl
     }
   }
 
-  d_counter += to_consume;
+  d_samples_counter += to_consume;
   consume_each(to_consume);
   return result;
 }
diff --git a/src/lib/gsm_receiver_cf.h b/src/lib/gsm_receiver_cf.h
index 8e30b42..ce05b81 100644
--- a/src/lib/gsm_receiver_cf.h
+++ b/src/lib/gsm_receiver_cf.h
@@ -1,8 +1,8 @@
 /* -*- c++ -*- */
 /*
- * Copyright 2004 Free Software Foundation, Inc.
- *
- * This file is part of GNU Radio
+ * @file
+ * @author Piotr Krysik <pkrysik@stud.elka.pw.edu.pl>
+ * @section LICENSE 
  *
  * GNU Radio is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -34,35 +34,30 @@ class gsm_receiver_cf;
 typedef boost::shared_ptr<gsm_receiver_cf> gsm_receiver_cf_sptr;
 typedef std::vector<gr_complex> vector_complex;
 
-/*!
- * \brief Return a shared_ptr to a new instance of gsm_receiver_cf.
- *
- * To avoid accidental use of raw pointers, gsm_receiver_cf's
- * constructor is private.  howto_make_square_ff is the public
- * interface for creating new instances.
- */
 gsm_receiver_cf_sptr gsm_make_receiver_cf(gr_feval_dd *tuner, int osr);
 
-/*!
- * \brief Receives fcch
+/** GSM Receiver GNU Radio block
+ * GSM Receiver class supports frequency correction, synchronisation and
+ * MLSE (Maximum Likelihood Sequence Estimation) estimation of synchronisation 
+ * bursts and normal bursts.
  * \ingroup block
- * \sa
  */
 
 class gsm_receiver_cf : public gr_block
 {
   private:
+    
     const int d_OSR;
     const int d_chan_imp_length;
 
-    gr_complex d_sch_training_seq[N_SYNC_BITS]; //encoded training sequence of a SCH burst
-    gr_complex d_norm_training_seq[TRAIN_SEQ_NUM][N_TRAIN_BITS];
-    
-    gr_feval_dd *d_tuner;
-    unsigned d_counter;
+    gr_complex d_sch_training_seq[N_SYNC_BITS]; ///<encoded training sequence of a SCH burst
+    gr_complex d_norm_training_seq[TRAIN_SEQ_NUM][N_TRAIN_BITS]; ///<encoded training sequences of a normal bursts and dummy bursts
+
+    gr_feval_dd *d_tuner; ///<callback to a python object which is used for frequency tunning
+    unsigned d_samples_counter; ///<samples counter - this is used in beetween find_fcch_burst and find_sch_burst
 
     //variables used to store result of the find_fcch_burst fuction
-    int d_fcch_start_pos;
+//     unsigned d_fcch_start_pos; 
     float d_freq_offset;
 
     burst_counter d_burst_nr;
@@ -81,20 +76,119 @@ class gsm_receiver_cf : public gr_block
     friend gsm_receiver_cf_sptr gsm_make_receiver_cf(gr_feval_dd *tuner, int osr);
     gsm_receiver_cf(gr_feval_dd *tuner, int osr);
 
+    
+    /**
+     * 
+     * @param in 
+     * @param nitems 
+     * @return 
+     */
     bool find_fcch_burst(const gr_complex *in, const int nitems);
+    
+    /**
+     * 
+     * @param best_sum 
+     * @param denominator 
+     * @return 
+     */
     double compute_freq_offset(double best_sum, unsigned denominator);
+    
+    /**
+     * 
+     * @param freq_offset 
+     */
     void set_frequency(double freq_offset);
+    
+    /**
+     * 
+     * @param val1 
+     * @param val2 
+     * @return 
+     */
     inline float compute_phase_diff(gr_complex val1, gr_complex val2);
 
+    /**
+     * 
+     * @param in 
+     * @param nitems 
+     * @param out 
+     * @return 
+     */
     bool find_sch_burst(const gr_complex *in, const int nitems , float *out);
+    
+    /**
+     * 
+     * @param in 
+     * @param chan_imp_resp 
+     * @return 
+     */
     int get_sch_chan_imp_resp(const gr_complex *in, gr_complex * chan_imp_resp);
+    
+    /**
+     * 
+     * @param in 
+     * @param chan_imp_resp 
+     * @param burst_start 
+     * @param output_binary 
+     */
     void detect_burst(const gr_complex * in, gr_complex * chan_imp_resp, int burst_start, unsigned char * output_binary);
+    
+    /**
+     * 
+     * @param input 
+     * @param ninput 
+     * @param gmsk_output 
+     * @param start_point 
+     */
     void gmsk_mapper(const unsigned char * input, int ninput, gr_complex * gmsk_output, gr_complex start_point);
+    
+    /**
+     * 
+     * @param sequence 
+     * @param input_signal 
+     * @param ninput 
+     * @return 
+     */
     gr_complex correlate_sequence(const gr_complex * sequence, const gr_complex * input_signal, int ninput);
+    
+    /**
+     * 
+     * @param input 
+     * @param out 
+     * @param length 
+     */
     inline void autocorrelation(const gr_complex * input, gr_complex * out, int length);
+    
+    /**
+     * 
+     * @param input 
+     * @param input_length 
+     * @param filter 
+     * @param filter_length 
+     * @param output 
+     */
     inline void mafi(const gr_complex * input, int input_length, gr_complex * filter, int filter_length, gr_complex * output);
+    
+    /**
+     * 
+     * @param in 
+     * @param chan_imp_resp 
+     * @param search_range 
+     * @param bcc 
+     * @return 
+     */
     int get_norm_chan_imp_resp(const gr_complex *in, gr_complex * chan_imp_resp, unsigned search_range, int bcc);
+    
+    /**
+     * 
+     * @param burst_nr 
+     * @param pakiet 
+     */
     void przetwarzaj_normalny_pakiet(burst_counter burst_nr, unsigned char * pakiet);
+    
+    /**
+     * 
+     */
     void konfiguruj_odbiornik();
 
   public:
-- 
cgit v1.2.3