[Hankot3 0]

Есть информационная последовательность. Должна изменяться частота дискретизации , несущая и символьная скорость. Далее после модуляции сигнал пишется в файл . Где можно обработать в матлабе и отрисовать периодиограмму. periodogram(s,[],2^22,485) - Команда матлаба где 1 - мой сигнал в виде вектора строки , 2- прямоугольное окно, 3- количество точек, 4 - частота дискретизации.

Код реализован в лоб. Так как в первую очередь нужно что бы тупо работало. Проблема в том что где то ошибка та как при увеличение символьной скорости спектр у меня сужается а не расширяется.

 

На первой картинки у меня символьная скорость 1 . А на второй 60. А спектр на оборот сжат.

 

 

#include <iostream>


#include <cstdlib>

#include <math.h>
#include <fstream>

#include <vector>
using namespace std;

int main(int argc, char *argv[])
{
    //-------------------------------------Информационная последовательность
    const    int    NN = 16;// Ее длина


    int  Binary[NN] = {1,1,0,0,1,0,1,1,0,1,1,0,0,0,0,1};


    int *b  = &Binary[0];//указательн на первый ее элемент
    int *b1 = &Binary[1];//указатель на второй элемент

// Нужно для того что бы считать через один так как в QPSK  последовательность разбивается на четный и нечетный


    //------------------------------------------------------------
    const double Sr = 1; // символьная скорость

    const double fs = 485// частота дискрет

    const double f0 = 20; // несущая


    const double Tsr = 1/Sr;// Длительность одного символа


    const double Ts1 = 1 / fs;//Период дискретизации

    const int fs_fo = floor( ( fs / f0 ) + 0.5 );// (fs / f0)  - количество отсчетов на полное колебание в ед времени. floor взял для округления
    cout <<fs_fo <<" ";
    double cosinus [fs_fo];// Количество отсчетов для косинуса
    double sinus [fs_fo];//Количество отсчетов для синуса

    const int NN_na_2 = NN / 2; // Длина нашей последовательности информации после разделения на четный и не четный

    const int T_array1 = floor( ( fs_fo / Tsr ) + 0.5 ); //количество отсчетов за длительность одного символа

    cout << T_array1;



    const int NNN = T_array1 * NN_na_2; // массив конечного сигнала



    const double PI = 3.141592653589793;
    const double PI_na_2 = PI / 2;
    const double  PI_na_4 = PI / 4;




    double Q_koder[NN_na_2]; //длина  закодированной последовательности
    double I_koder[NN_na_2];


    double Q[NNN];//Длина модулированных квадратур
    double I[NNN];


    long double S[NNN]; //Конечный сигнал



//...............КОДЕР.......................................
    const double koder0_cos =  0.7071 * cos( 5 * PI_na_4 );
    const double koder1_cos =  0.7071 * cos( 7 * PI_na_4 );
    const double koder2_cos =  0.7071 * cos( PI_na_4 );
    const double koder3_cos =  0.7071 * cos( 3 * PI_na_4 );

    const double koder0_sin =  0.7071 * sin( 5 * PI_na_4 );
    const double koder1_sin =  0.7071 * sin( 7 * PI_na_4 );
    const double koder2_sin =  0.7071 * sin( PI_na_4 );
    const double koder3_sin =  0.7071 * sin( 3 * PI_na_4 );







    for ( int  i = 0; i < NN_na_2; i++ ) {


        if ( (*b  == 0) && (*b1 == 0) ) {
            I_koder[i] = koder0_cos;
            Q_koder[i] = koder0_sin;
        }

        if ( (*b == 0) && (*b1 == 1) ) {
            I_koder[i] = koder1_cos;
            Q_koder[i] = koder1_sin;
        }
        if ( (*b == 1) && (*b1 == 1) ) {
            I_koder[i] = koder2_cos;
            Q_koder[i] = koder2_sin;
        }
        if ( (*b == 1) && (*b1 == 0) ) {
            I_koder[i] = koder3_cos;
            Q_koder[i] = koder3_sin;
        }

    b  += 2;
    b1 += 2;

    }


//......................Формирование косинуса и синуса несущих..........

    const double w0 = 2 * PI * f0;
    double p = 0;

    for ( int  i = 0; i < fs_fo; i++ , p+=Ts1 /*Время появления отстчетов (Период) */ ) {

        cosinus[i] = 127 * cos( w0 * p );

        sinus[i]   = 127 * cos( w0 * p + PI_na_2 );


}

    ofstream sinsout("sinsout.txt");
    for ( int  i = 0; i < fs_fo; i++ ) {

    sinsout <<   sinus[i] << "  ";

    }
    sinsout.close();

    ofstream cosout("cosout.txt");
    for ( int  i = 0; i < fs_fo; i++ ) {

    cosout <<   cosinus[i] << "  ";

    }
    cosout.close();


    //////-------------------
    int j = 0;
    int z = 0;

//.................Модулятор...............
    for ( long int i = 0; i < NNN; ) {

        I[i] = I_koder[z] * cosinus[j];//Модуляция несущей символами

        Q[i] = Q_koder[z] * sinus[j];

     ++j;

     if ( j == fs_fo ) { //Отсчеты полного колебания синуса и косинуса повторяются каждый раз сначала как только заканчивается полное колебание
         j = 0;
     }

        if ( (i % T_array1 )== 0 ) {  // Каждый раз когда количество отсчетов в символе совпадает с количеством отсчетов в последовательности  символ меняется на следующий
            ++z;
            if ( z == NN_na_2 ) { //Если символы закончились сбросить счетчик
                z = 0;
            }
        }


     ++i;

    }
//-------------Конечная сумма.
    vector<double>data;

    for ( long int  i = 0; i < NNN; i++ ) {

        S[i] = Q[i] + I[i];

        data.push_back(S[i]);


    }

    ofstream Sout("Sout.txt");
    for ( long int  i = 0; i < NNN; i++ ) {

    Sout <<  S[i] << "  ";

    }
    Sout.close();




    ofstream Iout("Iout.txt");
    for ( int  i = 0; i < NNN; i++ ) {

    Iout <<  I[i] << " ";

    }
    Iout.close();

    ofstream Qout("Qout.txt");
    for ( int  i = 0; i < NNN; i++ ) {

    Qout <<  Q[i] << " ";

    }
    Qout.close();






    return 0;
}