1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
|
#include "dvbt_signauxtests_v02.h"
/*! \fn CreateDVBTSignauxtests()
\brief
\~english Memory allocation and initialisation of structure DVBTSignauxtests.
\~french Allocation de mémoire et initialisation de la structure DVBTSignauxtests.
\return
\~english Pointer on structure DVBTSignauxtests.
\~french Pointeur sur structure DVBTSignauxtests.
*/
DVBTSignauxtests *CreateDVBTSignauxtests() {
DVBTSignauxtests *DS;
/* Memory allocation for structure DVBTSignauxtests. */
DS = (DVBTSignauxtests *)calloc(1, sizeof(DVBTSignauxtests));
if (!DS) {
printf("\nERROR !\tCreateDVBTSignauxtests : unable to allocate memory for DVBTSignauxtests structure.\n\n");
exit(EXIT_FAILURE);
}
return (DS);
}
/*! \fn FreeDVBTSignauxtests(DVBTSignauxtests *DS)
\brief
\~english Memory release of structure DVBTSignauxtests.
\~french Libération de la mémoire de la structure DVBTSignauxtests.
\param DS :
\~english Pointer on structure DVBTSignauxtests.
\~french Pointeur sur structure DVBTSignauxtests.
\return
-.
*/
void FreeDVBTSignauxtests(DVBTSignauxtests *DS) {
/* Test structure existence. */
if (!DS) {
printf("\nWARNING !\tFreeDVBTSignauxtests : structure DVBTSignauxtests does not exist.\n\n");
return;
}
/* Memory release. */
free(DS);
return;
}
/*! \fn UseDVBTSignauxtests(DVBTSignauxtests *DS, int source_reelle[],int source_imaginaire[],int surechantillonage,int echantillon)
\brief
\~english Memory allocation and initialisation of structure DVBTSignauxtests
\~french Allocation mémoire et initialisation de la structure DVBTSignauxtests
\param DS : Pointeur sur structure DVBTSignauxtests.
\param source_reelle[] : Tableau correspondant à une séquence (+1 -1) correspondant à une partie reelle
\param source_imaginaire[] : Tableau correspondant à une séquence correspondant à une partie imaginaire
\param surechantillon : Entier correspondant à un facteur de suréchantillonage
\param echantillon : Entier correspondant au nombre d'échantillons du signal source
\return
-.
*/
void UseDVBTSignauxtests(DVBTSignauxtests *DS, int source_reelle[],int source_imaginaire[],int surechantillonage,int echantillon) {
/*------déclaration des variables------*/
int N=echantillon; /* récupération du nombre d'échantillons du signal source*/
float signal_re[N],signal_im[N];
int i,j;
int Ns=surechantillonage; /* récupération du facteur de suréchantillonnage*/
int taille_signal;
float pas_echantillon,periodes,points,roll_off;
float *upsignal_re=NULL,*upsignal_im=NULL;
float *coef_nyquist=NULL;
float *signal_re_conv_nyquist=NULL,*signal_im_conv_nyquist=NULL;
int nombre_etages,interp;
double interpolation;
int taille_cic_interpolateur;
double *sortie_interp=NULL;
FILE * FicSortie;
printf("\nSource partie réelle:");
/*------------------------------------------------------------------------------------------------*/
/* Récupération des signaux */
/*------------------------------------------------------------------------------------------------*/
/*Récupération de la séquence reelle de +1 -1*/
for(i=0;i<N;i++)
{
signal_re[i] = source_reelle[i];
printf(" %f ",signal_re[i]);
}
printf("\nSource partie imaginaire:");
/*Récupération de la séquence imaginaire de 0*/
for(i=0;i<N;i++)
{
signal_im[i] = source_imaginaire[i];
printf(" %f ",signal_im[i]);
}
/*------------------------------------------------------------------------------------------------*/
/* Surechantillonnage des signaux */
/*------------------------------------------------------------------------------------------------*/
/*Suréchantillonnage du signal partie réelle par un facteur Ns qui a été demandé à l'utilisateur*/
upsignal_re=UpsamplingDVBTSignauxtests(signal_re,Ns,N);
printf("\n\nSignal partie reelle surechantillonnée de %d :",Ns);
/*Affichage du signal partie réelle surechantillonné*/
for(i=0;i<N*Ns;i++) /*La taille du signal surechantillonnée sera le résultat de la multiplication */
{ /*du nombre d'échantillons au départ par le facteur de surechantillonnage: N*Ns*/
printf("%f ",upsignal_re[i]);
}
/*Suréchantillonnage du signal partie imaginaire*/
upsignal_im=UpsamplingDVBTSignauxtests(signal_im,Ns,N);
printf("\n\nSignal partie imaginaire surechantillonnée de %d :",Ns);
/*Affichage du signal partie imaginaire surechantillonné*/
for(i=0;i<N*Ns;i++) /*La taille du signal surechantillonnée sera le résultat de la multiplication */
{ /*du nombre d'échantillons au départ par le facteur de surechantillonnage: N*Ns*/
printf("%f ",upsignal_im[i]);
}
/*------------------------------------------------------------------------------------------------*/
/* Calcul des coefficients du filtre à racine carrée de Nyquist */
/*------------------------------------------------------------------------------------------------*/
printf("\n\nCalcul des coefficients du filtre à racine carrée de Nyquist :");
printf("\nNombre de périodes :");
scanf("%f",&periodes);
printf("\nNombre de points par périodes :");
scanf("%f",&points);
printf("\nroll Off:");
scanf("%f",&roll_off);
coef_nyquist=RaisedCosineSQRT(periodes,points,roll_off);
/*-------------------------------------------------------------------------------------------------*/
/*Convolution des signaux surechantillonnés et les coefficients du filtre à racine carré de Nyquist*/
/*-------------------------------------------------------------------------------------------------*/
/*filtre : coef_nyquist , taille = periodes*points*/
/*signal : upsignal (signal surechantillonné) , taille = N*Ns (echantillon_source*facteur_surechantillonage)*/
/*Signal partie reelle*/
signal_re_conv_nyquist=conv(coef_nyquist, upsignal_re, N*(Ns), periodes*points);
printf("\nSignal partie reelle sortie du filtre de Nyquist:\n");
/*Affichage du signal partie reelle après le passage dans le filtre à racine de Nyquist*/
for(i=0;i<(periodes*points+N*Ns-1);i++)
{
printf("%f ", signal_re_conv_nyquist[i]);
}
/*Signal partie imaginaire*/
signal_im_conv_nyquist=conv(coef_nyquist, upsignal_im, N*(Ns), periodes*points);
printf("\nSignal partie imaginaire sortie du filtre de Nyquist:\n");
/*Affichage du signal partie reelle après le passage dans le filtre de Nyquist*/
// for(i=0;i<(periodes*points+N*Ns-1);i++)
// {
// printf("%f ", signal_im_conv_nyquist[i]);
// }
/*------------------------------------------------------------------------------------------------*/
/* Filtre FIR */
/*------------------------------------------------------------------------------------------------*/
printf("\n\nFiltre FIR");
/*------------------------------------------------------------------------------------------------*/
/* CIC interpolateur */
/*------------------------------------------------------------------------------------------------*/
printf("\nEntrez le Nombre d'étages du CIC :");
scanf("%d",&nombre_etages);
printf("\nEntrez le Rapport d'interpolation :");
scanf("%d",&interp);
// taille_cic_interpolateur= ((int)((periodes*points+N*Ns-1)*interp));
// double sortie_interp[taille_cic_interpolateur];
sortie_interp=malloc(sizeof(double)*(periodes*points+N*Ns-1)*interp);
CicNum_stages(DS, nombre_etages); /*Initialisation de la structure du CIC en fonction du nombre d'étages*/
printf("\n");
printf("\navant interpolation :\n");
for(i=0;i<(periodes*points+N*Ns-1);i++)
{
printf(" %f",signal_re_conv_nyquist[i]);
}
printf("\n");
for (i=0;i<(periodes*points+N*Ns-1)*interp;++i)
{
interpolation=CicInterpolate(DS,signal_re_conv_nyquist[i],1); /*Utilisation du CIC Interpolation*/
sortie_interp[i*interp]=interpolation;
for(j=1;j<interp;j++)
{
sortie_interp[j+interp*i]=interpolation;
}
}
printf("\ninterpolation :\n");
for(i=0;i<(periodes*points+N*Ns-1)*interp;i++)
{
printf(" %lf",sortie_interp[i]);
}
/*FicSortie= fopen("F:/Users/garnier/Matlab/sortie_cic.txt","w");
for (i=0;i<(periodes*points+N*Ns-1)*interp;++i)
{fprintf(FicSortie,"%f\n ",sortie_interp[i]);
}
fclose(FicSortie);
*/
/*-------------------------------------------------------------------------------------------------*/
/* Transposition fréquentielle */
/*-------------------------------------------------------------------------------------------------*/
printf("\nappel fonction transposition");
pas_echantillon= 1/((float)(Ns*interp));
taille_signal= (periodes*points+N*Ns-1)*interp;
FrequencyTransposition(sortie_interp,pas_echantillon,taille_signal);
return;
}
/*! \fn float * UpsamplingDVBTSignauxtests(float sig[],int fact_surechantillon,int echantillon)
\brief
\~english .
\~french Fonction permettant de suréchantillonner un signal
\param sig : Signal que l'on veut échantillonner.
\param fact_surechantillon : Facteur de suréchantillonnage
\param echantillon : Nombre d'échantillons avant le suréchantillonnage
\return
\~french Pointeur sur tableau du signal surechantillonné.
*/
float * UpsamplingDVBTSignauxtests(float sig[],int fact_surechantillon,int echantillon)
{
/*------déclaration et initialisation des variables------*/
int Ns=fact_surechantillon; /* récupération du facteur de suréchantillonnage*/
int N=echantillon;
int i;
float signal[N]; /*tableau qui va contenir le signal*/
float *up_signal= NULL;
float *p= NULL; /*pointeur pour parcourir le tableau correspndant au signal*/
up_signal=(float*)malloc(sizeof(int)*(N*Ns));
for(i=0;i<N;i++)
{
signal[i] = sig[i]; /* récupération du signal*/
}
/*-----------------surechantillonage----------------------*/
for (i=0,p=signal;i<N*Ns;++i)
{
if (i%Ns) /*A chaque indice non multiple du facteur d'échantillonnage+1*/
{
up_signal[i]=0; /*on insère les valeurs 0*/
}
else up_signal[i]=*p++; /*sinon on insère les valeurs du signal originales*/
}
return(up_signal);
}
/*! \fn float * conv(float *filtre, float *signal, int taille_entree, int taille_filtre)
\brief
\~english Convolution of x[N] with H[N]
\~french Fonction réalisant la convolution de X[N] avec H[N], le résultat sera stocké dans Y[N]
\param filtre : tableau correspondant au filtre.
\param signal : tableau correspondant au signal d'entree.
\param taille_entree : taille du signal d'entree.
\param taille_filtre : taille du filtre.
\return
\~french Pointeur sur tableau correspondant au signal convolué.
*/
float * conv(float *filtre, float *signal, int taille_entree, int taille_filtre)
{
int i,n=0,m=0;
int L=taille_entree; /*Récupération de la taille du signal d'entree*/
int M=taille_filtre; /*Récupération de la taille du filtre*/
float x[L+M]; /*Déclaration de tableau de taille correspondant à la longueur de la sortie du signal convoluée*/
float h[L+M];
float * y=NULL;
y=(float *)malloc(sizeof(float) * (L+M-1)); /*Allocation en mémoire*/
for(i=0;i<L+M-1;i++)
{ x[i]=0; /*Rajout de 0 dans le vecteur signal d'entree*/
h[i]=0; /*Rajout de 0 dans le vecteur filtre*/
}
for(i=0;i<M;i++)
{
h[i]=filtre[i]; /*Récupération des coefficcients du filtre*/
}
for(i=0;i<L;i++)
{
x[i]=signal[i]; /*Récupération du signal d'entree*/
}
for(i=0;i<L+M-1;i++) /*Initialisation du tableau de sortie*/
{ y[i]=0;
}
for(n=0;n<L+M-1;n++) /*Calcul de la convolution entre les 2 signaux*/
{
for(m=0;m<=n;m++)
{
y[n]=h[m]*x[n-m]+y[n];
}
}
return(y);
}
/*! \fn void FrequencyTransposition(float *signal_reel, float *signal_imag, float pas_echantillon, int taille_signal)
\brief
\~english
\~french Fonction réalisant une transposition fréquentielle
\param signal_reel : tableau correspondant au signal partie reelle.
\param signal_imag : tableau correspondant au signal partie imaginaire.
\param pas_echantillon : pas d'échantillons.
\param taille_signal : taille des tableaux.
\return
-.
*/
void FrequencyTransposition(float *signal_reel, float tk, int taille_signal)
{
int i;
int N=taille_signal; /*récupération de la taille des tableaux*/
float fp,cosinus[N];
// float sinus[N];
float signal_re[N];
// float signal_im[N];
float signal_re_transpose[N];
// float signal_im_transpose[N];
FILE * FicSortie;
for(i=0;i<N;i++)
{
signal_re[i]=signal_reel[i]; /*Récupération du signal partie réelle*/
}
// for(i=0;i<N;i++)
// {
// signal_im[i]=signal_imag[i]; /*Récupération du signal partie imaginaire*/
// }
printf("\n\nFréquence de la porteuse en MHz :");
scanf("%f",&fp);
printf("\n\nSignal partie réelle transposé par une porteuse de %f MHz :",fp);
for(i=0;i<N;i++)
{
cosinus[i] = cos(2*3.1416*fp*i*tk);
signal_re_transpose[i]=signal_re[i]*cosinus[i]; /*Multiplication du signal reel par cos(2*pi*fp*tk)*/
// printf("\n%d %f ",i+1,signal_re_transpose[i]);
// printf("%f",signal_re_transpose[i]);
}
// printf("\n\nSignal partie imaginaire transposé par une porteuse de %f MHz :",fp);
// for(i=0;i<N;i++)
// {
// sinus[i] = sin(2*3.1416*fp*i*tk);
// signal_im_transpose[i]=signal_im[i]*sinus[i]; /*Multiplication du signal imaginaire par sin(2*pi*fp*tk)*/
// printf("\n%d %f ",i+1,signal_im_transpose[i]);
// printf("%f",signal_im_transpose[i]);
// }
// FicSortie= fopen("F:/Users/garnier/Matlab/fich.txt","w");
// for (i=0;i<N;++i)
// {fprintf(FicSortie,"%f\n ",signal_re_transpose[i]);
// }
// fclose(FicSortie);
FicSortie= fopen("F:/Users/garnier/Matlab/reel.txt","w");
for (i=0;i<N;++i)
{fprintf(FicSortie,"%f\n ",signal_re_transpose[i]);
}
fclose(FicSortie);
return;
}
/*! \fn float * RaisedCosineSQRT(N,D,e)
\brief
\~english
\~french Création d'un vecteur de reel de forme racine d'un cosinus sureleve
\param N : Nombre de périodes.
\param D : Nombre de points par périodes.
\param e : Valeur de Roll-off.
\return
\~french Pointeur sur tableau correspondant aux coefficients réels de forme surcos.
*/
float * RaisedCosineSQRT(float nb_periodes,float nb_points,float roll_off)
{
/*------déclaration et initialisation des variables------*/
int i,n;
int t;
float N=nb_periodes;
float D=nb_points;
float e=roll_off;
float *w=NULL;
float racineD,x,oneplus,oneminus,den;
// FILE *FicSortie;
w=(float *)malloc(sizeof(float) * (N*D)); /*Allocation en mémoire*/
racineD = sqrt(D);
for(i=0;i<N*D;i++)
{ w[i]=0; /*vecteur de 0*/
}
for(n=0;n<N*D;n++)
{
t=n-N*D/2;
x=t/D;
oneplus=(1.0+e)*3.1416/D;
oneminus=(1.0-e)*3.1416/D;
if(t==0.000000)
{
w[n]=(4*e/3.1416+1-e)/ racineD;
}
else if(e==0.000000)
{
w[n]=racineD*sin(3.1416*x)/(3.1416*t);
}
else
{
den=t*t*16*e*e-D*D;
if(den==0)
{
w[n]=(D*racineD/(8*e*3.1416*t))*(oneplus*sin(oneplus*t)-(oneminus*D/(4*e*t))*cos(oneminus*t)+(D/(4*e*t*t))*sin(oneminus*t));
}
w[n]=(4*e/(3.1416*racineD))*(cos(oneplus*t)+sin(oneminus*t)/(x*4*e))/(1.0-16*e*e*x*x);
}
}
for(n=0;n<N*D;n++)
{ printf("\nw[i]%f",w[n]);
}
// FicSortie= fopen("F:/Users/garnier/Matlab/fich.txt","w");
// for (i=0;i<N*D;++i)
// {fprintf(FicSortie,"%f ",w[i]);
// }
// fclose(FicSortie);
return(w);
}
/*! \fn void CicNum_stages(DVBTSigauxtests *DS, int n)
\brief
\~english
\~french Fonction permettant d'initialiser le nombre d'étages du filtre CIC
\param DC : Pointeur sur structure DVBTCic
\param n : Entier correspondant au nombre d'étages du filtre CIC
\return
\~french .
*/
void CicNum_stages(DVBTSignauxtests *DS, int n)
{
DS->stages = n;
free(DS->nacc);
free(DS->diff);
free(DS->prev);
DS->nacc=malloc(sizeof(double)*(n)); /*Allocation mémoire correspondant au nombre d'étages du CIC*/
DS->diff=malloc(sizeof(double)*(n));
DS->prev=malloc(sizeof(double)*(n));
return;
}
/*! \fn double CicInterpolate(DVBTCic *DC, double in, int dump)
\brief
\~english
\~french Fonction permettant d'effectuer une interpolation
\param DC : Pointeur sur structure DVBTCic
\param in : Double représentant les échantillons en entrées avant interpolation.
\param dump : Entier représentant le taux d'interpoaltion.
\return
\~french Double représentant les échantillons après interpolation
*/
double CicInterpolate(DVBTSignauxtests *DS, double in, int dump)
{
int i;
if(dump) /*Dump autorise l'entrée d'un nouvel échantillon*/
{
DS->diff[0]=in-DS->prev[0];
DS->prev[0]=in;
for(i=1;i<DS->stages;i++)
{ DS->diff[i]= DS->diff[i-1]-DS->prev[i];
DS->prev[i]=DS->diff[i-1];
}
DS->nacc[0]+=DS->diff[DS->stages-1];
}
for(i=0;i<(DS->stages-1);i++)
{
DS->nacc[i+1] += DS->nacc[i];
}
return(DS->nacc[DS->stages-1]);
}
/*! \fn ResetDVBTSignauxtests(DVBTSignauxtests *DS)
\brief
\~english Reset of structure DVBTSignauxtests.
\~french Ré-initialisation de la structure DVBTSignauxtests.
\param DS :
\~english Pointer on structure DVBTSignauxtests.
\~french Pointeur sur structure DVBTSignauxtests.
\return
-.
*/
void ResetDVBTSignauxtests(DVBTSignauxtests *DS) {
return;
} |
erreur de segmentation
Répondre avec citation
Envoyé par sandball22
,
Partager