commit-gnuradio
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Commit-gnuradio] r3512 - gnuradio/branches/developers/jcorgan/pager/gr-


From: jcorgan
Subject: [Commit-gnuradio] r3512 - gnuradio/branches/developers/jcorgan/pager/gr-pager/src/lib
Date: Sun, 10 Sep 2006 13:20:13 -0600 (MDT)

Author: jcorgan
Date: 2006-09-10 13:20:13 -0600 (Sun, 10 Sep 2006)
New Revision: 3512

Modified:
   gnuradio/branches/developers/jcorgan/pager/gr-pager/src/lib/Makefile.am
   
gnuradio/branches/developers/jcorgan/pager/gr-pager/src/lib/pgr_flex_deframer.cc
   
gnuradio/branches/developers/jcorgan/pager/gr-pager/src/lib/pgr_flex_deframer.h
Log:
Work-in-progress on FLEX deinterleaving.  Appears to be working but
we'll know when we do the error correction whether it's emitting
garbage or not.


Modified: 
gnuradio/branches/developers/jcorgan/pager/gr-pager/src/lib/Makefile.am
===================================================================
--- gnuradio/branches/developers/jcorgan/pager/gr-pager/src/lib/Makefile.am     
2006-09-10 18:14:55 UTC (rev 3511)
+++ gnuradio/branches/developers/jcorgan/pager/gr-pager/src/lib/Makefile.am     
2006-09-10 19:20:13 UTC (rev 3512)
@@ -81,7 +81,7 @@
 # These headers get installed in ${prefix}/include/gnuradio
 grinclude_HEADERS = \
     pgr_slicer_fb.h \
-    pgr_flex_sync.h
+    pgr_flex_deframer.h
     # Additional header files here
 
 # These swig headers get installed in ${prefix}/include/gnuradio/swig

Modified: 
gnuradio/branches/developers/jcorgan/pager/gr-pager/src/lib/pgr_flex_deframer.cc
===================================================================
--- 
gnuradio/branches/developers/jcorgan/pager/gr-pager/src/lib/pgr_flex_deframer.cc
    2006-09-10 18:14:55 UTC (rev 3511)
+++ 
gnuradio/branches/developers/jcorgan/pager/gr-pager/src/lib/pgr_flex_deframer.cc
    2006-09-10 19:20:13 UTC (rev 3512)
@@ -44,6 +44,7 @@
               gr_make_io_signature (1, 1, sizeof(gr_int32))),
     d_sync(rate/1600) // Maximum samples per baud
 {
+    set_output_multiple(32); // Four phases, 8, 32-bit codewords per block
     d_rate = rate;
     enter_idle();
 }
@@ -116,6 +117,7 @@
     d_index = 0;
     d_count = 0;
     d_center = 0;
+    d_cdw = 0;
 }
 
 void pgr_flex_deframer::enter_syncing()
@@ -155,6 +157,7 @@
 {
     d_state = ST_DATA;
     d_count = 0;
+    d_cdw = 0;
 }
 
 void pgr_flex_deframer::do_multiphase_shift(unsigned char sym)
@@ -168,25 +171,49 @@
     //  2         0    0
     //  3         0    1
 
+    // Codewords are interleaved in blocks of 8
+    //
+    // ABCDEFGH
+    // ABCDEFGH
+    // ABCDEFGH
+    // ABCDEFGH
+    // ...
+    // etc., for all 32 bits. So each successive incoming bit is multiplexed
+    // into a different d_phase_x[], indexed by d_cdw
+
     if (d_baudrate == 1600) {
-        d_phase_a = (d_phase_a << 1) | (sym < 2);
-        if (d_levels == 4) 
-            d_phase_b = (d_phase_b << 1) | (sym == 0 || sym == 3);
+        d_phase_a[d_cdw] <<= 1;
+        d_phase_a[d_cdw]  |= (sym < 2);
+
+        if (d_levels == 4) {
+            d_phase_b[d_cdw] <<= 1;
+            d_phase_b[d_cdw]  |= (sym == 0 || sym == 3);
+        }
     }
