From 8d2bc49fb9e0c9a5fbd75aa3cad207608e72bf99 Mon Sep 17 00:00:00 2001 From: Piotr Krysik Date: Tue, 30 Jun 2009 23:03:33 +0200 Subject: moved gsm-receiver into directory - preparation to move to airprobe --- gsm-receiver/src/lib/gsm_receiver_cf.h | 254 +++++++++++++++++++++++++++++++++ 1 file changed, 254 insertions(+) create mode 100644 gsm-receiver/src/lib/gsm_receiver_cf.h (limited to 'gsm-receiver/src/lib/gsm_receiver_cf.h') diff --git a/gsm-receiver/src/lib/gsm_receiver_cf.h b/gsm-receiver/src/lib/gsm_receiver_cf.h new file mode 100644 index 0000000..21cb1ff --- /dev/null +++ b/gsm-receiver/src/lib/gsm_receiver_cf.h @@ -0,0 +1,254 @@ +/* -*- c++ -*- */ +/* + * @file + * @author Piotr Krysik + * @section LICENSE + * + * This program 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, or (at your option) + * any later version. + * + * This program 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 this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ +#ifndef INCLUDED_GSM_RECEIVER_CF_H +#define INCLUDED_GSM_RECEIVER_CF_H + +#include +#include +#include +#include +#include +#include +#include + +#include //TODO: remember to remove this line in the future! +#include "GSML1FEC.h" //!! +#include //!! +#include //!! +#include //!! + +class gsm_receiver_cf; + +typedef boost::shared_ptr gsm_receiver_cf_sptr; +typedef std::vector vector_complex; + +gsm_receiver_cf_sptr gsm_make_receiver_cf(gr_feval_dd *tuner, gr_feval_dd *synchronizer, int osr, std::string key); + +/** 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 + */ + +class gsm_receiver_cf : public gr_block +{ + private: + std::map d_hex_to_int; + FILE * d_gsm_file; //!! + byte d_KC[8]; //!! + GSM::TCHFACCHL1Decoder d_tch_decoder1; //!! + GSM::TCHFACCHL1Decoder d_tch_decoder2; //!! + GSM::TCHFACCHL1Decoder d_tch_decoder3; //!! + GSM::TCHFACCHL1Decoder d_tch_decoder4; //!! + GSM::TCHFACCHL1Decoder d_tch_decoder5; //!! + GSM::TCHFACCHL1Decoder d_tch_decoder6; //!! + GSM::TCHFACCHL1Decoder d_tch_decoder7; //!! + /**@name Configuration of the receiver */ + //@{ + const int d_OSR; ///< oversampling ratio + const int d_chan_imp_length; ///< channel impulse length + //@} + + gr_complex d_sch_training_seq[N_SYNC_BITS]; /// d_freq_offset_vals; + + /**@name Identifiers of the BTS extracted from the SCH burst */ + //@{ + int d_ncc; ///< network color code + int d_bcc; ///< base station color code + //@} + + /**@name Internal state of the gsm receiver */ + //@{ + enum states { + first_fcch_search, next_fcch_search, sch_search, // synchronization search part + synchronized // receiver is synchronized in this state + } d_state; + //@} + + /**@name Variables which make internal state in the "synchronized" state */ + //@{ + burst_counter d_burst_nr; ///< frame number and timeslot number + channel_configuration d_channel_conf; ///< mapping of burst_counter to burst_type + //@} + + unsigned d_failed_sch; ///< number of subsequent erroneous SCH bursts + + // GSM Stack + GS_CTX d_gs_ctx;//TODO: remove it! it'a not right place for a decoder + + friend gsm_receiver_cf_sptr gsm_make_receiver_cf(gr_feval_dd *tuner, gr_feval_dd *synchronizer, int osr, std::string key); + gsm_receiver_cf(gr_feval_dd *tuner, gr_feval_dd *synchronizer, int osr, std::string key); + + /** Function whis is used to search a FCCH burst and to compute frequency offset before + * "synchronized" state of the receiver + * + * TODO: Describe the FCCH search algorithm in the documentation + * @param input vector with input signal + * @param nitems number of samples in the input vector + * @return + */ + bool find_fcch_burst(const gr_complex *input, const int nitems); + + /** Computes frequency offset from FCCH burst samples + * + * @param input vector with input samples + * @param first_sample number of the first sample of the FCCH busrt + * @param last_sample number of the last sample of the FCCH busrt + * @return frequency offset + */ + double compute_freq_offset(const gr_complex * input, unsigned first_sample, unsigned last_sample); + + /** Calls d_tuner's method to set frequency offset from Python level + * + * @param freq_offset absolute frequency offset of the received signal + */ + void set_frequency(double freq_offset); + + /** Computes angle between two complex numbers + * + * @param val1 first complex number + * @param val2 second complex number + * @return + */ + inline float compute_phase_diff(gr_complex val1, gr_complex val2); + + /** Function whis is used to get near to SCH burst + * + * @param nitems number of samples in the gsm_receiver's buffer + * @return true if SCH burst is near, false otherwise + */ + bool reach_sch_burst(const int nitems); + + /** Extracts channel impulse response from a SCH burst and computes first sample number of this burst + * + * @param input vector with input samples + * @param chan_imp_resp complex vector where channel impulse response will be stored + * @return number of first sample of the burst + */ + int get_sch_chan_imp_resp(const gr_complex *input, gr_complex * chan_imp_resp); + + /** MLSE detection of a burst bits + * + * Detects bits of burst using viterbi algorithm. + * @param input vector with input samples + * @param chan_imp_resp vector with the channel impulse response + * @param burst_start number of the first sample of the burst + * @param output_binary vector with output bits + */ + void detect_burst(const gr_complex * input, gr_complex * chan_imp_resp, int burst_start, unsigned char * output_binary); + + /** Encodes differentially input bits and maps them into MSK states + * + * @param input vector with input bits + * @param nitems number of samples in the "input" vector + * @param gmsk_output bits mapped into MSK states + * @param start_point first state + */ + void gmsk_mapper(const unsigned char * input, int nitems, gr_complex * gmsk_output, gr_complex start_point); + + /** Correlates MSK mapped sequence with input signal + * + * @param sequence MKS mapped sequence + * @param length length of the sequence + * @param input_signal vector with input samples + * @return correlation value + */ + gr_complex correlate_sequence(const gr_complex * sequence, int length, const gr_complex * input); + + /** Computes autocorrelation of input vector for positive arguments + * + * @param input vector with input samples + * @param out output vector + * @param nitems length of the input vector + */ + inline void autocorrelation(const gr_complex * input, gr_complex * out, int nitems); + + /** Filters input signal through channel impulse response + * + * @param input vector with input samples + * @param nitems number of samples to pass through filter + * @param filter filter taps - channel impulse response + * @param filter_length nember of filter taps + * @param output vector with filtered samples + */ + inline void mafi(const gr_complex * input, int nitems, gr_complex * filter, int filter_length, gr_complex * output); + + /** Extracts channel impulse response from a normal burst and computes first sample number of this burst + * + * @param input vector with input samples + * @param chan_imp_resp complex vector where channel impulse response will be stored + * @param search_range possible absolute offset of a channel impulse response start + * @param bcc base station color code - number of a training sequence + * @return first sample number of normal burst + */ + int get_norm_chan_imp_resp(const gr_complex * input, gr_complex * chan_imp_resp, int bcc); + + + /** + * + */ + void read_key(std::string key); + + /** + * + */ + void process_normal_burst(burst_counter burst_nr, const unsigned char * burst_binary); + + /** + * + */ + void configure_receiver(); + + + + public: + ~gsm_receiver_cf(); + void forecast(int noutput_items, gr_vector_int &ninput_items_required); + int general_work(int noutput_items, + gr_vector_int &ninput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items); +}; + +#endif /* INCLUDED_GSM_RECEIVER_CF_H */ -- cgit v1.2.3