1.Iesire filtru H(z) dupa 2 filtre FIR in cascada H1(z)=0.4-1.8z-1 , H2(z)=1-0.5z-1+0.8z-2 .

Fct are 2
pointeri : input x, output y, lung N. Coef filtrului vor fi def in functie.

Void Filtru(word16 *x[], * word16 y[] ) {

Int N1=2 ,N2= 3;
Word16 h1[2]= {word16(0,4), word16(-1,8)}; Word16 h1[2]= {word16(1) word16(-0.5),
word16(0.8)}
Word16 delay[N1], delay[N2]; Word32 sum;
Int n,k,index1, index2;
For(n=0; n<DataBlockSize; n++) {
Delay1[index1%N1]=x[n];
sum=0;
for(k=0;k<N1;k++){
sum=L_mac(sum,h1[k],delay1[(index1-k)%N1]) }
temp=round(sum);
index1 ++;
delay2[index2%N2]=temp;
sum=0
for(k=0;k<N2;k++){
sum=L_mac(sum,h2[k],delay2[(index2-k)%N2]) }
y[n]=round(sum); index2++; } }
𝟏
2. Pt calc er medie patratica e= 𝑵 ∑𝑵−𝟏 𝟐
𝒌=𝟎 (𝒙[𝒌] − 𝒚[𝒌]) intre 2 vectori cu val fractionare lung N=8
b) optimizare

#define N 8
Word16 Eroare(word16 x[N], word16 y[N] ) {
Int i; Word16 e=0; Word16 temp;
For(i=0,i<N,i++) {
temp=sub(x[i],y[i]);
e=L_mac(e,temp,temp);
e=shr(e,3); / % N=8
e=round(e); } return(e); }

b) for (i=0; i<N; i+=2) {

temp1=sub(x[i], y[i]);
temp2=sub(x[i+1], y[i+1]);
e1=L_mac(e1,temp1,temp1);
e1=round(e1);
e2=L_mac(e2,temp2,temp2);
e2=round(e2); }
e1=add(e1,e2);
e1=L_shr(e1); return(e1); }
3. Hilbert optimizat
#pragma align X 8
#pragma align Y 8
void Hilbert_Transformer(Word16* X, Word16* Y, short N)
{
int i;
for(i=0; i<=N/2; i=i+2)
{
Y[2*i] = X[2*i+1];
Y[2*i+1] = -X[2*i];
Y[2*i+2] = X[2*i+3];
Y[2*i+3] = -X[2*i+2]; }
for(i=N/2+1; i<N; i=i+2){
y[2*i] = -X[2*i+1];
y[2*i+1] = X[2*i];
y[2*i+2] = -X[2*i+3];
y[2*i+3] = X[2*i+2]; }}

𝟏
2. ec matriceale care calc recursiv iesirile [𝒄̀ 𝒔́ ]=0.5 [ √𝟑 ][c s ] pe baza val anterioare c s.
−𝟏 √𝟑
Este osc in cuad(form quad si matrice) , identif termenii cosw0=sqrt(3) / 2, sinw0=1/2 .
sin(pi/6)=1/2
b)relatiile de recurenta sunt cele de mai sus
cosw0(n+1)=cos(w0n)*cosw0-sin(w0n)*sinw0
sinw0(n+1)=sin(w0n)*cosw0+cos(w0n)*sinw0

