Representación fasorial de señales paso-banda

Frecuencia. Modulación. Ruido. Comunicaciones digitales

  • Enviado por: Edu
  • Idioma: castellano
  • País: España España
  • 7 páginas
publicidad

Representación fasorial de señales paso - banda:

Notación: (^x)(t) => Transformada de Hilbert de x(t)

· Representación en fase y cuadratura:

· x(t)=xc(t)·cos(wc·t)-xs(t)·sen(wc·t)

· (^x)(t)=xc(t)·sen(wc·t)+xs(t)·cos(wc·t)

· Representación fasorial: x(t)=Re[r(t)·exp(j·psi(t))]

· Componente en fase: xc(t)=r(t)·cos(fi(t))=x(t)·cos(wc·t)+(^x)(t)·sin(wc·t)

· Comp en cuadratura: xs(t)=r(t)·sen(fi(t))=-x(t)·sen(wc·t)+(^x)(t)·cos(wc·t)

· Envolvente: r(t)=sqrt((xc(t))^2+(xs(t))^2)

· Fase instantánea: psi(t)=wc·t+fi(t)

· Fase relativa: fi(t)=arctan(xs(t)/xc(t))

· Frecuencia instantánea: (1/(2·pi))·d(psi(t))/dt=fc+(1/(2·pi))·dfi(t)/dt

· Envolvente compleja: v(t)=r(t)·exp(j·fi(t))=xc(t)+j·xs(t)

****

Modulación:

· AM:

· y(t)=Ac·[1+m·x(t)]·cos(wc·t)

· Ry(tau) => Ry(0)=Pt => TF[Ry(tau)]=Gy(f)

· Pt=Ry(0)=Ac^2/2+(Ac·m)^2/2·Rx(0)

· Ac^2/2 => Pot media de la portadora

· Ac·m)^2/2·pot(x) => Pot media de las 2 bandas laterales

· Relación=Pot1bdlateral/Potportadora

· Potencia envolvente ó de pico (ó de cresta):

· PEP=1/2·|y(t)|max^2=1/2·Ac^2·(a+m·|x(t)|max)^2=(|x|max=1)=1/2·Ac^2+Ac^2·m+1/2·Ac^2·m^2=Pt+Ac^2·m

· DEP: Gy(f)=F[Ry(tau)]=Ac^2/4·[delta(f-fc)+delta(f+fc)]+(Ac·m)^2/4·[Gx(f-fc)+Gx(f+fc)]

· DBL: (AM sin portadora)

· y(t)=m·Ac·x(t)·cos(wc·t)

· A partir de ahora tomaremos Ac como m·Ac

· Pt=Ac^2/2·Potx=2·P1bdlateral

· Gy(f)=TF[Ry(tau)]=Ac^2/4·[Gx(f-fc)+Gx(f+fc)]

· PEP=1/2·Ac^2

· BLU:

· y(t)=1/2·Ac·[x(t)·cos(wc·t)-(si BLU-S ó + si BLU-I)(^x)(t)·sen(wc·t))

· P=1/4·Ac^2·[Potx]=PotBL (pero como solo hay un Bl, pos de una solo k es toda :) )

· PEP=Ac^2·([x(t)^2+(^x)(t)^2]|max)/8

· BLResidual:

· y(t)=1/2·Ac·[x(t)·cos(wc·t)-xq(t)·sen(wc·t)], donde xq(t)=(^x)(t)+xbeta(t) y xbeta(t)=2·j·x(t)·w·hbeta(t)

· PtBLU=<PtBLR=<2·PtBLU

· BW=w+beta

· Resúmen: y(t)=[kc+km·x(t)]·cos(wc·t)-km·xq(t)·sen(wc·t)

· AM: xq=0, kc=Ac, km=m·Ac

· DBL: xq=0, kc=0, km=Ac

· BLU: xq=(^x)(t), kc=0, km=1/2·Ac

· BLR: xw=(^x)(t)+xbeta(t), kc=0, km=1/2·Ac

