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++; } }

1
2. Pt calc er medie patratica e= 𝑁 ∑𝑁−1 2
𝑘=0 (𝑥[𝑘] − 𝑦[𝑘]) 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]; }}

1
2. ec matriceala care calc recursiv iesirile [𝑐̀ 𝑠́ ]=0.5 [ √3 ][c s ] pe baza val anterioare c s.
−1 √3
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
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);}