bvec decode(Convolutional_Code& nsc, int constraint_length, const bvec& decoder_input, int blockSize, bool verbose) { BPSK mod; vec decoder_input_mod = mod.modulate_bits(decoder_input); int codedLen = 2 * (blockSize + (constraint_length - 1)); int nBlock_rcvd = decoder_input_mod.length() / codedLen; if (verbose) {cout << "rcvd number of blocks : " << nBlock_rcvd << endl;} vec codedBlock(codedLen); bvec bit_rcvd_tmp(blockSize); bvec bit_decoded; for (int j = 0; j < nBlock_rcvd; j++) { for (int k = 0; k < codedLen; k++) { codedBlock[k] = decoder_input_mod[k + j*codedLen]; } //cout << codedBlock << endl; bit_rcvd_tmp = nsc.decode_tail(codedBlock); bit_decoded = concat(bit_decoded, bit_rcvd_tmp); } // Deal with residual sources if remainder exsists vec residual_bits = decoder_input_mod.get(nBlock_rcvd*codedLen, decoder_input_mod.length()-1); nsc.decode_tail( residual_bits, bit_rcvd_tmp); bit_decoded = concat(bit_decoded, bit_rcvd_tmp); if (verbose) {cout << "decode output : " << bit_decoded << endl;} return bit_decoded; }
int main(int argc, char **argv) { // -- modulation and channel parameters (taken from command line input) -- int nC; // type of constellation (1=QPSK, 2=16-QAM, 3=64-QAM) int nRx; // number of receive antennas int nTx; // number of transmit antennas int Tc; // coherence time (number of channel vectors with same H) if (argc != 5) { cout << "Usage: cm nTx nRx nC Tc" << endl << "Example: cm 2 2 1 100000 (2x2 QPSK MIMO on slow fading channel)" << endl; exit(1); } else { sscanf(argv[1], "%i", &nTx); sscanf(argv[2], "%i", &nRx); sscanf(argv[3], "%i", &nC); sscanf(argv[4], "%i", &Tc); } cout << "Initializing.. " << nTx << " TX antennas, " << nRx << " RX antennas, " << (1 << nC) << "-PAM per dimension, coherence time " << Tc << endl; // -- simulation control parameters -- const vec EbN0db = "-5:0.5:50"; // SNR range const int Nmethods = 2; // number of demodulators to try const int Nbitsmax = 50000000; // maximum number of bits to ever simulate per SNR point const int Nu = 1000; // length of data packet (before applying channel coding) int Nbers, Nfers; // target number of bit/frame errors per SNR point double BERmin, FERmin; // BER/FER at which to terminate simulation if (Tc == 1) { // Fast fading channel, BER is of primary interest BERmin = 0.001; // stop simulating a given method if BER<this value FERmin = 1.0e-10; // stop simulating a given method if FER<this value Nbers = 1000; // move to next SNR point after counting 1000 bit errors Nfers = 200; // do not stop on this condition } else { // Slow fading channel, FER is of primary interest here BERmin = 1.0e-15; // stop simulating a given method if BER<this value FERmin = 0.01; // stop simulating a given method if FER<this value Nbers = -1; // do not stop on this condition Nfers = 200; // move to next SNR point after counting 200 frame errors } // -- Channel code parameters -- Convolutional_Code code; ivec generator(3); generator(0) = 0133; // use rate 1/3 code generator(1) = 0165; generator(2) = 0171; double rate = 1.0 / 3.0; code.set_generator_polynomials(generator, 7); bvec dummy; code.encode_tail(randb(Nu), dummy); const int Nc = length(dummy); // find out how long the coded blocks are // ============= Initialize ==================================== const int Nctx = (int)(2 * nC * nTx * ceil(double(Nc) / double(2 * nC * nTx))); // Total number of bits to transmit const int Nvec = Nctx / (2 * nC * nTx); // Number of channel vectors to transmit const int Nbitspvec = 2 * nC * nTx; // Number of bits per channel vector // initialize MIMO channel with uniform QAM per complex dimension and Gray coding ND_UQAM chan; chan.set_M(nTx, 1 << (2*nC)); cout << chan << endl; // initialize interleaver Sequence_Interleaver<bin> sequence_interleaver_b(Nctx); Sequence_Interleaver<int> sequence_interleaver_i(Nctx); sequence_interleaver_b.randomize_interleaver_sequence(); sequence_interleaver_i.set_interleaver_sequence(sequence_interleaver_b.get_interleaver_sequence()); // RNG_randomize(); Array<cvec> Y(Nvec); // received data Array<cmat> H(Nvec / Tc + 1); // channel matrix (new matrix for each coherence interval) ivec Contflag = ones_i(Nmethods); // flag to determine whether to run a given demodulator if (pow(2.0, nC*2.0*nTx) > 256) { // ML decoder too complex.. Contflag(1) = 0; } if (nTx > nRx) { Contflag(0) = 0; // ZF not for underdetermined systems } cout << "Running methods: " << Contflag << endl; cout.setf(ios::fixed, ios::floatfield); cout.setf(ios::showpoint); cout.precision(5); // ================== Run simulation ======================= for (int nsnr = 0; nsnr < length(EbN0db); nsnr++) { const double Eb = 1.0; // transmitted energy per information bit const double N0 = inv_dB(-EbN0db(nsnr)); const double sigma2 = N0; // Variance of each scalar complex noise sample const double Es = rate * 2 * nC * Eb; // Energy per complex scalar symbol // (Each transmitted scalar complex symbol contains rate*2*nC // information bits.) const double Ess = sqrt(Es); Array<BERC> berc(Nmethods); // counter for coded BER Array<BERC> bercu(Nmethods); // counter for uncoded BER Array<BLERC> ferc(Nmethods); // counter for coded FER for (int i = 0; i < Nmethods; i++) { ferc(i).set_blocksize(Nu); } long int nbits = 0; while (nbits < Nbitsmax) { nbits += Nu; // generate and encode random data bvec inputbits = randb(Nu); bvec txbits; code.encode_tail(inputbits, txbits); // coded block length is not always a multiple of the number of // bits per channel vector txbits = concat(txbits, randb(Nctx - Nc)); txbits = sequence_interleaver_b.interleave(txbits); // -- generate channel and data ---- for (int k = 0; k < Nvec; k++) { /* A complex valued channel matrix is used here. An alternative (with equivalent result) would be to use a real-valued (structured) channel matrix of twice the dimension. */ if (k % Tc == 0) { // generate a new channel realization every Tc intervals H(k / Tc) = Ess * randn_c(nRx, nTx); } // modulate and transmit bits bvec bitstmp = txbits(k * 2 * nTx * nC, (k + 1) * 2 * nTx * nC - 1); cvec x = chan.modulate_bits(bitstmp); cvec e = sqrt(sigma2) * randn_c(nRx); Y(k) = H(k / Tc) * x + e; } // -- demodulate -- Array<QLLRvec> LLRin(Nmethods); for (int i = 0; i < Nmethods; i++) { LLRin(i) = zeros_i(Nctx); } QLLRvec llr_apr = zeros_i(nC * 2 * nTx); // no a priori input to demodulator QLLRvec llr_apost = zeros_i(nC * 2 * nTx); for (int k = 0; k < Nvec; k++) { // zero forcing demodulation if (Contflag(0)) { chan.demodulate_soft_bits(Y(k), H(k / Tc), sigma2, llr_apr, llr_apost, ND_UQAM::ZF_LOGMAP); LLRin(0).set_subvector(k*Nbitspvec, llr_apost); } // ML demodulation if (Contflag(1)) { chan.demodulate_soft_bits(Y(k), H(k / Tc), sigma2, llr_apr, llr_apost); LLRin(1).set_subvector(k*Nbitspvec, llr_apost); } } // -- decode and count errors -- for (int i = 0; i < Nmethods; i++) { bvec decoded_bits; if (Contflag(i)) { bercu(i).count(txbits(0, Nc - 1), LLRin(i)(0, Nc - 1) < 0); // uncoded BER LLRin(i) = sequence_interleaver_i.deinterleave(LLRin(i), 0); // QLLR values must be converted to real numbers since the convolutional decoder wants this vec llr = chan.get_llrcalc().to_double(LLRin(i).left(Nc)); // llr=-llr; // UNCOMMENT THIS LINE IF COMPILING WITH 3.10.5 OR EARLIER (BEFORE HARMONIZING LLR CONVENTIONS) code.decode_tail(llr, decoded_bits); berc(i).count(inputbits(0, Nu - 1), decoded_bits(0, Nu - 1)); // coded BER ferc(i).count(inputbits(0, Nu - 1), decoded_bits(0, Nu - 1)); // coded FER } } /* Check whether it is time to terminate the simulation. Terminate when all demodulators that are still running have counted at least Nbers or Nfers bit/frame errors. */ int minber = 1000000; int minfer = 1000000; for (int i = 0; i < Nmethods; i++) { if (Contflag(i)) { minber = min(minber, round_i(berc(i).get_errors())); minfer = min(minfer, round_i(ferc(i).get_errors())); } } if (Nbers > 0 && minber > Nbers) { break;} if (Nfers > 0 && minfer > Nfers) { break;} } cout << "-----------------------------------------------------" << endl; cout << "Eb/N0: " << EbN0db(nsnr) << " dB. Simulated " << nbits << " bits." << endl; cout << " Uncoded BER: " << bercu(0).get_errorrate() << " (ZF); " << bercu(1).get_errorrate() << " (ML)" << endl; cout << " Coded BER: " << berc(0).get_errorrate() << " (ZF); " << berc(1).get_errorrate() << " (ML)" << endl; cout << " Coded FER: " << ferc(0).get_errorrate() << " (ZF); " << ferc(1).get_errorrate() << " (ML)" << endl; cout.flush(); /* Check wheter it is time to terminate simulation. Stop when all methods have reached the min BER/FER of interest. */ int contflag = 0; for (int i = 0; i < Nmethods; i++) { if (Contflag(i)) { if (berc(i).get_errorrate() > BERmin) { contflag = 1; } else { Contflag(i) = 0; } if (ferc(i).get_errorrate() > FERmin) { contflag = 1; } else { Contflag(i) = 0; } } } if (contflag) { continue; } else {break; } } return 0; }