Modulador de quadratura

De Viquipèdia

El modulador de quadratura és un dispositiu de telecomunicacions que permet enviar dos senyals analògics diferents a una mateixa freqüència portadora.

Si volem enviar el senyal x(t) i el senyal y(t) a l'emisor hem de multiplicar el senyal x(t) per un cosinus de freqüència igual a la que volguem que sigui la portadora (fp), i el senyal y(t) el multipliquem per un sinus de la mateixa freqüència (cal recordar que un sinus és com un cosinus però retardat 90º). Després sumem aquests senyals i obtenim el senyal que transmetrem z(t):

z(t) = x(t) * cos(2 * pi * fp * t) + y(t) * sin(2 * pi * fp * t)

Imatge:Moduladorq.jpg


En el demodulador obtenim el senyal z(t) i el dividim en dues branques diferents. La primera la múltipliquem per un cosinus de freqüència igual a fp i obtindrem una sortida i(t):

i(t) = z(t) * cos(2 * pi * fp * t) = [x(t) * cos(2 * pi * fp * t) + y(t) * sin(2 * pi * fp * t)] * cos(2 * pi * fp * t) =

= x(t) * cos(2 * pi * fp * t) * cos(2 * pi * fp * t) + y(t) * sin(2 * pi * fp * t) * cos(2 * pi * fp * t)


Utilizant les regles trigonomètriques següents:

cos2(A) = (1 / 2) * (1 + cos(2 * A))

cos(A) * sin(B) = (1 / 2) * sin(2 * A)

sin2(A) = (1 / 2) * (1 − cos(2 * A))


Tenim que el resultat és:

i(t) = x(t) * (1 / 2) * (1 + cos(2 * A)) + y(t) * (1 / 2) * sin(2 * A) = (1 / 2) * x(t) + (1 / 2) * x(t) * cos(4 * pi * fp * t) + (1 / 2) * y(t) * sin(4 * pi * fp * t)

Això si ho passem per un filtre pas baix de freqüènica de tall inferior a 2*fp obtindrem a la sortida: (1 / 2) * x(t)

Anàlogament, si multipliquem la segona branca del demodulador per un sinus de freqûència fp i ho passem per un filtre pas baix de freqüència de tall inferior a 2*fp, obtindrem a la sortida: (1 / 2) * y(t)

Imatge:Demoduladorq.jpg



Ara bé, per a que tot això funcioni cal que tant emisor i receptor estiguin sincronitzats i que els cosinus i sinus que fan servir per modular i demodular tinguin la mateixa fase. Això se sol aconseguir afegint un senyal de sincronisme en el senyal que s'envia, i el demodulador té un dispositiu específic que l'interpreta i així es sincronitza amb el modulador.

En cas de que aquest procés falli pot ser que cada branca del demodulador tingui un desfasament D respecte del modulador que provocarà efectes no desitjats en la recepció del senyal:


Observant la branca de d'alt tenim:

i(t) = z(t) * cos(2 * pi * fp * t + D) = [x(t) * cos(2 * pi * fp * t) + y(t) * sin(2 * pi * fp * t)] * cos(2 * pi * fp * t + D) =

= x(t) * cos(2 * pi * fp * t) * cos(2 * pi * fp * t + D) + y(t) * sin(2 * pi * fp * t) * cos(2 * pi * fp * t + D)


Podem resolstre els càlculs amb les regles trigonomètriques anteriors i aquestes:

cos(A + B) = cos(A) * cos(B) − sin(A) * sin(B)

sin(A + B) = sin(A) * cos(B) + cos(A) * sin(B)


i(t) = x(t) * cos(2 * pi * fp * t) * [cos(2 * pi * fp * t) * cos(D) − sin(2 * pi * fp * t) * sin(D)] + y(t) * sin(2 * pi * fp * t) * [cos(2 * pi * fp * t) * cos(D) − sin(2 * pi * fp * t) * sin(D)]

i(t) = (1 / 2) * x(t) * cos(D) + (1 / 2) * x(t) * cos(4 * pi * fp * t) * cos(D) − (1 / 2) * x(t) * sin(4 * pi * fp * t) * sin(D) + (1 / 2) * y(t) * sin(4 * pi * fp * t) * cos(D) − (1 / 2) * y(t) * sin(D) + (1 / 2) * y(t) * cos(4 * pi * fp * t) * sin(D)


Tot això si ho passem per un filtre pas baix de freqüència de tall inferior a 2*fp obtindrem a la sortida de la braca superior:

(1 / 2) * x(t) * cos(D) + (1 / 2) * y(t) * sin(D)


Si observem el resultat, veiem que quan D=0, i per tant no tenim desfasament, cos(D)=1 i sin(D)=0, i per tant el que tenim a la sortida és (1/2)*x(t) que és el que desitgem. A mesura que D augmenta, cos(D) es va fent més petit i perdem el senyal desitjat, i sin(D) es va fent més gran i tenim interferència de l'altre senyal. Quan el desfassament és de 90º, a la sortida tan sols tenim senyal y(t), que és el mateix que succeix a la branca inferior quan multipliquem z(t) per un sinus (recordem novament que un sinus és un cosinus desfasat 90º).

Anàlogament podem aplicar tots aquest càlculs a la branca inferior del demodulador per obtenir a la sortida:

(1 / 2) * y(t) * cos(D) + (1 / 2) * x(t) * sin(D)