3 * Copyright 2006,2007,2008 Free Software Foundation, Inc.
5 * This file is part of GNU Radio
7 * GNU Radio 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)
12 * GNU Radio 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.
17 * You should have received a copy of the GNU General Public License
18 * along with GNU Radio; see the file COPYING. If not, write to
19 * the Free Software Foundation, Inc., 51 Franklin Street,
20 * Boston, MA 02110-1301, USA.
28 #include <gr_ofdm_mapper_bcv.h>
29 #include <gr_io_signature.h>
33 gr_ofdm_mapper_bcv_sptr
34 gr_make_ofdm_mapper_bcv (const std::vector<gr_complex> &constellation, unsigned int msgq_limit,
35 unsigned int occupied_carriers, unsigned int fft_length)
37 return gr_ofdm_mapper_bcv_sptr (new gr_ofdm_mapper_bcv (constellation, msgq_limit,
38 occupied_carriers, fft_length));
41 // Consumes 1 packet and produces as many OFDM symbols of fft_length to hold the full packet
42 gr_ofdm_mapper_bcv::gr_ofdm_mapper_bcv (const std::vector<gr_complex> &constellation, unsigned int msgq_limit,
43 unsigned int occupied_carriers, unsigned int fft_length)
44 : gr_sync_block ("ofdm_mapper_bcv",
45 gr_make_io_signature (0, 0, 0),
46 gr_make_io_signature2 (1, 2, sizeof(gr_complex)*fft_length, sizeof(char))),
47 d_constellation(constellation),
48 d_msgq(gr_make_msg_queue(msgq_limit)), d_msg_offset(0), d_eof(false),
49 d_occupied_carriers(occupied_carriers),
50 d_fft_length(fft_length),
56 if (!(d_occupied_carriers <= d_fft_length))
57 throw std::invalid_argument("gr_ofdm_mapper_bcv: occupied carriers must be <= fft_length");
59 // this is not the final form of this solution since we still use the occupied_tones concept,
60 // which would get us into trouble if the number of carriers we seek is greater than the occupied carriers.
61 // Eventually, we will get rid of the occupied_carriers concept.
62 std::string carriers = "FE7F";
64 // A bit hacky to fill out carriers to occupied_carriers length
65 int diff = (d_occupied_carriers - 4*carriers.length());
67 carriers.insert(0, "f");
68 carriers.insert(carriers.length(), "f");
72 // if there's extras left to be processed
73 // divide remaining to put on either side of current map
74 // all of this is done to stick with the concept of a carrier map string that
75 // can be later passed by the user, even though it'd be cleaner to just do this
76 // on the carrier map itself
80 // dictionary to convert from integers to ascii hex representation
81 char abc[16] = {'0', '1', '2', '3', '4', '5', '6', '7',
82 '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
86 diff_left = (int)ceil((float)diff/2.0f); // number of carriers to put on the left side
87 c[0] = abc[(1 << diff_left) - 1]; // convert to bits and move to ASCI integer
88 carriers.insert(0, c);
90 diff_right = diff - diff_left; // number of carriers to put on the right side
91 c[0] = abc[0xF^((1 << diff_right) - 1)]; // convert to bits and move to ASCI integer
92 carriers.insert(carriers.length(), c);
95 // find out how many zeros to pad on the sides; the difference between the fft length and the subcarrier
96 // mapping size in chunks of four. This is the number to pack on the left and this number plus any
97 // residual nulls (if odd) will be packed on the right.
98 diff = (d_fft_length/4 - carriers.length())/2;
101 for(i = 0; i < carriers.length(); i++) {
102 char c = carriers[i]; // get the current hex character from the string
103 for(j = 0; j < 4; j++) { // walk through all four bits
104 k = (strtol(&c, NULL, 16) >> (3-j)) & 0x1; // convert to int and extract next bit
105 if(k) { // if bit is a 1,
106 d_subcarrier_map.push_back(4*(i+diff) + j); // use this subcarrier
111 // make sure we stay in the limit currently imposed by the occupied_carriers
112 if(d_subcarrier_map.size() > d_occupied_carriers) {
113 throw std::invalid_argument("gr_ofdm_mapper_bcv: subcarriers allocated exceeds size of occupied carriers");
116 d_nbits = (unsigned long)ceil(log10(d_constellation.size()) / log10(2.0));
119 gr_ofdm_mapper_bcv::~gr_ofdm_mapper_bcv(void)
123 int gr_ofdm_mapper_bcv::randsym()
125 return (rand() % d_constellation.size());
129 gr_ofdm_mapper_bcv::work(int noutput_items,
130 gr_vector_const_void_star &input_items,
131 gr_vector_void_star &output_items)
133 gr_complex *out = (gr_complex *)output_items[0];
137 //printf("OFDM BPSK Mapper: ninput_items: %d noutput_items: %d\n", ninput_items[0], noutput_items);
144 d_msg = d_msgq->delete_head(); // block, waiting for a message
147 d_pending_flag = 1; // new packet, write start of packet flag
149 if((d_msg->length() == 0) && (d_msg->type() == 1)) {
151 return -1; // We're done; no more messages coming.
156 if(output_items.size() == 2)
157 out_flag = (char *) output_items[1];
160 // Build a single symbol:
161 // Initialize all bins to 0 to set unused carriers
162 memset(out, 0, d_fft_length*sizeof(gr_complex));
165 unsigned char bits = 0;
166 //while((d_msg_offset < d_msg->length()) && (i < d_occupied_carriers)) {
167 while((d_msg_offset < d_msg->length()) && (i < d_subcarrier_map.size())) {
169 // need new data to process
170 if(d_bit_offset == 0) {
171 d_msgbytes = d_msg->msg()[d_msg_offset];
172 //printf("mod message byte: %x\n", d_msgbytes);
176 // take the residual bits, fill out nbits with info from the new byte, and put them in the symbol
177 d_resid |= (((1 << d_nresid)-1) & d_msgbytes) << (d_nbits - d_nresid);
180 out[d_subcarrier_map[i]] = d_constellation[bits];
183 d_bit_offset += d_nresid;
186 //printf("mod bit(r): %x resid: %x nresid: %d bit_offset: %d\n",
187 // bits, d_resid, d_nresid, d_bit_offset);
190 if((8 - d_bit_offset) >= d_nbits) { // test to make sure we can fit nbits
191 // take the nbits number of bits at a time from the byte to add to the symbol
192 bits = ((1 << d_nbits)-1) & (d_msgbytes >> d_bit_offset);
193 d_bit_offset += d_nbits;
195 out[d_subcarrier_map[i]] = d_constellation[bits];
198 else { // if we can't fit nbits, store them for the next
199 // saves d_nresid bits of this message where d_nresid < d_nbits
200 unsigned int extra = 8-d_bit_offset;
201 d_resid = ((1 << extra)-1) & (d_msgbytes >> d_bit_offset);
202 d_bit_offset += extra;
203 d_nresid = d_nbits - extra;
208 if(d_bit_offset == 8) {
214 // Ran out of data to put in symbol
215 if (d_msg_offset == d_msg->length()) {
223 //while(i < d_occupied_carriers) { // finish filling out the symbol
224 while(i < d_subcarrier_map.size()) { // finish filling out the symbol
225 out[d_subcarrier_map[i]] = d_constellation[randsym()];
230 if (d_msg->type() == 1) // type == 1 sets EOF
232 d_msg.reset(); // finished packet, free message
233 assert(d_bit_offset == 0);
237 out_flag[0] = d_pending_flag;
240 return 1; // produced symbol