#include "stdafx.h"
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <stdio.h>
#include <malloc.h>
#include <iostream>
#define PI 3.141592654
#include <ctime>
#include <cstdlib>
#include <fstream>

//(28,23)
//Kamil Grądzki 149192
//Aleksandra Kusztal 149247


float gauss(float mean, float sigma);
float licz_BER(int il_bit, int *ciag_a, int *ciag_b);  //Funkcja liczaca Bit Error Rate

//************************************************************************

// Na wejsciu wartosci binarne (0/1) na wyjsciu wartosci w postaci zmiennych rzeczywistych
// Funkcja kanal zamienia wartości binarne na symbole -1/+1 i dodaje szum
//es_n0 - Es/N0, dl_kan - liczba bitow wejsciowych *wej-wektor wejsciowy *wyj-wektor wyjsciowy
void kanal(float es_n0, long dl_kan, int *wej, float *wyj)
{
    float mean = 0;
    float es = 1;
    float sygnal;
    float sigma;
    float s_n;
    long y;

    s_n = (float)pow(10, (es_n0 / 10));
    sigma = (float)sqrt(es / (2 * s_n));

    for (y = 0; y<dl_kan; y++)
    {
        sygnal = 2 * *(wej + y) - 1; // zamiana z wart binarnej 0/1 na symbole -1/+1
        *(wyj + y) = sygnal + gauss(mean, sigma);  // dodanie szumu
    }
}
//**********************************************************************
float gauss(float mean, float sigma)
{
    double x;
    double z;

    z = (double)rand() / RAND_MAX;
    if (z == 1.0) z = 0.9999999;
    x = sigma*sqrt(2.0*log(1.0 / (1.0 - z)));

    z = (double)rand() / RAND_MAX;
    if (z == 1.0) z = 0.9999999;
    return((float)(mean + x*cos(2 * PI*z)));
}
//*******************************************************************

float licz_BER(int il_bit, int *ciag_a, int *ciag_b)
{
    float BER = 0;
    for (int i = 0; i < il_bit; i++)
    {
        if (ciag_a[i] != ciag_b[i]) {
            BER++;
        }
        else {
            BER = BER;
        }
    }

    BER = BER / il_bit;

    return BER;
}



using namespace std;