#include <stdio.h>
#include <prototype.h>
#define MAX_16 (Word16)0x7fff
Word16 c[DataSize],s[DataSize],c0,s0;
Word32 temp;
int main(){
int i;
s0=WORD16(-0.866); //cos(w0)
c0=WORD16(0.5); //sin(w0)
s[0]=MAX_16; //cos(0)
c[0]=0; //sin(0)
for (i = 0; i < DataSize-1; i++) {
temp=L_mult(c[i],s0);
c[i+1]=mac_r(temp,s[i],c0);
temp=L_mult(s[i],s0);
5. dtmf tasta 3,f1=697H f2=1477h fs=8k 0,5 s liniste/ton
#define DataSize4000
int main(){
Word16 s[DataSize],c0,c1,s1,s2,s3,s4,s5,s6,temp,temp1;
c0=WORD16(0.853868905); //cos(w0),
s1=WORD16(0.260244065); //y[-1] = sin(w0)
s2=0;//y[-2] = 0.4
c1=WORD16(0.399309195);
s3=WORD16(0.458408161);
s4=0;//y[-2] = 0.4
for (i = 0; i < DataSize; i++)
{
temp=mult_r(c0,s1);
temp=shl_nosat(temp,1);
s5=sub(temp,s2); s2=s1; s1=s5;
temp1=mult_r(c1,s3);
temp1=shl_nosat(temp1,1);
s6=sub(temp1,s4);
s4=s3; s3=s6; s[i]=add(s5,s6);} open..}

N 1
3.Sa se realizeze un proiect C pentru : P   a(k ) x
k 0
k

#include <prototype.h>

#include "constants.h"
Word16 Prod(Word16 a[], Word16 x)
{ Word16 i;
Word32 sum;
Word16 prod;
sum=0L;
prod=0x7fff;
for(i=0;i<DataBlockSize;i++)
{ sum=L_mac(sum,a[i],prod);
prod=mult(prod,x);
}
return(round(sum));
}

#include <prototype.h>
#include "constants.h"
Word16 Prod(Word16 a[], Word16 x)
{Word16 i;
Word32 sum, sum0, sum1;
Word16 prod;
sum0=sum1=0L;
prod=0x7fff;
for(i=0;i<DataBlockSize;i+=2)
{ sum0=L_mac(sum0,a[i],prod);
prod=mult(prod,x);
sum1=L_mac(sum1,a[i+1],prod);
prod=mult(prod,x);
}sum=L_add(sum0, sum1);
return(round(sum));}
X. Prod a 2 vect de elem complexe element cu element
void Prod(Word16 x[DataBlockSize], Word16 y[DataBlockSize], Word32 z[DataBlockSize])
{
Word16 i;
for(i=0;i<2*DataBlockSize;i+=2)
{
z[i] = L_mac(0,x[i],y[i]);
z[i] = L_msu(z[i],x[i+1],y[i+1]);
z[i+1] = L_mac(0,x[i],y[i+1]);
z[i+1] = L_mac(z[i+1],x[i+1],y[i]);
}
}

P=X4(k)

#include <prototype.h>
#include <stdio.h>
#define N 16
Word16
x[N]={WORD16(0.05),WORD16(0.1),WORD16(0.15),WORD16(0.2),WORD16(0.25),WORD16(0.3
),....)};
Word16 sum,term;
int main(){
short i;
for(i=0;i<N;i++){
term=mult(x[i],x[i]);
sum=add(sum,mult(term,term));}
printf("Suma este este:%d",sum);
return(0);}

b)Optimizat
#include <prototype.h>
#include <stdio.h>
#define N 16
Word16
x[N]={WORD16(0.05),WORD16(0.1),WORD16(0.15),WORD16(0.2),WORD16(0.25),WORD16(0.3
),..)};
Word16 sum0,sum1,sum2,sum3;
int main(){
short i;
for(i=0;i<N;i=i+4){
sum0=add(sum0,mult(mult(x[i],x[i]),mult(x[i],x[i])));
sum1=add(sum1,mult(mult(x[i+1],x[i+1]),mult(x[i+1],x[i+1])));
sum2=add(sum2,mult(mult(x[i+2],x[i+2]),mult(x[i+2],x[i+2])));
sum3=add(sum3,mult(mult(x[i+3],x[i+3]),mult(x[i+3],x[i+3])));}
sum0=add(sum0.sum1);
sum2=add(sum2,sum3);
sum0=add(sum0,sum2);
printf("Suma este este:%d",sum0);
return(0);}
x. Calc polin de ordin N . In main declar polin w16 x[n] (val lu x), coef[], short N, open.
Word16 poly(Word16 x,Word16* coef, short N)
{
short i;
Word16 p,temp;
p = coef[N];
for(i=N-1;i>=0;i--){
temp = mult_r(p,x);//p=p*x;
p = add(coef[i],temp);//p=p*x+c(i);}
return(p);}

1. Implementeaza sist din figura.determinati lungimea

liniei de intarziere M a.i. ecoul sa aiba o intarziere de 0.3 sec.Semnalul de intrare va fi generat in
matlab de fisier audio. Intarzierea se va calcula in fctie de frecv de esant a fisierului wav.

clear all
close all

[x,Fs,Nbit]=wavread('speech.wav');
L=length(x)
Fs
fid=fopen('..\x.dat','w','b');
fwrite(fid,x.*2^15,'int16');
fclose(fid);
display('APASA O TASTA');
pause
fid=fopen('..\y.dat','r','b');
y=fread(fid,L,'int16');
fclose(fid);
y=y'/(2^15);
sound(y,Fs)

#include <stdio.h>
#include <stdlib.h>
#include <prototype.h>
#define DataBlockSize 160 /* size of data block to process */
#define N 6615 /* buffer length */

int main()
{
Word16 x[DataBlockSize],y[DataBlockSize],delay[N],w;
short n,k;
long unsigned index=0;
FILE *fpx,*fpy;

fpx=fopen("x.dat","r+b");
if (!fpx)
printf("\nNu s-a deschis");
fpy=fopen("y.dat","w+b");
if (!fpy)
printf("\nNu s-a deschis");

for (k=0; k<687; k++)

{ fread(x,sizeof(Word16),DataBlockSize,fpx);
for (n=0; n<DataBlockSize; n++)
{ w=mult_r(x[n],WORD16(0.4));
y[n]=mac_r(L_deposit_h(w),delay[index%N],WORD16(0.5));
delay[index%N]=w;
index++;
}
fwrite(y,sizeof(Word16),DataBlockSize,fpy);
}
fclose(fpx);
fclose(fpy); return(0); }
FTS -IIR
clear all,close all,clc
Fp=3500;
Fs=2000;
Fes=10000;
wp=2*pi*Fp/Fes;
ws=2*pi*Fs/Fes;
Op=2*Fes*tan(wp/2);
Os=2*Fes*tan(ws/2);
[n,Wt]=buttord(Op,Os,1,30,'s')
[bs,as]=butter(n,Wt,'high','s');
[bd,ad]=bilinear(bs,as,Fes)

t=0:1/Fes:1-1/Fes;
x=chirp(t,0,1,Fes/2);
k=fix(length(x)/100)
L=k*100;
y_ref=filter(bd,ad,x);
nr=0:L-1;
plot(nr,y_ref)

h=impz(bd,ad);
k0=sum(abs(h));
if (k0>1)
bd_s=bd./k0
end
h_in=impz(1,ad);
k1=sum(abs(h_in));
x=x./k1;

fid=fopen('..\x.dat','w','b');
fwrite(fid,x.*2^15,'int16');
fclose(fid);

display('APASA O TASTA');
pause

fid=fopen('..\y.dat','r','b');
y=fread(fid,L,'int16');
fclose(fid);
y=y'/(2^15);
y=k0*k1*y;

n=0:L-1;
figure(5),plot(n,y),grid
figure(6),plot(n,y-y_ref),grid

#include <stdio.h>
#include <stdlib.h>
#include <prototype.h>
#define DataBlockSize 100 /* dimensiunea unui bloc de date */
#define BlockLength 100 /* numarul de blocuri de date */

Word16 x[DataBlockSize],y[DataBlockSize];
Word16 w,w1,w2,w3,w4,w5;
//Word16 b[]={WORD16(b0/2), WORD16(b1/2), WORD16(b2/2)};
//Word16 a[]={WORD16(a1/2), WORD16(a2/2)};

Word16 b[]={WORD16(0.0120/2), WORD16(-0.0600/2), WORD16(0.1200/2),WORD16(-0.1200/2),

WORD16(0.0600/2), WORD16(-0.0120/2)};
Word16 a[]={WORD16(1.1388/2), WORD16(1.0885/2),WORD16(0.4671/2),
WORD16(0.1315/2),WORD16(0.0140/2)};

Word32 sum;

int main()
{
short n,i;

FILE *fpx,*fpy;

fpx=fopen("x.dat","r+b");
if (!fpx)
printf("\nNu s-a deschis");
fpy=fopen("y.dat","w+b");
if (!fpy)
printf("\nNu s-a deschis");

for (i=0; i<BlockLength; i++)

{
fread(x,sizeof(Word16),DataBlockSize,fpx);

for (n=0; n<DataBlockSize; n++)

{
sum = L_deposit_h(shr(x[n],1));
sum = L_msu(sum,a[0],w1);
sum = L_msu(sum,a[1],w2);
sum = L_msu(sum,a[2],w3);
sum = L_msu(sum,a[3],w4);
sum = L_msu(sum,a[4],w5);
w = shl(round(sum),1);
sum = L_mult(b[0],w);
sum = L_mac(sum,b[1],w1);
 sum = L_mac(sum,b[2],w2);
sum = L_mac(sum,b[3],w3);
sum = L_mac(sum,b[4],w4);
y[n]= shl(mac_r(sum,b[5],w5),1);
w5=w4;
w4=w3;
w3=w2;
w2=w1;
w1=w;
}

fwrite(y,sizeof(Word16),DataBlockSize,fpy);
}

fclose(fpx);
fclose(fpy);

return(0);
}

2.Realizati un proiect SC140 sa contina un program main si fctie de calcul a sumei produsului
elem a doi vectori.Prototip fctie: word16 r=prod(word16*x,word16*y,short N) x,y sunt pointerii
vectorului , r suma rezultata iar N lungimea vectorilor. Fctia trebuie optimizata. Sa se verifice
pentru2 vectori de lungime 16 cu val generate de Matlab.

clear all
close all
clc
N=16;
% x=0.05*rand([1,N])
% y=0.05*rand([1,N])
x=-0.5:1/N:0.5-1/N;
y=-0.6:1.2/N:0.6-1.2/N;
sum=0;
for i=1:N
sum=sum+x(i)*y(i);
end
fid=fopen('..\x.dat','w','b');
fwrite(fid,x.*2^15,'int16');
fclose(fid);

fid=fopen('..\y.dat','w','b');
fwrite(fid,y.*2^15,'int16');
fclose(fid);

display('APASA O TASTA');
pause

fid=fopen('..\r.dat','r','b');
r=fscanf(fid,'%d');
fclose(fid);
r=r'/(2^15);
er=r-sum
#include <stdio.h>
#include <stdlib.h>
#include <prototype.h>
extern Word32 prod(Word16 *x,Word16 *y,short dim);
#define N 16
int main()
{
Word16 x[N],y[N];
Word32 r;
FILE *fp;
fp=fopen("x.dat","r+b");
if (!fp)
printf("\nxNu s-a deschis");
fread(x,sizeof(Word16),N,fp);
fclose(fp);

fp=fopen("y.dat","r+b");
if (!fp)
printf("\nyNu s-a deschis");
fread(y,sizeof(Word16),N,fp);
fclose(fp);

r=prod(x,y,N);

fp=fopen("r.dat","w+b");
if (!fp)
printf("\nrNu s-a deschis");
fprintf(fp,"%d",r);
fclose(fp);
return(0);
}
_______________________________

#include <stdio.h>
#include <stdlib.h>
#include <prototype.h>
extern Word32 prod(Word16 *x,Word16 *y,short dim)
{
#pragma align *x 8
#pragma align *y 8
short i;
Word32 sum1=0,sum2=0,sum3=0,sum4=0,sum=0;
for(i=0;i<dim;i+=4)
{
sum1=L_mac(sum1,x[i],y[i]);
sum2=L_mac(sum2,x[i+1],y[i+1]);
sum3=L_mac(sum3,x[i+2],y[i+2]);
sum4=L_mac(sum4,x[i+3],y[i+3]);
}
sum1=L_add(sum1,sum2);
sum3=L_add(sum3,sum4);
sum=L_add(sum1,sum3);
return (sum);
}
3.Modificaţi programul pentru a calcula suma elementelor vectorului INPUT.Rezultatul (o
singură valoare) trebuie scris la adresa OUTPUT.
N equ 16
INPUT equ $100
OUTPUT equ $400
org p:INPUT
dc 0.1,-0.9,0.2,-0.8,0.3,-0.7,0.4,-0.6
dc 0.6,-0.4,0.7,-0.3,0.8,-0.2,0.9,-0.1
org p:0
jmp $1000
org p:$1000
init: type func
doensh0 #N ; processing 1 samples
move.w #INPUT,r0
move.w #OUTPUT,r7
Finit_end
kernel: type func
clr d1
loopstart0
move.f (r0)+,d0
add d0,d1,d1
loopend0
Fkernel_end

Modificaţi programul pentru a calcula suma pătratelor elementelor vectorului

INPUT.
N equ 16
INPUT equ $100
OUTPUT equ $400
org p:INPUT
dc 0.1,-0.9,0.2,-0.8,0.3,-0.7,0.4,-0.6
dc 0.6,-0.4,0.7,-0.3,0.8,-0.2,0.9,-0.1
org p:0
jmp $1000
org p:$1000
init: type func
doensh0 #N/4
move.w #INPUT,r0
move.w #OUTPUT,r7
Finit_end
kernel: type func
[ clr d4 clr d5 clr d6 clr d7 ]
move.4f (r0)+,d0:d1:d2:d3
loopstart0
[ mac d0,d0,d4
mac d1,d1,d5
mac d2,d2,d6
mac d3,d3,d7
move.4f (r0)+,d0:d1:d2:d3 ]
loopend0
add d4,d5,d5
add d6,d7,d7
add d5,d7,d7
move.f d7,(r7)
Fkernel_end
1.Definiţi un al doilea vector cu 16 elemente aleatoare (de ex. 0.1,-0.1,...).Modificaţi programul
astfel ca vectorul rezultat OUTPUT să fie suma element cu element a celor doi vectori.
N equ 16
INPUT equ $100
VECTOR equ $400
OUTPUT equ $800
org p:INPUT
dc 0.1,-0.9,0.2,-0.8,0.3,-0.7,0.4,-0.6
dc 0.6,-0.4,0.7,-0.3,0.8,-0.2,0.9,-0.1

org p:VECTOR
dc 0.3,-0.6,0.5,-0.7,0.9,-0.7,-0.1,0.2
dc -0.1,0.2,0.2,-0.8,0.7,-0.9,-0.7,0.8

org p:0
jmp $1000

org p:$1000
init: type func
doensh0 #N/4
move.w #INPUT,r0
move.w #VECTOR,r2
move.w #OUTPUT,r7
Finit_end

kernel: type func

[ clr d8 clr d9 clr d10 clr d11 ]
move.4f (r0)+,d0:d1:d2:d3
loopstart0
[ add d0,d4,d8
add d1,d5,d9
add d2,d6,d10
add d3,d7,d11
move.4f (r0)+,d0:d1:d2:d3
move.4f (r2)+,d4:d5:d6:d7 ]
loopend0
Fkernel_end

Modificaţi programul de la punctul 4 pentru a calcula suma produselor elementelor celor doi
vectori în variabila OUTPUT.
N equ 16
INPUT equ $100
VECTOR equ $400
OUTPUT equ $800
org p:INPUT
dc 0.1,-0.9,0.2,-0.8,0.3,-0.7,0.4,-0.6
dc 0.6,-0.4,0.7,-0.3,0.8,-0.2,0.9,-0.1

org p:VECTOR
dc 0.3,-0.6,0.5,-0.7,0.9,-0.7,-0.1,0.2
dc -0.1,0.2,0.2,-0.8,0.7,-0.9,-0.7,0.8

org p:0
jmp $1000
 org p:$1000
init: type func
doensh0 #N/4
move.w #INPUT,r0
move.w #VECTOR,r2
move.w #OUTPUT,r7
Finit_end

kernel: type func

[ clr d8 clr d9 clr d10 clr d11 ]
move.4f (r0)+,d0:d1:d2:d3
loopstart0
[ mac d0,d4,d8
mac d1,d5,d9
mac d2,d6,d10
mac d3,d7,d11
move.4f (r0)+,d0:d1:d2:d3
move.4f (r2)+,d4:d5:d6:d7 ]
loopend0
add d8,d9,d9
add d10,d11,d11
add d9,d11,d11
move.f d11,(r7)
Fkernel_end
3.Realizati un proiect SC140 sa contina un program main si fctie de imultire cu un vector
fereastra w a unui vector de date x. Prototipul fctie: void wind(word16*x, word16*w,
word16*y,short N) x,y sunt pointerii vectorului , r suma rezultata iar N lungimea vectorilor.
Fctia trebuie optimizata. Sa se verifice pentru2 vectori de lungime 16 cu val generate de Matlab.

clear all,close all,clc

N=16;
w=hamming(N);
w=w';
n=0:length(w)-1;
figure(1),plot(n,w)
Nx=4*N;
k=0:Nx-1;
x=sin(2*pi*1000/8000*k);
y=zeros(1,Nx);
contor=0;
for i=1:Nx
j=i-contor*N;
y(i)=x(i)*w(j);
if(mod(i,N)==0)
contor=contor+1;
end
end

fid=fopen('..\x.dat','w','b');
fwrite(fid,x.*2^15,'int16');
fclose(fid);

fid=fopen('..\w.dat','w','b');
fwrite(fid,w.*2^15,'int16');
fclose(fid);

display('APASA O TASTA');
pause

fid=fopen('..\y.dat','r','b');
y_cw=fread(fid,Nx,'int16');
fclose(fid);
y_cw=y_cw'/(2^15);

n=1:Nx;
subplot(3,1,1),plot(n,y),grid on
subplot(3,1,2),plot(n,y_cw),grid on
subplot(3,1,3),plot(n,y-y_cw),grid on
____________________________________________

#include <stdio.h>
#include <stdlib.h>
#include <prototype.h>
extern void wind(Word16 *x,Word16 *w,Word16 *y,short dim);
#define DataBlockSize 16
#define BlockLength 4
int main()
{
Word16 x[DataBlockSize],w[DataBlockSize],y[DataBlockSize];
short i;
FILE *fpx,*fpw,*fpy;

fpx=fopen("x.dat","r+b");
if (!fpx)
printf("\nxNu s-a deschis");

fpw=fopen("w.dat","r+b");
if (!fpw)
printf("\nwNu s-a deschis");
fread(w,sizeof(Word16),DataBlockSize,fpw);
fclose(fpw);

fpy=fopen("y.dat","w+b");
if (!fpy)
printf("\nNu s-a deschis");
for (i=0; i<BlockLength; i++)
{
fread(x,sizeof(Word16),DataBlockSize,fpx);
wind(x,w,y,DataBlockSize);
fwrite(y,sizeof(Word16),DataBlockSize,fpy);
}
fclose(fpx);
fclose(fpy);

return(0);
}
_________________________________________

#include <stdio.h>
#include <stdlib.h>
#include <prototype.h>
void wind(Word16 *x,Word16 *w,Word16 *y,short dim)
{
short i;
for(i=0;i<dim;i++)
{
y[i]=mult_r(x[i],w[i]);
}
}
4.RFI TRECE BANDA cu frecvente de taiere F1=2KHZ, F2=3Khz,lungime N=51 care lucreaza
la frecv de esantionare Fs=8khz. Caracteristica amplit-frecv?
In C realizati un proiect care sa implemnteze filtrul. Testati progr in simulator folosind un
semnal sinusoidal de frecv var intre 100hz si 4khz de durata 0.5 sec generat cu functia chirp.
N=51;
Fs=8000;
F1=2000;
F2=3000;
w1=2*F1/Fs;
w2=2*F2/Fs;
wn=[w1,w2];
h=fir1(N-1,wn);
H=fft(h,512);
n=0:N-1;
stem(n,h)
w=-pi:2*pi/512:pi-2*pi/512;
plot(w,fftshift(abs(H))),grid

%intrarea
t=0:1/Fs:0.5-1/Fs;
x=chirp(t,100,0.5,Fs/2);

kx=fix(length(x)/160)
L=kx*160;
nr=0:L-1;

figure(1),plot(nr,x),grid,title('semnalul de la in')

y_ref=filter(h,1,x);
figure(2)
subplot(2,1,1), plot(nr,y_ref),grid,title('semnalul de la iesire - Matlab')

fid=fopen('..\x.dat','w','b');
fwrite(fid,x.*2^15,'int16');
fclose(fid);

fid=fopen('..\h.dat','w','b');
fwrite(fid,h.*2^15,'int16');
fclose(fid);

pause

fid=fopen('..\y.dat','r','b');
y=fread(fid,L,'int16');
fclose(fid);
y=y'/2^15;

suplot(2,1,2),plot(nr,y),grid,title('semnalul de la iesire - CW')

#include <prototype.h>
#include <stdio.h>
#define DataBlockSize 160 /* dimensiunea unui bloc de date */
#define BlockLength 25 /* numarul de blocuri de date */
#define N 51 /* N = lungimea filtrului */
int main()
{
Word16 x[DataBlockSize],y[DataBlockSize],delay[N],h[N];
Word32 sum;
short n,i;
long unsigned k,index;
FILE *fph,*fpx,*fpy;

fph=fopen("h.dat","r+b");
if (!fph)
printf("\nh Nu s-a deschis");
fread(h,sizeof(Word16),N,fph);
fclose(fph);

fpx=fopen("x.dat","r+b");
if (!fpx)
printf("\nx Nu s-a deschis");
fpy=fopen("y.dat","w+b");
if (!fpy)
printf("\ny Nu s-a deschis");

for (i=0; i<BlockLength; i++)

{
fread(x,sizeof(Word16),DataBlockSize,fpx);
for (n=0; n<DataBlockSize; n++)
{
delay[index%N]=x[n];
sum=0;
for (k=0; k<N; k++)
{
sum=L_mac(sum,h[k],delay[(index-k)%N]);
}
y[n]=round(sum);
index++;
}
fwrite(y,sizeof(Word16),DataBlockSize,fpy);
}
fclose(fpx);
fclose(fpy);
return(0);

}
3.Realizati un proiect SC140 sa contina un program main si fctie a unui polinom. Prototipul
fctie: Word16 poly(word16*x, word16*coef,,short N),unde x val in care se calc polin de oridin N
definit de coeficientii din vetorul coef. Verificti pt polinomul p(x)=1+0.85x-0.375x^2+0.05x^3 si
pt valorile lui x(-1,-0.25,0.25,-0.5,0.5)

#include <stdio.h>
#include <stdlib.h>
#include <prototype.h>
extern Word16 poly(Word16 x,Word16 *coef, short N);
int main ()
{
 short i, N=4;
Word16 x[5]={WORD16(-1),WORD16(-0.25),WORD16(0.25),WORD16(-
0.5),WORD16(0.5)} ;
Word16 coef[]={WORD16(0.5),WORD16(0.85/2),WORD16(-0.375/2),WORD16(-
0.175/2),WORD16(0.05/2)};
Word16 p;
for(i=0;i<5;i++)
{
printf("x[%d]=%d\n",i,x[i]);
p=poly(x[i],coef,N);
printf("poly(%d)=%d\n",x[i],p);
}

return(0);
}

#include <stdio.h>
#include <stdlib.h>
#include <prototype.h>
Word16 poly(Word16 x, Word16 *coef, short N)
{
short i;
Word16 temp;
Word16 rez;
rez=coef[0];
temp=x;
for(i=1;i<=N;i++)
{
rez=add(rez,mult_r(coef[i],temp));
temp=mult(temp,x);
}
rez=shl(rez,1);
return (rez);
}

1. folosind metoda de cautare in tabel cu delta intreg folosing un tabel de lungime N care contine
o singura perioada de sinusoida s(n)=0.2*sin(w0n)+0.4sin(w0n) F1=609hz,F2=1000HZ si frecv
de esantonare Fs=48khz.

close all
clear all
clc
DataSize=256;

N=240;
delta1=3;
delta2=5;

k=0:N-1;
table=0.5*sin(2*pi/N*k);

fid=fopen('..\table.dat','w','b');
fwrite(fid,table.*2^15,'int16');
fclose(fid);
pause

fid=fopen('..\s.dat','r','b');
s=fread(fid,DataSize,'int16');
fclose(fid);
s=s'/(2^15)

k=0:DataSize-1;
s_ref=0.5*(0.2*sin(2*pi/N*delta1*k)+0.4*sin(2*pi/N*delta2*k));
figure(1)
subplot(2,1,1),plot(k,s_ref),grid
subplot(2,1,2), plot(k,s,'g'), grid on
figure(2), plot(k,s_ref-s), grid on

#include <stdio.h>
#include <stdlib.h>
#include <prototype.h>
#define DataSize 256 /* number of samples */
#define N 240 /* size of sine table */

int main()
{
Word16 table[N];
Word16 s[DataSize];

short i, delta1=3,delta2=5;

FILE *fpt,*fps;
fpt=fopen("table.dat","r+b");
fread(table,sizeof(Word16),N,fpt);
if (!fpt)
printf("\nNu s-a deschis");
fclose(fpt);

for (i=0; i<DataSize; i++)

{
s[i]=add(mult(table[(i*delta1)%N],WORD16(0.2)),mult(table[(i*delta2)%N],WORD16(0.4)))
;
}

fps=fopen("s.dat","w+b");
fwrite(s,sizeof(Word16),DataSize,fps);
if (!fps)
printf("\nNu s-a deschis");
fclose(fps);

return(0);
}
1.s(n)=0.4*[1+0.5x(n)]*cos(w0n) a unui semnal de intrare x(n) citit din fisier generat de
matlab.purtatoarea de frecv F0=7khz generate folosind metoda oscilatorului digital si frecv de
esantonare Fs=40khz.
clear all,close all, clc

DataSize=2560;
F = 7000;
Fs = 40000;
w0 = 2*pi*F/Fs;
coef=[cos(w0) sin(w0) 0]

n=1:DataSize;
x=sin(2*pi*100/Fs*n);

fid=fopen('..\x.dat','w','b');
fwrite(fid,x.*2^15,'int16');
fclose(fid);
pause
fid=fopen('..\s.dat','r','b');
s = fread(fid,DataSize,'int16');
fclose(fid);
s = s/(2^15);

for n=1:DataSize
s_ref(n)=(0.4+0.2*x(n))*sin(2*pi*F/Fs*(n+1));
end

n=2:DataSize+1;
figure(1), plot(n,s_ref),grid on
figure(2), plot(n,s),grid on
figure(3), plot(n,s_ref-s'), grid on

#include <prototype.h>
#include <stdio.h>

#define DataSize 2560 /* number of samples */

int main()
{
Word16 s[DataSize],x[DataSize],s_out[DataSize],c0,s1,s2,temp;

short i;
FILE *fp;

c0=WORD16(0.4540); //cos(w0), F=1kHz, Fs=48kHz;

s1=WORD16(0.8910); //y[-1] = sin(w0)
s2=0; //y[-2] = 0

fp=fopen("x.dat","r+b");
if (!fp)
printf("\nNu s-a deschis");
fread(x,sizeof(Word16),DataSize,fp);
fclose(fp);
for (i = 0; i < DataSize; i++)
{
temp=mult_r(c0,s1);
temp=shl_nosat(temp,1);
s[i]=sub(temp,s2);
s2=s1;
s1=s[i];
temp = mac_r(L_deposit_h(WORD16(0.4)),WORD16(0.2),x[i]);
s_out[i] = mult(temp,s[i]);
}

fp=fopen("s.dat","w+b");
fwrite(s_out,sizeof(Word16),DataSize,fp);
if (!fp)
printf("\nNu s-a deschis");
fclose(fp);

return(0);
}

1.Semnal sinusoidal cu frecv F0=1260HZ folosind cautarea in tabel cu pasul delta rational cu
interpolare liniara. Lungimea tabelului este N=512 si frecv de esant Fs=8khz. Pasul delta
corespunzator? Si reprezentarea acestuia in format hexazecimal. Se genereaza semnalul pe o
durata de 1 sec urmat de 0.5 sec de liniste si tot asa.

close all,clear all,clc

Fs = 8000;
F = 1260;
N = 512;
delta = N*F/Fs;

k=0:N-1;
table=0.5*sin(2*pi/N*k);

fid=fopen('..\table.dat','w','b');
fwrite(fid,table.*2^15,'int16');
fclose(fid);

display('APASA O TASTA');
pause
t=1+0.5;%1 sec de sin + 0.5 s de liniste
M = t*Fs;

fid=fopen('..\s.dat','r','b');
s_cw=fread(fid,M,'int16');
fclose(fid);
s_cw=s_cw'/(2^15);
s_matlab = zeros(1,M);

for n=0:M-1
if(n<8000)
s_matlab(n+1) = 0.5*sin(2*pi/N*delta*n);
 end
end
n=0:M-1;
figure(1), plot(n,s_cw), grid on
figure(2), plot(n,s_matlab), grid on
figure(3), plot(n,s_matlab-s_cw), grid on

#include <prototype.h>
#include <stdio.h>

#define DataSize 8000 /* number of samples */

#define Liniste 4000
#define N 512 /* size of sine table */

int main()
{
Word16 table[N];
Word16 s[DataSize],semnal_iesire[DataSize+Liniste];

short i;
unsigned short i_index1,i_index2;
Word16 i_tone1,i_tone2,frac;
UWord32 phaseaccum = 0;
Word32 delta = 0x0050A3D7; // delta=80.64

FILE *fp;

fp=fopen("table.dat","r+b");
fread(table,sizeof(Word16),N,fp);
if (!fp)
printf("\nNu s-a deschis");
fclose(fp);

for (i = 0; i < DataSize; i++)

{

i_index1 = (phaseaccum >> 16)%N;

i_index2 = (i_index1+1)%N;
i_tone1 = table[i_index1];
i_tone2 = table[i_index2];

/* partea fractionara se obtine prin pastrand 16 LSB*/

frac = (Word16) ((Word32)((phaseaccum & 0xffff)>>1));

/* interpolare liniara */

s[i] = add(mult(sub(i_tone2,i_tone1),frac),i_tone1);

/* phaseaccum este un intreg unsigned ce variaza intre 0 si 0xffffffff,

apoi, prin incrementare, porneste din nou de la 0 */
phaseaccum+=delta;
}
for (i = 0; i < DataSize+Liniste; i++)
if(i<DataSize)
semnal_iesire[i] = s[i];
else
semnal_iesire[i] = 0;

fp=fopen("s.dat","w+b");
fwrite(semnal_iesire,sizeof(Word16),DataSize+Liniste,fp);
if (!fp)
printf("\nNu s-a deschis");
fclose(fp);
return(0);
}

1.FTB digital RII ordin 2 cu frecv de taiere F1=2KHZ si F2=3KHZ. Fs =8khz. Caract
amplitudine frecv? Aplicati regula de scalare L1 pt fctia de transfer. Sa se implementeze filtrul
in C a.i sa aiba un semnal sinusoidal de frecv variabila intre 100hz si 4khz de durata 0.5 sec
generat cu ajutorul chirp.
clear all
close all
clc

Fs = 8000;
Ft1=2000;
wt1=2*Ft1/Fs;
Ft2=3000;
wt2=2*Ft2/Fs;
wn=[wt1,wt2];
[b,a]=butter(1,wn)

figure(1),freqz(b,a)
figure(2),zplane(b,a)
h=impz(b,a);
k0=sum(abs(h));
if(k0>1)
bs=b/k0
end
h1=impz(1,a);
k1=sum(abs(h1));
% Simulare cu un semnal sinusoidal cu frecventa liniar crescatoare
t=0:1/Fs:1-1/Fs; % 1 secs @ 8kHz sample rate
x=chirp(t,0,1,Fs/2); % Start @ DC, cross 4kHz at t=1sec
k=fix(length(x)/160)
L=k*160;
x=x/k1;

fid=fopen('..\x.dat','w','b');
fwrite(fid,x.*2^15,'int16');
fclose(fid);

display('APASA O TASTA');
pause

fid=fopen('..\y.dat','r','b');
y=fread(fid,L,'int16');
fclose(fid);
y=k0*k1*y'/(2^15);

y_ref=k1*filter(b,a,x);

n=0:L-1;

figure(3),plot(n,x)
figure(4),plot(n,y_ref),grid
figure(5),plot(n,y),grid
figure(6),plot(n,y-y_ref),grid
#include <prototype.h>
#include <stdio.h>
#define DataBlockSize 160 /* dimensiunea unui bloc de date */
#define BlockLength 50 /* numarul de blocuri de date */

Word16 x[DataBlockSize],y[DataBlockSize];
Word16 w,w1,w2;

Word16 b[]={WORD16(0.2300), WORD16(0), WORD16(-0.2300)};

Word16 a[]={WORD16(0.5858/2), WORD16(0.4142/2)};

Word32 sum;

int main()
{
short n,i;

FILE *fpx,*fpy;

fpx=fopen("x.dat","r+b");
if (!fpx)
printf("\nNu s-a deschis");
fpy=fopen("y.dat","w+b");
if (!fpy)
printf("\nNu s-a deschis");

for (i=0; i<BlockLength; i++)

{
fread(x,sizeof(Word16),DataBlockSize,fpx);

for (n=0; n<DataBlockSize; n++)

{
sum = L_deposit_h(shr(x[n],1));
sum = L_msu(sum,a[0],w1);
sum = L_msu(sum,a[1],w2);
w = shl(round(sum),1);
sum = L_mult(b[0],w);
sum = L_mac(sum,b[1],w1);
y[n]= mac_r(sum,b[2],w2);
w2=w1;
 w1=w;
}

fwrite(y,sizeof(Word16),DataBlockSize,fpy);
}

fclose(fpx);
fclose(fpy);

return(0);
}

1.Metoda osc digital. Sa se generee semnalul DTMF asociat tastei 3 ,semnalul este generat de
suma a doua frecv F1=697 hz si F2=1477hz. Fs=8000hz. Tonul generat are 0.5 sec urmat de 0.5
sec liniste. Apoi se reia de 2 ori generarea.
clear all
close all
clc

DataSize=256;
F1=697;
F2=1477;
Fs=8000;
Ns=4000;
Nl=4000;

fid=fopen('..\s.dat','r','b');
s=fread(fid,Ns+Nl,'int16');
fclose(fid);
s=s'/(2^15)*2;
length(s)

s_ref=zeros(1,Ns+Nl);
for n=0:(Ns+Nl-1)
if(n<Ns)
s_ref(n+1)=sin(2*pi*F1/Fs*n)+sin(2*pi*F2/Fs*n);
end
end

n=0:(Ns+Nl-1);
figure(1), plot(n,s), grid on
figure(2), plot(n,s_ref), grid on

s_final_ref=[s_ref,s_ref];
s_final=[s,s];
k=0:(2*(Ns+Nl)-1);
figure(3),plot(k,s_final_ref),grid on
figure(4),plot(k,s_final),grid on

________________________________________________________________________

#define DataSize 256 /* number of samples */

#define Ns 4000
#define Nl 4000
int main()
{
Word16 semnal_iesire[Ns+Nl],s[Ns],sA[Ns],sB[Ns],c0,c1,s1,s2,s3,s4,temp1,temp2;

short i;
FILE *fp;

c0=WORD16(0.853868905);
s1=WORD16(0.260244065);
s2=0;

c1=WORD16(0.399309195);
s3=WORD16(0.458408161);
s4=0;

for (i = 0; i < Ns; i++)

{
temp1=mult_r(c0,s1);
temp1=shl_nosat(temp1,1);
sA[i]=sub(temp1,s2);
s2=s1;
s1=sA[i];

temp2=mult_r(c1,s3);
temp2=shl_nosat(temp2,1);
sB[i]=sub(temp2,s4);
s4=s3;
s3=sB[i];

s[i]=add(sA[i],sB[i]);
}

for (i = 0; i < Ns+Nl; i++)

if(i<Ns)
semnal_iesire[i] = s[i];
else
semnal_iesire[i] = 0;

fp=fopen("s.dat","w+b");
fwrite(semnal_iesire,sizeof(Word16),Ns+Nl,fp);
if (!fp)
printf("\nNu s-a deschis");
fclose(fp);

return(0);
}