int main() { RNG_reset(12345); cout << "===========================================================" << endl; cout << " Test of Modulators " << endl; cout << "===========================================================" << endl; const int no_symbols = 5; const double N0 = 0.1; { cout << endl << "Modulator_1D (configured as BPSK)" << endl; Modulator_1D mod("1.0 -1.0", "0 1"); int bps = round_i(mod.bits_per_symbol()); bvec tx_bits = randb(no_symbols * bps); ivec tx_sym_numbers = randi(no_symbols, 0, pow2i(bps) - 1); vec noise = sqrt(N0) * randn(no_symbols); vec tx_symbols = mod.modulate_bits(tx_bits); vec rx_symbols = tx_symbols + noise; bvec decbits = mod.demodulate_bits(rx_symbols); cout << "* modulating bits:" << endl; cout << " tx_bits = " << tx_bits << endl; cout << " tx_symbols = " << tx_symbols << endl; cout << " rx_symbols = " << rx_symbols << endl; cout << " decbits = " << decbits << endl; tx_symbols = mod.modulate(tx_sym_numbers); rx_symbols = tx_symbols + noise; ivec dec_sym_numbers = mod.demodulate(rx_symbols); cout << "* modulating symbol numbers:" << endl; cout << " tx_sym_numbers = " << tx_sym_numbers << endl; cout << " tx_symbols = " << tx_symbols << endl; cout << " rx_symbols = " << rx_symbols << endl; cout << " dec_sym_numbers = " << dec_sym_numbers << endl; cout << endl << "BPSK (real signal)" << endl; BPSK bpsk; bpsk.modulate_bits(tx_bits, tx_symbols); rx_symbols = tx_symbols + noise; bpsk.demodulate_bits(rx_symbols, decbits); cout << "* modulating bits:" << endl; cout << " tx_bits = " << tx_bits << endl; cout << " tx_symbols = " << tx_symbols << endl; cout << " rx_symbols = " << rx_symbols << endl; cout << " decbits = " << decbits << endl; cout << endl << "BPSK (complex signal)" << endl; BPSK_c bpsk_c; cvec tx_csymbols = bpsk_c.modulate_bits(tx_bits); cvec rx_csymbols = tx_csymbols + to_cvec(noise, -noise); decbits = bpsk_c.demodulate_bits(rx_csymbols); vec softbits_approx = bpsk_c.demodulate_soft_bits(rx_csymbols, N0, APPROX); vec softbits = bpsk_c.demodulate_soft_bits(rx_csymbols, N0, LOGMAP); cout << "* modulating bits:" << endl; cout << " tx_bits = " << tx_bits << endl; cout << " tx_csymbols = " << tx_csymbols << endl; cout << " rx_csymbols = " << rx_csymbols << endl; cout << " decbits = " << decbits << endl; cout << " softbits = " << softbits << endl; cout << " softbits_approx = " << softbits_approx << endl << endl; } cout << "===========================================================" << endl; { cout << endl << "Modulator_1D (configured as 4-PAM)" << endl; Modulator_1D mod("-3.0 -1.0 1.0 3.0", "0 1 3 2"); int bps = round_i(mod.bits_per_symbol()); bvec tx_bits = randb(no_symbols * bps); ivec tx_sym_numbers = randi(no_symbols, 0, pow2i(bps) - 1); vec noise = sqrt(N0) * randn(no_symbols); vec tx_symbols = mod.modulate_bits(tx_bits); vec rx_symbols = tx_symbols + noise; bvec decbits = mod.demodulate_bits(rx_symbols); cout << "* modulating bits:" << endl; cout << " tx_bits = " << tx_bits << endl; cout << " tx_symbols = " << tx_symbols << endl; cout << " rx_symbols = " << rx_symbols << endl; cout << " decbits = " << decbits << endl; tx_symbols = mod.modulate(tx_sym_numbers); rx_symbols = tx_symbols + noise; ivec dec_sym_numbers = mod.demodulate(rx_symbols); cout << "* modulating symbol numbers:" << endl; cout << " tx_sym_numbers = " << tx_sym_numbers << endl; cout << " tx_symbols = " << tx_symbols << endl; cout << " rx_symbols = " << rx_symbols << endl; cout << " dec_sym_numbers = " << dec_sym_numbers << endl; cout << endl << "4-PAM (real signal)" << endl; PAM pam(4); pam.modulate_bits(tx_bits, tx_symbols); rx_symbols = tx_symbols + noise; pam.demodulate_bits(rx_symbols, decbits); cout << "* modulating bits:" << endl; cout << " tx_bits = " << tx_bits << endl; cout << " tx_symbols = " << tx_symbols << endl; cout << " rx_symbols = " << rx_symbols << endl; cout << " decbits = " << decbits << endl; cout << endl << "4-PAM (complex signal)" << endl; PAM_c pam_c(4); cvec tx_csymbols = pam_c.modulate_bits(tx_bits); cvec rx_csymbols = tx_csymbols + to_cvec(noise, -noise); decbits = pam_c.demodulate_bits(rx_csymbols); vec softbits_approx = pam_c.demodulate_soft_bits(rx_csymbols, N0, APPROX); vec softbits = pam_c.demodulate_soft_bits(rx_csymbols, N0, LOGMAP); cout << "* modulating bits:" << endl; cout << " tx_bits = " << tx_bits << endl; cout << " tx_csymbols = " << tx_csymbols << endl; cout << " rx_csymbols = " << rx_csymbols << endl; cout << " decbits = " << decbits << endl; cout << " softbits = " << softbits << endl; cout << " softbits_approx = " << softbits_approx << endl << endl; } cout << "===========================================================" << endl; { cout << endl << "Modulator_2D (configured as 256-QAM)" << endl; QAM qam(256); Modulator_2D mod(qam.get_symbols(), qam.get_bits2symbols()); int bps = round_i(mod.bits_per_symbol()); bvec tx_bits = randb(no_symbols * bps); ivec tx_sym_numbers = randi(no_symbols, 0, pow2i(bps) - 1); cvec noise = sqrt(N0) * randn_c(no_symbols); cvec tx_symbols = mod.modulate(tx_sym_numbers); cvec rx_symbols = tx_symbols + noise; ivec dec_sym_numbers = mod.demodulate(rx_symbols); cout << "* modulating symbol numbers:" << endl; cout << " tx_sym_numbers = " << tx_sym_numbers << endl; cout << " tx_symbols = " << tx_symbols << endl; cout << " rx_symbols = " << rx_symbols << endl; cout << " dec_sym_numbers = " << dec_sym_numbers << endl; tx_symbols = mod.modulate_bits(tx_bits); rx_symbols = tx_symbols + noise; bvec decbits = mod.demodulate_bits(rx_symbols); vec softbits_approx = mod.demodulate_soft_bits(rx_symbols, N0, APPROX); vec softbits = mod.demodulate_soft_bits(rx_symbols, N0, LOGMAP); cout << "* modulating bits:" << endl; cout << " tx_bits = " << tx_bits << endl; cout << " tx_symbols = " << tx_symbols << endl; cout << " rx_symbols = " << rx_symbols << endl; cout << " decbits = " << decbits << endl; cout << " softbits = " << softbits << endl; cout << " softbits_approx = " << softbits_approx << endl; cout << endl << "256-QAM" << endl; tx_symbols = qam.modulate(tx_sym_numbers); rx_symbols = tx_symbols + noise; dec_sym_numbers = qam.demodulate(rx_symbols); cout << "* modulating symbol numbers:" << endl; cout << " tx_sym_numbers = " << tx_sym_numbers << endl; cout << " tx_symbols = " << tx_symbols << endl; cout << " rx_symbols = " << rx_symbols << endl; cout << " dec_sym_numbers = " << dec_sym_numbers << endl; tx_symbols = qam.modulate_bits(tx_bits); rx_symbols = tx_symbols + noise; decbits = qam.demodulate_bits(rx_symbols); softbits_approx = qam.demodulate_soft_bits(rx_symbols, N0, APPROX); softbits = qam.demodulate_soft_bits(rx_symbols, N0, LOGMAP); cout << "* modulating bits:" << endl; cout << " tx_bits = " << tx_bits << endl; cout << " tx_symbols = " << tx_symbols << endl; cout << " rx_symbols = " << rx_symbols << endl; cout << " decbits = " << decbits << endl; cout << " softbits = " << softbits << endl; cout << " softbits_approx = " << softbits_approx << endl << endl; } cout << "===========================================================" << endl; { cout << endl << "8-PSK" << endl; PSK psk(8); int bps = round_i(psk.bits_per_symbol()); bvec tx_bits = randb(no_symbols * bps); ivec tx_sym_numbers = randi(no_symbols, 0, pow2i(bps) - 1); cvec noise = sqrt(N0) * randn_c(no_symbols); cvec tx_symbols = psk.modulate(tx_sym_numbers); cvec rx_symbols = tx_symbols + noise; ivec dec_sym_numbers = psk.demodulate(rx_symbols); cout << "* modulating symbol numbers:" << endl; cout << " tx_sym_numbers = " << tx_sym_numbers << endl; cout << " tx_symbols = " << tx_symbols << endl; cout << " rx_symbols = " << rx_symbols << endl; cout << " dec_sym_numbers = " << dec_sym_numbers << endl; tx_symbols = psk.modulate_bits(tx_bits); rx_symbols = tx_symbols + noise; bvec decbits = psk.demodulate_bits(rx_symbols); vec softbits_approx = psk.demodulate_soft_bits(rx_symbols, N0, APPROX); vec softbits = psk.demodulate_soft_bits(rx_symbols, N0, LOGMAP); cout << "* modulating bits:" << endl; cout << " tx_bits = " << tx_bits << endl; cout << " tx_symbols = " << tx_symbols << endl; cout << " rx_symbols = " << rx_symbols << endl; cout << " decbits = " << decbits << endl; cout << " softbits = " << softbits << endl; cout << " softbits_approx = " << softbits_approx << endl << endl; } cout << "===========================================================" << endl; { cout << endl << "16-QAM" << endl; QAM qam(16); int bps = round_i(qam.bits_per_symbol()); bvec tx_bits = randb(no_symbols * bps); ivec tx_sym_numbers = randi(no_symbols, 0, pow2i(bps) - 1); cvec noise = sqrt(N0) * randn_c(no_symbols); cvec tx_symbols = qam.modulate(tx_sym_numbers); cvec rx_symbols = tx_symbols + noise; ivec dec_sym_numbers = qam.demodulate(rx_symbols); cout << "* modulating symbol numbers:" << endl; cout << " tx_sym_numbers = " << tx_sym_numbers << endl; cout << " tx_symbols = " << tx_symbols << endl; cout << " rx_symbols = " << rx_symbols << endl; cout << " dec_sym_numbers = " << dec_sym_numbers << endl; tx_symbols = qam.modulate_bits(tx_bits); rx_symbols = tx_symbols + noise; bvec decbits = qam.demodulate_bits(rx_symbols); vec softbits_approx = qam.demodulate_soft_bits(rx_symbols, N0, APPROX); vec softbits = qam.demodulate_soft_bits(rx_symbols, N0, LOGMAP); cout << "* modulating bits:" << endl; cout << " tx_bits = " << tx_bits << endl; cout << " tx_symbols = " << tx_symbols << endl; cout << " rx_symbols = " << rx_symbols << endl; cout << " decbits = " << decbits << endl; cout << " softbits = " << softbits << endl; cout << " softbits_approx = " << softbits_approx << endl << endl; } }
int main(void) { //general parameters double threshold_value = 10; string map_metric="maxlogMAP"; ivec gen = "07 05";//octal form, feedback first int constraint_length = 3; int nb_errors_lim = 3000; int nb_bits_lim = int(1e6); int perm_len = (1<<14);//total number of bits in a block (with tail) int nb_iter = 10;//number of iterations in the turbo decoder vec EbN0_dB = "0:0.1:5"; double R = 1.0/3.0;//coding rate (non punctured PCCC) double Ec = 1.0;//coded bit energy //other parameters int nb_bits = perm_len-(constraint_length-1);//number of bits in a block (without tail) vec sigma2 = (0.5*Ec/R)*pow(inv_dB(EbN0_dB), -1.0);//N0/2 double Lc;//scaling factor int nb_blocks;//number of blocks int nb_errors; ivec perm(perm_len); ivec inv_perm(perm_len); bvec bits(nb_bits); int cod_bits_len = perm_len*gen.length(); bmat cod1_bits;//tail is added bvec tail; bvec cod2_input; bmat cod2_bits; int rec_len = int(1.0/R)*perm_len; bvec coded_bits(rec_len); vec rec(rec_len); vec dec1_intrinsic_coded(cod_bits_len); vec dec2_intrinsic_coded(cod_bits_len); vec apriori_data(perm_len);//a priori LLR for information bits vec extrinsic_coded(perm_len); vec extrinsic_data(perm_len); bvec rec_bits(perm_len); int snr_len = EbN0_dB.length(); mat ber(nb_iter,snr_len); ber.zeros(); register int en,n; //Recursive Systematic Convolutional Code Rec_Syst_Conv_Code cc; cc.set_generator_polynomials(gen, constraint_length);//initial state should be the zero state //BPSK modulator BPSK bpsk; //AWGN channel AWGN_Channel channel; //SISO modules SISO siso; siso.set_generators(gen, constraint_length); siso.set_map_metric(map_metric); //BER BERC berc; //Randomize generators RNG_randomize(); //main loop for (en=0;en<snr_len;en++) { cout << "EbN0_dB = " << EbN0_dB(en) << endl; channel.set_noise(sigma2(en)); Lc = -2/sigma2(en);//normalisation factor for intrinsic information (take into account the BPSK mapping) nb_errors = 0; nb_blocks = 0; while ((nb_errors<nb_errors_lim) && (nb_blocks*nb_bits<nb_bits_lim)) { //permutation perm = sort_index(randu(perm_len)); //inverse permutation inv_perm = sort_index(perm); //bits generation bits = randb(nb_bits); //parallel concatenated convolutional code cc.encode_tail(bits, tail, cod1_bits);//tail is added here to information bits to close the trellis cod2_input = concat(bits, tail); cc.encode(cod2_input(perm), cod2_bits); for (n=0;n<perm_len;n++)//output with no puncturing { coded_bits(3*n) = cod2_input(n);//systematic output coded_bits(3*n+1) = cod1_bits(n,0);//first parity output coded_bits(3*n+2) = cod2_bits(n,0);//second parity output } //BPSK modulation (1->-1,0->+1) + AWGN channel rec = channel(bpsk.modulate_bits(coded_bits)); //form input for SISO blocks for (n=0;n<perm_len;n++) { dec1_intrinsic_coded(2*n) = Lc*rec(3*n); dec1_intrinsic_coded(2*n+1) = Lc*rec(3*n+1); dec2_intrinsic_coded(2*n) = 0.0;//systematic output of the CC is already used in decoder1 dec2_intrinsic_coded(2*n+1) = Lc*rec(3*n+2); } //turbo decoder apriori_data.zeros();//a priori LLR for information bits for (n=0;n<nb_iter;n++) { //first decoder (terminated trellis) siso.rsc(extrinsic_coded, extrinsic_data, dec1_intrinsic_coded, apriori_data, true); //interleave apriori_data = extrinsic_data(perm); //threshold apriori_data = SISO::threshold(apriori_data, threshold_value); //second decoder (unterminated trellis) siso.rsc(extrinsic_coded, extrinsic_data, dec2_intrinsic_coded, apriori_data); //decision apriori_data += extrinsic_data;//a posteriori information rec_bits = bpsk.demodulate_bits(-apriori_data(inv_perm));//take into account the BPSK mapping //count errors berc.clear(); berc.count(bits, rec_bits.left(nb_bits)); ber(n,en) += berc.get_errorrate(); //deinterleave for the next iteration apriori_data = extrinsic_data(inv_perm); }//end iterations nb_errors += int(berc.get_errors());//get number of errors at the last iteration nb_blocks++; }//end blocks (while loop) //compute BER over all tx blocks ber.set_col(en, ber.get_col(en)/nb_blocks); } it_file ff("pccc_bersim_awgn.it"); ff << Name("EbN0_dB") << EbN0_dB; ff << Name("BER") << ber; ff.close(); return 0; }
/** Channel known * Original ESE with perfect CSI */ Array<bvec> IdmaRx::receive(cvec &recv_sig, Array<cmat> &ch_coeffs, double noise_var) { LOG4CXX_DEBUG(logger, "IdmaRx::receive()"); int no_taps = ch_coeffs(0).cols(); LOG4CXX_DEBUG(logger, "channel taps = " <<no_taps); BPSK bpsk; int num_user = intls.size(); int len_recv = recv_sig.size(); Array<bvec> est_bmsgs(num_user); // TODO: To be modified if a convolutional code is not used int constraint_length = fec_wrap->get_constraint_length(); int len_tx_sym = recv_sig.size() - no_taps + 1; int len_sp_codeword = len_tx_sym * pqam->bits_per_symbol(); int len_codeword = len_sp_codeword / len_spread; int len_msg = len_codeword * fec_wrap->get_rate(); if(constraint_length>0) len_msg -= constraint_length - 1; LOG4CXX_DEBUG(logger, "constraint_length="<<constraint_length); LOG4CXX_DEBUG(logger, "len_tx_sym="<<len_tx_sym); LOG4CXX_DEBUG(logger, "len_sp_codeword="<<len_sp_codeword); LOG4CXX_DEBUG(logger, "len_codeword="<<len_codeword); LOG4CXX_DEBUG(logger, "len_msg="<<len_msg); // initialize ese ese.recv_init(recv_sig, ch_coeffs, noise_var); // Beginning from zero prior Array<vec> llr_priors(num_user); for(int i=0; i<llr_priors.size(); i++) llr_priors(i) = zeros(len_sp_codeword); // TODO: len_sp_spread for(int iter=0; iter<num_iteration; iter++) { LOG4CXX_TRACE(logger, "================================================"); LOG4CXX_TRACE(logger, " ite="<<iter<<" "); LOG4CXX_TRACE(logger, "================================================"); for(int nuser=0; nuser<num_user; nuser++) { /* ESE */ #ifdef GRAY_IDMA vec llr_ese = ese.siso_user(nuser, llr_priors(nuser)); #else vec llr_ese = ese.siso_user(nuser, recv_sig, *pqam, llr_priors(nuser)); #endif check_llr(llr_ese); LOG4CXX_DEBUG(logger, "llr_ese: "<<llr_ese); /* de-interleaving */ vec deintl_llr_ese = intls(nuser).deinterleave(llr_ese); LOG4CXX_TRACE(logger, "deintl_llr_ese: "<<deintl_llr_ese); /* despread */ vec desp_llr_prior = spreader.llr_despread(deintl_llr_ese); check_llr(desp_llr_prior); LOG4CXX_TRACE(logger, "desp_llr_prior: "<<desp_llr_prior); /* soft-decoding */ vec extrinsic_coded; vec extrinsic_data; vec appllr_coded; fec_wrap->inner_soft_decode(desp_llr_prior, extrinsic_coded, extrinsic_data, appllr_coded, true); /*with_padded*/ LOG4CXX_TRACE(logger, "extrinsic_coded="<<extrinsic_coded); LOG4CXX_DEBUG(logger, "extrinsic_data="<<extrinsic_data); LOG4CXX_DEBUG(logger, "appllr_coded="<<appllr_coded); est_bmsgs(nuser) = bpsk.demodulate_bits(extrinsic_data).left(len_msg); // hard-decoding LOG4CXX_TRACE(logger, "est_bmsgs("<<nuser<<"): "<<est_bmsgs(nuser)); /* spread */ //vec llr_sp_dec = spreader.llr_spread(extrinsic_coded) - deintl_llr_ese; vec llr_sp_dec = spreader.llr_spread(appllr_coded) - deintl_llr_ese; LOG4CXX_DEBUG(logger, "llr_sp_dec: "<<llr_sp_dec); /* interleaving */ llr_priors(nuser) = intls(nuser).interleave(llr_sp_dec); check_llr(llr_priors(nuser)); LOG4CXX_TRACE(logger, "llr_priors("<<nuser<<"): "<<llr_priors(nuser)); } } return est_bmsgs; }
int main(void) { //general parameters double threshold_value = 50; string map_metric="logMAP"; ivec gen = "037 021";//octal form int constraint_length = 5; int nb_errors_lim = 1500; int nb_bits_lim = int(1e6); int perm_len = pow2i(14);//permutation length int nb_iter = 10;//number of iterations in the turbo decoder vec EbN0_dB = "0:0.1:5"; double R = 1.0/4.0;//coding rate (non punctured SCCC) double Ec = 1.0;//coded bit energy //other parameters string filename = "Res/sccc_"+map_metric+".it"; int nb_bits_tail = perm_len/gen.length(); int nb_bits = nb_bits_tail-(constraint_length-1);//number of bits in a block (without tail) vec sigma2 = (0.5*Ec/R)*pow(inv_dB(EbN0_dB), -1.0);//N0/2 double Lc;//scaling factor for intrinsic information int nb_blocks;//number of blocks int nb_errors; bvec bits(nb_bits);//data bits bvec nsc_coded_bits;//tail is added bmat rsc_parity_bits; ivec perm(perm_len); ivec inv_perm(perm_len); int rec_len = gen.length()*perm_len; bvec coded_bits(rec_len); vec rec(rec_len); //SISO RSC vec rsc_intrinsic_coded(rec_len); vec rsc_apriori_data(perm_len); vec rsc_extrinsic_coded; vec rsc_extrinsic_data; //SISO NSC vec nsc_intrinsic_coded(perm_len); vec nsc_apriori_data(nb_bits_tail); nsc_apriori_data.zeros();//always zero vec nsc_extrinsic_coded; vec nsc_extrinsic_data; //decision bvec rec_bits(nb_bits_tail); int snr_len = EbN0_dB.length(); mat ber(nb_iter,snr_len); ber.zeros(); register int en,n; //Non recursive non Systematic Convolutional Code Convolutional_Code nsc; nsc.set_generator_polynomials(gen, constraint_length); //Recursive Systematic Convolutional Code Rec_Syst_Conv_Code rsc; rsc.set_generator_polynomials(gen, constraint_length);//initial state should be the zero state //BPSK modulator BPSK bpsk; //AWGN channel AWGN_Channel channel; //SISO blocks SISO siso; siso.set_generators(gen, constraint_length); siso.set_map_metric(map_metric); //BER BERC berc; //Progress timer tr::Progress_Timer timer; timer.set_max(snr_len); //Randomize generators RNG_randomize(); //main loop timer.progress(0.0); for (en=0;en<snr_len;en++) { channel.set_noise(sigma2(en)); Lc = -2.0/sigma2(en);//take into account the BPSK mapping nb_errors = 0; nb_blocks = 0; while ((nb_errors<nb_errors_lim) && (nb_blocks*nb_bits<nb_bits_lim))//if at the last iteration the nb. of errors is inferior to lim, then process another block { //permutation perm = sort_index(randu(perm_len)); //inverse permutation inv_perm = sort_index(perm); //bits generation bits = randb(nb_bits); //serial concatenated convolutional code nsc.encode_tail(bits, nsc_coded_bits);//tail is added here to information bits to close the trellis nsc_coded_bits = nsc_coded_bits(perm);//interleave rsc.encode(nsc_coded_bits, rsc_parity_bits);//no tail added for(n=0;n<perm_len;n++) { coded_bits(2*n) = nsc_coded_bits(n);//systematic output coded_bits(2*n+1) = rsc_parity_bits(n,0);//parity output } //BPSK modulation (1->-1,0->+1) + channel rec = channel(bpsk.modulate_bits(coded_bits)); //turbo decoder rsc_intrinsic_coded = Lc*rec;//intrinsic information of coded bits rsc_apriori_data.zeros();//a priori LLR for information bits for (n=0;n<nb_iter;n++) { //first decoder siso.rsc(rsc_extrinsic_coded, rsc_extrinsic_data, rsc_intrinsic_coded, rsc_apriori_data, false); //deinterleave+threshold nsc_intrinsic_coded = threshold(rsc_extrinsic_data(inv_perm), threshold_value); //second decoder siso.nsc(nsc_extrinsic_coded, nsc_extrinsic_data, nsc_intrinsic_coded, nsc_apriori_data, true); //decision rec_bits = bpsk.demodulate_bits(-nsc_extrinsic_data);//suppose that a priori info is zero //count errors berc.clear(); berc.count(bits, rec_bits.left(nb_bits)); ber(n,en) += berc.get_errorrate(); //interleave rsc_apriori_data = nsc_extrinsic_coded(perm); }//end iterations nb_errors += int(berc.get_errors());//get number of errors at the last iteration nb_blocks++; }//end blocks (while loop) //compute BER over all tx blocks ber.set_col(en, ber.get_col(en)/nb_blocks); //show progress timer.progress(1+en); } timer.toc_print(); #ifdef TO_FILE //save results to file it_file ff(filename); ff << Name("BER") << ber; ff << Name("EbN0_dB") << EbN0_dB; ff << Name("gen") << gen; ff << Name("R") << R; ff << Name("nb_iter") << nb_iter; ff << Name("total_nb_bits") << nb_bits; ff << Name("nb_errors_lim") << nb_errors_lim; ff << Name("nb_bits_lim") << nb_bits_lim; ff.close(); #else //show BER cout << ber << endl; #endif return 0; }
/** Channel unknown * ESE with CE */ Array<bvec> IdmaRx::receive(cvec &recv_sig, double noise_var, int no_taps) { LOG4CXX_DEBUG(logger, "IdmaRx::receive() with CE"); BPSK bpsk; int num_user = intls.size(); int len_recv = recv_sig.size(); int len_sym = len_recv - no_taps + 1; Array<bvec> est_bmsgs(num_user); LOG4CXX_TRACE(logger, "recv_sig="<<recv_sig); // TODO: To be modified if a convolutional code is not used int constraint_length = fec_wrap->get_constraint_length(); int len_msg = recv_sig.size() * 2 / len_spread * fec_wrap->get_rate(); if(constraint_length>0) len_msg -= constraint_length - 1; LOG4CXX_DEBUG(logger, "len_msg="<<len_msg); // initialize ese LOG4CXX_DEBUG(logger, "ce_init"); ese.ce_init(recv_sig, no_taps, noise_var); // Beginning from zero prior Array<vec> llr_priors(num_user); for(int i=0; i<llr_priors.size(); i++) llr_priors(i) = zeros(len_recv*2); // TODO: len_sp_spread // // Initialize ch_coeffs // Array<cmat> ch_coeffs(num_user); // for(int i=0; i<num_user; i++) { // ch_coeffs(i).set_size(len_sym, no_taps); // } /* Itarative decoding */ for(int iter=0; iter<num_iteration; iter++) { LOG4CXX_TRACE(logger, "================================================"); LOG4CXX_TRACE(logger, " ite="<<iter<<" "); LOG4CXX_TRACE(logger, "================================================"); for(int nuser=0; nuser<num_user; nuser++) { /* Channel estimation * Single-path and block fading channel only * TODO: multipath & time-varying channels */ #ifdef LI_CE cvec hval = ese.li_est_ch(nuser, llr_priors(nuser)); #else cvec hval = ese.est_ch(nuser, llr_priors(nuser)); #endif LOG4CXX_DEBUG(logger, "hval: "<<hval); /* SISO */ // TODO: check #ifdef GRAY_IDMA vec llr_ese = ese.ce_siso_user(nuser); #else vec llr_ese = ese.ce_siso_user(nuser, recv_sig, *pqam, llr_priors(nuser)); #endif check_llr(llr_ese); LOG4CXX_TRACE(logger, "llr_ese: "<<llr_ese); /* de-interleaving */ vec deintl_llr_ese = intls(nuser).deinterleave(llr_ese); LOG4CXX_TRACE(logger, "deintl_llr_ese: "<<deintl_llr_ese); /* despread */ vec desp_llr_prior = spreader.llr_despread(deintl_llr_ese); LOG4CXX_TRACE(logger, "desp_llr_prior: "<<desp_llr_prior); /* soft-decoding */ vec extrinsic_coded; vec extrinsic_data; vec appllr_coded; fec_wrap->inner_soft_decode(desp_llr_prior, extrinsic_coded, extrinsic_data, appllr_coded, true); /*with_padded*/ LOG4CXX_TRACE(logger, "extrinsic_coded="<<extrinsic_coded); LOG4CXX_TRACE(logger, "extrinsic_data="<<extrinsic_data); LOG4CXX_DEBUG(logger, "appllr_coded="<<appllr_coded); est_bmsgs(nuser) = bpsk.demodulate_bits(extrinsic_data).left(len_msg); // hard-decoding LOG4CXX_TRACE(logger, "est_bmsgs("<<nuser<<"): "<<est_bmsgs(nuser)); /* spread */ //vec llr_sp_dec = spreader.llr_spread(extrinsic_coded) - deintl_llr_ese; vec llr_sp_dec = spreader.llr_spread(appllr_coded) - deintl_llr_ese; LOG4CXX_TRACE(logger, "llr_sp_dec: "<<llr_sp_dec); /* interleaving */ llr_priors(nuser) = intls(nuser).interleave(llr_sp_dec); check_llr(llr_priors(nuser)); LOG4CXX_TRACE(logger, "llr_priors("<<nuser<<"): "<<llr_priors(nuser)); } mse.calculate(iter, ese.get_h()); } return est_bmsgs; }
int main(void) { //general parameters double threshold_value = 50; string map_metric = "maxlogMAP"; ivec gen = "07 05";//octal notation int constraint_length = 3; int ch_nb_taps = 4;//number of channel multipaths int nb_errors_lim = 3000; int nb_bits_lim = int(1e6); int perm_len = pow2i(14);//permutation length int nb_iter = 10;//number of iterations in the turbo decoder vec EbN0_dB = "0:0.5:10"; double R = 1.0 / 2.0;//coding rate of FEC double Ec = 1.0;//coded bit energy #ifdef USE_PRECODER ivec prec_gen = "03 02";//octal notation int prec_gen_length = 2; #endif //other parameters int nb_bits_tail = perm_len / gen.length(); int nb_bits = nb_bits_tail - (constraint_length - 1);//number of bits in a block (without tail) vec sigma2 = (0.5 * Ec / R) * pow(inv_dB(EbN0_dB), -1.0);//N0/2 int nb_blocks;//number of blocks int nb_errors; bvec bits(nb_bits);//data bits bvec nsc_coded_bits(perm_len);//tail is added bvec em_bits(perm_len); bmat parity_bits; ivec perm(perm_len); ivec inv_perm(perm_len); vec rec(perm_len); //SISO equalizer vec eq_apriori_data(perm_len); vec eq_extrinsic_data; //SISO NSC vec nsc_intrinsic_coded(perm_len); vec nsc_apriori_data(nb_bits_tail); nsc_apriori_data.zeros();//always zero vec nsc_extrinsic_coded; vec nsc_extrinsic_data; //decision bvec rec_bits(nb_bits_tail); int snr_len = EbN0_dB.length(); mat ber(nb_iter, snr_len); ber.zeros(); register int en, n; //CCs Convolutional_Code nsc; nsc.set_generator_polynomials(gen, constraint_length); #ifdef USE_PRECODER Rec_Syst_Conv_Code prec; prec.set_generator_polynomials(prec_gen, prec_gen_length); #endif //BPSK BPSK bpsk; //AWGN AWGN_Channel awgn; //multipath channel impulse response (Rayleigh fading) with real coefficients vec ch_imp_response(ch_nb_taps); vec ini_state = ones(ch_nb_taps);//initial state is zero MA_Filter<double, double, double> multipath_channel; //SISO blocks SISO siso; siso.set_generators(gen, constraint_length); siso.set_map_metric(map_metric); #ifdef USE_PRECODER siso.set_precoder_generator(prec_gen(0), prec_gen_length); #endif //BER BERC berc; //Randomize generators RNG_randomize(); //main loop for (en = 0;en < snr_len;en++) { cout << "EbN0_dB = " << EbN0_dB(en) << endl; awgn.set_noise(sigma2(en)); siso.set_noise(sigma2(en)); nb_errors = 0; nb_blocks = 0; while ((nb_errors < nb_errors_lim) && (nb_blocks*nb_bits < nb_bits_lim))//if at the last iteration the nb. of errors is inferior to lim, then process another block { //permutation perm = sort_index(randu(perm_len)); //inverse permutation inv_perm = sort_index(perm); //bits generation bits = randb(nb_bits); //convolutional code nsc.encode_tail(bits, nsc_coded_bits);//tail is added here to information bits to close the trellis //permutation em_bits = nsc_coded_bits(perm); #ifdef USE_PRECODER //precoder prec.encode(em_bits, parity_bits); em_bits = parity_bits.get_col(0); #endif //BPSK modulation (1->-1,0->+1) + multipath channel ch_imp_response = randray(ch_nb_taps); ch_imp_response /= sqrt(sum_sqr(ch_imp_response));//normalized power profile multipath_channel.set_coeffs(ch_imp_response); multipath_channel.set_state(ini_state);//inital state is zero rec = awgn(multipath_channel(bpsk.modulate_bits(em_bits))); //turbo equalizer eq_apriori_data.zeros();//a priori information of emitted symbols siso.set_impulse_response(ch_imp_response); for (n = 0;n < nb_iter;n++) { //first decoder siso.equalizer(eq_extrinsic_data, rec, eq_apriori_data, false);//no tail //deinterleave+threshold nsc_intrinsic_coded = SISO::threshold(eq_extrinsic_data(inv_perm), threshold_value); //second decoder siso.nsc(nsc_extrinsic_coded, nsc_extrinsic_data, nsc_intrinsic_coded, nsc_apriori_data, true);//tail //decision rec_bits = bpsk.demodulate_bits(-nsc_extrinsic_data);//assume that a priori info is zero //count errors berc.clear(); berc.count(bits, rec_bits.left(nb_bits)); ber(n, en) += berc.get_errorrate(); //interleave eq_apriori_data = nsc_extrinsic_coded(perm); }//end iterations nb_errors += int(berc.get_errors());//get number of errors at the last iteration nb_blocks++; }//end blocks (while loop) //compute BER over all tx blocks ber.set_col(en, ber.get_col(en) / nb_blocks); } //save results to file it_file ff("turbo_equalizer_bersim_multipath.it"); ff << Name("BER") << ber; ff << Name("EbN0_dB") << EbN0_dB; ff.close(); return 0; }
TEST(SISO, all) { //general parameters string map_metric="maxlogMAP"; ivec gen = "07 05";//octal form, feedback first int constraint_length = 3; int nb_errors_lim = 300; int nb_bits_lim = int(1e4); int perm_len = (1<<14);//total number of bits in a block (with tail) int nb_iter = 10;//number of iterations in the turbo decoder vec EbN0_dB = "0.0 0.5 1.0 1.5 2.0"; double R = 1.0/3.0;//coding rate (non punctured PCCC) double Ec = 1.0;//coded bit energy //other parameters int nb_bits = perm_len-(constraint_length-1);//number of bits in a block (without tail) vec sigma2 = (0.5*Ec/R)*pow(inv_dB(EbN0_dB), -1.0);//N0/2 double Lc;//scaling factor int nb_blocks;//number of blocks int nb_errors; ivec perm(perm_len); ivec inv_perm(perm_len); bvec bits(nb_bits); int cod_bits_len = perm_len*gen.length(); bmat cod1_bits;//tail is added bvec tail; bvec cod2_input; bmat cod2_bits; int rec_len = int(1.0/R)*perm_len; bvec coded_bits(rec_len); vec rec(rec_len); vec dec1_intrinsic_coded(cod_bits_len); vec dec2_intrinsic_coded(cod_bits_len); vec apriori_data(perm_len);//a priori LLR for information bits vec extrinsic_coded(perm_len); vec extrinsic_data(perm_len); bvec rec_bits(perm_len); int snr_len = EbN0_dB.length(); mat ber(nb_iter,snr_len); ber.zeros(); register int en,n; //Recursive Systematic Convolutional Code Rec_Syst_Conv_Code cc; cc.set_generator_polynomials(gen, constraint_length);//initial state should be the zero state //BPSK modulator BPSK bpsk; //AWGN channel AWGN_Channel channel; //SISO modules SISO siso; siso.set_generators(gen, constraint_length); siso.set_map_metric(map_metric); //BER BERC berc; //Fix random generators RNG_reset(12345); //main loop for (en=0;en<snr_len;en++) { channel.set_noise(sigma2(en)); Lc = -2/sigma2(en);//normalisation factor for intrinsic information (take into account the BPSK mapping) nb_errors = 0; nb_blocks = 0; while ((nb_errors<nb_errors_lim) && (nb_blocks*nb_bits<nb_bits_lim))//if at the last iteration the nb. of errors is inferior to lim, then process another block { //permutation perm = sort_index(randu(perm_len)); //inverse permutation inv_perm = sort_index(perm); //bits generation bits = randb(nb_bits); //parallel concatenated convolutional code cc.encode_tail(bits, tail, cod1_bits);//tail is added here to information bits to close the trellis cod2_input = concat(bits, tail); cc.encode(cod2_input(perm), cod2_bits); for (n=0;n<perm_len;n++)//output with no puncturing { coded_bits(3*n) = cod2_input(n);//systematic output coded_bits(3*n+1) = cod1_bits(n,0);//first parity output coded_bits(3*n+2) = cod2_bits(n,0);//second parity output } //BPSK modulation (1->-1,0->+1) + AWGN channel rec = channel(bpsk.modulate_bits(coded_bits)); //form input for SISO blocks for (n=0;n<perm_len;n++) { dec1_intrinsic_coded(2*n) = Lc*rec(3*n); dec1_intrinsic_coded(2*n+1) = Lc*rec(3*n+1); dec2_intrinsic_coded(2*n) = 0.0;//systematic output of the CC is already used in decoder1 dec2_intrinsic_coded(2*n+1) = Lc*rec(3*n+2); } //turbo decoder apriori_data.zeros();//a priori LLR for information bits for (n=0;n<nb_iter;n++) { //first decoder siso.rsc(extrinsic_coded, extrinsic_data, dec1_intrinsic_coded, apriori_data, true); //interleave apriori_data = extrinsic_data(perm); //second decoder siso.rsc(extrinsic_coded, extrinsic_data, dec2_intrinsic_coded, apriori_data, false); //decision apriori_data += extrinsic_data;//a posteriori information rec_bits = bpsk.demodulate_bits(-apriori_data(inv_perm));//take into account the BPSK mapping //count errors berc.clear(); berc.count(bits, rec_bits.left(nb_bits)); ber(n,en) += berc.get_errorrate(); //deinterleave for the next iteration apriori_data = extrinsic_data(inv_perm); }//end iterations nb_errors += int(berc.get_errors());//get number of errors at the last iteration nb_blocks++; }//end blocks (while loop) //compute BER over all tx blocks ber.set_col(en, ber.get_col(en)/nb_blocks); } // Results for max log MAP algorithm vec ref = "0.158039 0.110731 0.0770358 0.0445611 0.0235014"; assert_vec(ref, ber.get_row(0)); ref = "0.14168 0.0783177 0.0273471 0.00494445 0.00128189"; assert_vec(ref, ber.get_row(1)); ref = "0.141375 0.0565865 0.00817971 0.000305213 0"; assert_vec(ref, ber.get_row(2)); ref = "0.142412 0.0421194 0.000732511 0 0"; assert_vec(ref, ber.get_row(3)); ref = "0.144244 0.0282017 0.000183128 0 0"; assert_vec(ref, ber.get_row(4)); ref = "0.145587 0.0142229 0 0 0"; assert_vec(ref, ber.get_row(5)); ref = "0.148517 0.00714199 0 0 0"; assert_vec(ref, ber.get_row(6)); ref = "0.141619 0.00225858 0 0 0"; assert_vec(ref, ber.get_row(7)); ref = "0.149676 0.000549383 0 0 0"; assert_vec(ref, ber.get_row(8)); ref = "0.14461 0 0 0 0"; assert_vec(ref, ber.get_row(9)); }
int main(void) { //general parameters string mud_method = "maxlogTMAP"; int nb_usr = 2; int spreading_factor = 16; #ifdef USE_CC string map_metric="maxlogMAP"; ivec gen = "037 021"; int constraint_length = 5; spreading_factor = 8; #endif double threshold_value = 50; int ch_nb_taps = 4;//number of channel multipaths int nb_errors_lim = 1500; int nb_bits_lim = int(1e3);//int(1e6); int perm_len = 1024;//38400;//permutation length int nb_iter = 15;//number of iterations in the turbo decoder vec EbN0_dB = "10";//"0:10:20"; double Ec = 1.0;//chip energy #ifdef USE_CC int inv_R = spreading_factor*gen.length(); #else int inv_R = spreading_factor; #endif double R = 1.0/double(inv_R);//coding rate //other parameters string filename = "IDMA_"+mud_method+"_"+to_str(nb_usr)+".it"; #ifdef USE_CC filename = "cc"+filename; #endif filename = "Res/"+filename; int nb_bits = perm_len/inv_R;//number of bits in a block vec sigma2 = (0.5*Ec/R)*pow(inv_dB(EbN0_dB), -1.0);//N0/2 int nb_blocks = 0;//number of blocks int nb_errors = 0;//number of errors bmat bits(nb_usr,nb_bits);//data bits #ifdef USE_CC bvec coded_bits(nb_bits*gen.length()); vec mod_bits(nb_bits*gen.length()); #else vec mod_bits(nb_bits); #endif vec chips(perm_len); imat perm(nb_usr,perm_len); imat inv_perm(nb_usr,perm_len); vec em(perm_len); vec rec(perm_len+ch_nb_taps-1);//padding zeros are added //SISO MUD mat mud_apriori_data(nb_usr,perm_len); mat mud_extrinsic_data; //SISO decoder (scrambler or CC) vec dec_intrinsic_coded(perm_len); vec dec_apriori_data(nb_bits); dec_apriori_data.zeros();//always zero vec dec_extrinsic_coded; vec dec_extrinsic_data; //decision bvec rec_bits(nb_bits); int snr_len = EbN0_dB.length(); mat ber(nb_iter,snr_len); ber.zeros(); register int en,n,u; #ifdef USE_CC //CC Convolutional_Code nsc; nsc.set_generator_polynomials(gen, constraint_length); #endif //BPSK BPSK bpsk; //scrambler pattern vec pattern = kron(ones(spreading_factor/2), vec("1.0 -1.0")); //AWGN AWGN_Channel awgn; //multipath channel impulse response (Rayleigh fading) with real coefficients vec single_ch(ch_nb_taps); mat ch_imp_response(nb_usr, ch_nb_taps); vec ini_state = zeros(ch_nb_taps); MA_Filter<double,double,double> multipath_channel(ini_state); multipath_channel.set_state(ini_state);//initial state is always 0 due to Zero Padding technique vec padding_zeros = zeros(ch_nb_taps-1); //SISO blocks SISO siso; siso.set_scrambler_pattern(pattern); siso.set_mud_method(mud_method); #ifdef USE_CC siso.set_generators(gen, constraint_length); siso.set_map_metric(map_metric); siso.set_tail(false); #endif //BER BERC berc; //progress timer tr::Progress_Timer timer; timer.set_max(snr_len); //Randomize generators RNG_randomize(); //main loop timer.progress(0.0); for (en=0; en<snr_len; en++) { awgn.set_noise(sigma2(en)); siso.set_noise(sigma2(en)); nb_errors = 0; nb_blocks = 0; while ((nb_errors<nb_errors_lim) && (nb_blocks*nb_bits<nb_bits_lim))//if at the last iteration the nb. of errors is inferior to lim, then process another block { rec.zeros(); for (u=0; u<nb_usr; u++) { //permutation perm.set_row(u, sort_index(randu(perm_len))); //inverse permutation inv_perm.set_row(u, sort_index(perm.get_row(u))); //bits generation bits.set_row(u, randb(nb_bits)); #ifdef USE_CC //convolutional code nsc.encode(bits.get_row(u), coded_bits);//no tail //BPSK modulation (1->-1,0->+1) mod_bits = bpsk.modulate_bits(coded_bits); #else //BPSK modulation (1->-1,0->+1) mod_bits = bpsk.modulate_bits(bits.get_row(u)); #endif //scrambler chips = kron(mod_bits, pattern); //permutation em = chips(perm.get_row(u)); //multipath channel single_ch = randray(ch_nb_taps); single_ch /= sqrt(sum_sqr(single_ch));//normalized power profile ch_imp_response.set_row(u, single_ch); multipath_channel.set_coeffs(ch_imp_response.get_row(u)); rec += multipath_channel(concat(em, padding_zeros));//Zero Padding } rec = awgn(rec); //turbo MUD mud_apriori_data.zeros();//a priori LLR of emitted symbols siso.set_impulse_response(ch_imp_response); for (n=0; n<nb_iter; n++) { //MUD siso.mud(mud_extrinsic_data, rec, mud_apriori_data); berc.clear();//mean error rate over all users for (u=0; u<nb_usr; u++) { //deinterleave dec_intrinsic_coded = mud_extrinsic_data.get_row(u)(inv_perm.get_row(u)); #ifdef USE_CC //decoder+descrambler siso.nsc(dec_extrinsic_coded, dec_extrinsic_data, dec_intrinsic_coded, dec_apriori_data); #else //descrambler siso.descrambler(dec_extrinsic_coded, dec_extrinsic_data, dec_intrinsic_coded, dec_apriori_data); #endif //decision rec_bits = bpsk.demodulate_bits(-dec_extrinsic_data);//suppose that a priori info is zero //count errors berc.count(bits.get_row(u), rec_bits); //interleave+threshold mud_apriori_data.set_row(u, threshold(dec_extrinsic_coded(perm.get_row(u)), threshold_value)); } ber(n,en) += berc.get_errorrate(); }//end iterations nb_errors += int(berc.get_errors());//get number of errors at the last iteration nb_blocks++; }//end blocks (while loop) //compute BER over all tx blocks ber.set_col(en, ber.get_col(en)/nb_blocks); //show progress timer.progress(1+en); } timer.toc_print(); //save results to file #ifdef TO_FILE it_file ff(filename); ff << Name("BER") << ber; ff << Name("EbN0_dB") << EbN0_dB; ff << Name("nb_usr") << nb_usr; ff << Name("gen") << spreading_factor; ff << Name("nb_iter") << nb_iter; ff << Name("total_nb_bits") << nb_bits; ff << Name("nb_errors_lim") << nb_errors_lim; ff << Name("nb_bits_lim") << nb_bits_lim; #ifdef USE_CC ff << Name("gen") << gen; #endif ff.close(); #else //show BER cout << ber << endl; #endif return 0; }
int main(int argc, char *argv[]) { //receiver parameters ivec gen = "0133 0171"; int constraint_length = 7; int const_size = 16;//constellation size int coherence_time = 512;//expressed in symbol durations, multiple of T, T<=coherence_time<=tx_duration, T is the ST code duration double threshold_value = 50; string map_metric="maxlogMAP"; string demapper_method = "mmsePIC";//Hassibi_maxlogMAP or GA or sGA or mmsePIC or zfPIC or Alamouti_maxlogMAP int nb_errors_lim = 1500; int nb_bits_lim = int(1e6); int perm_len = pow2i(14);//permutation length int nb_iter = 5;//number of iterations in the turbo decoder int rec_antennas = 2;//number of reception antennas vec EbN0_dB = "0:20"; double Es = 1.0;//mean symbol energy int em_antennas = 2;//number of emission antennas int channel_uses = 1;//ST code duration string code_name = "V-BLAST_MxN";//V-BLAST_MxN, Golden_2x2, Damen_2x2, Alamouti_2xN bool ideal_channel = false; bool to_file = false; //get parameters if any if (EXIT_FAILURE == get_opts(argc, argv, demapper_method, const_size, nb_errors_lim, nb_bits_lim, perm_len, nb_iter, rec_antennas, em_antennas, channel_uses, code_name, ideal_channel, to_file, EbN0_dB)) { print_help(argv[0]); return EXIT_FAILURE; } //convolutional code generator polynomials Convolutional_Code nsc; nsc.set_generator_polynomials(gen, constraint_length); double coding_rate = 1.0/2.0; //QAM modulator class QAM mod(const_size); //Space-Time code parameters STC st_block_code(code_name, const_size, em_antennas, channel_uses);//generate matrices for LD code (following Hassibi's approach) int symb_block = st_block_code.get_nb_symbols_per_block(); em_antennas = st_block_code.get_nb_emission_antenna();//these parameters could by changed depending on the selected code channel_uses = st_block_code.get_channel_uses(); //recompute interleaver length int G = coherence_time*mod.bits_per_symbol()*symb_block; perm_len = G*(perm_len/G);//recompute interleaver length int block_len = int(coding_rate*perm_len);//informational block length int nb_symb = perm_len/mod.bits_per_symbol();//number of symbols at the modulator output int nb_subblocks = nb_symb/symb_block;//number of blocks of ST code emitted in an interleaver period int tx_duration = channel_uses*nb_subblocks;//transmission duration expressed in number of symbol periods //show configuration parameters std::cout << "const_size = " << const_size << "\ndemapper_method = " << demapper_method << "\nnb_errors_lim = " << nb_errors_lim << "\nnb_bits_lim = " << nb_bits_lim << "\nperm_len = " << perm_len << "\ncode_name = " << code_name << "\nem_antennas = " << em_antennas << "\nchannel_uses = " << channel_uses << "\nnb_iter = " << nb_iter << "\nrec_antennas = " << rec_antennas << "\nEbN0_dB = " << EbN0_dB << std::endl; if (true == ideal_channel) { if (em_antennas == rec_antennas) { std::cout << "Using ideal AWGN MIMO channel (no MAI)" << std::endl; } else { std::cout << "Warning: cannot use ideal AWGN MIMO channel" << std::endl; ideal_channel = false; } } else { std::cout << "Using random MIMO channel (with MAI)" << std::endl; } //fading channel parameters if (coherence_time%channel_uses)//check if the coherence time is a multiple of channel_uses { coherence_time = channel_uses*(coherence_time/channel_uses); std::cout << "Warning! The coherence time must be a multiple of T. Choosing coherence_time=channel_uses*floor(coherence_time/channel_uses) = "\ << coherence_time << std::endl; } if (coherence_time>tx_duration) { coherence_time = channel_uses*(tx_duration/channel_uses); std::cout << "Warning! The coherence time must be <= tx_duration. Choosing coherence_time = channel_uses*floor(tx_duration/channel_uses) = "\ << coherence_time << std::endl; } cmat fading_pattern = ones_c(1, coherence_time/channel_uses); //other parameters string filename = "STBICM_"+map_metric+"_"+demapper_method+".it"; if (true == to_file) { std::cout << "Saving results to " << filename << std::endl; } double R = coding_rate*double(mod.bits_per_symbol()*symb_block)/double(channel_uses);//ST code rate in (info.) bits/channel use vec sigma2 = (0.5*Es/(R*double(mod.bits_per_symbol())))*pow(inv_dB(EbN0_dB), -1.0);//N0/2 int nb_blocks;//number of blocks int nb_errors; bvec bits(block_len);//data bits bvec coded_bits(perm_len);//no tail cvec em(nb_symb); ivec perm(perm_len); ivec inv_perm(perm_len); //SISO demapper vec demapper_apriori_data(perm_len); vec demapper_extrinsic_data(perm_len); //SISO NSC vec nsc_intrinsic_coded(perm_len); vec nsc_apriori_data(block_len); nsc_apriori_data.zeros();//always zero vec nsc_extrinsic_coded(perm_len); vec nsc_extrinsic_data(block_len); //decision bvec rec_bits(block_len); int snr_len = EbN0_dB.length(); mat ber(nb_iter,snr_len); ber.zeros(); register int en,n,ns; cmat S(tx_duration, em_antennas); cmat rec(tx_duration,rec_antennas); //Rayleigh fading cmat ch_attenuations(em_antennas*rec_antennas,tx_duration/channel_uses); //SISO blocks SISO siso; siso.set_map_metric(map_metric); siso.set_generators(gen, constraint_length); siso.set_demapper_method(demapper_method); siso.set_constellation(mod.bits_per_symbol(), mod.get_symbols()/sqrt(em_antennas), mod.get_bits2symbols()); siso.set_st_block_code(st_block_code.get_nb_symbols_per_block(), st_block_code.get_1st_gen_matrix(), st_block_code.get_2nd_gen_matrix(), rec_antennas); //decision BPSK bpsk; //BER BERC berc; //Randomize generators RNG_randomize(); //main loop std::cout << std::endl; for (en=0;en<snr_len;en++) { std::cout << "EbN0_dB = " << EbN0_dB[en] << std::endl; siso.set_noise(sigma2(en)); nb_errors = 0; nb_blocks = 0; while ((nb_errors<nb_errors_lim) && (nb_blocks*block_len<nb_bits_lim))//if at the last iteration the nb. of errors is inferior to lim, then process another block { //permutation perm = sort_index(randu(perm_len)); //inverse permutation inv_perm = sort_index(perm); //bits generation bits = randb(block_len); //convolutional code nsc.encode(bits, coded_bits);//no tail //permutation+QAM modulation em = mod.modulate_bits(coded_bits(perm))/sqrt(em_antennas);//normalize emitted symbols //ST code S = st_block_code.encode(em); /* channel matrices (there are tx_duration/tau_c different channel matrices MxN) * a channel matrix is represented as a M*Nx1 vector (first M elements are the first column of the channel matrix) * the channel matrix is constant over tau_c symbol periods (a multiple of T symbol durations) * the channel matrix is the transpose of the true channel matrix */ if (false == ideal_channel) { ch_attenuations = kron(randn_c(em_antennas*rec_antennas, tx_duration/coherence_time), fading_pattern); } else { cmat mimo_channel = kron(reshape(eye_c(em_antennas), em_antennas*rec_antennas, 1), ones_c(1, tx_duration/coherence_time)); ch_attenuations = kron(mimo_channel, fading_pattern); } //flat-fading MIMO channel for (ns=0;ns<nb_subblocks;ns++) rec.set_submatrix(ns*channel_uses, 0, \ S(ns*channel_uses, (ns+1)*channel_uses-1, 0, em_antennas-1)*reshape(ch_attenuations.get_col(ns), em_antennas, rec_antennas)); rec += sqrt(2*sigma2(en))*randn_c(tx_duration,rec_antennas);//sigma2 is the variance on each dimension //turbo receiver demapper_apriori_data.zeros();//a priori information of emitted bits siso.set_impulse_response(ch_attenuations); for (n=0;n<nb_iter;n++) { //first decoder siso.demapper(demapper_extrinsic_data, rec, demapper_apriori_data); //deinterleave+threshold nsc_intrinsic_coded = SISO::threshold(demapper_extrinsic_data(inv_perm), threshold_value); //second decoder siso.nsc(nsc_extrinsic_coded, nsc_extrinsic_data, nsc_intrinsic_coded, nsc_apriori_data, false); //decision rec_bits = bpsk.demodulate_bits(-nsc_extrinsic_data);//suppose that a priori info is zero //count errors berc.clear(); berc.count(bits, rec_bits); ber(n,en) += berc.get_errorrate(); //interleave demapper_apriori_data = nsc_extrinsic_coded(perm); }//end iterations nb_errors += int(berc.get_errors());//get number of errors at the last iteration nb_blocks++; }//end blocks (while loop) //compute BER over all tx blocks ber.set_col(en, ber.get_col(en)/nb_blocks); } if (true == to_file) { //save results to file it_file ff(filename); ff << Name("BER") << ber; ff << Name("EbN0_dB") << EbN0_dB; ff << Name("gen") << gen; ff << Name("coding_rate") << coding_rate; ff << Name("nb_iter") << nb_iter; ff << Name("block_len") << block_len; ff << Name("nb_errors_lim") << nb_errors_lim; ff << Name("nb_bits_lim") << nb_bits_lim; ff << Name("const_size") << const_size; ff.close(); } else { //show BER cout << "BER = " << ber << endl; } return 0; }