· QAM (Modulación en amplitud de cuadratura):

· Se obtiene haciendo modulaciones DBL

· Mandamos 2 señales a la ves (una en coseno y otra en seno)

· y(t)=1/2·Ac·[x1(t)·cos(wc·t)+x2(t)·sen(wc·t)]

****

Modulaciones angulares o exponenciales:

· y(t)=Ac·Cos[wc·t+fi(t)]=RE[Ac·exp(j·psi(t))] donde:

· Fase instantánea: psi(t)=wc·t+fi(t), fi(t)= variación de la fase instantánea (fase relativa)

· Frecuencua equivalente o instantánea: f(t)=(1/(2·pi))·dpsi(t)/dt=fc+(1/(2·pi))·dfi(t)/dt

--------------------> deltaf(t) => Variación de la frecuencia instantánea (frecuencia relativa)

· PM: fi(t)=deltapsi(t)=mud·x(t)

· Como |x(t)|=<1 => mud=<pi => y(t)|PM=Ac·cos[wc·t+mud·x(t)]

· FM: deltaf(t)=fd·x(t)

· y(t)|FM=Ac·cos[wc·t+fi(t)]=Ac·cos[2·pi·fc·t+2·pi·fd·int(-inf,t,x(landa),landa)]

· x(t)->(integrador)->(modulador PM)->y(t)|FM

· x(t)->(derivador)->(modulador FM)->y(t)|PM

· Análisis espectral de modulación angular:

· fd·Am (Am=x(t)|máx) = deltaf = desviación máxima de frecuencia (máxima excursión de la señal respecto de la portadora) (75KHz en FM)

· deltaf/fm=fd·Am/fm=beta=índice de modulación (desviación máxima de fase)

· Si x(t)=Am·cos(wm·t)

· y(t)|FM=Ac·cos[wc·t+beta·sen(wm·t)]=Re[Ac·exp(j·wc·t)·exp(j·beta·sen(wm·t))]

· exp(j·beta·sen(wm·t))=sum(n=-inf,inf,Cn·exp(j·n·wm·t)), Cn=Jn(beta) => función real

=> y(t)|FM=Ac·sum(n=-inf,inf,Jn(beta)·(exp(wc+n·wm)·t)+exp(-j·(wc+n·wm)·t))/2

