Turbo with CRC

[jdayana]

Hi,

I am having some trouble with the usage of CRC for the Turbo Code implementation using the AFF3CT library. I am getting the following error:

The following is the test code I used:

#include "aff3ct.hpp"
using namespace aff3ct;

int main(int argc, char** argv)
{
    char  arg0[] = "FactoryProject.exe";
    // Encoder parameters
    char  E1Name[] = "-K";
    char  E1Value[] = "40";         // info bits
    char  E2Name[] = "--enc-sub-std";
    char  E2Value[] = "LTE";        // standard: CCSDS, LTE
    char  E3Name[] = "--enc-sub-type";
    char  E3Value[] = "RSC";        // encoder type
    char  E4Name[] = "--enc-type";
    char  E4Value[] = "TURBO";      // encoder type

    // Decoder parameters
    char  D1Name[] = "--dec-implem";
    char  D1Value[] = "STD";        // algo implementation: FAST, NAIVE, STD
    char  D2Name[] = "--dec-ite";
    char  D2Value[] = "6";          // no. of iterations
    char  D3Name[] = "--dec-sf-type";
    char  D3Value[] = "LTE";        // scaling factor: ADAPTIVE, ARRAY, CST, LTE, LTE_VEC
    char  D4Name[] = "--dec-sub-implem";
    char  D4Value[] = "STD";        // algo implementation: FAST, GENERIC, NAIVE, STD, VERY_FAST
    char  D5Name[] = "--dec-sub-max";
    char  D5Value[] = "MAX";        // MAX implementation for the nodes: MAX, MAXL, MAXS
    char  D6Name[] = "--dec-sub-type";
    char  D6Value[] = "BCJR";       // decode algo
    char  D7Name[] = "--dec-type";
    char  D7Value[] = "TURBO";      // decode algo
    char  D8Name[] = "--crc-poly";
    char  D8Value[] = "0x864CFB";       // crc poly
    char  D9Name[] = "--crc-size";
    char  D9Value[] = "24";             // crc size
    char* argList[] = { &arg0[0], &E1Name[0], &E1Value[0], &E2Name[0], &E2Value[0], &E3Name[0], &E3Value[0], &E4Name[0], &E4Value[0], &D1Name[0], &D1Value[0], &D2Name[0], &D2Value[0], &D3Name[0], &D3Value[0], &D4Name[0], &D4Value[0], &D5Name[0], &D5Value[0], &D6Name[0], &D6Value[0], &D7Name[0], &D7Value[0], &D8Name[0], &D8Value[0], &D9Name[0], &D9Value[0], NULL };

    const int   K =  40;                // number of information bits
    const int   N =  K * 3 + 12;        // codeword size
    int   fe = 100;
    int   seed = 0;                   // PRNG seed for the AWGN channel
    float ebn0_min = 0.00f;            // minimum SNR value
    float ebn0_max = 1.01f;           // maximum SNR value
    float ebn0_step = 0.25f;          // SNR step
    float R = (float)K / (float)N;    // code rate (R=K/N)

    std::vector<int  > ref_bits = std::vector<int  >(K);
    std::vector<int  > enc_bits = std::vector<int  >(N);
    std::vector<float> symbols = std::vector<float>(N);
    std::vector<float> noisy_symbols = std::vector<float>(N);
    std::vector<float> LLRs = std::vector<float>(N);
    std::vector<int  > dec_bits = std::vector<int  >(K);

    std::unique_ptr<module::Source_random<>>        source;
    std::unique_ptr<module::Modem_BPSK<>>           modem;
    std::unique_ptr<module::Channel_AWGN_LLR<>>     channel;
    std::unique_ptr<module::Monitor_BFER<>>         monitor;

    source = std::unique_ptr<module::Source_random          <>>(new module::Source_random         <>(K));
    modem = std::unique_ptr<module::Modem_BPSK              <>>(new module::Modem_BPSK            <>(N));
    channel = std::unique_ptr<module::Channel_AWGN_LLR      <>>(new module::Channel_AWGN_LLR      <>(N, seed));
    monitor = std::unique_ptr<module::Monitor_BFER          <>>(new module::Monitor_BFER          <>(K, fe));

    std::unique_ptr<factory::Codec_turbo::parameters> p_codec;
    std::unique_ptr<module::Codec_SIHO<>>   m_codec;
    p_codec = std::unique_ptr<factory::Codec_turbo::parameters>(new factory::Codec_turbo::parameters());
    std::vector<factory::Factory::parameters*> params_list = { p_codec.get() };
    int   noOfArgs = (int)(sizeof(argList) / sizeof(argList[0])) - 1;
    factory::Command_parser cp(noOfArgs, argList, params_list, true);
    if (cp.parsing_failed())
    {
        cp.print_help();
        cp.print_warnings();
        cp.print_errors();
        std::exit(1);
    }
    m_codec = std::unique_ptr<module::Codec_SIHO  <>>(p_codec->build());
    module::Encoder<>* encoder;
    module::Decoder_SIHO<>* decoder;
    encoder = m_codec->get_encoder().get();
    decoder = m_codec->get_decoder_siho().get();
    auto& interleaver = m_codec->get_interleaver();
    interleaver->init();

    R = (float)p_codec->enc->K / (float)p_codec->enc->N_cw; // compute the code rate

    std::unique_ptr<tools::Sigma<>>               noise;     // a sigma noise type
    std::vector<std::unique_ptr<tools::Reporter>> reporters; // list of reporters dispayed in the terminal
    std::unique_ptr<tools::Terminal_std>          terminal;  // manage the output text in the terminal

    // create a sigma noise type
    noise = std::unique_ptr<tools::Sigma<>>(new tools::Sigma<>());
    // report the noise values (Es/N0 and Eb/N0)
    reporters.push_back(std::unique_ptr<tools::Reporter>(new tools::Reporter_noise<>(*noise)));
    // report the bit/frame error rates
    reporters.push_back(std::unique_ptr<tools::Reporter>(new tools::Reporter_BFER<>(*monitor)));
    // report the simulation throughputs
    reporters.push_back(std::unique_ptr<tools::Reporter>(new tools::Reporter_throughput<>(*monitor)));
    // create a terminal that will display the collected data from the reporters
    terminal = std::unique_ptr<tools::Terminal_std>(new tools::Terminal_std(reporters));

    // get the AFF3CT version
    const std::string v = "v" + std::to_string(tools::version_major()) + "." +
        std::to_string(tools::version_minor()) + "." +
        std::to_string(tools::version_release());

    std::cout << "#----------------------------------------------------------" << std::endl;
    std::cout << "# This is a basic program using the AFF3CT library (" << v << ")" << std::endl;
    std::cout << "# Feel free to improve it as you want to fit your needs." << std::endl;
    std::cout << "#----------------------------------------------------------" << std::endl;
    std::cout << "#" << std::endl;

    std::cout << "# Simulation parameters: " << std::endl;
    factory::Header::print_parameters(params_list); // display the headers (= print the AFF3CT parameters on the screen)
    std::cout << "#" << std::endl;
    cp.print_warnings();

    // display the legend in the terminal
    terminal->legend();

    // loop over the various SNRs
    for (auto ebn0 = ebn0_min; ebn0 < ebn0_max; ebn0 += ebn0_step)
    {
        // compute the current sigma for the channel noise
        const auto esn0 = tools::ebn0_to_esn0(ebn0, R);
        const auto sigma = tools::esn0_to_sigma(esn0);

        noise->set_noise(sigma, ebn0, esn0);

        // update the sigma of the modem and the channel
        modem->set_noise(*noise);
        channel->set_noise(*noise);

        // display the performance (BER and FER) in real time (in a separate thread)
        terminal->start_temp_report();

        // run the simulation chain
        while (!monitor->fe_limit_achieved() && !terminal->is_interrupt())
        {
            source->generate(ref_bits);
            encoder->encode(ref_bits, enc_bits);
            modem->modulate(enc_bits, symbols);
            channel->add_noise(symbols, noisy_symbols);
            modem->demodulate(noisy_symbols, LLRs);
            decoder->decode_siho(LLRs, dec_bits);
            monitor->check_errors(dec_bits, ref_bits);
        }

        // display the performance (BER and FER) in the terminal
        terminal->final_report();

        // reset the monitor for the next SNR
        monitor->reset();
        terminal->reset();

        // if user pressed Ctrl+c twice, exit the SNRs loop
        if (terminal->is_over()) break;
    }

    std::cout << "# End of the simulation" << std::endl;

    system("pause");
    return 0;
}

Is there something I am missing?

I hope to hear from you.

Thanks, Dayana

[kouchy]

Hi @jdayana,

This is because the CRC parameters have to be given to a factory::CRC and not to a factory::Codec_turbo.

I hope it helps.