Changes between Version 4 and Version 5 of howto/bitfields_in_microblaze

Timestamp:

Feb 18, 2015, 10:45:33 AM (9 years ago)

Author:

chunter

Comment:

--

howto/bitfields_in_microblaze

@@ -132 +132 @@
 
 ----
-= Example: Interpretation of Byte Array =
+
+The following two sections show "real-world" examples from the [wiki:802.11 802.11 Reference Design] that use bit-fields.
+
+= Example: Interpretation of PHY Header Byte Array =
+
+The 802.11n specification of the HT (High Throughput) PHY designates many parameters as collections of bits in front of every MAC payload. For the purposes of this document, we refer to this collection of parameters as the "PHY header." Specifically, an HT packet includes: a 3-byte legacy SIGNAL (L-SIG) field, a 6-byte HT-SIGNAL (H-SIG) field, and finally a 2-byte SERVICE field.
+
+Each of these fields are actually made up of many parameters of varying bit widths. Bit-fields provide an excellent way of allowing code to interpret the underlying lying parameters that are packed into the PHY header. To begin, the following is an actual array of bytes that make up the PHY header of a received 802.11n waveform:
+
+{{{
+#!div style="font-size: 90%"
+  {{{#!C
+        u8 rx_bytes[] = { 0xab, 0x02, 0x00, 0x07, 0x64, 0x00, 0x07, 0x58, 0x03, 0x00, 0x00 };
+  }}}
+}}}
+
+{{{rx_bytes}}} is an 11-byte array that is composed of 3 bytes of L-SIG followed by 6 bytes of HT-SIG and finally 2 bytes of SERVICE. Our goal in this example is to use bit-fields to be able to interpret the underlying parameters in this array of bytes. Next, we define the bit-fields and structs that will allow us to perform this interpretation:
+
+{{{
+#!div style="font-size: 90%"
+  {{{#!C
+// L-SIG Bit-field
+typedef union{
+        u8 raw_array[3];
+        struct __attribute__ ((__packed__)){
+                unsigned rate           :4;  //b[3:0]
+                unsigned reserved       :1;  //b[4]
+                unsigned length         :12; //b[16:5]
+                unsigned parity         :1;      //b[17]
+                unsigned tail           :6;  //b[23:18]
+        };
+} l_sig_bf;
+
+// HT-SIG Bit-field
+typedef union{
+        u8 raw_array[6];
+        struct __attribute__ ((__packed__)){
+                unsigned mcs                    :7;  //b[6:0]
+                unsigned bw                     :1;  //b[7]
+                unsigned len                    :16; //b[23:8]
+                unsigned smoothing              :1;  //b[24]
+                unsigned not_sounding   :1;  //b[25]
+                unsigned reserved               :1;  //b[26]
+                unsigned agg                :1;  //b[27]
+                unsigned stbc                   :2;  //b[29:38]
+                unsigned fec                    :1;  //b[30]
+                unsigned short_gi               :1;  //b[31]
+                unsigned n_ess                  :2;  //b[33:32]
+                unsigned crc                    :8;  //b[41]
+                unsigned tail                   :6;  //b[47]
+        };
+} ht_sig_bf;
+
+// PHY Header Struct
+typedef struct __attribute__ ((__packed__)){
+        l_sig_bf l_sig;                         //B[2:0]
+        ht_sig_bf  ht_sig;              //B[8:3]
+        u16     service;                                        //B[10:9]
+} phy_header;
+  }}}
+}}}
+
+{{{phy_header}}} is a struct made up of two bit-fields ({{{l_sig_bf}}} and {{{ht_sig_bf}}}) followed by a 16-bit variable {{{service}}}.
 
 = Example: Register Access =