-    else { // baudrate == 3200, multiplex alternating bits
+    else { 
         if (!d_hibit) {
-            d_phase_a = (d_phase_a << 1) | (sym < 2);
-            if (d_levels == 4)
-                d_phase_b = (d_phase_b << 1) | (sym == 0 || sym == 3);
+            d_phase_a[d_cdw] <<= 1;
+            d_phase_a[d_cdw]  |= (sym < 2);
+
+            if (d_levels == 4) {
+                d_phase_b[d_cdw] <<= 1;
+                d_phase_b[d_cdw]  |= (sym == 0 || sym == 3);
+            }
             d_hibit = true;
         }
         else {
-            d_phase_c = (d_phase_a << 1) | (sym < 2);
-            if (d_levels == 4)
-                d_phase_d = (d_phase_b << 1) | (sym == 0 || sym == 3);
+            d_phase_c[d_cdw] <<= 1;
+            d_phase_c[d_cdw]  |= (sym < 2);
+
+            if (d_levels == 4) {
+                d_phase_d[d_cdw] <<= 1;
+                d_phase_d[d_cdw]  |= (sym == 0 || sym == 3);
+            }
             d_hibit = false;
         }
     }
+
+    d_cdw = ++d_cdw % 8;
 }
 
 int pgr_flex_deframer::general_work(int noutput_items,
@@ -202,6 +229,9 @@
 
     while (i++ < ninputs && j < noutput_items) {
         unsigned char sym = *in++;
+        if (++d_index >= d_spb)
+            d_index = 0;
+
         switch (d_state) {
             case ST_IDLE:
                 if (test_sync(sym))
@@ -218,10 +248,10 @@
 
             case ST_SYNC1:
                 if (d_index == d_center) {
-                    do_multiphase_shift(sym);
+                    d_sync[d_index] = (d_sync[d_index] << 1) | (sym < 2);
                     if (++d_count == 48) { // Skip 16 bits of dotting
                         // Output frame information word
-                        *out++ = d_phase_a; j++;
+                        *out++ = (gr_int32)(d_sync[d_index] & 
0x00000000FFFFFFFFULL); j++;
                         enter_sync2();
                     }
                 }
@@ -229,11 +259,10 @@
 
             case ST_SYNC2:
                 if (d_index == d_center) {
-                    do_multiphase_shift(sym);
                     // Skip 25 ms = 40 bits @ 1600 bps, 80 @ 3200 bps
                     if (++d_count == d_baudrate/40) {
                         enter_data();
-                        break;
+                        goto done; // Return to scheduler to garauntee 
'output_multiple' for data delivery
                     }
                 }
                 break;
@@ -243,19 +272,28 @@
                     do_multiphase_shift(sym);
                     d_count++;
 
-                    // Send 32-bit code words for each defined phase
-                    if (d_count % (d_baudrate/50) == 0) {
+                    // If a block has passed, output its 8 codewords
+                    // Do this for each phase defined by the FLEX mode
+                    if (d_count % (d_baudrate*4/25) == 0) { // 256 or 512 bits 
per block
                         if (flex_modes[d_mode].phase_a) {
-                            *out++ = d_phase_a; j++;
+                            for (int k = 0; k < 8; k++) {
+                                *out++ = d_phase_a[k]; j++;
+                            }
                         }
                         if (flex_modes[d_mode].phase_b) {
-                            *out++ = d_phase_b; j++;
+                            for (int k = 0; k < 8; k++) {
+                                *out++ = d_phase_b[k]; j++;
+                            }
                         }
                         if (flex_modes[d_mode].phase_c) {
-                            *out++ = d_phase_c; j++;
+                            for (int k = 0; k < 8; k++) {
+                                *out++ = d_phase_c[k]; j++;
+                            }
                         }
                         if (flex_modes[d_mode].phase_d) {
-                            *out++ = d_phase_d; j++;
+                            for (int k = 0; k < 8; k++) {
+                                *out++ = d_phase_d[k]; j++;
+                            }
                         }
                     }
 
@@ -270,10 +308,9 @@
                 break;
         }
 
-        if (++d_index >= d_spb)
-            d_index = 0;
     }
 
+done:
     // Inform scheduler what we did;
     consume_each(i-1);
     return j;

Modified: 
gnuradio/branches/developers/jcorgan/pager/gr-pager/src/lib/pgr_flex_deframer.h
===================================================================
--- 
gnuradio/branches/developers/jcorgan/pager/gr-pager/src/lib/pgr_flex_deframer.h 
    2006-09-10 18:14:55 UTC (rev 3511)
+++ 
gnuradio/branches/developers/jcorgan/pager/gr-pager/src/lib/pgr_flex_deframer.h 
    2006-09-10 19:20:13 UTC (rev 3512)
@@ -71,11 +71,13 @@
     bool d_hibit;   // Current bit is high bit when 3200 baud
 
     gr_int64_vector d_sync; // Trial synchronizers
-    gr_int32 d_phase_a;     // PHASEA accumulator
-    gr_int32 d_phase_b;     // PHASEB accumulator
-    gr_int32 d_phase_c;     // PHASEB accumulator
-    gr_int32 d_phase_d;     // PHASEB accumulator
 
+    int d_cdw;
+    gr_int32 d_phase_a[8];     // PHASEA block accumulator
+    gr_int32 d_phase_b[8];     // PHASEB block accumulator
+    gr_int32 d_phase_c[8];     // PHASEB block accumulator
+    gr_int32 d_phase_d[8];     // PHASEB block accumulator
+
 public:
     void forecast(int noutput_items, gr_vector_int &inputs_required);
 





reply via email to

[Prev in Thread] Current Thread [Next in Thread]