int main()
{
    float szum_min, szum_max, szum_krok;
    int ilosc_bitow;
    float BER = 0, BER_bk = 0;
    int pozycja_bledu;


//Kodowanie korekcyjne (28,23)
    int n = 28; // dl. slowa kodowego
    int k = 23; // dl. bloku wejsciowego

//Macierze testow i generujaca
    int gen[23][28] = {
        { 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
        { 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
        { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
        { 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
        { 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
        { 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 },
        { 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }
    };
    int Ht[28][5] = { { 1,0,0,0,0 },{ 0,1,0,0,0 },{ 1,1,0,0,0 },{ 0,0,1,0,0 },{ 1,0,1,0,0 },{ 0,1,1,0,0 },{ 1,1,1,0,0 },{ 0,0,0,1,0 },
    { 1,0,0,1,0 },{ 0,1,0,1,0 },{ 1,1,0,1,0 },{ 0,0,1,1,0 },{ 1,0,1,1,0 },{ 0,1,1,1,0 },{ 1,1,1,1,0 },{ 0,0,0,0,1 },
    { 1,0,0,0,1 },{ 0,1,0,0,1 },{ 1,1,0,0,1 },{ 0,0,1,0,1 },{ 1,0,1,0,1 },{ 0,1,1,0,1 },{ 1,1,1,0,1 },{ 0,0,0,1,1 },
    { 1,0,0,1,1 },{ 0,1,0,1,1 },{ 1,1,0,1,1 },{ 0,0,1,1,1 } };


    cout << "Podaj ilosc bitow w ciagu informacyjnym: ";
    cin >> ilosc_bitow;
    cout << endl << "Podaj maksymalne Es/E0...: ";
    cin >> szum_max;
    cout << endl << "Podaj minimalne Es/E0....: ";
    cin >> szum_min;
    cout << endl << "Podaj krok Es/E0.........: ";
    cin >> szum_krok;


//Uzupelnianie bitow aby ich ilosc byla wielokrotnoscia k = 23
    for (int i = 1; i < 23; i++)
    {
        if (ilosc_bitow % k == i) {
            ilosc_bitow = ilosc_bitow + (k - ilosc_bitow % k);
        }
    }

    //Deklaracje ciagow wykorzystywanych w projekcie
    int * ciag_wej = new int[ilosc_bitow]; // ciag bitow wejscioweych
    int * ciag_zakodowany = new int[(ilosc_bitow*n) / k]; // ciag bitow zakodowanych
    float * ciag_kanal = new float[(ilosc_bitow*n) / k]; // ciag bitow zakodowanych po przejsciu przez kanal (+szum)
    int * ciag_decyzyjny = new int[(ilosc_bitow*n) / k];   // ciag zakodowany w dekoderze po podjeciu decyzji o nadaniu 1 lub 0
    int * ciag_decyzyjny_bk = new int[ilosc_bitow]; // ciag niezakodowany w dekoderze po podjeciu decyzji o nadaniu 1 lub 0
    int * synd = new int[(5 * ilosc_bitow) / k];  //ciag z syndromami
    float * ciag_kanal_bk = new float[ilosc_bitow]; // ciag bitow niezakodowanych po przejsciu przez kanal (+szum)
    int * ciag_kon = new int[ilosc_bitow]; // ciag bit po korekcji


// petla wypelniajaca ciagi ciag_zakodowany oraz synd zerami
    for (int i = 0; i < ((ilosc_bitow*n) / k); i++) {
        ciag_zakodowany[i] = 0;
        if (i<(5 * ilosc_bitow) / k) {
            synd[i] = 0;
        }
    }

    int pomocnicza = 0; // zmienna pomocniczaocnicza
    srand(time(0));

//generacja ciagu pseudoprzypadkowego
    for (int i = 0; i < ilosc_bitow; i++)
    {
        ciag_wej[i] = rand() % 2;
    }

    cout << "\n\n\n";


//Kodujemy ciag wejsciowy przy pomocy macierzy generujacej
    pomocnicza = 0;
    for (int i = 0; i < (ilosc_bitow) / k; i++) {
        for (int j = 0; j < n; j++) {
            for (int l = 0; l < k; l++) {
                ciag_zakodowany[(n*i) + j] += (ciag_wej[(k*i) + l] * gen[l][j]);
                ciag_zakodowany[(n*i) + j] %= 2;
            }
        }
    }

    cout << "\n\n";

//Zapis danych do pliku wynik.txt
    ofstream fout("wynik.txt");
    fout << "ilosc bitow wej: " << ilosc_bitow << endl;

//Analizujemy BER dla kodowania korekcyjnego i BER bez kodowania dla roznych warosci szumu
    for (int szum = szum_min; szum <= szum_max; szum += szum_krok) {
        int dl_kan = (ilosc_bitow*n) / k;
        kanal(szum, dl_kan, ciag_zakodowany, ciag_kanal);
        kanal(szum, ilosc_bitow, ciag_wej, ciag_kanal_bk);
        fout << "Wartosc szumu: " << szum << endl;
        for (int j = 0; j < ilosc_bitow; j++)
        {
            if (ciag_kanal_bk[j] >= 0) {
                ciag_decyzyjny_bk[j] = 1;
            }
            else {
                ciag_decyzyjny_bk[j] = 0;
            }
        }

//zerowanie syndromu
        for (int j = 0; j < 5 * ilosc_bitow / k; j++) {
            synd[j] = 0;
        }

//Liczymy BER dla ciagu bitow bez kodowania korekcyjnego
        BER_bk = licz_BER(ilosc_bitow, ciag_wej, ciag_decyzyjny_bk);

        fout << "BER bez korekcji: " << BER_bk << endl;
        cout << "BER bez korekcji dla szumu[" << szum << "]...: " << BER_bk << endl;
        pomocnicza = 0;


//Dokonujemy decyzji o nadaniu 1/0 na podstawie zaszumianego odebranego ciagu z kodowaniem korekcyjnym
        for (int j = 0; j < (ilosc_bitow*n) / k; j++) {
            if (ciag_kanal[j] >= 0) {
                ciag_decyzyjny[j] = 1;
            }
            else {
                ciag_decyzyjny[j] = 0;
            }
        }

//Liczymy syndromy dla odebranego ciagu bitow z wykorzystaniem macierzy testow Ht
        pomocnicza = 0;
        for (int m = 0; m < (ilosc_bitow) / k; m++) {
            pozycja_bledu = 0;

            for (int j = 0; j < (n - k); j++) {
                for (int l = 0; l < n; l++) {
                    synd[((n - k)*m) + j] += (ciag_decyzyjny[(n*m) + l] * Ht[l][j]);
                    synd[((n - k)*m) + j] %= 2;
                }

//Ustalanie pozycji bledu dzieki syndromowi
                if (synd[(n - k)*m + j] == 1 && j == 0) {
                    pozycja_bledu++;
                }
                else if (synd[(n - k)*m + j] == 1 && j == 1) {
                    pozycja_bledu += 2;
                }
                else if (synd[(n - k)*m + j] == 1 && j == 2) {
                    pozycja_bledu += 4;
                }
                else if (synd[(n - k)*m + j] == 1 && j == 3) {
                    pozycja_bledu += 8;
                }
                else if (synd[(n - k)*m + j] == 1 && j == 4) {
                    pozycja_bledu += 16;
                }
                else {
                    pozycja_bledu = pozycja_bledu;
                }
            }
//Zamieniamy bledy bit wg syndromu
            if (pozycja_bledu != 0) {
                ciag_decyzyjny[n*m + pozycja_bledu - 1] = (ciag_decyzyjny[n*m + pozycja_bledu - 1] + 1) % 2;
            }

        }
//Usuwamy bity parzystosci z zkorygowanego odebranego ciagu kodowego
        int przesuniecie = 0;
        for (int i = 0; i < ilosc_bitow / k; i++) {
            for (int j = 0; j < n; j++) {
                if (j != 0 && j != 1 && j != 3 && j!=7 && j!=15) {
                    ciag_kon[przesuniecie] = ciag_decyzyjny[i*n + j];
                    przesuniecie++;
                }
            }
        }
// Liczy BER dla kodu z korekcja i zapisuje do pliku wynik.txt
        BER = licz_BER(ilosc_bitow, ciag_wej, ciag_kon);
        fout << "BER z korekcja: " << BER << "\n" << endl;
        cout << "BER z korekcja dla szumu[" << szum << "].....: " << BER << "\n" << endl;
    }

    cout << "\n\n";
    system("PAUSE");
}