summaryrefslogtreecommitdiff
path: root/gsm-receiver/src/lib
diff options
context:
space:
mode:
Diffstat (limited to 'gsm-receiver/src/lib')
-rw-r--r--gsm-receiver/src/lib/decoder/gsmstack.c92
-rw-r--r--gsm-receiver/src/lib/decoder/gsmstack.h2
-rw-r--r--gsm-receiver/src/lib/gsm.i2
-rw-r--r--gsm-receiver/src/lib/gsm_receiver_cf.cc274
-rw-r--r--gsm-receiver/src/lib/gsm_receiver_cf.h24
-rw-r--r--gsm-receiver/src/lib/gsm_receiver_config.cc21
-rw-r--r--gsm-receiver/src/lib/gsm_receiver_config.h23
7 files changed, 308 insertions, 130 deletions
diff --git a/gsm-receiver/src/lib/decoder/gsmstack.c b/gsm-receiver/src/lib/decoder/gsmstack.c
index 3766268..e5734b9 100644
--- a/gsm-receiver/src/lib/decoder/gsmstack.c
+++ b/gsm-receiver/src/lib/decoder/gsmstack.c
@@ -229,9 +229,8 @@ GS_new(GS_CTX *ctx)
* 142 bit
*/
int
-GS_process(GS_CTX *ctx, int ts, int type, const unsigned char *src, int fn)
+GS_process(GS_CTX *ctx, int ts, int type, const unsigned char *src, int fn, int first_burst)
{
-// int fn;
int bsic;
int ret;
unsigned char *data;
@@ -240,39 +239,49 @@ GS_process(GS_CTX *ctx, int ts, int type, const unsigned char *src, int fn)
memset(ctx->msg, 0, sizeof(ctx->msg));
-#if 0
- if (ts != 0) {
- /* non-0 timeslots should end up in PCAP */
- data = decode_cch(ctx, ctx->burst, &len);
- if (data == NULL)
+ if (ts_ctx->type == TST_TCHF && type == NORMAL) {
+ /* Dieter: we came here because the burst might contain FACCH bits */
+ ctx->fn = fn;
+ ts_ctx->burst_count2 = fn % 26;
+
+ if (ts_ctx->burst_count2 >= 12)
+ ts_ctx->burst_count2--;
+ ts_ctx->burst_count2 = ts_ctx->burst_count2 % 8;
+
+ /* copy data bits and stealing flags to buffer */
+ memcpy(ts_ctx->burst2 + (116 * ts_ctx->burst_count2), src, 58);
+ memcpy(ts_ctx->burst2 + (116 * ts_ctx->burst_count2) + 58, src + 58 + 26, 58);
+
+ /* Return if not enough bursts for a full gsm message */
+ if ((ts_ctx->burst_count2 % 4) != 3)
+ return 0;
+
+ data = decode_facch(ctx, ts_ctx->burst2, &len, (ts_ctx->burst_count2 == 3) ? 1 : 0);
+ if (data == NULL) {
+ DEBUGF("cannot decode FACCH fnr=%d ts=%d\n", ctx->fn, ts);
return -1;
-// write_pcap_packet(ctx->pcap_fd, 0 /* arfcn */, ts, ctx->fn, data, len);
- return;
+ }
+
+ out_gsmdecode(0, 0, ts, ctx->fn, data, len);
+
+ if (ctx->gsmtap_fd >= 0) {
+ struct msgb *msg;
+ uint8_t chan_type = GSMTAP_CHANNEL_TCH_F;
+ uint8_t ss = 0;
+ int fn = (ctx->fn - 3); /* "- 3" for start of frame */
+
+ msg = gsmtap_makemsg(0, ts, chan_type, ss, ctx->fn, 0, 0, data, len);
+ if (msg)
+ write(ctx->gsmtap_fd, msg->data, msg->len);
+ }
+ return 0;
}
-#endif
-/* if (ts == 0) {
- if (type == SCH) {
-// ret = decode_sch(src, &fn, &bsic);
- if (ret != 0)
- return 0;
- if ((ctx->bsic > 0) && (bsic != ctx->bsic))
- fprintf(stderr, "WARN: BSIC changed.\n");
- //DEBUGF("FN %d, BSIC %d\n", fn, bsic);
- ctx->fn = fn;
- ctx->bsic = bsic;
- /* Reset message concatenator */
-// ts_ctx->burst_count = 0;
-// return 0;
-// }
-
- /* If we did not get Frame Number yet then return */
-// if (ctx->fn < 0)
-// return 0;
-
-// ctx->fn++;
-// }
- ctx->fn = fn;
+ /* normal burst processing */
+ if (first_burst) /* Dieter: it is important to start with the correct burst */
+ ts_ctx->burst_count = 0;
+
+ ctx->fn = fn;
if (type == NORMAL) {
/* Interested in these frame numbers (cch)
* 2-5, 12-15, 22-25, 23-35, 42-45
@@ -290,18 +299,25 @@ GS_process(GS_CTX *ctx, int ts, int type, const unsigned char *src, int fn)
ts_ctx->burst_count = 0;
data = decode_cch(ctx, ts_ctx->burst, &len);
if (data == NULL) {
- DEBUGF("cannot decode fnr=0x%08x ts=%d\n", ctx->fn, ts);
+ DEBUGF("cannot decode fnr=0x%06x (%6d) ts=%d\n", ctx->fn, ctx->fn, ts);
return -1;
}
//DEBUGF("OK TS %d, len %d\n", ts, len);
- out_gsmdecode(0, 0, ts, ctx->fn - 4, data, len);
+ out_gsmdecode(0, 0, ts, ctx->fn, data, len);
if (ctx->gsmtap_fd >= 0) {
+ /* Dieter: set channel type according to configuration */
struct msgb *msg;
+ uint8_t chan_type = GSMTAP_CHANNEL_BCCH;
+ uint8_t ss = 0;
+ int fn = (ctx->fn - 3); /* "- 3" for start of frame */
+
+ chan_type = get_chan_type(ts_ctx->type, fn, &ss);
+
/* arfcn, ts, chan_type, ss, fn, signal, snr, data, len */
- msg = gsmtap_makemsg(0, ts, GSMTAP_CHANNEL_BCCH, 0,
- ctx->fn-4, 0, 0, data, len);
+ msg = gsmtap_makemsg(0, ts, chan_type, ss,
+ ctx->fn, 0, 0, data, len);
if (msg)
write(ctx->gsmtap_fd, msg->data,
msg->len);
@@ -318,13 +334,15 @@ GS_process(GS_CTX *ctx, int ts, int type, const unsigned char *src, int fn)
/*
- * Output data so that it can be parsed from gsmdeocde.
+ * Output data so that it can be parsed from gsmdecode.
*/
static void
out_gsmdecode(char type, int arfcn, int ts, int fn, char *data, int len)
{
char *end = data + len;
+ printf("%6d %d:", (fn + 0), ts);
+
/* FIXME: speed this up by first printing into an array */
while (data < end)
printf(" %02.2x", (unsigned char)*data++);
diff --git a/gsm-receiver/src/lib/decoder/gsmstack.h b/gsm-receiver/src/lib/decoder/gsmstack.h
index ea84d60..5fceb45 100644
--- a/gsm-receiver/src/lib/decoder/gsmstack.h
+++ b/gsm-receiver/src/lib/decoder/gsmstack.h
@@ -59,7 +59,7 @@ typedef struct
} GS_CTX;
int GS_new(GS_CTX *ctx);
-int GS_process(GS_CTX *ctx, int ts, int type, const unsigned char *src, int fn);
+int GS_process(GS_CTX *ctx, int ts, int type, const unsigned char *src, int fn, int first_burst);
#ifdef __cplusplus
}
diff --git a/gsm-receiver/src/lib/gsm.i b/gsm-receiver/src/lib/gsm.i
index 3a5c561..15af8b7 100644
--- a/gsm-receiver/src/lib/gsm.i
+++ b/gsm-receiver/src/lib/gsm.i
@@ -38,7 +38,7 @@
GR_SWIG_BLOCK_MAGIC(gsm,receiver_cf);
-gsm_receiver_cf_sptr gsm_make_receiver_cf ( gr_feval_dd *tuner, gr_feval_dd *synchronizer, int osr, std::string key);
+gsm_receiver_cf_sptr gsm_make_receiver_cf ( gr_feval_dd *tuner, gr_feval_dd *synchronizer, int osr, std::string key, std::string configuration);
class gsm_receiver_cf : public gr_block
{
diff --git a/gsm-receiver/src/lib/gsm_receiver_cf.cc b/gsm-receiver/src/lib/gsm_receiver_cf.cc
index 80611e3..9feabef 100644
--- a/gsm-receiver/src/lib/gsm_receiver_cf.cc
+++ b/gsm-receiver/src/lib/gsm_receiver_cf.cc
@@ -45,14 +45,25 @@
//FIXME: decide to use this define or not
//TODO: this shouldn't be here - remove it when gsm receiver's interface will be ready
-void decrypt(const unsigned char * burst_binary, byte * KC, float * decrypted_data, unsigned FN)
+void decrypt(const unsigned char * burst_binary, byte * KC, unsigned char * decrypted_data, unsigned FN)
{
byte AtoB[2*DATA_BITS];
+ /* KC is all zero: no decryption */
+
+ if(KC[0] == 0 && KC[1] == 0 && KC[2] == 0 && KC[3] == 0 &
+ KC[4] == 0 && KC[5] == 0 && KC[6] == 0 && KC[7] == 0) {
+ for (int i = 0; i < 148; i++) {
+ decrypted_data[i] = burst_binary[i];
+ }
+ return;
+ }
+
keysetup(KC, FN);
runA51(AtoB);
- for (int i = 0; i < 148; i++) {
+ /* guard bits */
+ for (int i = 0; i < 3; i++) {
decrypted_data[i] = burst_binary[i];
}
@@ -60,13 +71,55 @@ void decrypt(const unsigned char * burst_binary, byte * KC, float * decrypted_da
decrypted_data[i+3] = AtoB[i] ^ burst_binary[i+3];
}
+ /* stealing bits and midamble */
+ for (int i = 60; i < 88; i++) {
+ decrypted_data[i] = burst_binary[i];
+ }
+
for (int i = 0; i < 57; i++) {
decrypted_data[i+88] = AtoB[i+57] ^ burst_binary[i+88];
}
+
+ /* guard bits */
+ for (int i = 145; i < 148; i++) {
+ decrypted_data[i] = burst_binary[i];
+ }
+}
+
+//TODO: this shouldn't be here */
+void dump_bits(const unsigned char * burst_binary, unsigned char * decrypted_data, burst_counter burst_nr, bool first_burst)
+{
+ int i;
+
+ /* Cipher bits */
+ printf("C%d %d %d: ", first_burst, burst_nr.get_frame_nr(), burst_nr.get_frame_nr_mod());
+ for (int i = 0; i < 57; i++)
+ printf("%d", burst_binary[i+3]);
+ for (int i = 0; i < 57; i++)
+ printf("%d", burst_binary[i+88]);
+ printf("\n");
+
+ /* Plain bits */
+ printf("P%d %d %d: ", first_burst, burst_nr.get_frame_nr(), burst_nr.get_frame_nr_mod());
+ for (int i = 0; i < 57; i++)
+ printf("%d", decrypted_data[i+3]);
+ for (int i = 0; i < 57; i++)
+ printf("%d", decrypted_data[i+88]);
+ printf("\n");
+
+ /* Keystream bits */
+ printf("S%d %d %d: ", first_burst, burst_nr.get_frame_nr(), burst_nr.get_frame_nr_mod());
+ for (int i = 0; i < 57; i++)
+ printf("%d", burst_binary[i+3] ^ decrypted_data[i+3]);
+ for (int i = 0; i < 57; i++)
+ printf("%d", burst_binary[i+88] ^ decrypted_data[i+88]);
+ printf("\n");
}
void gsm_receiver_cf::read_key(std::string key)
{
+ printf("Key: '%s'\n", key.c_str());
+
int i;
int b;
for (i = 0;i < 8;i++) {
@@ -75,86 +128,133 @@ void gsm_receiver_cf::read_key(std::string key)
}
}
-void gsm_receiver_cf::process_normal_burst(burst_counter burst_nr, const unsigned char * burst_binary)
+void gsm_receiver_cf::read_configuration(std::string configuration)
{
- float decrypted_data[148];
+ printf("Configuration: '%s'\n", configuration.c_str());
+
+ if ((char)configuration[0] == 0) {
+ printf(" No configuration set.\n");
+ return;
+ }
+
+ /* get timeslot */
+ int ts = atoi(configuration.c_str());
+ if (ts < 0 || ts > 7) {
+ printf(" Invalid TS: %d\n", ts);
+ return;
+ }
+
+ printf(" Configuration TS: %d\n", ts);
+
+ if((char)configuration[1] == 'C')
+ d_gs_ctx.ts_ctx[ts].type = TST_FCCH_SCH_BCCH_CCCH_SDCCH4;
+ else if((char)configuration[1] == 'B')
+ d_gs_ctx.ts_ctx[ts].type = TST_FCCH_SCH_BCCH_CCCH;
+ else if((char)configuration[1] == 'S')
+ d_gs_ctx.ts_ctx[ts].type = TST_SDCCH8;
+ else if((char)configuration[1] == 'T')
+ d_gs_ctx.ts_ctx[ts].type = TST_TCHF;
+ else {
+ printf(" Invalid configuration: %c\n", (char)configuration[1]);
+ return;
+ }
+ /* any other timeslot than 0: turn TS0 off */
+ if(ts != 0) {
+ d_gs_ctx.ts_ctx[0].type = TST_OFF;
+ d_trace_sch = false;
+ printf(" TS0 is turned off\n");
+ }
+}
+
+void gsm_receiver_cf::process_normal_burst(burst_counter burst_nr, const unsigned char * burst_binary, bool first_burst)
+{
+ unsigned char decrypted_data[148];
+ float decrypted_data_float[148];
unsigned char * voice_frame;
+ int ts = burst_nr.get_timeslot_nr();
+
+ /* no processing if turned off*/
+ if (d_gs_ctx.ts_ctx[ts].type == TST_OFF)
+ return;
-// if (burst_nr.get_timeslot_nr() == 7) {
+ /* handle traffic timeslots */
+#if 0
+ /* always try to decrypt and decode traffic in TS 1...7 */
+ /* TODO: this will fail if there is unencrypted traffic in more than one TS */
if (burst_nr.get_timeslot_nr() >= 1 && burst_nr.get_timeslot_nr() <= 7) {
+#else
+ if (d_gs_ctx.ts_ctx[ts].type == TST_TCHF) {
+#endif
decrypt(burst_binary, d_KC, decrypted_data, burst_nr.get_frame_nr_mod());
- GSM::Time time(burst_nr.get_frame_nr(), burst_nr.get_timeslot_nr());
- GSM::RxBurst rxbrst(decrypted_data, time);
- switch (burst_nr.get_timeslot_nr()) {
- case 1:
- if ( d_tch_decoder1.processBurst( rxbrst ) == true) {
- fwrite(d_tch_decoder1.get_voice_frame(), 1 , 33, d_gsm_file);
- }
- break;
- case 2:
- if ( d_tch_decoder2.processBurst( rxbrst ) == true) {
- fwrite(d_tch_decoder2.get_voice_frame(), 1 , 33, d_gsm_file);
- }
- break;
- case 3:
- if ( d_tch_decoder3.processBurst( rxbrst ) == true) {
- fwrite(d_tch_decoder3.get_voice_frame(), 1 , 33, d_gsm_file);
- }
- break;
- case 4:
- if ( d_tch_decoder4.processBurst( rxbrst ) == true) {
- fwrite(d_tch_decoder4.get_voice_frame(), 1 , 33, d_gsm_file);
- }
- break;
- case 5:
- if ( d_tch_decoder5.processBurst( rxbrst ) == true) {
- fwrite(d_tch_decoder5.get_voice_frame(), 1 , 33, d_gsm_file);
- }
- break;
- case 6:
- if ( d_tch_decoder6.processBurst( rxbrst ) == true) {
- fwrite(d_tch_decoder6.get_voice_frame(), 1 , 33, d_gsm_file);
+ int i;
+ for (i = 0; i< 148; i++)
+ decrypted_data_float[i] = decrypted_data[i];
+
+ GSM::Time time(burst_nr.get_frame_nr(), ts);
+ GSM::RxBurst rxbrst(decrypted_data_float, time);
+ if (ts - TIMESLOT1 >= 0 && ts - TIMESLOT1 < N_TCH_DECODER) {
+ if ( d_tch_decoder[ts - TIMESLOT1]->processBurst( rxbrst ) == true) {
+ fwrite(d_tch_decoder[ts - TIMESLOT1]->get_voice_frame(), 1 , 33, d_gsm_file);
}
- break;
- case 7:
- if ( d_tch_decoder7.processBurst( rxbrst ) == true) {
- fwrite(d_tch_decoder7.get_voice_frame(), 1 , 33, d_gsm_file);
+ else if (rxbrst.Hl() || rxbrst.Hu()) {
+ /* Stolen bits are set, might be FACCH */
+ GS_process(&d_gs_ctx, TIMESLOT0 + ts, NORMAL, &decrypted_data[3], burst_nr.get_frame_nr(), first_burst);
}
- break;
}
}
- if (burst_nr.get_timeslot_nr() == 0) {
- GS_process(&d_gs_ctx, TIMESLOT0, 6, &burst_binary[3], burst_nr.get_frame_nr());
+ /* handle SDCCH/8 timeslots */
+ if (d_gs_ctx.ts_ctx[ts].type == TST_SDCCH8) {
+ decrypt(burst_binary, d_KC, decrypted_data, burst_nr.get_frame_nr_mod());
+ #if 1 /* dump cipher, plain and keystream bits */
+ dump_bits(burst_binary, decrypted_data, burst_nr, first_burst);
+ #endif
+ GS_process(&d_gs_ctx, TIMESLOT0 + ts, NORMAL, &decrypted_data[3], burst_nr.get_frame_nr(), first_burst);
}
+
+ /* TS0 is special (TODO) */
+ if (ts == 0) {
+ memcpy(decrypted_data, burst_binary, sizeof(decrypted_data));
+ if (d_gs_ctx.ts_ctx[ts].type == TST_FCCH_SCH_BCCH_CCCH_SDCCH4) {
+ if (SDCCH_SACCH_4_MAP[burst_nr.get_frame_nr() % 51] != 0) { /* SDCCH/4 or SACCH/4 */
+ decrypt(burst_binary, d_KC, decrypted_data, burst_nr.get_frame_nr_mod());
+ #if 1 /* dump cipher, plain and keystream bits */
+ dump_bits(burst_binary, decrypted_data, burst_nr, first_burst);
+ #endif
+ }
+ }
+ GS_process(&d_gs_ctx, TIMESLOT0 + ts, NORMAL, &decrypted_data[3], burst_nr.get_frame_nr(), first_burst);
+ }
+
}
//TODO: this shouldn't be here also - the same reason
void gsm_receiver_cf::configure_receiver()
{
- d_channel_conf.set_multiframe_type(TSC0, multiframe_51);
-
- d_channel_conf.set_burst_types(TSC0, TEST_CCH_FRAMES, sizeof(TEST_CCH_FRAMES) / sizeof(unsigned), dummy_or_normal);
- d_channel_conf.set_burst_types(TSC0, FCCH_FRAMES, sizeof(FCCH_FRAMES) / sizeof(unsigned), fcch_burst);
-
- d_channel_conf.set_multiframe_type(TIMESLOT1, multiframe_26);
- d_channel_conf.set_burst_types(TIMESLOT1, TRAFFIC_CHANNEL_F, sizeof(TRAFFIC_CHANNEL_F) / sizeof(unsigned), dummy_or_normal);
- d_channel_conf.set_multiframe_type(TIMESLOT2, multiframe_26);
- d_channel_conf.set_burst_types(TIMESLOT2, TRAFFIC_CHANNEL_F, sizeof(TRAFFIC_CHANNEL_F) / sizeof(unsigned), dummy_or_normal);
+ int ts;
+ printf("configure_receiver\n");
- d_channel_conf.set_multiframe_type(TIMESLOT3, multiframe_26);
- d_channel_conf.set_burst_types(TIMESLOT3, TRAFFIC_CHANNEL_F, sizeof(TRAFFIC_CHANNEL_F) / sizeof(unsigned), dummy_or_normal);
- d_channel_conf.set_multiframe_type(TIMESLOT4, multiframe_26);
- d_channel_conf.set_burst_types(TIMESLOT4, TRAFFIC_CHANNEL_F, sizeof(TRAFFIC_CHANNEL_F) / sizeof(unsigned), dummy_or_normal);
+ /* configure TS0, TS0 is special (TODO) */
- d_channel_conf.set_multiframe_type(TIMESLOT5, multiframe_26);
- d_channel_conf.set_burst_types(TIMESLOT5, TRAFFIC_CHANNEL_F, sizeof(TRAFFIC_CHANNEL_F) / sizeof(unsigned), dummy_or_normal);
- d_channel_conf.set_multiframe_type(TIMESLOT6, multiframe_26);
- d_channel_conf.set_burst_types(TIMESLOT6, TRAFFIC_CHANNEL_F, sizeof(TRAFFIC_CHANNEL_F) / sizeof(unsigned), dummy_or_normal);
+ d_channel_conf.set_multiframe_type(TIMESLOT0, multiframe_51);
+ d_channel_conf.set_burst_types(TIMESLOT0, TEST_CCH_FRAMES, TEST_CCH_FIRST, sizeof(TEST_CCH_FRAMES) / sizeof(unsigned), normal_burst);
+ /* FCCH bursts */
+ d_channel_conf.set_burst_types(TIMESLOT0, FCCH_FRAMES, sizeof(FCCH_FRAMES) / sizeof(unsigned), fcch_burst);
+ /* SCH bursts */
+ d_channel_conf.set_burst_types(TIMESLOT0, SCH_FRAMES, sizeof(SCH_FRAMES) / sizeof(unsigned), sch_burst);
- d_channel_conf.set_multiframe_type(TIMESLOT7, multiframe_26);
- d_channel_conf.set_burst_types(TIMESLOT7, TRAFFIC_CHANNEL_F, sizeof(TRAFFIC_CHANNEL_F) / sizeof(unsigned), dummy_or_normal);
+ /* configure TS1...TS7 */
+ for (ts = TIMESLOT1; ts < TIMESLOT7; ts++) {
+ if (d_gs_ctx.ts_ctx[ts].type == TST_TCHF) {
+ d_channel_conf.set_multiframe_type(ts, multiframe_26);
+ d_channel_conf.set_burst_types(ts, TRAFFIC_CHANNEL_F, sizeof(TRAFFIC_CHANNEL_F) / sizeof(unsigned), dummy_or_normal);
+ }
+ else if (d_gs_ctx.ts_ctx[ts].type == TST_SDCCH8) {
+ d_channel_conf.set_multiframe_type(ts, multiframe_51);
+ d_channel_conf.set_burst_types(ts, SDCCH_SACCH_8_FRAMES, SDCCH_SACCH_8_FIRST, sizeof(SDCCH_SACCH_8_FRAMES) / sizeof(unsigned), dummy_or_normal);
+ }
+ }
}
@@ -164,9 +264,9 @@ typedef std::vector<float> vector_float;
typedef boost::circular_buffer<float> circular_buffer_float;
gsm_receiver_cf_sptr
-gsm_make_receiver_cf(gr_feval_dd *tuner, gr_feval_dd *synchronizer, int osr, std::string key)
+gsm_make_receiver_cf(gr_feval_dd *tuner, gr_feval_dd *synchronizer, int osr, std::string key, std::string configuration)
{
- return gsm_receiver_cf_sptr(new gsm_receiver_cf(tuner, synchronizer, osr, key));
+ return gsm_receiver_cf_sptr(new gsm_receiver_cf(tuner, synchronizer, osr, key, configuration));
}
static const int MIN_IN = 1; // mininum number of input streams
@@ -177,7 +277,7 @@ static const int MAX_OUT = 1; // maximum number of output streams
/*
* The private constructor
*/
-gsm_receiver_cf::gsm_receiver_cf(gr_feval_dd *tuner, gr_feval_dd *synchronizer, int osr, std::string key)
+gsm_receiver_cf::gsm_receiver_cf(gr_feval_dd *tuner, gr_feval_dd *synchronizer, int osr, std::string key, std::string configuration)
: gr_block("gsm_receiver",
gr_make_io_signature(MIN_IN, MAX_IN, sizeof(gr_complex)),
gr_make_io_signature(MIN_OUT, MAX_OUT, 142 * sizeof(float))),
@@ -190,13 +290,7 @@ gsm_receiver_cf::gsm_receiver_cf(gr_feval_dd *tuner, gr_feval_dd *synchronizer,
d_state(first_fcch_search),
d_burst_nr(osr),
d_failed_sch(0),
- d_tch_decoder1( GSM::gFACCH_TCHFMapping ), //!!
- d_tch_decoder2( GSM::gFACCH_TCHFMapping ), //!!
- d_tch_decoder3( GSM::gFACCH_TCHFMapping ), //!!
- d_tch_decoder4( GSM::gFACCH_TCHFMapping ), //!!
- d_tch_decoder5( GSM::gFACCH_TCHFMapping ), //!!
- d_tch_decoder6( GSM::gFACCH_TCHFMapping ), //!!
- d_tch_decoder7( GSM::gFACCH_TCHFMapping ) //!!
+ d_trace_sch(true)
{
int i;
gmsk_mapper(SYNC_BITS, N_SYNC_BITS, d_sch_training_seq, gr_complex(0.0, -1.0));
@@ -212,7 +306,10 @@ gsm_receiver_cf::gsm_receiver_cf(gr_feval_dd *tuner, gr_feval_dd *synchronizer,
gmsk_mapper(train_seq[i], N_TRAIN_BITS, d_norm_training_seq[i], startpoint);
}
- d_gsm_file = fopen( "speech.gsm", "wb" ); //!!
+ for (i = 0; i < N_TCH_DECODER; i++)
+ d_tch_decoder[i] = new GSM::TCHFACCHL1Decoder(GSM::gFACCH_TCHFMapping);
+
+ d_gsm_file = fopen( "speech.au.gsm", "wb" ); //!!
d_hex_to_int['0'] = 0; //!!
d_hex_to_int['4'] = 4; //!!
d_hex_to_int['8'] = 8; //!!
@@ -230,8 +327,14 @@ gsm_receiver_cf::gsm_receiver_cf(gr_feval_dd *tuner, gr_feval_dd *synchronizer,
d_hex_to_int['b'] = 0xb; //!!
d_hex_to_int['f'] = 0xf; //!!
read_key(key); //!!
- /* Initialize GSM Stack */
+
+ /* Initialize GSM Stack, clear d_gs_ctx */
GS_new(&d_gs_ctx); //TODO: remove it! it's not a right place for a decoder
+
+ /* configuration is stored in d_gs_ctx */
+ read_configuration(configuration);
+
+ configure_receiver();
}
/*
@@ -295,16 +398,23 @@ gsm_receiver_cf::general_work(int noutput_items,
burst_start = get_sch_chan_imp_resp(input, &channel_imp_resp[0]); //get channel impulse response from it
detect_burst(input, &channel_imp_resp[0], burst_start, output_binary); //detect bits using MLSE detection
if (decode_sch(&output_binary[3], &t1, &t2, &t3, &d_ncc, &d_bcc) == 0) { //decode SCH burst
- DCOUT("sch burst_start: " << burst_start);
- DCOUT("bcc: " << d_bcc << " ncc: " << d_ncc << " t1: " << t1 << " t2: " << t2 << " t3: " << t3);
+ if(d_trace_sch)
+ {
+ DCOUT("sch burst_start: " << burst_start);
+ DCOUT("bcc: " << d_bcc << " ncc: " << d_ncc << " t1: " << t1 << " t2: " << t2 << " t3: " << t3);
+ }
d_burst_nr.set(t1, t2, t3, 0); //set counter of bursts value
+ #if 0 /* Dieter: now done in constructor */
//configure the receiver - tell him where to find which burst type
d_channel_conf.set_multiframe_type(TIMESLOT0, multiframe_51); //in the timeslot nr.0 bursts changes according to t3 counter
configure_receiver();//TODO: this shouldn't be here - remove it when gsm receiver's interface will be ready
+ // Dieter: don't call it, otherwise overwrites configuration of configure_receiver()
d_channel_conf.set_burst_types(TIMESLOT0, FCCH_FRAMES, sizeof(FCCH_FRAMES) / sizeof(unsigned), fcch_burst); //tell where to find fcch bursts
d_channel_conf.set_burst_types(TIMESLOT0, SCH_FRAMES, sizeof(SCH_FRAMES) / sizeof(unsigned), sch_burst); //sch bursts
d_channel_conf.set_burst_types(TIMESLOT0, BCCH_FRAMES, sizeof(BCCH_FRAMES) / sizeof(unsigned), normal_burst);//!and maybe normal bursts of the BCCH logical channel
+ #endif
+
d_burst_nr++;
consume_each(burst_start + BURST_SIZE * d_OSR); //consume samples up to next guard period
@@ -326,6 +436,7 @@ gsm_receiver_cf::general_work(int noutput_items,
unsigned char output_binary[BURST_SIZE];
burst_type b_type = d_channel_conf.get_burst_type(d_burst_nr); //get burst type for given burst number
+ bool first_burst = d_channel_conf.get_first_burst(d_burst_nr); // first burst of four ?
switch (b_type) {
case fcch_burst: { //if it's FCCH burst
@@ -355,9 +466,12 @@ gsm_receiver_cf::general_work(int noutput_items,
if (decode_sch(&output_binary[3], &t1, &t2, &t3, &d_ncc, &d_bcc) == 0) { //and decode SCH data
// d_burst_nr.set(t1, t2, t3, 0); //but only to check if burst_start value is correct
d_failed_sch = 0;
- DCOUT("bcc: " << d_bcc << " ncc: " << d_ncc << " t1: " << t1 << " t2: " << t2 << " t3: " << t3);
offset = burst_start - floor((GUARD_PERIOD) * d_OSR); //compute offset from burst_start - burst should start after a guard period
- DCOUT(offset);
+ if(d_trace_sch)
+ {
+ DCOUT("bcc: " << d_bcc << " ncc: " << d_ncc << " t1: " << t1 << " t2: " << t2 << " t3: " << t3);
+ DCOUT(offset);
+ }
to_consume += offset; //adjust with offset number of samples to be consumed
} else {
d_failed_sch++;
@@ -373,7 +487,7 @@ gsm_receiver_cf::general_work(int noutput_items,
case normal_burst: //if it's normal burst
burst_start = get_norm_chan_imp_resp(input, &channel_imp_resp[0], d_bcc); //get channel impulse response for given training sequence number - d_bcc
detect_burst(input, &channel_imp_resp[0], burst_start, output_binary); //MLSE detection of bits
- process_normal_burst(d_burst_nr, output_binary); //TODO: this shouldn't be here - remove it when gsm receiver's interface will be ready
+ process_normal_burst(d_burst_nr, output_binary, first_burst); //TODO: this shouldn't be here - remove it when gsm receiver's interface will be ready
break;
case dummy_or_normal: {
@@ -389,7 +503,7 @@ gsm_receiver_cf::general_work(int noutput_items,
burst_start = get_norm_chan_imp_resp(input, &channel_imp_resp[0], d_bcc);
detect_burst(input, &channel_imp_resp[0], burst_start, output_binary);
if (!output_binary[0] && !output_binary[1] && !output_binary[2]) {
- process_normal_burst(d_burst_nr, output_binary); //TODO: this shouldn't be here - remove it when gsm receiver's interface will be ready
+ process_normal_burst(d_burst_nr, output_binary, first_burst); //TODO: this shouldn't be here - remove it when gsm receiver's interface will be ready
}
}
}
diff --git a/gsm-receiver/src/lib/gsm_receiver_cf.h b/gsm-receiver/src/lib/gsm_receiver_cf.h
index 21cb1ff..d32ad4c 100644
--- a/gsm-receiver/src/lib/gsm_receiver_cf.h
+++ b/gsm-receiver/src/lib/gsm_receiver_cf.h
@@ -36,12 +36,14 @@
#include <string>//!!
#include <map>//!!
+#define N_TCH_DECODER 7 /* for TS1..TS7 */
+
class gsm_receiver_cf;
typedef boost::shared_ptr<gsm_receiver_cf> gsm_receiver_cf_sptr;
typedef std::vector<gr_complex> 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_cf_sptr gsm_make_receiver_cf(gr_feval_dd *tuner, gr_feval_dd *synchronizer, int osr, std::string key, std::string configuration);
/** GSM Receiver GNU Radio block
*
@@ -57,13 +59,8 @@ class gsm_receiver_cf : public gr_block
std::map<char,int> 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; //!!
+ GSM::TCHFACCHL1Decoder *d_tch_decoder[N_TCH_DECODER]; //!!
+ bool d_trace_sch;
/**@name Configuration of the receiver */
//@{
const int d_OSR; ///< oversampling ratio
@@ -117,8 +114,8 @@ class gsm_receiver_cf : public gr_block
// 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);
+ friend gsm_receiver_cf_sptr gsm_make_receiver_cf(gr_feval_dd *tuner, gr_feval_dd *synchronizer, int osr, std::string key, std::string configuration);
+ gsm_receiver_cf(gr_feval_dd *tuner, gr_feval_dd *synchronizer, int osr, std::string key, std::string configuration);
/** Function whis is used to search a FCCH burst and to compute frequency offset before
* "synchronized" state of the receiver
@@ -233,7 +230,12 @@ class gsm_receiver_cf : public gr_block
/**
*
*/
- void process_normal_burst(burst_counter burst_nr, const unsigned char * burst_binary);
+ void read_configuration(std::string configuration);
+
+ /**
+ *
+ */
+ void process_normal_burst(burst_counter burst_nr, const unsigned char * burst_binary, bool first_burst);
/**
*
diff --git a/gsm-receiver/src/lib/gsm_receiver_config.cc b/gsm-receiver/src/lib/gsm_receiver_config.cc
index 44344f7..33e66b3 100644
--- a/gsm-receiver/src/lib/gsm_receiver_config.cc
+++ b/gsm-receiver/src/lib/gsm_receiver_config.cc
@@ -82,3 +82,24 @@ burst_type channel_configuration::get_burst_type(burst_counter burst_nr)
return d_timeslots_descriptions[timeslot_nr].get_burst_type(nr);
}
+
+bool channel_configuration::get_first_burst(burst_counter burst_nr)
+{
+ uint32_t timeslot_nr = burst_nr.get_timeslot_nr();
+ multiframe_type m_type = d_timeslots_descriptions[timeslot_nr].get_type();
+ uint32_t nr;
+
+ switch (m_type) {
+ case multiframe_26:
+ nr = burst_nr.get_t2();
+ break;
+ case multiframe_51:
+ nr = burst_nr.get_t3();
+ break;
+ default:
+ nr = 0;
+ break;
+ }
+
+ return d_timeslots_descriptions[timeslot_nr].get_first_burst(nr);
+}
diff --git a/gsm-receiver/src/lib/gsm_receiver_config.h b/gsm-receiver/src/lib/gsm_receiver_config.h
index b7ba43a..26dd100 100644
--- a/gsm-receiver/src/lib/gsm_receiver_config.h
+++ b/gsm-receiver/src/lib/gsm_receiver_config.h
@@ -38,10 +38,12 @@ class multiframe_configuration
private:
multiframe_type d_type;
std::vector<burst_type> d_burst_types;
+ std::vector<bool> d_first_burst;
public:
multiframe_configuration() {
d_type = unknown;
fill(d_burst_types.begin(), d_burst_types.end(), empty);
+ fill(d_first_burst.begin(), d_first_burst.end(), false);
}
~multiframe_configuration() {}
@@ -49,9 +51,13 @@ class multiframe_configuration
void set_type(multiframe_type type) {
if (type == multiframe_26) {
d_burst_types.resize(26);
+ d_first_burst.resize(26);
} else {
d_burst_types.resize(51);
+ d_first_burst.resize(51);
}
+ fill(d_burst_types.begin(), d_burst_types.end(), empty);
+ fill(d_first_burst.begin(), d_first_burst.end(), false);
d_type = type;
}
@@ -60,6 +66,10 @@ class multiframe_configuration
d_burst_types[nr] = type;
}
+ void set_first_burst(int nr, bool first_burst) {
+ d_first_burst[nr] = first_burst;
+ }
+
multiframe_type get_type() {
return d_type;
}
@@ -67,6 +77,10 @@ class multiframe_configuration
burst_type get_burst_type(int nr) {
return d_burst_types[nr];
}
+
+ bool get_first_burst(int nr) {
+ return d_first_burst[nr];
+ }
};
class burst_counter
@@ -154,11 +168,20 @@ class channel_configuration
}
}
+ void set_burst_types(int timeslot_nr, const unsigned mapping[], const unsigned first_burst[], unsigned mapping_size, burst_type b_type) {
+ unsigned i;
+ for (i = 0; i < mapping_size; i++) {
+ d_timeslots_descriptions[timeslot_nr].set_burst_type(mapping[i], b_type);
+ d_timeslots_descriptions[timeslot_nr].set_first_burst(mapping[i], first_burst[i] != 0);
+ }
+ }
+
void set_single_burst_type(int timeslot_nr, int burst_nr, burst_type b_type) {
d_timeslots_descriptions[timeslot_nr].set_burst_type(burst_nr, b_type);
}
burst_type get_burst_type(burst_counter burst_nr);
+ bool get_first_burst(burst_counter burst_nr);
};
#endif /* INCLUDED_GSM_RECEIVER_CONFIG_H */
personal git repositories of Harald Welte. Your mileage may vary