GNU Radio's GSM Package: receiver_impl.h Source File

GNU Radio's GSM Package

receiver_impl.h
Go to the documentation of this file.
1 /* -*- c++ -*- */
2 /*
3 * @file
4 * @author (C) 2009-2017 by Piotr Krysik <ptrkrysik@gmail.com>
5 * @section LICENSE
6 *
7 * Gr-gsm is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 3, or (at your option)
10 * any later version.
11 *
12 * Gr-gsm is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with gr-gsm; see the file COPYING. If not, write to
19 * the Free Software Foundation, Inc., 51 Franklin Street,
20 * Boston, MA 02110-1301, USA.
21 */
22
23 #ifndef INCLUDED_GSM_RECEIVER_IMPL_H
24 #define INCLUDED_GSM_RECEIVER_IMPL_H
25
26 #include <grgsm/receiver/receiver.h>
27 #include <grgsm/gsmtap.h>
28 #include <gsm_constants.h>
29 #include <receiver_config.h>
30 #include <vector>
31
32 namespace gr {
33 namespace gsm {
34 class receiver_impl : public receiver
35 {
36 private:
37 unsigned int d_c0_burst_start;
38 float d_c0_signal_dbm;
39
40 /**@name Configuration of the receiver */
41 //@{
42 const int d_OSR; ///< oversampling ratio
43 bool d_process_uplink;
44 const int d_chan_imp_length; ///< channel impulse length
45 float d_signal_dbm;
46 std::vector<int> d_tseq_nums; ///< stores training sequence numbers for channels different than C0
47 std::vector<int> d_cell_allocation; ///< stores cell allocation - absolute rf channel numbers (ARFCNs) assigned to the given cell. The variable should at least contain C0 channel number.
48 //@}
49
50 gr_complex d_sch_training_seq[N_SYNC_BITS]; ///<encoded training sequence of a SCH burst
51 gr_complex d_norm_training_seq[TRAIN_SEQ_NUM][N_TRAIN_BITS]; ///<encoded training sequences of a normal and dummy burst
52
53 float d_last_time;
54
55 /** Counts samples consumed by the receiver
56 *
57 * It is used in beetween find_fcch_burst and reach_sch_burst calls.
58 * My intention was to synchronize this counter with some internal sample
59 * counter of the USRP. Simple access to such USRP's counter isn't possible
60 * so this variable isn't used in the "synchronized" state of the receiver yet.
61 */
62 unsigned d_counter;
63
64 /**@name Variables used to store result of the find_fcch_burst fuction */
65 //@{
66 bool d_freq_offset_tag_in_fcch; ///< frequency offset tag presence
67 unsigned d_fcch_start_pos; ///< position of the first sample of the fcch burst
68 float d_freq_offset_setting; ///< frequency offset set in frequency shifter located upstream
69 //@}
70 std::list<double> d_freq_offset_vals;
71
72 /**@name Identifiers of the BTS extracted from the SCH burst */
73 //@{
74 int d_ncc; ///< network color code
75 int d_bcc; ///< base station color code
76 //@}
77
78 /**@name Internal state of the gsm receiver */
79 //@{
80 enum states {
81 fcch_search, sch_search, // synchronization search part
82 synchronized // receiver is synchronized in this state
83 } d_state;
84 //@}
85
86 /**@name Variables which make internal state in the "synchronized" state */
87 //@{
88 burst_counter d_burst_nr; ///< frame number and timeslot number
89 channel_configuration d_channel_conf; ///< mapping of burst_counter to burst_type
90 //@}
91
92 unsigned d_failed_sch; ///< number of subsequent erroneous SCH bursts
93
94 /** Function whis is used to search a FCCH burst and to compute frequency offset before
95 * "synchronized" state of the receiver
96 *
97 * @param input vector with input signal
98 * @param nitems number of samples in the input vector
99 * @return
100 */
101 bool find_fcch_burst(const gr_complex *input, const int nitems, double & computed_freq_offset);
102
103 /** Computes frequency offset from FCCH burst samples
104 *
105 * @param[in] input vector with input samples
106 * @param[in] first_sample number of the first sample of the FCCH busrt
107 * @param[in] last_sample number of the last sample of the FCCH busrt
108 * @param[out] computed_freq_offset contains frequency offset estimate if FCCH burst was located
109 * @return true if frequency offset was faound
110 */
111 double compute_freq_offset(const gr_complex * input, unsigned first_sample, unsigned last_sample);
112 /** Computes angle between two complex numbers
113 *
114 * @param val1 first complex number
115 * @param val2 second complex number
116 * @return
117 */
118 inline float compute_phase_diff(gr_complex val1, gr_complex val2);
119
120 /** Function whis is used to get near to SCH burst
121 *
122 * @param nitems number of samples in the gsm_receiver's buffer
123 * @return true if SCH burst is near, false otherwise
124 */
125 bool reach_sch_burst(const int nitems);
126
127 /** Extracts channel impulse response from a SCH burst and computes first sample number of this burst
128 *
129 * @param input vector with input samples
130 * @param chan_imp_resp complex vector where channel impulse response will be stored
131 * @return number of first sample of the burst
132 */
133 int get_sch_chan_imp_resp(const gr_complex *input, gr_complex * chan_imp_resp);
134
135 /** MLSE detection of a burst bits
136 *
137 * Detects bits of burst using viterbi algorithm.
138 * @param input vector with input samples
139 * @param chan_imp_resp vector with the channel impulse response
140 * @param burst_start number of the first sample of the burst
141 * @param output_binary vector with output bits
142 */
143 void detect_burst(const gr_complex * input, gr_complex * chan_imp_resp, int burst_start, unsigned char * output_binary);
144
145 /** Encodes differentially input bits and maps them into MSK states
146 *
147 * @param input vector with input bits
148 * @param nitems number of samples in the "input" vector
149 * @param gmsk_output bits mapped into MSK states
150 * @param start_point first state
151 */
152 void gmsk_mapper(const unsigned char * input, int nitems, gr_complex * gmsk_output, gr_complex start_point);
153
154 /** Correlates MSK mapped sequence with input signal
155 *
156 * @param sequence MKS mapped sequence
157 * @param length length of the sequence
158 * @param input_signal vector with input samples
159 * @return correlation value
160 */
161 gr_complex correlate_sequence(const gr_complex * sequence, int length, const gr_complex * input);
162
163 /** Computes autocorrelation of input vector for positive arguments
164 *
165 * @param input vector with input samples
166 * @param out output vector
167 * @param nitems length of the input vector
168 */
169 inline void autocorrelation(const gr_complex * input, gr_complex * out, int nitems);
170
171 /** Filters input signal through channel impulse response
172 *
173 * @param input vector with input samples
174 * @param nitems number of samples to pass through filter
175 * @param filter filter taps - channel impulse response
176 * @param filter_length nember of filter taps
177 * @param output vector with filtered samples
178 */
179 inline void mafi(const gr_complex * input, int nitems, gr_complex * filter, int filter_length, gr_complex * output);
180
181 /** Extracts channel impulse response from a normal burst and computes first sample number of this burst
182 *
183 * @param input vector with input samples
184 * @param chan_imp_resp complex vector where channel impulse response will be stored
185 * @param search_range possible absolute offset of a channel impulse response start
186 * @param bcc base station color code - number of a training sequence
187 * @return first sample number of normal burst
188 */
189 int get_norm_chan_imp_resp(const gr_complex *input, gr_complex * chan_imp_resp, float *corr_max, int bcc);
190
191 /**
192 * Sends burst through a C0 (for burst from C0 channel) or Cx (for other bursts) message port
193 *
194 * @param burst_nr - frame number of the burst
195 * @param burst_binary - content of the burst
196 * @b_type - type of the burst
197 */
198 void send_burst(burst_counter burst_nr, const unsigned char * burst_binary, uint8_t burst_type, unsigned int input_nr);
199
200 /**
201 * Configures burst types in different channels
202 */
203 void configure_receiver();
204
205 /* State machine handlers */
206 void fcch_search_handler(gr_complex *input, int noutput_items);
207 void sch_search_handler(gr_complex *input, int noutput_items);
208 void synchronized_handler(gr_complex *input,
209 gr_vector_const_void_star &input_items, int noutput_items);
210
211 public:
212 receiver_impl(int osr, const std::vector<int> &cell_allocation, const std::vector<int> &tseq_nums, bool process_uplink);
213 ~receiver_impl();
214
215 int work(int noutput_items, gr_vector_const_void_star &input_items, gr_vector_void_star &output_items);
216 virtual void set_cell_allocation(const std::vector<int> &cell_allocation);
217 virtual void set_tseq_nums(const std::vector<int> & tseq_nums);
218 virtual void reset();
219 };
220 } // namespace gsm
221 } // namespace gr
222
223 #endif /* INCLUDED_GSM_RECEIVER_IMPL_H */
224
channel_configuration
Definition: receiver_config.h:131
gr::gsm::receiver_impl::set_cell_allocation
virtual void set_cell_allocation(const std::vector< int > &cell_allocation)
gr::gsm::receiver_impl::reset
virtual void reset()
gr::gsm::receiver_impl::work
int work(int noutput_items, gr_vector_const_void_star &input_items, gr_vector_void_star &output_items)
N_TRAIN_BITS
#define N_TRAIN_BITS
Definition: gsm_constants.h:36
TRAIN_SEQ_NUM
#define TRAIN_SEQ_NUM
Definition: gsm_constants.h:92
burst_type
burst_type
Definition: gsm_constants.h:62
gsm_constants.h
receiver.h
gr
Definition: constants.h:29
gsmtap.h
N_SYNC_BITS
#define N_SYNC_BITS
Definition: gsm_constants.h:37
gr::gsm::receiver_impl::receiver_impl
receiver_impl(int osr, const std::vector< int > &cell_allocation, const std::vector< int > &tseq_nums, bool process_uplink)
gr::gsm::receiver_impl::~receiver_impl
~receiver_impl()
receiver_config.h
burst_counter
Definition: receiver_config.h:67
gr::gsm::receiver_impl
Definition: receiver_impl.h:34
gr::gsm::receiver_impl::set_tseq_nums
virtual void set_tseq_nums(const std::vector< int > &tseq_nums)
gr::gsm::receiver
<+description of block+>
Definition: receiver.h:40