=> Y(f)|FM=TF[y(t)|FM]=sum(n=-inf,inf,1/2·Ac·Jn(beta)·[delta(f-(fc+n·fm))+delta(f-(fc-n·fm))]

· Propiedades de Jn(beta):

· J-n(beta)=(-1)^n·Jn(beta)

· Si beta<<1 (beta<0.3) => FM de Banda Estrecha => J0(beta)(aprox)=1, J1(beta)(aprox)=beta/2, J-1(beta)(aprox)=-beta/2, Jn(beta)(aprox)=0 para n>1

· sum(n=-inf,inf,(Jn(beta))^2)=1

=> Pt=2·Ac^2/4·sum(n=-inf,inf,(Jn(beta))^2)=Ac^2/2·sum(-inf,inf,(Jn(beta))^2)=Ac^2/2

· Según beta => Bt=f(beta)

· FM-Banda Estrecha => beta<<1 (beta=<0.2) => Bt=2·fm

· FM-Banda Ancha => beta>>1 => Bt=2·fd·Am (como fd es cte, Bt solo es función de Am)

· Criterio de Carson (vale para BA y BE): Bt=2·(beta+1)·fm=2·(1/beta+1)·deltaf

· Criterio del 1%: |JM(beta)|>0.01>|JM+1(beta)| => Bt=2·M·fm

· Como beta=deltaf/fm => D=(0.2 en BE)índice de desviación=deltaf/w

· Carson: Bt=2·(1/beta+1)·deltaf=2·(1+D)·w (w en Hz, nada de pulsación) (Hz)

· 1%: |JM(D)|>0.01>|JM+1(D)| => BT=2·M·w (Hz)

· Para generar FM (modular):

· Método indirecto: Mediante multiplicadores. Lo que multiplicamos en los multiplicadores es fc, deltaf y D.

· Método directo: Un VCO

· Para demodular FM (se usa un discriminador de frecuencia):

· Conversión FM-AM: y(t)|FM->(derivador con el que obtenemos AM)->(detector de envolvente)

· Con un PLL

****

Ruido:

· Para hacer presente este factor en el sistema se usa la relación señal-ruido (S/N), mejor cuanto más alta, claroxtá.

· Sin modular: (S/N)r=gamma=Sr/(neta·w)

· En modulaciones lineales, el detector devuelve la componente en fase.

· En modulaciones angulares, el detector devuelve zeta(t)=fid·x(t) si PM ó fd·x(t)=1/(2·pi)·dzeta(t)/dt si FM

· pot(nc)=pot(ns)=pot(n)

· Como en otra señal cualquiera..

· nc(t)=n(t)·cos(wc·t)+(^n)(t)·Sen(wc·t)

· ns(t)=-n(t)·sen(wc·t)+(^n)(t)·cos(wc·t)

· n(t)=nc(t)·cos(wc·t)-ns(t)·sen(wc·t)

· Gy(w)=Gx(w)·|H(w)|^2 =>

· Rn(^n)(tau)=-(^R)n(tau)

· R(^n)n(tau)=(^R)n(tau)

· R(^n)(tau)=Rn(tau)

· Att=Pt/Sr (Att no está en decibelios)

· Gnc(f)=Gns(w)={Gn(f) corriendo las dos bandas fc hacia el orígen}

· IMPORTANTE: Tras el demodulador no hay que usar Gn(f), sino Gnc(f)

· DBL:

· (S/N)r=Ac^2·Sx/(4·neta·w)

· (S/N)d=gamma

· BLU:

· (S/N)r=(1/4)·Ac^2·Sx/(neta·w)

· (S/N)d=gamma

· AM (usando detector coherente):

· (S/N)r=(1/2)·Ac^2·(1+m^2·Sx)/(2·neta·w)

· NOTA: La componente contínua se elimina con un condensador, quedando lo que sigue:

· (S/N)d=(m^2·Sx/(1+m^2·Sx))·gamma

· (S/N)d|max=gamma/2

· En FM y PM:

· Sr>>pot(ns),pot(nc),pot(n)

· Ac>>rn(t)

· ArcTg(alfa)(aprox)=alfa si alfa es pequeña

· ns(t)=rn(t)·sen(fin(t))

=> zeta(t)=fi(t)+ns(t)/sqrt(2·Sr)

señal<----- ---------------->ruido

· PM:

· (S/N)d=fid^2·Sx·gamma

· FM:

· (S/N)d=3·Sr·(fd^2)·Sx/(neta·w^3)=(aplicando Carson)=3·(D^2)·Sx·gamma

· Deénfasis:

· Filtro de deénfasis (en tx será al revés): Hde(f)=1/sqrt(1+(f/Bde)^2)

· Bde=fcorte=1/tau (tau vale 50·10^(-6) segundos en España)

· (S/N)de=(fd^2)·Sx·Sr/(neta·(Bde^3)·[w/Bde-ArcTg(w/Bde)])

· Mejora respecto a no usar esta técnica: (S/N)de/(S(N)d=1/3·(w/Bde)^2 (cabe la opción de poner esta mejora en dB haciendo 10·log(mejora))

· Efecto umbral: gamma ha de ser mayor que gammath, que es:

· Carson: gammath=20·(D+1)

· 1%: gammath=20·M(D)

· ((S/N)r,th)=10

· de no cumplirse esto, no podemos tomar Ac>>rn(t) y por tanto no podremos separar la señal del ruído, y en AM aún se oye algo, pero en FM na de na.

· Sx lo suelen dar, y Sr y Sd a veces se sacan facilemnte haciendo la autocorrelación de la señal en tau=0.

****

Comunicaciones digitales:

· mi => cada símbolo (lo que tx) representado como una sucesión de bits.

· Pi => probabilidad de ocurrencia de un símbolo

· Info de un símbolo: Ii=Log2(1/Pi) (bits de información)

· Entropía: H=Imediaporsímbolo(bits/símbolo)=sum(i=1,M,Pi·Log2(1/Pi)

=> Si equiprobables (M=número total de símbolos): Ii=Log2(M)

· Velocidad binaria (bps): R=nºbits/segundo=(equiprobables)=(Log2(M))/T=Vt·Log2(M), T=período de símbolo

(no equiprobables)=H/T=velocidad media

· Codificador de línea: Símbolos -> Señales eléctricas

· Forma matemática: x(t)=sum(k=-inf,inf,ak·p(t-K·D)), p(t-K·D)=(1 en t=K·D, 0 en t<>K·D)

· D=1/Vt => período de símbolo, Vt=velocidad de símbolo (baudios), p(t)=rect(t/tau), tau=<D

· NRZ unipolar: p(t)=rect((t-D/2)/D), RZ polar: p(t)=rect((t-D/4)/(D/2)) (con ak=0,1)

· Códigos multinivel: x bits -> 2^x niveles

· Espectro de potenca de esos códigos:

· media: ma=E[ak]=sum(probi·valori)

· varianza: (sigma^2)=potencia-(media^2)=E[ak^2]-{(E[ak])^2} siendo E[ak^x]=sum(probi·(valori^x))

· Si ak incorreladas => Gx(f)=(sigma^2)·(|P(f)|^2)/D+(ma^2)/(D^2)·sum(n=-inf,inf,(|P(n/D)|^2)·delta(f-n/D))

· P(n)=TF[p(t)]

· TF[rect(t/tau)]=tau·sinc(f·tau)

· x(t-to)<->X(w)·exp(-j·w·t0)

· sinc(x)=(sen(pi·x))/(pi·x)

· 1<->2·pi·delta(w)=delta(f)

· Si ak no incorreladas => Gx(f)=(|P(f)|^2)/D·sum(n=-inf,inf,Ra(n)·exp(-j·2·pi·n·f·D))

· Limitaciones en la tx digital en banda base. ISI y ruido e interferencias:

· Lo que recibimos tras el muestreo es: y(t)=ak+sum(n=-inf y n<>k,inf, an·p'((k-n)·D))+n(tk) (tk=t sub k)

lo que queremos<--- ISI----------------------------------- ----->ruido

siendo p'(t)=p(t)*ht(t)*hc(t)*hr(t) ( * = convolución )

· En el muestreo: t=tk=k·D+td, td=retardo del canal

· Regenerador: Muestreador+comparador

· P(A|B)=Prob de que ocurra A tras haber ocurrido B.

· Criterio de Bayes: P(Hi|y)·P(y)=P(y|Hi)·P(Hi)

· Criterio de máxima verosimilitud: P(y|H1)(>si H1,< si H0)P(y|H0)

· P(y|H1)=Pn(y-a1) (Pn=Pnoise=Prob de ruido)

· P(y|H0)=Pn(y-a0)

· fdp(y|H1)=1/(sqrt(2·pi)·sigma0)·exp(-sq(y-a1)/(2·(sigma0^2)))

· Si P(y|H0)=P(y|H1)=> gammaóptimo=((a1+a0)/2) (si señal binaria, claroxtá)

· ((sigma0)^2)=potencia media de ruido (ya que suele ser ruido con media nula)=N=int(-inf,inf,neta/2·|Hr(f)|^2,f)=neta/2·int(-inf,inf,(hr(t))^2,t)=neta/2·int(0,D,(hr(t))^2,t)

· Ancho de banda mínimo: Criterio de Nyquist: Vt<2·BW

· Probabilidad de error (caso binario): Pb=Pe0·P(H0)+Pe1·P(H1) siendo Pei la Probabilidad de error del bit i.

· Pe0=P(y>gamma|H0)=int(gamma,inf,1/(sqrt(2·pi)·sigma0)·exp(-1/2·sq(y-a0)/(sigma0^2)),y) siendo sigma0 la desviación de ruido en el momento del muestreo

· Pe1=P(y<gamma|H1)=int(-inf,gamma,1/(sqrt(2·pi)·sigma0)·exp(-1/2·sq(y-a1)/(sigma0^2)),y)

· Si gamma=(a1+a0)/2, P(H0)=P(H1)=1/2 => Pe1 y Pe0 simétricas => Pb=int((a1+a0)/2,inf,1/(sqrt(2·pi)·sigma0)·exp(-1/2·sq(y-a0)/(sigma0^2)),y)

=> con u=(y-a0)/sigma0 => Pb=int((a1-a0)/(2·sigma0),inf,1/sqrt(2·pi)·exp(-sq(u)/2),u)=Q((a1-a0)/(2·sigma0))=(con filtro adaptado)=Q(sqrt(Ed/(2·neta)))

=> Si sube (S/N) => baja Pb porque esto acerca el límite inferior de la integral al límite superior de la misma

· Pe(axy)=Q(axi/sigma0)

· Para subir (S/N) => filtro óptimo, adaptado ó acoplado previo al muestreo:

· S/N=sq(ai)/N=> (S/N)óptimo=(sería =< sin filtro adaptado)=2/neta·int(-inf,inf,sq(|Si(f)|),f)<=>Hr(f)=conj(Si(f)·exp(-j·2·pi·f·D)) => hr(t)=(TF^(-1))[Hr(f)]=C·Si(D-t)

· Si queremos adaptarlo a S1 y S0 => Si=S1(t)-S0(t)

· Una implementación práctica es el correlador: Si->[(multiplicador por S1, S0 ó S1-S0)]->[C·int(0,D,·,t)]->ai

· Ahora gamma=K·E=(si equiprobables)=1/2·D

· Con Hr=>sq(a1-a0)/(sigma0^2)|max=1/neta·Ed

· Ed=int(0,D,sq(Si(t)),t)

· Energía=E=sum(Probi·Edi)

· Caso multinivel: Pb=2·[(1-1/M)·Q(A/(2·sigma0))]

· A => mínimo salto entre niveles

· M => número de niveles

· Para que no exista ISI se debe cumplir Nyquist => Vt<2·BW

· Frecuencias de interés => los nulos

· BW=> La parte real del ancho en frecuencia de la DEP, ó la mitad del lóbulo principal si es una función Sinc.

· Eficiencia espectral: Ef=(Velocidad tx símbolo/BW que ocupa el código)=R/w bps/Hz, donde R es el régimen binario y w el ancho de banda en herzios

· Energía media por bit: Eb=sum(Probi·Ebiti)

----->int(0,duración,amplitud^2,t)

· NOTA: Energía biti=Ei=int(0,D,(Si(t))^2,t)

· Umbral óptimo de decisión (si símbolos binarios equiprobables): gamma0=(a1+a0)/2=(con filtro adaptado)=C·[E1-E0]/2 (C es la cte de hr(t))

· Régimen binario: R=Vt·Log2(M) bps

baudios<--- ->número de niveles

· Potencia total (si binario) = Prob(H0)·Potencia(y|H0)+Prob(H1)·Potencia(y|H1)

· Potencia(y|H0)=1/D·int(0,D,sq(|S0(t)|),t)

****

Modulaciones digitales:

· ASK: y(t)=Ac·sum(k=-inf,inf,ak·p(t-K·D))·cos(wc·t+zeta)

· QAM (Duplica la Ef del ASK): y(t)=Ac·[(xc(t)|(Vt'=Vt/2))·cos(wc·t+zeta)-(xs(t)|(Vt'=Vt/2))·sen(wc·t+zeta)]

· xentrada(t)=sum(k=-inf,inf,ak·p(t-K·D)) => Convertidor Serie-Paralelo

=> xc(t)=sum(k=-inf,inf,a2k·p(t-K·D))

=> xs(t)=sum(k=-inf,inf,a(2k+1)·p(t-K·D))

· Constelaciones: ejex => yc(ó xc), ejey => ys(ó xs)

· PSK: y(t)=Ac·[(sum(k=-inf,inf,cos(fik)·p(t-K·D)))·cos(wc·t+zeta)-(sum(k=-inf,inf,sen(fik)·p(t-K·D))·sen(wc·t+zeta)]

· BPSK => PSK de 2 niveles

· FSK:

· Banco de filtros: y(t)=Ac·sum(k=-inf,inf,cos(wc·t+zeta+2·pi·fd·ak·t)·p(t-K·D)), fd=N/(2·D), Ef=1bps/Hz

· CPFSK: y(t)=sqrt(2·E/D)·cos(2·pi·fc·t+2·pi·fd·int(-inf,t,v(landa),landa)+fi0), si fd=1/(4·D) señales ortogonales y ocupa menos BW, Ef=2bps/Hz

· Gy(f)=sq(Ac)/4·[Gpb(f-fc)+Gpb(f+fc)]

· Gpb=Gc(f)+Gs(f), Gc(f) y Gs(f) DEP de yc(t) e ys(t) respectivamente

· Comparación:

· OOK:

· Primera modulación en radiotelegrafía

· Poco eficiente en potencia

· El umbral debe ser ajustado según la atenuación introducida por el canal

· Permite detección no coherente a costa de aumentar la Pb (porque total, no es más k ver si llega o no llega señal (ASK de 2 niveles))

· Peores prestaciones que BPSK en igualdad de condiciones (igual relación Eb/neta) => No se utiliza

· BPSK:

· En general (M niveles), tiene buena eficiencia espectral => Usada en sistemas limitados en banda

· Permite detección no coherente => DPSK (Differential PSK)

· Al tener envolvente constante, es menos vulnerable a la distorsión de amplitud

· Menor Pb que OOK y FSK para la misma relación (Eb/neta)

· BFSK:

· MSK: Buena eficiencia espectral

· Usada en sistemas limitados en potencia

· Permite detección no coherente con fdmín=1/D a costa de aumentar el ancho de banda de transmisión, Bt, y la Pb

****

Notas:

· cos(alfa)·cos(beta)=1/2·(cos(alfa+beta)+cos(alfa-beta))

· (^x)(f)=-j·sign(f)·X(f)

· cos(alfa)=(exp(j·alfa)+exp(-j·alfa))/2

· TF[exp(j·alfa·t)]=delta(f-alfa), donde alfa, obviamente, es frecuencia, no pulsación

· cos(alfa+beta)=cos(alfa)·cos(beta)-sen(alfa)·sen(beta)

· cos(alfa)=cos(-alfa)

· sen(alfa)=-sen(-alfa)

· Moduladores y demoduladores:

· El detector de envolvente devuelve Kd·r(t)

· El detector de envolvente solo vale para demodular AM. Para el resto hay que usar un demodulador síncrono (o coherente) al cuál hemos de introducirle la señal portadora (portadora piloto) para sincronizarlo.

· En FM, fm=w (si usamos fm en lugar de w es porque trabajamos con un tono) (w es el ancho de banda en Hz (es decir, sin el 2·pi))

· Respuesta filtro => y(t)=Si(t)*hr(t) ( * = convolución)

· Respuesta filtro mediante correlador => ai=C·int(0,D,Si·Si(D-t),t)

------>S1(D-t)-S0(D-t) si adaptado a S1 y S0

· Distingue entre Actx y Acrx (entra en juego la atenuación)

· Al sacar potencias en gráficas hay que contar también la parte negativa de la gráfica (imaginaria)

· Demodulador de FM devuelve fd·x(t)

· Demodulador coherente devuelve Ac·x(t)

· Si no puedes sacar algo empezando desde el principio... enpieza desde el final.

· Para sacar potencias y DEP, la fdt de los filtros ha de estar como (|H(f)|^2)

****"