API tools faq
paste
martaczaska

projekt 2 - kzik

martaczaska
Jan 28th, 2022 (edited)
507
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 16.49 KB | None | 0 0
raw download clone embed print report
  1. #include <stdlib.h>
  2. #include <time.h>
  3. #include <math.h>
  4. #include <stdio.h>
  5. #include <malloc.h>
  6. #include <vector>
  7. #include <cstdlib>
  8. #include <string>
  9. #include <iostream>
  10. #include <fstream>
  11. #define PI 3.141592654
  12. using namespace std;
  13.  
  14. //Deklaracje stałych
  15. const int n = 14;
  16. const int k = 5; // + 2 bity do zerowania rejestrow
  17.  
  18. //Deklaracje zmiennych
  19. int min_E_b_N_t = 10;
  20. int max_E_b_N_t = 11;
  21. int krok = 1;
  22. long double BER = 0.0;
  23. int numer_blokow = 10;
  24.  
  25. //Deklaracje wektorow
  26. typedef int bit;
  27. typedef vector<bit> bitVector;
  28. typedef vector<float> floatVector;
  29. vector<bitVector> wygenerowany_ciag;
  30. vector<bitVector> zakodowany_ciag;
  31. vector<bitVector> ciag_po_dekod_Vit;
  32.  
  33.  
  34. //Deklaracje funkcji
  35. vector<bitVector> wygenerujCiag();
  36. vector<bitVector> zakodujCiag(vector<bitVector> ciag_wygenerowany);
  37. vector<bitVector> Detekcja(vector<floatVector>& wejscie);
  38. vector<bitVector> zdekodujCiag(vector<bitVector>& ciag_odebrany);
  39. int okreslRozniceMiedzyCiagami(bit x1, bit x2, bit t1, bit t2);
  40. long double obliczanieBER(vector<bitVector>& ciag_zakodowany, vector<bitVector>& ciag_detekcji);
  41. float gauss(float mean, float sigma);
  42. void kanal(float es_n0, long dl_kan, int* wej, float* wyj);
  43.  
  44. ofstream plik_zakodowane;
  45. ofstream plik_wygenerowane;
  46. ofstream plik_odebrane;
  47. ofstream plik_zdekodowane;
  48. //
  49.  
  50. //main
  51. int main() {
  52.     vector<floatVector> ciag_po_kanale;
  53.     vector<float> wyjscie_kanalu(n);
  54.     vector<bitVector> po_detekcji;
  55.     plik_odebrane.open("odebrane.txt");
  56.  
  57.     cout << "Podaj liczbe transmitowanych blokow danych: " ;
  58.     cin >> numer_blokow;
  59.     cout << endl << "Podaj minimalna wartosc E_b/N_0 : ";
  60.     cin >> min_E_b_N_t ;
  61.     cout << endl << "Podaj maksymalna wartosc E_b/N_0 : ";
  62.     cin >> max_E_b_N_t ;
  63.     cout << endl << "Podaj krok zmian wartosci E_b/N_0 : ";
  64.     cin >> krok;
  65.     cout << endl;
  66.  
  67.     wygenerowany_ciag = wygenerujCiag();
  68.     zakodowany_ciag = zakodujCiag(wygenerowany_ciag);
  69.  
  70.     for(int eb_n0 = min_E_b_N_t; eb_n0 <= max_E_b_N_t; eb_n0 = eb_n0 + krok){
  71.         plik_odebrane << "Ciagi na wyjsciu kanalu dla Eb/N0 = " << eb_n0 << endl;
  72.         for (int i = 0; i < numer_blokow; i++) {
  73.             kanal(eb_n0, n, zakodowany_ciag[i].data(), wyjscie_kanalu.data());
  74.             ciag_po_kanale.push_back(wyjscie_kanalu);
  75.  
  76.             for(int k=0; k < wyjscie_kanalu.size(); ++k){
  77.                 plik_odebrane << wyjscie_kanalu[k] << "  ";
  78.             }
  79.             plik_odebrane << endl;
  80.         }
  81.         plik_odebrane << endl;
  82.  
  83.         po_detekcji = Detekcja(ciag_po_kanale);
  84.  
  85.         //ciag_po_dekod_Vit = zdekodujCiag(po_detekcji);
  86.         //BER = obliczanieBER(wygenerowany_ciag, ciag_po_dekod_Vit);
  87.        
  88.         ciag_po_kanale.clear();
  89.     }
  90.  
  91.     plik_odebrane.close();
  92.     system("pause");
  93.     return 0;
  94. }
  95.  
  96. // generowanie bitow wejsciowych
  97. vector<bitVector> wygenerujCiag() {
  98.     vector<bit> wektor;
  99.     vector<bitVector> wygenerowany;
  100.     plik_wygenerowane.open("wygenerowane.txt");
  101.     srand(time(NULL));
  102.  
  103.     for (int i = 0; i < numer_blokow; i++) {
  104.         for (int j = 0; j < k; j++) {
  105.             wektor.push_back(rand() % 2);
  106.         }
  107.         for (int j =0; j < 2; j++){
  108.             wektor.push_back(0);              // bity zerujące rejestr przesuwny
  109.         }
  110.         wygenerowany.push_back(wektor);
  111.  
  112.         for(int k=0; k < wektor.size(); ++k){
  113.             plik_wygenerowane << wektor[k];
  114.         }
  115.         plik_wygenerowane << endl;
  116.  
  117.         wektor.clear();
  118.     }
  119.  
  120.     plik_wygenerowane.close();
  121.     return wygenerowany;
  122. }
  123.  
  124. //koder
  125. vector<bitVector> zakodujCiag(vector<bitVector> ciag_wygenerowany) {
  126.     vector<bit> wektor;
  127.     vector<bit> wyjscie_kodera;
  128.     vector<bitVector> zakodowany_ciag;
  129.     char stan = 'A'; //stany przedstawiane literami -> stan A : 00, stan B : 10, stan C : 01, stan D : 11
  130.     plik_zakodowane.open("zakodowane.txt");
  131.  
  132.     for (int i = 0; i < numer_blokow; i++) {
  133.         wektor = ciag_wygenerowany[i];
  134.         for (int j = 0; j <(k+2); j++) {
  135.             switch(stan){
  136.                 case 'A':
  137.                     if(wektor[j] == 0){
  138.                         wyjscie_kodera.push_back(0); wyjscie_kodera.push_back(0);
  139.                         stan = 'A';
  140.                     }
  141.                     else if(wektor[j] == 1){
  142.                         wyjscie_kodera.push_back(1); wyjscie_kodera.push_back(1);
  143.                         stan = 'B';
  144.                     }
  145.                     break;
  146.                 case 'B':
  147.                     if(wektor[j] == 0){
  148.                         wyjscie_kodera.push_back(1); wyjscie_kodera.push_back(0);
  149.                         stan = 'C';
  150.                     }
  151.                     else if(wektor[j] == 1){
  152.                         wyjscie_kodera.push_back(0); wyjscie_kodera.push_back(1);
  153.                         stan = 'D';
  154.                     }
  155.                     break;
  156.                 case 'C':
  157.                     if(wektor[j] == 0){
  158.                         wyjscie_kodera.push_back(1); wyjscie_kodera.push_back(1);
  159.                         stan = 'A';
  160.                     }
  161.                     else if(wektor[j] == 1){
  162.                         wyjscie_kodera.push_back(0); wyjscie_kodera.push_back(0);
  163.                         stan = 'B';
  164.                     }
  165.                     break;
  166.                 case 'D':
  167.                     if(wektor[j] == 0){
  168.                         wyjscie_kodera.push_back(0); wyjscie_kodera.push_back(1);
  169.                         stan = 'C';
  170.                     }
  171.                     else if(wektor[j] == 1){
  172.                         wyjscie_kodera.push_back(1); wyjscie_kodera.push_back(0);
  173.                         stan = 'D';
  174.                     }
  175.                     break;
  176.             }
  177.         }
  178.         zakodowany_ciag.push_back(wyjscie_kodera);
  179.  
  180.         for(int k=0; k < wyjscie_kodera.size(); ++k){
  181.             plik_zakodowane << wyjscie_kodera[k];
  182.         }
  183.         plik_zakodowane << endl;
  184.  
  185.         wyjscie_kodera.clear();
  186.     }
  187.     plik_zakodowane.close();
  188.  
  189.     return zakodowany_ciag;
  190. }
  191.  
  192. //Detekcja bitów dla dekodowania twardodecyzyjnego
  193. vector<bitVector> Detekcja(vector<floatVector>& wejscie) {
  194.     vector<bit> wyjscie;
  195.     vector<bitVector> ciag_po_detekcji;
  196.  
  197.     for (int i = 0; i < numer_blokow; i++) {
  198.         for (int j = 0; j < n; j++) {
  199.             if (wejscie[i][j] < 0) {
  200.                 wyjscie.push_back(0);
  201.             }              
  202.             else {
  203.                 wyjscie.push_back(1);
  204.             }
  205.         }
  206.         ciag_po_detekcji.push_back(wyjscie);
  207.  
  208.         wyjscie.clear();
  209.     }
  210.  
  211.     return ciag_po_detekcji;
  212. }
  213.  
  214. //Dekoder twardodecyzyjny Viterbiego
  215. vector<bitVector> zdekodujCiag(vector<bitVector>& ciag_odebrany) {
  216.     vector<bitVector> zdekodowany_ciag;
  217.     vector<bit> wyjscie_dekodera;
  218.     plik_zdekodowane.open("zdekodowane.txt");
  219.  
  220.     int najlepsza_trasa_stan_A[7][2];
  221.     int odl_Hamm_A = 0;
  222.     int najlepsza_trasa_stan_B[7][2];
  223.     int odl_Hamm_B = 0;
  224.     int najlepsza_trasa_stan_C[7][2];
  225.     int odl_Hamm_C = 0;
  226.     int najlepsza_trasa_stan_D[7][2];
  227.     int odl_Hamm_D = 0;
  228.  
  229.     //string najlepsza_trasa = "";
  230.  
  231.     for (int i = 0; i < numer_blokow; i++) {
  232.         for (int j = 0; j < n/2; j++) {
  233.             if(j == 0){ //zaczynamy od stanu A (00)
  234.                 odl_Hamm_A = okreslRozniceMiedzyCiagami(ciag_odebrany[i][2*j], ciag_odebrany[i][2*j+1], 0, 0);
  235.                 najlepsza_trasa_stan_A[j][0] = odl_Hamm_A;
  236.                 najlepsza_trasa_stan_B[j][0] = odl_Hamm_A;
  237.                 najlepsza_trasa_stan_C[j][0] = odl_Hamm_A;
  238.                 najlepsza_trasa_stan_D[j][0] = odl_Hamm_A;
  239.  
  240.                 odl_Hamm_B = okreslRozniceMiedzyCiagami(ciag_odebrany[i][2*j], ciag_odebrany[i][2*j+1], 1, 1);
  241.                 najlepsza_trasa_stan_A[j][1] = odl_Hamm_B;
  242.                 najlepsza_trasa_stan_B[j][1] = odl_Hamm_B;
  243.                 najlepsza_trasa_stan_C[j][1] = odl_Hamm_B;
  244.                 najlepsza_trasa_stan_D[j][1] = odl_Hamm_B;
  245.  
  246.             }
  247.             else if(j == 1){ //znajdujemy się tylko w stanie A i stanie B
  248.                 //po dwa rozwidlenia ze stanu A i B
  249.                 odl_Hamm_A = okreslRozniceMiedzyCiagami(ciag_odebrany[i][2*j], ciag_odebrany[i][2*j+1], 0, 0);
  250.                 najlepsza_trasa_stan_A[j][0] = najlepsza_trasa_stan_A[j-1][0] + odl_Hamm_A;
  251.                 najlepsza_trasa_stan_A[j][1] = najlepsza_trasa_stan_A[j-1][1] + odl_Hamm_A;
  252.  
  253.                 odl_Hamm_B = okreslRozniceMiedzyCiagami(ciag_odebrany[i][2*j], ciag_odebrany[i][2*j+1], 1, 1);
  254.                 najlepsza_trasa_stan_B[j][0] = najlepsza_trasa_stan_A[j-1][0] + odl_Hamm_B;
  255.                 najlepsza_trasa_stan_B[j][1] = najlepsza_trasa_stan_A[j-1][1] + odl_Hamm_B;
  256.  
  257.                 odl_Hamm_C = okreslRozniceMiedzyCiagami(ciag_odebrany[i][2*j], ciag_odebrany[i][2*j+1], 1, 0);
  258.                 najlepsza_trasa_stan_C[j][0] = najlepsza_trasa_stan_B[j-1][0] + odl_Hamm_C;
  259.                 najlepsza_trasa_stan_C[j][1] = najlepsza_trasa_stan_B[j-1][1] + odl_Hamm_C;
  260.  
  261.                 odl_Hamm_D = okreslRozniceMiedzyCiagami(ciag_odebrany[i][2*j], ciag_odebrany[i][2*j+1], 0, 1);
  262.                 najlepsza_trasa_stan_D[j][0] = najlepsza_trasa_stan_B[j-1][0] + odl_Hamm_D;
  263.                 najlepsza_trasa_stan_D[j][1] = najlepsza_trasa_stan_B[j-1][1] + odl_Hamm_D;
  264.  
  265.             }
  266.             else{
  267.                 //po dwie możliwości rozwidleń z każdego stanu
  268.                 //stan A:
  269.                 odl_Hamm_A = okreslRozniceMiedzyCiagami(ciag_odebrany[i][2*j], ciag_odebrany[i][2*j+1], 0, 0);
  270.                 najlepsza_trasa_stan_A[j][0] = najlepsza_trasa_stan_A[j-1][0] + odl_Hamm_A;
  271.                 odl_Hamm_A = okreslRozniceMiedzyCiagami(ciag_odebrany[i][2*j], ciag_odebrany[i][2*j+1], 1, 1);
  272.                 najlepsza_trasa_stan_A[j][1] = najlepsza_trasa_stan_C[j-1][0] + odl_Hamm_A;
  273.  
  274.                 //stan B:
  275.                 odl_Hamm_B = okreslRozniceMiedzyCiagami(ciag_odebrany[i][2*j], ciag_odebrany[i][2*j+1], 1, 1);
  276.                 najlepsza_trasa_stan_B[j][0] = najlepsza_trasa_stan_A[j-1][0] + odl_Hamm_B;
  277.                 odl_Hamm_B = okreslRozniceMiedzyCiagami(ciag_odebrany[i][2*j], ciag_odebrany[i][2*j+1], 0, 0);
  278.                 najlepsza_trasa_stan_B[j][1] = najlepsza_trasa_stan_C[j-1][1] + odl_Hamm_B;
  279.  
  280.                 //stan C:
  281.                 odl_Hamm_C = okreslRozniceMiedzyCiagami(ciag_odebrany[i][2*j], ciag_odebrany[i][2*j+1], 1, 0);
  282.                 najlepsza_trasa_stan_C[j][0] = najlepsza_trasa_stan_B[j-1][0] + odl_Hamm_C;
  283.                 odl_Hamm_C = okreslRozniceMiedzyCiagami(ciag_odebrany[i][2*j], ciag_odebrany[i][2*j+1], 0, 1);
  284.                 najlepsza_trasa_stan_C[j][1] = najlepsza_trasa_stan_D[j-1][0] + odl_Hamm_C;
  285.  
  286.                 //stan D:
  287.                 odl_Hamm_D = okreslRozniceMiedzyCiagami(ciag_odebrany[i][2*j], ciag_odebrany[i][2*j+1], 0, 1);
  288.                 najlepsza_trasa_stan_D[j][0] = najlepsza_trasa_stan_B[j-1][1] + odl_Hamm_D;
  289.                 odl_Hamm_D = okreslRozniceMiedzyCiagami(ciag_odebrany[i][2*j], ciag_odebrany[i][2*j+1], 1, 0);
  290.                 najlepsza_trasa_stan_D[j][1] = najlepsza_trasa_stan_D[j-1][1] + odl_Hamm_D;
  291.  
  292.             }
  293.             //Obliczenie minimum, jeśli nie zakończyliśmy dekodowania ciągu w stanie A, to znaczy, że ciąg został błędnie zdekodowany
  294.             // tu obliczenie minimum
  295.             //...
  296.  
  297.             int trasa_końcowa[7];
  298.             char stan = 'A';
  299.             int licznik = 1;
  300.  
  301.             if((najlepsza_trasa_stan_A[6][0] - najlepsza_trasa_stan_C[6][0]) > 0){ //koniec na stanie A (00)
  302.                 trasa_końcowa[6] = 0;
  303.                 stan = 'C';
  304.             }else{
  305.                 trasa_końcowa[6] = 0;
  306.                 stan = 'A';
  307.             }
  308.  
  309.             while (licznik < 5){
  310.                 switch(stan){
  311.                     case 'A':
  312.                         if((najlepsza_trasa_stan_A[6 - licznik][0] - najlepsza_trasa_stan_C[6 - licznik][0]) > 0){
  313.                             trasa_końcowa[6 - licznik] = 0;
  314.                             stan = 'C';
  315.                         }
  316.                         else{
  317.                             trasa_końcowa[6 - licznik] = 0;
  318.                             stan = 'A';
  319.                         }
  320.                         break;
  321.                     case 'B':
  322.                         if((najlepsza_trasa_stan_A[6 - licznik][1] - najlepsza_trasa_stan_C[6 - licznik][1]) > 0){
  323.                             trasa_końcowa[6 - licznik] = 1;
  324.                             stan = 'C';
  325.                         }
  326.                         else{
  327.                             trasa_końcowa[6 - licznik] = 1;
  328.                             stan = 'A';
  329.                         }
  330.                         break;
  331.                     case 'C':
  332.                         if((najlepsza_trasa_stan_B[6 - licznik][0] - najlepsza_trasa_stan_D[6 - licznik][0]) > 0){
  333.                             trasa_końcowa[6 - licznik] = 0;
  334.                             stan = 'D';
  335.                         }
  336.                         else{
  337.                             trasa_końcowa[6 - licznik] = 0;
  338.                             stan = 'B';
  339.                         }
  340.                         break;
  341.                     case 'D':
  342.                         if((najlepsza_trasa_stan_B[6 - licznik][1] - najlepsza_trasa_stan_D[6 - licznik][1]) > 0){
  343.                             trasa_końcowa[6 - licznik] = 1;
  344.                             stan = 'D';
  345.                         }
  346.                         else{
  347.                             trasa_końcowa[6 - licznik] = 1;
  348.                             stan = 'B';
  349.                         }
  350.                         break;
  351.                     licznik ++;
  352.                 }
  353.             }
  354.             switch(stan){
  355.                 case 'A':
  356.                     trasa_końcowa[1] = 0;
  357.                     stan = 'A';
  358.                     break;
  359.                 case 'B':
  360.                     trasa_końcowa[1] = 1;
  361.                     stan = 'A';
  362.                     break;
  363.                 case 'C':
  364.                     trasa_końcowa[1] = 0;
  365.                     stan = 'B';
  366.                     break;
  367.                 case 'D':
  368.                     trasa_końcowa[1] = 1;
  369.                     stan = 'B';
  370.                     break;
  371.             }
  372.             if(stan == 'A'){
  373.                 trasa_końcowa[1] = 0;
  374.             }
  375.             else{
  376.                 trasa_końcowa[1] = 1;
  377.             }
  378.            
  379.             for (int j = 0; j < (k+2); j++) {
  380.                 wyjscie_dekodera.push_back(trasa_końcowa[j]);
  381.             }
  382.  
  383.         }
  384.        
  385.         for(int k=0; k < wyjscie_dekodera.size(); ++k){
  386.             plik_zdekodowane << wyjscie_dekodera[k];
  387.         }
  388.         plik_zdekodowane << endl;
  389.  
  390.         zdekodowany_ciag.push_back(wyjscie_dekodera);
  391.         wyjscie_dekodera.clear();
  392.     }
  393.  
  394.     plik_zdekodowane.close();
  395.     return zdekodowany_ciag;
  396. }
  397.  
  398.  
  399. int okreslRozniceMiedzyCiagami(bit x1, bit x2, bit t1, bit t2) {
  400.     int roznica = 0;
  401.  
  402.     if(x1 != t1){roznica += 1;}
  403.     if(x2 != t1){roznica += 1;}
  404.  
  405.     return roznica;
  406. }
  407.  
  408.  
  409. //************************************************************************
  410.  
  411. // Function kanal changes binary values into bipolar ones (-1/+1) and adds noise
  412. // *wej - Input vector of binary values (0/1)
  413. // *wyj - Output vector of real numbers
  414. // es_n0 - Es/N0
  415. // dl_kan - the number of input bits
  416. void kanal(float es_n0, long dl_kan, int *wej, float *wyj)
  417. {
  418.   float mean=0;
  419.   float es=1;
  420.   float sygnal;
  421.   float sigma;
  422.   float s_n;
  423.   long y;
  424.  
  425.   s_n=(float) pow(10, (es_n0/10));
  426.   sigma=(float) sqrt (es/(2*s_n));
  427.  
  428.   for (y=0; y<dl_kan; y++)
  429.     {
  430.       sygnal = 2 * *(wej+y)-1; // change the binary value (0/1) into symbol (-1/+1)
  431.       *(wyj+y)=sygnal+gauss(mean,sigma);  // noise addition
  432.      
  433.     }
  434. }
  435. //**********************************************************************
  436. float gauss(float mean, float sigma)
  437. {
  438.   double x;
  439.   double z;
  440.  
  441.   z=(double)rand()/RAND_MAX;
  442.   if (z==1.0) z=0.9999999;
  443.   x=sigma*sqrt(2.0*log(1.0/(1.0-z)));
  444.  
  445.   z=(double)rand()/RAND_MAX;
  446.   if (z==1.0) z=0.9999999;
  447.   return((float)(mean+x*cos(2*PI*z)));
  448. }
  449. //*******************************************************************
  450.  
  451. long double obliczanieBER(vector<bitVector>& ciag_zakodowany, vector<bitVector>& ciag_detekcji){
  452.     float bledy = 0.0;
  453.     long double ber = 0.0;
  454.  
  455.     for (int i = 0; i < numer_blokow; i++) {
  456.         for (int j = 0; j < k; j++) {
  457.             if(ciag_zakodowany[i][j] != ciag_detekcji[i][j]){
  458.                 bledy++;
  459.             }
  460.         }
  461.     }
  462.     ber = bledy/(numer_blokow*n);
  463.     cout << endl << "KONIEC! BER wynosi: " << ber << endl;
  464.  
  465.     return ber;
  466. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!