API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 17th, 2019
57
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 10.23 KB | None | 0 0
raw download clone embed print report
  1. #include "mainwindow.h"
  2. #include "ui_mainwindow.h"
  3. #include <math.h>
  4. #include <vector>
  5. #include <time.h>
  6. #include <iostream>
  7. #include <algorithm>
  8. #include <cmath>
  9. #define pi 3.14159265359
  10.  
  11. MainWindow::MainWindow(QWidget *parent) :
  12.     QMainWindow(parent),
  13.     ui(new Ui::MainWindow)
  14. {
  15.     ui->setupUi(this);
  16.     MainWindow::makePlot();
  17. }
  18.  
  19. MainWindow::~MainWindow()
  20. {
  21.     delete ui;
  22. }
  23.  
  24. QVector <double> l1z1(double f, double fs, double phi, double n){
  25.     QVector <double> x;
  26.    for (double i=0;i<n;i++)
  27.    {
  28.                      // 0.9*sin(2*pi * f *(i/fs) * cos(pi * (i/fs)) + phi);
  29.                       //0.9*(sin(2*pi * f *(i/fs) * cos(pi * (i/fs)) + phi));
  30.       // double funkcja = 0.9*(sin(2*pi * f *(i/fs) * cos(pi * (i/fs)) + phi));
  31.        double funkcja = 0.9 * sin(2*pi * f * (i/fs) * cos(pi*(i/fs))+phi);
  32.         x << funkcja;
  33.  
  34.    }
  35.    return x;
  36. }
  37.  
  38. QVector <double> l1z2a(double f, double fs, double phi, double n){
  39.     QVector <double> x;
  40.     for (double i=0;i<n;i++)
  41.     {
  42.         double funkcjay = (2 * i + 1.5) * cos((24*pi) * (i/fs) + pi);
  43.         double funkcjax = 0.9 * sin(2*pi * f * (i/fs) * cos(pi*(i/fs))+phi);
  44.         double funkcjaz = funkcjay + std::abs(funkcjax) * (funkcjay + 0.7);
  45.         x << funkcjaz;
  46.     }
  47.     return x;
  48. }
  49.  
  50. QVector <double> l1z2b(double f, double fs, double phi, double n){
  51.     QVector <double> x;
  52.     for (double i=0;i<n;i++)
  53.     {
  54.         double funkcjay = (2 * i + 1.5) * cos((24*pi) * (i/fs) + pi);
  55.         double funkcjax = 0.9 * sin(2*pi * f * (i/fs) * cos(pi*(i/fs))+phi);
  56.         double funkcjaz = funkcjax * (std::abs(funkcjay) + 1.2) * sin(12 * pi + (i/fs));
  57.         x << funkcjaz;
  58.     }
  59.     return x;
  60. }
  61.  
  62. QVector <double> l1z3()
  63. {
  64.     QVector <double> x;
  65.     QVector <double> y;
  66.  
  67.     // 0.2 > t >= 0
  68.     for (double i=0; i<=0.2; i+=0.01)
  69.     {
  70.         double funkcja = i * sin(34*pi*i);
  71.         y << funkcja;
  72.     }
  73.  
  74.     // 0.8 > t >= 0.2
  75.     for (double i=0.2; i<=0.8; i+=0.01)
  76.     {
  77.         double funkcja = (1/i) * log10(i+1) - 0.27;
  78.         y << funkcja;
  79.     }
  80.  
  81.     // 1.4 > t >= 0.8
  82.     for (double i=0.8; i<=1.4; i+=0.01)
  83.     {
  84.         double funkcja = (((pow(i,2)+1)/10)) * sin(12*pi*i);
  85.         y << funkcja;
  86.     }
  87.  
  88.     // 2.2 > t >= 1.4
  89.     for (double i=1.4; i<=2.2; i+=0.01)
  90.     {
  91.         double funkcja = sin(20*pi*i + i/3 + 2.3);
  92.         y << funkcja;
  93.     }
  94.     return y;
  95. }
  96.  
  97. QVector <double> l1z4(double n, int h, double fs){
  98.  
  99.     QVector <double> x;
  100.     QVector <double> y;
  101.     double tmp = 0;
  102.  
  103.     for (int i=0; i<n; i++){
  104.         for (int j=1; j<h; j++){
  105.             tmp += (pow(-1, j)/pow(j,2))*cos((2*pi*j*i)/fs);
  106.         }
  107.         double funkcja = (pow(pi, 2)/3) + (4*tmp);
  108.         x << funkcja;
  109.     }
  110.     return x;
  111. }
  112.  
  113. void DFT(double *rzeczywiste, double *urojone, QVector<double> signal, double n){
  114.     for (int i=0; i < n; i++){
  115.         urojone[i]=0;
  116.         rzeczywiste[i]=0;
  117.         for (int j=0; j < n; j++)
  118.         {
  119.             rzeczywiste[i] += signal[j] * cos((-2 * pi * i * j) / n);
  120.             urojone[i] += signal[j] * sin((-2 * pi * i * j) / n);
  121.         }
  122.     }
  123. }
  124.  
  125. QVector <double> Widmo(double *rzeczywiste, double *urojone, double *W1, double *W2, double n, double fs,double fk = 0){
  126.    QVector <double> x;
  127.     for (int i=0; i<n/2; i++){
  128.                 W1[i] = sqrt(pow(rzeczywiste[i],2) + pow(urojone[i],2));
  129.                 W2[i] = 10 * log(W1[i]);
  130.                 fk = i * (fs/n);
  131.                 x << fk;
  132.     }
  133.     return x;
  134. }
  135.  
  136. /*
  137.    This computes an in-place complex-to-complex FFT
  138.    x and y are the real and imaginary arrays of 2^m points.
  139.    dir =  1 gives forward transform
  140.    dir = -1 gives reverse transform
  141. */
  142. void FFT(short int dir,long m,double *rzeczywiste,double *urojone)
  143. {
  144.     long n,i,i1,j,k,i2,l,l1,l2;
  145.     double c1,c2,tx,ty,t1,t2,u1,u2,z;
  146.  
  147.     /* Calculate the number of points */
  148.     n = 1;
  149.     for (i=0;i<m;i++)
  150.         n *= 2;
  151.  
  152.     /* Do the bit reversal */
  153.     i2 = n >> 1;
  154.     j = 0;
  155.     for (i=0;i<n-1;i++) {
  156.         if (i < j) {
  157.             tx = rzeczywiste[i];
  158.             ty = urojone[i];
  159.             rzeczywiste[i] = rzeczywiste[j];
  160.             urojone[i] = urojone[j];
  161.             rzeczywiste[j] = tx;
  162.             urojone[j] = ty;
  163.         }
  164.         k = i2;
  165.         while (k <= j) {
  166.             j -= k;
  167.             k >>= 1;
  168.         }
  169.         j += k;
  170.     }
  171.  
  172.     /* Compute the FFT */
  173.     c1 = -1.0;
  174.     c2 = 0.0;
  175.     l2 = 1;
  176.     for (l=0;l<m;l++) {
  177.         l1 = l2;
  178.         l2 <<= 1;
  179.         u1 = 1.0;
  180.         u2 = 0.0;
  181.         for (j=0;j<l1;j++) {
  182.             for (i=j;i<n;i+=l2) {
  183.                 i1 = i + l1;
  184.                 t1 = u1 * rzeczywiste[i1] - u2 * rzeczywiste[i1];
  185.                 t2 = u1 * urojone[i1] + u2 * rzeczywiste[i1];
  186.                 rzeczywiste[i1] = rzeczywiste[i] - t1;
  187.                 urojone[i1] = urojone[i] - t2;
  188.                 rzeczywiste[i] += t1;
  189.                 urojone[i] += t2;
  190.             }
  191.             z =  u1 * c1 - u2 * c2;
  192.             u2 = u1 * c2 + u2 * c1;
  193.             u1 = z;
  194.         }
  195.         c2 = sqrt((1.0 - c1) / 2.0);
  196.         if (dir == 1)
  197.             c2 = -c2;
  198.         c1 = sqrt((1.0 + c1) / 2.0);
  199.     }
  200.  
  201.     /* Scaling for forward transform */
  202.     if (dir == 1) {
  203.         for (i=0;i<n;i++) {
  204.             rzeczywiste[i] /= n;
  205.             urojone[i] /= n;
  206.         }
  207.     }
  208. }
  209.  
  210. QVector <double> fASK(double tb, double fn, double fs, double A1, double A2, int in[], double out[])
  211. {
  212.     QVector <double> x;
  213.     for (int i=0; i<fs; i++)
  214.     {
  215.         double probki = fs/tb;
  216.         int bit = i/probki;
  217.         if (in[bit] == 0)
  218.         {
  219.             out[i] = A1 * sin(2*pi*fn*(i/fs));
  220.             x << out[i];
  221.         }
  222.         else
  223.         {
  224.             out[i] = A2 * sin(2*pi*fn*(i/fs));
  225.             x << out[i];
  226.         }
  227.     }
  228.     return x;
  229. }
  230. QVector <double> fFSK(double tb, double fn1, double fn2, double fs, double A1, double A2, int in[], double out[])
  231. {
  232.     QVector <double> x;
  233.     for (int i=0; i<fs; i++)
  234.     {
  235.         double probki = fs/tb;
  236.         int bit = i/probki;
  237.         if (in[bit] == 0)
  238.         {
  239.             out[i] = A1 * sin(2*pi*fn1*(i/fs));
  240.             x << out[i];
  241.         }
  242.         else
  243.         {
  244.             out[i] = A2 * sin(2*pi*fn2*(i/fs));
  245.             x << out[i];
  246.         }
  247.     }
  248.     return x;
  249. }
  250. QVector <double> fPSK(double tb, double fn, double fs, double A1, double A2, int in[], double out[])
  251. {
  252.     QVector <double> x;
  253.     for (int i=0; i<fs; i++)
  254.     {
  255.         double probki = fs/tb;
  256.         int bit = i/probki;
  257.         if (in[bit] == 0)
  258.         {
  259.             out[i] = sin(2*pi*fn*(i/fs));
  260.             x << out[i];
  261.         }
  262.         else
  263.         {
  264.             out[i] = sin(2*pi*fn*(i/fs)+pi);
  265.             x << out[i];
  266.         }
  267.     }
  268.     return x;
  269. }
  270. QVector <double> modulacja_amplitudy(double m[], double kA, int fn, int t)
  271. {
  272.  
  273. }
  274.  
  275.  
  276. void MainWindow::makePlot()
  277. {
  278.     QVector <double> AxisX;
  279.     QVector <double> AxisY;
  280.     QVector <double> sl1z1;
  281.     QVector <double> sl1z2a;
  282.     QVector <double> sl1z2b;
  283.     QVector <double> sl1z3;
  284.     QVector <double> sl1z4a;
  285.     QVector <double> sl1z4b;
  286.     QVector <double> sl1z4c;
  287.     QVector <double> ASK;
  288.     QVector <double> FSK;
  289.     QVector <double> PSK;
  290.  
  291. /*
  292.     int bit[9] = {1,0,0,1,1,0,1,1,0};
  293.     int length = sizeof(bit)/sizeof(int);
  294.     double A1 = 6;
  295.     double A2 = 9;
  296.     double t = 2;
  297.     double n = 2;
  298.     double tb = length;
  299.     double fn = n * tb;
  300.     double fs = 300;
  301.     double fn1 = (n+1) * tb;
  302.     double fn2 = (n+2) * tb;
  303.     //n*27 = dlugosc tablicy z sygnalem
  304.     double ZA[540] = {0.0};
  305.     double ZF[540] = {0.0};
  306.     double ZP[540] = {0.0};
  307.     double *urojoneA = new double[600];
  308.     double *rzeczywisteA = new double[600];
  309.     double *urojoneF = new double[600];
  310.     double *rzeczywisteF = new double[600];
  311.     double *urojoneP = new double[600];
  312.     double *rzeczywisteP = new double[600];
  313.  
  314.     double *W1 = new double[300];  //Lin
  315.     double *W2 = new double[300];  //Log
  316.     double fk;
  317. */
  318.  
  319.     int fm = 10;
  320.     int fn = 10*fm;
  321.     int Am = 2;
  322.     int fs = 3000;
  323.     double kAa = 0.69;
  324.     double kAb = 7;
  325.     double kAc = 33;
  326.     double kPa = 1;
  327.     double kPb = 2;
  328.     double kPc = 69;
  329.  
  330.     double m[3000] = { 0 };
  331.     double zA1[3000] = { 0 };
  332.     double zA2[3000] = { 0 };
  333.     double zA3[3000] = { 0 };
  334.     double zP1[3000] = { 0 };
  335.     double zP2[3000] = { 0 };
  336.     double zP3[3000] = { 0 };
  337.     //Sygnal informacyjny
  338.     for (int i = 0; i < fs; i++)
  339.     {
  340.         m[i] = Am*sin(2*pi*fm*i/fs);
  341.     }
  342.  
  343.     //Modulacja amplitudy
  344.     for (int i = 0; i < fs; i++)
  345.     {
  346.         zA1[i] = (kAa*m[i]+1)*cos(2*pi*fn*fs);
  347.         zA2[i] = (kAb*m[i]+1)*cos(2*pi*fn*fs);
  348.         zA3[i] = (kAc*m[i]+1)*cos(2*pi*fn*fs);
  349.         AxisX << zA1[i];
  350.         AxisY << fs;
  351.     }
  352.  
  353.  
  354.  
  355.  
  356.  
  357.  
  358.  
  359.  
  360. /*
  361.      double ModA[600] = {0};
  362.      double ModF[600] = {0};
  363.      double ModP[600] = {0};
  364.      //Widmo
  365.      for (int i = 0; i < 300; i++)
  366.      {
  367.          ModA[i] = 20 * log10(sqrt(pow(rzeczywisteA[i],2) + pow(urojoneA[i],2)));
  368.          ModF[i] = 20 * log10(sqrt(pow(rzeczywisteF[i],2) + pow(urojoneF[i],2)));
  369.          ModP[i] = 50*log10(sqrt(pow(rzeczywisteP[i],2) + pow(urojoneP[i],2)));
  370.          fk = i;
  371.          AxisX << ModP[i];
  372.          AxisY << fk;
  373.      }
  374. */
  375.       /*  for (int i=0; i<150; i++)
  376.         {
  377.             AxisX << ModA[i];
  378.             AxisY << fk;
  379.         }
  380.         */
  381.      //Widmo
  382.  
  383.     /* for (int i=0; i<300; i++){
  384.                  W1[i] = sqrt(pow(rzeczywiste[i],2) + pow(urojone[i],2));
  385.                  W2[i] = 10 * log(W1[i]);
  386.                  fk = i * (150/600);
  387.                  AxisX << W1[i];
  388.                  AxisY << fk;
  389.              }
  390. */
  391.  
  392.     // AxisY << Widmo(rzeczywiste, urojone, W1, W2, 600, fs);
  393.  
  394.   /*  AxisY << PSK;
  395.     for (int i=0; i<fs; i++)
  396.     {
  397.         AxisX << i;
  398.     }
  399.     */
  400.  
  401.  
  402.  
  403.  
  404.  
  405.  
  406.  
  407.   // std::cout <<"FS WYNOSI: ";
  408.   // std::cout <<fs;
  409.  
  410.  
  411.         ui->customPlot->addGraph();
  412.         ui->customPlot->graph(0)->setData(AxisX, AxisY);
  413.         ui->customPlot->xAxis->setLabel("x");
  414.         ui->customPlot->yAxis->setLabel("y");
  415.         ui->customPlot->xAxis->setRange(-500, 755);
  416.         ui->customPlot->yAxis->setRange(-1000, 1000);
  417.         ui->customPlot->replot();
  418.  
  419. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!