Transmissão Banda Base e Passa Banda utilizado Python

Prévia do material em texto

INSTITUTO POLITECNICO CASTELO BRANCO 
 
ESCOLA SUPERIOR DE TECNOLOGIA 
 
DISCIPLINA DE Comunicações Digital 
Curso Engenharia Eletrotécnica e Telecomunicações 
TRABALHO Nº 1 
 Transmissão Banda Base e 
 Passa-Banda 
 
Aluno: 
Leandro Tito Manjate 
Brawlin Pires 
 
 
Professor: 
 Paulo Torres 
 
 
Castelo Branco, ao 31 de outubro 
2 
 
Índice 
1 Introdução ............................................................................................................................................. 4 
2 Objetivos ............................................................................................................................................... 5 
3 Resumo Teórico .................................................................................................................................... 5 
3.1 Banda base .................................................................................................................................... 5 
3.2 Modulações de Portadora Digital ................................................................................................. 5 
3.2.1 PAM ....................................................................................................................................... 5 
3.2.2 PWM...................................................................................................................................... 6 
3.2.3 PPM ....................................................................................................................................... 6 
3.3 Código de Linha ............................................................................................................................. 7 
3.3.1 Tipos de código de linha ....................................................................................................... 7 
3.3.2 Códigos de linha: onde se usam? ........................................................................................ 10 
3.4 Recetor ótico ............................................................................................................................... 11 
3.4.1 Desempenho do Código NRZ .............................................................................................. 11 
3.4.2 Desempenho do Código Unipolar ....................................................................................... 13 
3.4.3 Desempenho do Código AMI .............................................................................................. 14 
4 Resultado e Discussão ......................................................................................................................... 14 
4.1 Impulsos retangulares ................................................................................................................. 14 
4.1.1 Tau=1s e Ts=2s .................................................................................................................... 15 
4.1.2 Tau=1s e Ts=4s .................................................................................................................... 17 
4.2 Ilustração de modulação ............................................................................................................. 19 
4.2.1 PAM ..................................................................................................................................... 19 
4.2.2 PWM.................................................................................................................................... 21 
4.3 Ilustração para código de Linha .................................................................................................. 23 
4.3.1 NRZ ...................................................................................................................................... 23 
4.3.2 Diferencial ........................................................................................................................... 24 
4.3.3 Manchester ......................................................................................................................... 26 
4.3.4 RZ unipolar .......................................................................................................................... 27 
4.3.5 RZ bipolar ............................................................................................................................ 29 
4.4 Desempenho para probabilidade de erro ................................................................................... 30 
4.4.1 NRZ ...................................................................................................................................... 30 
4.4.2 AMI ...................................................................................................................................... 33 
3 
 
4.4.3 Diferencial ........................................................................................................................... 36 
4.4.4 Unipolar ............................................................................................................................... 40 
4.4.5 Manchester ......................................................................................................................... 42 
4.4.6 RZ polar ............................................................................................................................... 45 
4.5 Desempenho de probabilidade de erro transmissão passa banda. ........................................... 48 
4.5.1 ASK ...................................................................................................................................... 48 
4.5.2 FSK ....................................................................................................................................... 49 
4.5.3 4PSK..................................................................................................................................... 50 
4.5.4 4QAM .................................................................................................................................. 54 
5 Conclusões .......................................................................................................................................... 57 
6 Bibliografia .......................................................................................................................................... 58 
 
 
4 
 
1 Introdução 
No presente relatório será abortado o tema de Transmissão banda base onde o mesmo será 
implementado através de uma linguagem de Programação denominada Python e utilizaremos 
uma IDE recomenda pelo professor que possui o nome de Anaconda. 
O trabalho é constituído pelas seguintes partes. As partes são resumo teórico, a modulação de 
impulsos, a ilustração das modulações digitais com sinal modulante analógico, códigos de linha e 
o desempenho da probabilidade de erro de código de linha. 
5 
 
2 Objetivos 
• Aplicar os conhecimentos adquiridos na aula; 
• Adquir conhecimento critico; 
• Implementação da linguagem de programação python. 
3 Resumo Teórico 
Nessa parte será abortado o resumo teórico sobre a matérias que será implementada com a 
linguagem de programação em python 
3.1 Banda base 
Em telecomunicações, designamos por o sinal original que pretendemos transmitir. A voz ao 
telefone (áudio) é um sinal de banda base. O vídeo filmado por uma câmara, é também um sinal 
de banda base. 
3.2 Modulações de Portadora Digital 
A modulação analógica podem ser de três tipos PAM (Pulse Amplitude Modulation),PWM(Pulse 
Width Modulation),PPM(Pulse Position Modulation). 
3.2.1 PAM 
O sistema PAM é aquele onde se aplica diretamente o conceito de um sinal amostrado, pois o 
sinal modulado pode sercompreendido como o produto do sinal modulante pelo trem-de-pulsos 
da portadora. Na modulação PAM a amplitude dos pulsos, regularmente espaçados, é variada 
proporcionalmente aos valores amostrados do sinal contínuo de mensagem. Na amostragem 
natural, o topo de cada pulso retangular modulador pode variar com o sinal de mensagem. 
 
Figura 1 Modulação de PAM 
6 
 
3.2.2 PWM 
A modulação por largura de pulso (MLP) - mais conhecida pela sigla em inglês PWM (Pulse-
Width Modulation) - de um sinal ou em fontes de alimentação envolve a modulação de sua razão 
cíclica (duty cycle) para transportar qualquer informação sobre um canal de comunicação ou 
controlar o valor da alimentação entregue à carga. 
 
 
Figura 2 Modulação PWM 
 
3.2.3 PPM 
A modulação da posição de pulsos (PPM - pulse position modulation) consiste em posicionar 
um pulso retangular de amplitude e duração fixas dentro do intervalo de amostragem, de forma 
que a posição relativa seja proporcional ao sinal analógico. A vantagem desta modulação sobre 
as anteriores reside no fato de que o formato de pulso é sempre o mesmo, facilitando a 
regeneração do sinal. 
 
O sinal PPM é gerado a partir do PWM, bastante utilizar um circuito mono estável gatinhado na 
transição de descida dos pulsos do sinal PWM. A duração dos pulsos será determinada pela 
constante R.C 
 
7 
 
 
Figura 3 Modulação PPM, 
 
 
3.3 Código de Linha 
Códigos de linha código de transmissão em Banda Base são utilizados na transmissão digital, 
através do sinal digital original é gerado um sinal digital codificado, que é mais adequado ás 
condições às condições à transmissão no meio de comunicação. Como estes códigos são simples 
e eficientes eles são amplamente utilizados em transmissões com distâncias limitas. 
3.3.1 Tipos de código de linha 
Os principais códigos de linha são: NRZ, RZ unipolar e polar, Manchester, AMI e Diferencial. 
3.3.1.1 NRZ 
O código NRZ pode ser classificado em dois tipos: 
• NRZ (que contém os valores de “0” ou “1”) ou; 
• NRZ-BIP (que contém os valores de “1” ou “-1”). 
A codificação NRZ-BIP é obtida através da troca do nível do sinal a ser codificado, onde se tem 
o nível “0” passará a ter “-1”. 
O código NRZ BIP é utilizado na comunicação RS-232 que é a interface utilizada na transmissão 
entre o computador e outros periféricos via porta serial. 
 
8 
 
 
Figure 4 Códigos de Linha NRZ 
 
3.3.1.2 RZ 
Assim como o código NRZ o código RZ, pode ser classificado de dois tipos: 
• RZ (que contém os valores de “0” ou “1”)ou; 
• RZ-BIP (que contém os valores de “1” ou “-1”). 
O código RZ se assemelha muito ao código NRZ,a diferença está no tempo de duração do bit, no 
código NRZ o tempo de duração do bit codificado é o mesmo tempo de duração do bit do sinal 
de informação, já no RZ o tempo de duração é de apenas metade do tempo do bit do sinal de 
informação. 
 
Figure 5 Código de Linha RZ 
3.3.1.3 Manchester 
O código Manchester é um código de dois níveis de tensão:”0” e “1”. 
Quando se codifica um bit de nível alto tem-se um nível alto na primeira metade do tempo de bit 
e um nível baixo na segunda metade do tempo de bit, e quando se codifica um nível baixo, temos 
na primeira metade do tempo de bit um nível baixo, e na segunda metade do tempo de bit um 
nível alto, esta explicação está detalhada. 
9 
 
 
Figure 6 Código de Linha Manchester 
 
3.3.1.4 AMI 
Código AMI (Alternate mark inversion) também conhecida como código bipolar, associa a cada 
bit “1” um bit com nível de tensão alternado entre “1” e “-1” e com de duração de meio tempo 
de bit. Esse código foi desenvolvido originalmente na década de 60 pela empresa americana Bell, 
para sistemas PCM(Pulse Code Modulation) 
 
Figure 7 Código de Linha AMI 
 
3.3.1.5 Código Diferencial 
 
No código diferencial a informação é codificada em termos da transirão do sinal. O sinal pode 
ser invertido sem afetar a sua interpretação, sendo a informação original recuperada por 
comparação da polaridade dos símbolos adjacentes, para saber se existiram, ou não, transições. 
 
10 
 
 
Figure 8 Sequência ”1011010010” em código ”Unipolar” convertida em ”AMI”. 
 
 
 
 
Figure 9 Comparação do Código Unipolar (A) com o Diferencial (B) dos bits ”01101001”. 
 
3.3.2 Códigos de linha: onde se usam? 
 
• AMI 
Primeiro a ser usado nos sistemas de pares simétricos de cobre. Substituído por códigos AMI 
modificados. 
11 
 
• HDB3 
Norma G.703 da ITU-T para sistemas PCM multiplexados a 2, 8 e 34 Mbit/s. 
• CMI 
Norma G.703 da ITU-T para PCM multiplexado a 140 Mbit/s. 
• Código bifásico (Manchester) 
Distribuição de sinais de relógio em circuitos VLSI. Gravação magnética. Redes locais Ethernet. 
Sistema RDS (“Radio Data System”) em radiodifusão FM. 
• 4B3T 
Sistemas de alta capacidade (sistemas de longa distância em cabo coaxial a 34 e 140 Mbit/s). • 
2B1Q Acesso básico da RDIS (160 kbit/s) . 
 
• nBmB (5B6B, etc.) 
 Sistemas de alta capacidade com grande largura de banda (fibras óticas). 
 
3.4 Recetor ótico 
3.4.1 Desempenho do Código NRZ 
Ao código NRZ, com amplitude ´ ±A e uma duração de impulso ˜ τ”, aplica-se um circuito de 
decisão do sinal recebido ˜ x(t) cuja referencia e a amplitude nula ( ´ λ = 0). 
 
Figura 10 Diagrama de blocos de um recetor em banda base com código de linha NRZ 
 
12 
 
 
Figura 11 Analise do efeito do ruído em constelação BNRZ 
 
Na Fig. 11 pode-se observar a probabilidade de ocorrência de erro no caso de ser enviado o bit 
”0” 
(A =−1) e ser descodificado como A = 1 em que com λ =( a1+a2)/2 . 
A probabilidade de erro e a soma das probabilidades de todas as formas de um erro poder 
ocorrer, ou seja, 
 
porque 
A probabilidade de erro para BNRZ e dada por 
 
 
13 
 
 
 
 
Para Códigos QNRZ 
 
com Ed = 4A2 τ , logo 
 
logo a probabilidade de erro e dada por 
 
 
3.4.2 Desempenho do Código Unipolar 
 
O desempenho do código unipolar em presença do ruído gaussiano pode ser deduzido a partir do 
desempenho do código bipolar, em que o limiar passa a ser ´ λ = A/2, passando a probabilidade 
de erro a ser 
 
14 
 
 
Figura 13 Comparação do desempenho para códigos multinível 
 
3.4.3 Desempenho do Código AMI 
No código AMI devem ser considerados dois limiares de decis ´ ao com amplitudes iguais a ˜ 
metade da amplitude do impulso da polaridade respetiva (A/2). A diferença no desempenho entre 
os código AMI e Unipolar ´ e devida ao facto de um ”1” ´ transmitido no código AMI tanto 
poder ser afetado por ruido positivo como negativo, enquanto que o mesmo ”1” no código 
unipolar s ´ o pode ser afetado por ruido positivo. 
Como os símbolos são equiparáveis ( p0 = p1 = 1/2) e existem duas situações em que pode ˜ 
ocorrer erro no bit ”1” enquanto ocorre apenas uma no caso do bit ”1”. 
 
4 Resultado e Discussão 
Em seguida será discutido os resultados obtidos nas implementações dos códigos feitos. 
4.1 Impulsos retangulares 
Nesta primeira parte será executada dois impulsos retangular um que possui um ducty cyle de 
50% e outro com duty cyle de 25%. 
15 
 
4.1.1 Tau=1s e Ts=2s 
Nesse programa será executado um código que possui o perdido de 2s e a duração de 1s,assim 
formado um sinal retangular com 50% de duty cicly. 
Para executar o programa foi implementado o seguinte código. 
# -*- coding: utf-8 -*- 
""" 
Created on Tue Oct 24 22:28:05 2017 
 
@author: Leandro 
""" 
import matplotlib.pyplot as plt 
from scipy import signal 
#from numpy import * 
import numpy as np 
from numpy.fft import fft, fftshift 
 
namostras_simb= 2**8 # numero de amostras por simbolo 2**5 
t_lim = 2**3 # 2**2 
N = t_lim*namostras_simb; 
f_lim = N/t_lim 
t = np.linspace(0,t_lim-1/namostras_simb,N) 
f = np.linspace(-f_lim/2,f_lim/2-f_lim/N,N) 
 
 
 
App = 1 
Ts = 2 
tau=1 
fs = 1/Ts 
ductie=tau/Ts 
sc = App*signal.square(2 * np.pi * fs * t,ductie)/2+.5 
 
Sc_f = fftshift(fft(sc))/N # fft computing and normalization 
 
ax1 = plt.subplot(211) 
ax1.plot(t,sc) 
ax1.set_xticks(np.arange(0,t_lim+.1,1)) 
#ax1.set_xticklabels(arange(0,2,.5)) 
plt.xlim(0, 5) 
ax1.set_xlabel('t (seg.)') 
ax1.set_ylabel('Amplitude') 
plt.grid(True) 
plt.show() 
 
plt.stem(f, abs(Sc_f)) 
plt.xlim(-7.01, 7.01) 
16 
 
plt.grid(True) 
plt.show() 
 
Nesse código foi utilizado as bibliotecas numpy ,scipy , matplotlib.pyplot pelo qual essas 
bibliotecas são usadas para criar gráficos de forma similar como o matlab.Onde o numpy é o 
que permite trabalhar com arranjos, vetores e matrizes de N dimensões. O Scipy é o que permite 
transmitir sinal que podem ser retangulares, triangular e etc. O matplotlib.pyplot é o que permite 
configurar e mostrar os gráficos. 
4.1.1.1 Analise no domínio do tempo 
 
Com a implementação do código acima foi obtido como o resultado o gráfico abaixo. Porém o 
gráfico esta no domino do tempo. 
 
 
Figure 14 Sinal Retangular no domino do tempo 
Podemos observar no gráfico que o sinal possui ducty cyle de 50% porque a duração do sinal é 
igual a metade do período. 
 
17 
 
4.1.1.2 Analise no domínio da frequência 
Em seguida com o mesmo código verificamos o sinal obtido no gráfico acima, porém no domino 
da frequência e foi obtido o gráfico abaixo. 
 
 
Figure 15 Espectro no domínio da frequência 
 
4.1.2 Tau=1s e Ts=4s 
Nesse programa será executado um código que possui o perdido de 4s e a duração de 1s, assim 
formado um sinal retangular com 25% de duty ciclye. 
Para executar o programa foi implementado o seguinte código. 
# -*- coding: utf-8 -*- 
""" 
Created on Tue Oct 24 23:02:09 2017 
 
@author: Leandro 
""" 
 
import matplotlib.pyplot as plt 
from scipy import signal 
#from numpy import * 
import numpy as np 
from numpy.fft import fft, fftshift 
 
namostras_simb = 2**8 # numero de amostras por simbolo 2**5 
t_lim = 2**3 # 2**2 
N = t_lim*namostras_simb; 
f_lim = N/t_lim 
t = np.linspace(0,t_lim-1/namostras_simb,N) 
f = np.linspace(-f_lim/2,f_lim/2-f_lim/N,N) 
 
 
18 
 
 
App = 1 
Ts = 4 
tau=1 
fs = 1/Ts 
ductie=tau/Ts 
sc = App*signal.square(2 * np.pi * fs * t,ductie)/2+.5 
 
Sc_f = fftshift(fft(sc))/N # fft computing and normalization 
 
ax1 = plt.subplot(211) 
ax1.plot(t,sc) 
ax1.set_xticks(np.arange(0,t_lim+.1,1)) 
#ax1.set_xticklabels(arange(0,2,.5)) 
plt.xlim(0, 5) 
ax1.set_xlabel('t (seg.)') 
ax1.set_ylabel('Amplitude') 
plt.grid(True) 
plt.show() 
 
plt.stem(f, abs(Sc_f)) 
ax2.set_xlabel('f (Hz)') 
ax2.set_ylabel('|Espetro|') 
plt.xlim(-4, 4) 
plt.grid(True) 
plt.show() 
 
4.1.2.1 Analise no domínio do tempo 
Com a implementação do código acima foi obtido como o resultado o gráfico abaixo. Porém o 
gráfico esta no domino do tempo. 
 
Figure 16 Sinal Retangular no domino do tempo 
 
Podemos observar o sinal e notar que o duty cycle é de 25% isso porque a duração do sinal é 
igual há ¼ do período do sinal. 
19 
 
4.1.2.2 Analise no domínio da frequência 
Em seguida com o mesmo código verificamos o sinal obtido no gráfico acima, porém no domino 
da frequência e foi obtido o gráfico abaixo. 
 
 
Figure 17 Espectro no domínio da frequência 
 
4.2 Ilustração de modulação 
Nessa parte será ilustrada a implementação dos seguintes códigos PAM, PWM e PPM. 
4.2.1 PAM 
Será apresentada a modulação de impulsos com amplitude onde a amplitude é que varia. Para 
implementação dessa modulação foi utilizado o código abaixo. 
# -*- coding: utf-8 -*- 
""" 
Created on Tue Oct 24 23:08:36 2017 
 
@author: Leandro 
""" 
 
import matplotlib.pyplot as plt 
from scipy import signal 
#from numpy import * 
import numpy as np 
from numpy import * 
from numpy.fft import fft, ifft, fftshift 
from numpy.fft import fft, fftshift 
 
 
20 
 
 
 
namostras_simb = 2**7 # numero de amostras por simbolo 2**5 
t_lim = 2**3 # 2**2 
N = t_lim*namostras_simb; 
f_lim = N/t_lim 
t = linspace(0,t_lim-1/namostras_simb,N) 
f = linspace(-f_lim/2,f_lim/2-f_lim/N,N) 
 
App = 1 
Ts = 1/2 
fs = 1/Ts 
tau = Ts/2 
scR = App*signal.square(2 * np.pi * fs * t)/2+.5 
 
Tm=Ts*7 
fm=1/Tm 
scA = cos(2*pi*fm*t) 
 
pam=scA*scR 
Sc_f = fftshift(fft(pam))/N 
 
plt.subplot(211) 
plt.plot(t, pam) 
plt.ylim(-1.5, 1.5) 
 
 
plt.subplot(212) 
plt.stem(f, abs(Sc_f)) 
 
plt.xlim(-1, 1) 
plt.grid(True) 
plt.show() 
 
 
 
 
 
 
21 
 
4.2.1.1 Analise no domínio do tempo 
Depois da implementação do código acima foi obtido o gráfico abaixo. 
 
Figura 18 Modulação PAM no domínio do tempo 
 
Podemos verificar que a amplitude varia ao longo do tempo e se tivéssemos um sinal sinusoidal, 
podia se verificar que quando a amplitude é máxima no sinal resultante a amplitude é máxima e 
vice-versa. 
4.2.1.2 Analise no domínio da frequência 
Em seguida analisamos o sinal no domino da frequência e obtivemos o gráfico abaixo. 
 
 
Figure 19 Modulação PAM no domínio da frequência 
 
4.2.2 PWM 
Será apresentada a modulação de impulsos com largura e onde a duração do impulso é que varia. 
Para implementação dessa modulação foi utilizado o código abaixo. 
# -*- coding: utf-8 -*- 
""" 
Created on Wed Oct 25 01:17:08 2017 
 
@author: Leandro 
""" 
 
from scipy import signal 
import matplotlib.pyplot as plt 
import numpy as np 
22 
 
 
 
namostras_simb = 2**8 # numero de amostras por simbolo 2**5 
t_lim = 2**3 # 2**2 
N = t_lim*namostras_simb; 
f_lim = N/t_lim 
t = np.linspace(0,t_lim-1/namostras_simb,N) 
f = np.linspace(-f_lim/2,f_lim/2-f_lim/N,N) 
 
 
 
App = 1 
Ts = 1/2 
fs = 1/Ts 
tau = Ts/2 
Tm=Ts*15 
fm=1/Tm 
 
 
 
plt.figure() 
sig = np.sin(2 * np.pi * t*fm) 
pwm = signal.square(2 * np.pi * fs * t, duty=(sig + 1)/2) 
 
Sc_f = fftshift(fft(pwm))/N 
 
plt.subplot(211) 
plt.plot(t, pwm) 
plt.ylim(-1.5, 1.5) 
 
plt.subplot(212) 
plt.stem(f, abs(Sc_f)) 
 
plt.xlim(-1, 1) 
plt.grid(True) 
plt.show() 
 
 
 
 
4.2.2.1 Analise no domínio do tempo 
Podemos verificar que o PWM no domínio da frequência varia a largura da duração do sinal 
onde quando o sinal modulante da sinusoide esta no máximo o sinal modulado fica com uma 
largura máxima e quando o sinal modulante está no mínimo o sinal modulado fica com a largura 
máxima. 
23 
 
 
Figura 20 Modulação PWM no domínio do tempo 
4.2.2.2 Analise no domínio da frequência 
No domino da frequência podemos observar que o espectro nas frequência bem próxima de zero 
possui um amplitude alta e ao longo das frequências positivas ou negativas a amplitude do 
espectro é próximo de zero. 
 
Figura 20 Modulação PWM no domínio da frequência 
 
4.3 Ilustração para código de Linha 
Em seguida será executados códigos de linha relacionados com NRZ, AMI e Manchester,RZ 
polar,RZ unipolar. 
4.3.1 NRZ 
Primeiramente será executado o NRZ que consistir em transformar o 1 em +1 e o 0 em -1. 
Para implementar a explicação em cima foi usado o código abaixo. 
import numpy as np 
import matplotlib.pyplot as plt 
import numpy as np 
import matplotlib.pyplot as plt 
from numpy.random import randn, randint 
import scipy.special 
 
N=1*10**6 
sn=randint(0,2,size = N) 
 
NRZ=-((-1)**sn) 
print('sinal ',sn) 
24 
 
print('NRZ ',NRZ)Através do código a cima obtivemos como resultado abaixo. 
 
Figure 21 Código de Linha NRZ 
Podemos verificar no código que quando o sinal é 0 no NRZ o valor é 1 e quando o sinal é 1 o valor no 
NRZ é -1. 
4.3.2 Diferencial 
Em seguida foi feita a codificação diferencial que no xor negado entre o sinal transmitido com o sinal 
resultado do xor.Na implementação abaixo foi feita a codificação e a descodificação. 
# -*- coding: utf-8 -*- 
""" 
Created on Fri Oct 27 19:19:09 2017 
 
@author: Leandro 
""" 
print('Codificacao') 
print('') 
N=8 
dk_1=randint(0,1,size = N) 
dk_1[0]=1 
memoria=randint(0,1,size = N) 
memoria[0]=1 
mk=[1,0,0,1,0,1,1,0] 
dk=randint(0,1,size = N) 
dkAux=randint(0,1,size = N) 
mkDescodificado=randint(0,1,size = N) 
## Codificador 
for i in range(0, len(dk)): 
 dk_1[i]=memoria[i] 
 dkAux[i]=dk_1[i]^mk[i] 
 if(dkAux[i]==1): 
 dk[i]=0 
 # print(dk[i]) 
 if(dkAux[i]==0): 
 dk[i]=1 
 
 if(i<(N-1)): 
25 
 
 memoria[i+1]=dk[i] 
 
 
print('mk ',mk) 
print('dk_1 ',dk_1) 
print('dk ',dk) 
 
#Descodificador 
print('') 
print('Descodificacao') 
dkNot=randint(0,1,size = N) 
memoria[0]=1 
for i in range(0, len(dk)): 
 dk_1[i]=memoria[i] 
 if(i<(N-1)): 
 memoria[i+1]=dk[i] 
 
 if(dk[i]==1): 
 dkNot[i]=0 
 
 if(dk[i]==0): 
 dkNot[i]=1 
 
 mkDescodificado[i]=dkNot[i]^dk_1[i] 
 
print('dk ',dk) 
print('dkNot ',dkNot) 
print('dk_1 ',dk_1) 
print('mkDescodificado ',mkDescodificado) 
 
 
 
 
A partir do código acima foi obtido como o resultado a figura abaixo. 
26 
 
 
Figure 22 Código de linha diferencial 
 
 
 
4.3.3 Manchester 
Despois foi feito código Manchéster que consiste em 1 em Manchéster ser representado por 
V-V+, e o 0 ser representado por +-. Para implementação da explicação foi feito o código abaixo. 
# -*- coding: utf-8 -*- 
""" 
Created on Thu Oct 26 16:22:16 2017 
 
@author: Leandro 
""" 
 
import numpy as np 
from numpy import* 
import matplotlib.pyplot as plt 
import numpy as np 
import matplotlib.pyplot as plt 
from numpy.random import randn, randint 
import scipy.special 
from scipy import signal 
 
N=1*10**6 
sn=[1,1,1,1] 
sd=randint(0,2,size = N) 
manchester=[0,0,0,0,0,0,0,0] 
 
 
j=0 
27 
 
for i in range(0, 4,): 
 if(sn[i]==1): 
 manchester[i+j]=0 
 manchester[i+j+1]=1 
 j=j+1 
 m=signal.square(2 * np.pi * t,1) 
 
 if(sn[i]==0): 
 manchester[i+j]=1 
 manchester[i+j+1]=0 
 j=j+1 
 m=0 
 
 
 
print('sinal ', sn) 
print('manchester ',manchester) 
Com a implementação do código acima foi obtido a figura em baixo. 
 
Figure 23 Código de linha Manchester 
No resultado do Manchester o 0 representa o V- e o 1 representa o V+. Então sinal 1 no Manchester é 
representado por 0 1 e o sinal 0 é representado no Manchester por 1 0. 
4.3.4 RZ unipolar 
Depois foi escrito o código RZ Unipolar que consiste em transformar o sinal 1 no RZ unipolar que seria 
V+ e 0, e o sinal 0 é representado no RZ unipolar por 0. Em seguida segue o código. 
 
# -*- coding: utf-8 -*- 
""" 
Created on Fri Oct 27 18:35:28 2017 
 
@author: Leandro 
""" 
 
# -*- coding: utf-8 -*- 
""" 
Created on Fri Oct 27 18:29:38 2017 
 
@author: Leandro 
""" 
28 
 
 
# -*- coding: utf-8 -*- 
""" 
Created on Thu Oct 26 16:22:16 2017 
 
@author: Leandro 
""" 
 
import numpy as np 
from numpy import* 
import matplotlib.pyplot as plt 
import numpy as np 
import matplotlib.pyplot as plt 
from numpy.random import randn, randint 
import scipy.special 
from scipy import signal 
 
N=1*10**6 
sn=[1,1,0,0] 
sd=randint(0,2,size = N) 
nrzuniPolar=[0,0,0,0,0,0,0,0] 
 
 
j=0 
for i in range(0, 4,): 
 if(sn[i]==1): 
 nrzuniPolar[i+j]=1 
 nrzuniPolar[i+j+1]=0 
 j=j+1 
 
 
 if(sn[i]==0): 
 nrzuniPolar[i+j]=-0 
 nrzuniPolar[i+j+1]=0 
 j=j+1 
 
 
 
 
print('sinal ', sn) 
print('RZunipolar ',nrzuniPolar) 
 
Em seguida será apresentado o resultado do código implementado. 
29 
 
 
Figure 24 Código de linha RZ unipolar 
Podemos observar o resultado e notar que quando o sinal é 1 no RZunipolar é representado por 10 e o 
sinal 0 no RZunipolar é representado por 0. 
4.3.5 RZ bipolar 
Em seguida foi implementado o código RZ bipolar que consisti que o sinal 1 é representado no RZ 
bipolar com V+ e 0 e o sinal 0 é representado no RZ bipolar por V- e 0. 
""" 
Created on Thu Oct 26 16:22:16 2017 
 
@author: Leandro 
""" 
 
import numpy as np 
from numpy import* 
import matplotlib.pyplot as plt 
import numpy as np 
import matplotlib.pyplot as plt 
from numpy.random import randn, randint 
import scipy.special 
from scipy import signal 
 
N=1*10**6 
sn=[1,0,0,0] 
sd=randint(0,2,size = N) 
nrzPolar=[0,0,0,0,0,0,0,0] 
 
 
j=0 
for i in range(0, 4,): 
 if(sn[i]==1): 
 nrzPolar[i+j]=1 
 nrzPolar[i+j+1]=0 
 j=j+1 
 
 
 if(sn[i]==0): 
 nrzPolar[i+j]=-1 
 nrzPolar[i+j+1]=0 
 j=j+1 
30 
 
 
 
 
 
print('sinal ', sn) 
print('RZpolar ',nrzPolar) 
 
Depois como resultado foi obtido a figura abaixo. 
 
Figure 25 RZ bipolar 
Podes observar que o sinal 1 no RZ polar é representado por 1 e 0 e o sinal 0 é representado por -1 e 0. 
4.4 Desempenho para probabilidade de erro 
Nessa parte será implementada a simulação de transmissão e receção dos códigos de linha e será 
analisado a probabilidade de erros ocorrer. 
4.4.1 NRZ 
Para a simulação e transmissão, receção e a probabilidade de erro no desempenho foi desenvolvido o 
código abaixo. 
#################################################### 
############Importação de Bibliotecas############### 
#################################################### 
import numpy as np 
import matplotlib.pyplot as plt 
from numpy.random import randn, randint 
import scipy.special 
#################################################### 
#####################Código NRZ #################### 
#################################################### 
qfunc = lambda x: (1/2)*(scipy.special.erfc(x/np.sqrt(2))) 
 
EbNodB=np.arange(0,11,2) 
ebno=10.0**(EbNodB/10.0) 
print ('EbNo:', EbNodB) 
 
M=2 
k=int(np.log2(M)) 
print("M = {a:2d} simbolos -->> {b:1d} bit/simbolo".format(a=M,b=k)) 
 
31 
 
eb=1 
N=1*10**6 
 
SIMS=10 
print('SIMS = ', SIMS) 
##################### DATA ############################## 
sn=randint(0,2,size = N) 
print('sn',sn) 
##################### MODULATOR ######################### 
sm=-((-1)**sn) 
print('sm:',sm) 
########################################################## 
itr = len(EbNodB) 
ber = [None]*itr 
ber_t = [None]*itr 
########################################################## 
###################### Simulação ######################### 
print("") 
for n in range(0,len(EbNodB)): 
 erros=0 
# print('EbNo ', EbNodB[n],' -->>Erros = ', erros) 
 
 sigma = np.sqrt(eb/(2*ebno[n])) 
 
 for sims in range(1,SIMS+1,1): 
 yn=sm +sigma*randn(1, N) 
##################### DEMODULATOR ######################## 
 sm_hat=yn>0 
########################################################## 
 erros= erros + (sn != sm_hat).sum() 
 print("Eb/No = {a:2d} dB -->> {b:8d} erros".format(a=EbNodB[n],b=erros)) 
 
 ber[n] = 1.0*erros/(N*SIMS) 
############################################################ 
##################### Teórica############################## 
ber_t = qfunc(np.sqrt(ebno*2)) 
############################################################# 
print("") 
print("ber_theory = [",', '.join('{:.2e}'.format(x) for x in ber_t),"]") 
################## Gráfico ################################## 
plt.plot(EbNodB, ber, 'r',EbNodB, ber_t, 'bo') 
plt.axis([0, 10, 1e-6, 0.1]) 
plt.xscale('linear') 
plt.yscale('log') 
plt.xlabel('Eb/No(dB)') 
plt.ylabel('BER') 
plt.grid(True) 
plt.title('NRZ') 
32 
 
plt.show() 
############################################################### 
 for sims in range(1,SIMS+1,1): 
 yn=sm +sigma*randn(1, N) 
##################### DEMODULATOR ######################## 
 sm_hat=yn>0 
########################################################## 
 erros= erros + (sn != sm_hat).sum() 
 print("Eb/No = {a:2d} dB -->> {b:8d} erros".format(a=EbNodB[n],b=erros)) 
 
 ber[n] = 1.0*erros/(N*SIMS) 
############################################################ 
##################### Teórica ############################## 
ber_t = qfunc(np.sqrt(ebno*2)) 
############################################################# 
print("") 
print("ber_theory = [",', '.join('{:.2e}'.format(x) for x in ber_t),"]") 
################## Gráfico ################################## 
plt.plot(EbNodB, ber, 'r',EbNodB, ber_t, 'bo') 
plt.axis([0, 10, 1e-6, 0.1]) 
plt.xscale('linear') 
plt.yscale('log') 
plt.xlabel('Eb/No(dB)') 
plt.ylabel('BER') 
plt.grid(True) 
plt.title('NRZ') 
plt.show() 
############################################################### 
 
Executado o código acima foi obtido o resultado mostrado abaixo. 
 
Figura 24 Probabilidade de erro de NRZ 
O código acima podemos verificar os erros detetado nos diferentes Eb/No e a teoria de ber. 
33 
 
Em seguida veremos o gráfico da probabilidade de erro teórico e simulado. 
 
Figure 25 Gráfico da probabilidade de erro 
4.4.2 AMI 
Para a simulação e transmissão, receção e a probabilidade de erro no desempenho foi desenvolvido o 
código abaixo. 
#################################################### 
############Importação de Bibliotecas############### 
#################################################### 
import numpy as np 
import matplotlib.pyplot as plt 
from numpy.random import randn, randint 
import scipy.special 
import array 
 
#################################################### 
#####################Código AMI #################### 
#################################################### 
qfunc = lambda x: (1/2)*(scipy.special.erfc(x/np.sqrt(2))) 
 
EbNodB=np.arange(0,11,2) 
 
ebno=10.0**(EbNodB/10.0) 
print ('EbNo:', ebno) 
 
M=2 
k=int(np.log2(M)) 
print("M = {a:2d} simbolos -->> {b:1d} bit/simbolo".format(a=M,b=k)) 
 
eb=1 
N=1*10**6 
34 
 
 
SIMS=10 
print('SIMS = ', SIMS) 
##################### DATA ############################## 
#sn=randint(0,2,size = N) 
sn=[1,1,0,0] 
print('DATA',sn) 
##################### MODULATOR ######################### 
somaEntrada=0 
#ami=randint(0,1,size = N) 
ami=randint(0,1,size = 4) 
somaEntrada=0 
for i in range(0, len(sn)): 
 if(sn[i]==1): 
 somaEntrada=somaEntrada+1 
 if(somaEntrada%2==1): 
 ami[i]=1 
 else: 
 ami[i]=-1 
 
 else: 
 ami[i]=0 
 
 
sm=ami 
 
print('sm:',sm) 
########################################################## 
itr = len(EbNodB) 
ber = [None]*itr 
ber_t = [None]*itr 
########################################################## 
###################### Simulação ######################### 
print("") 
for n in range(0,len(EbNodB)): 
 erros=0 
# print('EbNo ', EbNodB[n],' -->>Erros = ', erros) 
 
 sigma = np.sqrt(eb/(2*ebno[n])) 
 
 for sims in range(1,SIMS+1,1): 
 #yn=sm +sigma*randn(1, N)*0 
 yn=sm+sigma*randn(1,4) 
 
 print('yn ',yn) 
##################### DEMODULATOR ######################## 
 yn=np.abs(yn) 
 sm_hat=yn>0 
35 
 
########################################################### 
 erros= erros + (sn != sm_hat).sum() 
 print("Eb/No = {a:2d} dB -->> {b:8d} erros".format(a=EbNodB[n],b=erros)) 
# 
 ber[n] = 1.0*erros/(N*SIMS) 
############################################################# 
###################### Teórica ############################## 
ber_t = 3/2*qfunc(np.sqrt(ebno)) 
############################################################## 
print("") 
print("ber_theory = [",', '.join('{:.2e}'.format(x) for x in ber_t),"]") 
################### Gráfico ################################## 
plt.plot(EbNodB, ber, 'r',EbNodB, ber_t, 'bo') 
##plt.axis([0, 10, 1e-6, 0.1]) 
#plt.xscale('linear') 
#plt.yscale('log') 
#plt.xlabel('Eb/No(dB)') 
#plt.ylabel('BER') 
#plt.grid(True) 
#plt.title('AMI') 
#plt.show() 
################################################################ 
 
Executado o código acima foi obtido o resultado mostrado abaixo. 
 
Figure 26 Probabilidade de erros 
No código acima podemos verificar os erros detetado nos diferentes Eb/No e a teoria de ber. 
Em seguida veremos o gráfico da probabilidade de erro teórico e simulado. 
 
36 
 
 
Figure 27 Gráfico de probabilidade de erro. 
4.4.3 Diferencial 
Para a simulação e transmissão, receção e a probabilidade de erro no desempenho foi desenvolvido o 
código abaixo. 
#################################################### 
############Importação de Bibliotecas############### 
#################################################### 
import numpy as np 
import matplotlib.pyplot as plt 
from numpy.random import randn, randint 
import scipy.special 
#################################################### 
#####################Código Diferencial #################### 
#################################################### 
qfunc = lambda x: (1/2)*(scipy.special.erfc(x/np.sqrt(2))) 
 
EbNodB=np.arange(0,11,2) 
ebno=10.0**(EbNodB/10.0) 
print ('EbNo:', EbNodB) 
 
M=2 
k=int(np.log2(M)) 
print("M = {a:2d} simbolos -->> {b:1d} bit/simbolo".format(a=M,b=k)) 
 
eb=1 
N=1*10**6 
 
SIMS=10 
print('SIMS = ', SIMS) 
##################### DATA ############################## 
sn=randint(0,2,size = N) 
print('DATA',sn) 
##################### MODULATOR ######################### 
37 
 
 
dk_1=randint(0,1,size = N) 
dk_1[0]=1 
memoria=randint(0,1,size = N) 
memoria[0]=1 
mk=randint(0,2,size = N) 
dk=randint(0,1,size = N) 
yn==randint(0,1,size = N) 
dkAux=randint(0,1,size = N) 
mkDescodificado=randint(0,1,size = N) 
## Codificador 
for i in range(0, len(dk)): 
 dk_1[i]=memoria[i] 
 dkAux[i]=dk_1[i]^mk[i] 
 if(dkAux[i]==1): 
 dk[i]=0 
 # print(dk[i]) 
 if(dkAux[i]==0): 
 dk[i]=1 
 
 if(i<(N-1)): 
 memoria[i+1]=dk[i] 
 
 
print('mk ',mk) 
print('dk_1 ',dk_1) 
print('dk ',dk) 
 
 
sm=dk 
print('sm:',sm) 
########################################################## 
itr = len(EbNodB) 
ber = [None]*itr 
ber_t = [None]*itr 
########################################################## 
###################### Simulação ######################### 
print("") 
dkNot=randint(0,1,size = N) 
memoria[0]=1 
for n in range(0,len(EbNodB)): 
 erros=0 
# print('EbNo ', EbNodB[n],' -->>Erros = ', erros) 
 
 sigma = np.sqrt(eb/(2*ebno[n])) 
 
 for sims in range(1,SIMS+1,1): 
 yn=sm +sigma*randn(1, N) 
38 
 
##################### DEMODULATOR ######################## 
# dkNot=randint(0,1,size = N) 
# memoria[0]=1 
# 
# for i in range(0, N): 
# dk_1[i]=memoria[i] 
# if(i<(N-1)): 
# memoria[i+1]=dk[i] 
# 
# if(dk[i]==1): 
# dkNot[i]=0 
# 
# if(dk[i]==0): 
#dkNot[i]=1 
# 
# mkDescodificado[i]=dkNot[i]^dk_1[i] 
# print(mkDescodificado) 
 sm_hat=yn>0.5 
 
########################################################### 
 erros= erros + (sn != sm_hat).sum() 
 print("Eb/No = {a:2d} dB -->> {b:8d} erros".format(a=EbNodB[n],b=erros)) 
 
 ber[n] = 1.0*erros/(N*SIMS) 
############################################################# 
###################### Teórica ############################## 
ber_t = 2*qfunc(np.sqrt(2*ebno)) 
############################################################## 
print("") 
print("ber_theory = [",', '.join('{:.2e}'.format(x) for x in ber_t),"]") 
print('yn',yn) 
################### Gráfico ################################## 
plt.plot(EbNodB, ber, 'r',EbNodB, ber_t, 'bo') 
plt.axis([0, 10, 1e-6, 0.1]) 
plt.xscale('linear') 
plt.yscale('log') 
plt.xlabel('Eb/No(dB)') 
plt.ylabel('BER') 
plt.grid(True) 
plt.title('Diferencial') 
plt.show() 
################################################################ 
 
39 
 
Executado o código acima foi obtido o resultado mostrado abaixo. 
 
Figura 28 Probabilidade de erros 
No código acima podemos verificar os erros detetado nos diferentes Eb/No e a teoria de ber. 
Em seguida veremos o gráfico da probabilidade de erro teórico e simulado. 
 
 
 
40 
 
 
4.4.4 Unipolar 
Para a simulação e transmissão, receção e a probabilidade de erro no desempenho foi desenvolvido o 
código abaixo. 
#################################################### 
############Importação de Bibliotecas############### 
#################################################### 
import numpy as np 
import matplotlib.pyplot as plt 
from numpy.random import randn, randint 
import scipy.special 
#################################################### 
#####################Código Unipolar #################### 
#################################################### 
qfunc = lambda x: (1/2)*(scipy.special.erfc(x/np.sqrt(2))) 
 
EbNodB=np.arange(0,11,2) 
ebno=10.0**(EbNodB/10.0) 
print ('EbNo:', EbNodB) 
 
M=2 
k=int(np.log2(M)) 
print("M = {a:2d} simbolos -->> {b:1d} bit/simbolo".format(a=M,b=k)) 
 
eb=.5 
N=1*10**6 
 
SIMS=10 
print('SIMS = ', SIMS) 
##################### DATA ############################## 
sn=randint(0,2,size = N) 
print('sn',sn) 
##################### MODULATOR ######################### 
sm=sn 
print('sm:',sm) 
########################################################## 
itr = len(EbNodB) 
ber = [None]*itr 
ber_t = [None]*itr 
########################################################## 
###################### Simulação ######################### 
print("") 
for n in range(0,len(EbNodB)): 
 erros=0 
# print('EbNo ', EbNodB[n],' -->>Erros = ', erros) 
 
41 
 
 sigma = np.sqrt(eb/(2*ebno[n])) 
 
 for sims in range(1,SIMS+1,1): 
 yn=sm +sigma*randn(1, N) 
 print('yn',yn) 
##################### DEMODULATOR ######################## 
 sm_hat=yn>0.5 
 
########################################################## 
 erros= erros + (sn != sm_hat).sum() 
 print("Eb/No = {a:2d} dB -->> {b:8d} erros".format(a=EbNodB[n],b=erros)) 
 
 ber[n] = 1.0*erros/(N*SIMS) 
############################################################ 
##################### Teórica ############################## 
ber_t = qfunc(np.sqrt(ebno)) 
############################################################# 
print("") 
print("ber_theory = [",', '.join('{:.2e}'.format(x) for x in ber_t),"]") 
################## Gráfico ################################## 
plt.plot(EbNodB, ber, 'r',EbNodB, ber_t, 'bo') 
plt.axis([0, 10, 1e-6, 0.1]) 
plt.xscale('linear') 
plt.yscale('log') 
plt.xlabel('Eb/No(dB)') 
plt.ylabel('BER') 
plt.grid(True) 
plt.title('Codigo Unipolar') 
plt.show() 
############################################################### 
 
Executado o código acima foi obtido o resultado mostrado abaixo. 
 
42 
 
 
 
4.4.5 Manchester 
Para a simulação e transmissão, receção e a probabilidade de erro no desempenho foi desenvolvido o 
código abaixo 
#################################################### 
############Importação de Bibliotecas############### 
from IPython import get_ipython 
get_ipython().magic('reset -sf') 
import pdb 
#################################################### 
import numpy as np 
import matplotlib.pyplot as plt 
from numpy.random import randn, randint 
import scipy.special 
#################################################### 
#####################Código Manchester #################### 
#################################################### 
qfunc = lambda x: (1/2)*(scipy.special.erfc(x/np.sqrt(2))) 
 
EbNodB=np.arange(0,11,2) 
ebno=10.0**(EbNodB/10.0) 
print ('EbNo:', EbNodB) 
 
M=2 
k=int(np.log2(M)) 
print("M = {a:2d} simbolos -->> {b:1d} bit/simbolo".format(a=M,b=k)) 
 
eb=1 
N=1*10**6 
 
SIMS=10 
print('SIMS = ', SIMS) 
##################### DATA ############################## 
#sn=randint(0,2,size = N) 
 
##################### MODULATOR ######################### 
#sn=np.array([1,1,0,0],dtype=int)a = np.array([[1, 2], [3, 4]]) 
#>>> b = np.array([[5, 6]]) 
#manchester=randint(0,2,size = 2*N) 
#sm=randint(0,2,size = N) 
 
#sn=[1,1,0,0] 
sn=randint(0,2,size = 4) 
manchester=randint(0,1,size = 8) 
43 
 
yn=randint(0,1,size = 4) 
yn1=randint(0,1,size = 8) 
#manchester=[0,0,0,0,0,0,0,0] 
 
 
j=0 
for i in range(0, 4): 
 if(sn[i]==1): 
 manchester[i+j]=-1 
 manchester[i+j+1]=1 
 j=j+1 
 
 
 if(sn[i]==0): 
 manchester[i+j]=1 
 manchester[i+j+1]=-1 
 j=j+1 
 m=0 
 
 
print('sinal ', sn) 
print('manchester ',manchester) 
sm=manchester 
 
 
 
########################################################## 
itr = len(EbNodB) 
ber = [None]*itr 
ber_t = [None]*itr 
########################################################## 
####################### Simulação ######################### 
print("") 
j=0 
for n in range(0,len(EbNodB)): 
 erros=0 
 print('EbNo ', EbNodB[n],' -->>Erros = ', erros) 
 sigma = np.sqrt(eb/(2*ebno[n])) 
 
 for sims in range(1,SIMS+1,1): 
 yn1=sm +sigma*randn(1,8) 
 print(yn1) 
 
 for i in range(0,3): 
 j=i+1 
 yn[i]=yn1[0,i]+yn1[0,j] 
##################### DEMODULATOR ######################## 
 # pdb.set_trace() 
44 
 
############################################################ 
 sm_hat=yn>0 
 print(yn) 
########################################################## 
 erros= erros + (sn != sm_hat).sum() 
 print("Eb/No = {a:2d} dB -->> {b:8d} erros".format(a=EbNodB[n],b=erros)) 
 
 ber[n] = 1.0*erros/(N*SIMS) 
############################################################ 
##################### Teórica ############################## 
ber_t = qfunc(np.sqrt(ebno*2)) 
############################################################# 
print("") 
print("ber_theory = [",', '.join('{:.2e}'.format(x) for x in ber_t),"]") 
################## Gráfico ################################## 
plt.plot(EbNodB, ber, 'r',EbNodB, ber_t, 'bo') 
plt.axis([0, 10, 1e-6, 0.1]) 
plt.xscale('linear') 
plt.yscale('log') 
plt.xlabel('Eb/No(dB)') 
plt.ylabel('BER') 
plt.grid(True) 
plt.title('Manchester') 
plt.show() 
############################################################### 
 
Executado o código acima foi obtido o resultado mostrado abaixo. 
 
 
 
45 
 
4.4.6 RZ polar 
Para a simulação e transmissão, receção e a probabilidade de erro no desempenho foi desenvolvido o 
código abaixo. 
################################################################Importação de Bibliotecas############### 
from IPython import get_ipython 
get_ipython().magic('reset -sf') 
import pdb 
#################################################### 
import numpy as np 
import matplotlib.pyplot as plt 
from numpy.random import randn, randint 
import scipy.special 
#################################################### 
#####################Código Manchester #################### 
#################################################### 
qfunc = lambda x: (1/2)*(scipy.special.erfc(x/np.sqrt(2))) 
 
EbNodB=np.arange(0,11,2) 
ebno=10.0**(EbNodB/10.0) 
print ('EbNo:', EbNodB) 
 
M=2 
k=int(np.log2(M)) 
print("M = {a:2d} simbolos -->> {b:1d} bit/simbolo".format(a=M,b=k)) 
 
eb=1 
N=1*10**6 
 
SIMS=10 
print('SIMS = ', SIMS) 
##################### DATA ############################## 
#sn=randint(0,2,size = N) 
 
##################### MODULATOR ######################### 
#sn=np.array([1,1,0,0],dtype=int)a = np.array([[1, 2], [3, 4]]) 
#>>> b = np.array([[5, 6]]) 
#manchester=randint(0,2,size = 2*N) 
#sm=randint(0,2,size = N) 
 
#sn=[1,1,0,0] 
sn=randint(0,2,size = 4) 
rzBipolar=randint(0,1,size = 8) 
yn=randint(0,1,size = 4) 
yn1=randint(0,1,size = 8) 
#manchester=[0,0,0,0,0,0,0,0] 
 
46 
 
 
j=0 
for i in range(0, 4): 
 if(sn[i]==1): 
 rzBipolar[i+j]=1 
 rzBipolar[i+j+1]=0 
 j=j+1 
 
 
 if(sn[i]==0): 
 rzBipolar[i+j]=-1 
 rzBipolar[i+j+1]=0 
 j=j+1 
 m=0 
 
 
print('sinal ', sn) 
print('manchester ',rzBipolar) 
sm=rzBipolar 
 
 
 
########################################################## 
itr = len(EbNodB) 
ber = [None]*itr 
ber_t = [None]*itr 
########################################################## 
####################### Simulação ######################### 
print("") 
j=0 
for n in range(0,len(EbNodB)): 
 erros=0 
 print('EbNo ', EbNodB[n],' -->>Erros = ', erros) 
 sigma = np.sqrt(eb/(2*ebno[n])) 
 
 for sims in range(1,SIMS+1,1): 
 yn1=sm +sigma*randn(1,8) 
 print(yn1) 
 
 for i in range(0,3): 
 j=i+1 
 yn[i]=yn1[0,i]+yn1[0,j] 
##################### DEMODULATOR ######################## 
 # pdb.set_trace() 
############################################################ 
 sm_hat=yn>0 
 print(yn) 
########################################################## 
47 
 
 erros= erros + (sn != sm_hat).sum() 
 print("Eb/No = {a:2d} dB -->> {b:8d} erros".format(a=EbNodB[n],b=erros)) 
 
 ber[n] = 1.0*erros/(N*SIMS) 
############################################################ 
##################### Teórica ############################## 
ber_t = 2*qfunc(np.sqrt(ebno*2)) 
############################################################# 
print("") 
print("ber_theory = [",', '.join('{:.2e}'.format(x) for x in ber_t),"]") 
################## Gráfico ################################## 
plt.plot(EbNodB, ber, 'r',EbNodB, ber_t, 'bo') 
plt.axis([0, 10, 1e-6, 0.1]) 
plt.xscale('linear') 
plt.yscale('log') 
plt.xlabel('Eb/No(dB)') 
plt.ylabel('BER') 
plt.grid(True) 
plt.title('RZ Bipolar') 
plt.show() 
############################################################### 
 
Executado o código acima foi obtido o resultado mostrado abaixo. 
 
 
 
 
 
 
48 
 
4.5 Desempenho de probabilidade de erro transmissão passa banda. 
Nessa secção será avaliado a probabilidade de erro da transmissão passa banda de entre quais entra o 
ASK,FSK,PSK,4QAM,4PSK. 
4.5.1 ASK 
Para a simulação e transmissão, receção e a probabilidade de erro no desempenho foi desenvolvido o 
código abaixo. 
# -*- coding: utf-8 -*- 
""" 
Created on Tue Dec 19 23:47:17 2017 
 
@author: Leandro 
""" 
from numpy import sqrt 
from numpy.random import rand, randn 
import matplotlib.pyplot as plt 
N = 5000000 
EbNodB_range = range(0,14) 
itr = len(EbNodB_range) 
ber = [None]*itr 
for n in range (0, itr): 
 EbNodB = EbNodB_range[n] 
 EbNo=10.0**(EbNodB/10.0) 
 x = 2 * (rand(N) >= 0.5)-1 
 noise_std = 1/sqrt(EbNo) 
 y = x + noise_std * randn(N) 
 y_d = 2 * (y >= 0) - 1 
 errors = (x != y_d).sum() 
 ber[n] = 2 * errors / N 
 
plt.plot(EbNodB_range, ber, 'bo', EbNodB_range, ber, 'k') 
plt.axis([0, 13, 1e-6, 1]) 
plt.xscale('linear') 
plt.yscale('log') 
plt.xlabel('EbNo(dB)') 
plt.ylabel('Erros') 
plt.grid(True) 
plt.title('Modelação ASK') 
plt.show() 
 
 
~ 
 
49 
 
Com a base do código acima obtivemos o gráfico abaixo. 
 
 
4.5.2 FSK 
Para a simulação e transmissão, receção e a probabilidade de erro no desempenho foi desenvolvido o 
código abaixo. 
# -*- coding: utf-8 -*- 
""" 
Created on Tue Dec 19 23:50:02 2017 
 
@author: Leandro 
""" 
 
from numpy import sqrt 
from numpy.random import rand, randn 
import matplotlib.pyplot as plt 
N = 5000000 
EbNodB_range = range(0,11) 
itr = len(EbNodB_range) 
ber = [None]*itr 
for n in range (0, itr): 
 EbNodB = EbNodB_range[n] 
 EbNo=10.0**(EbNodB/10.0) 
 x = 2 * (rand(N) >= 0.5) -1 
 noise_std = 1/sqrt(EbNo) 
 y = x + noise_std * randn(N) 
 y_d = 2 * (y >= 0) - 1 
 errors = (x != y_d).sum() 
 ber[n] = 1.0 * errors / N 
 
plt.plot(EbNodB_range, ber, 'bo', EbNodB_range, ber, 'k') 
50 
 
plt.axis([0, 10, 6e-4, 0.2]) 
plt.xscale('linear') 
plt.yscale('log') 
plt.xlabel('EbNo(dB)') 
plt.ylabel('Erros') 
plt.grid(True) 
plt.title('Modelação FSK') 
plt.show() 
 
Com a base do código acima obtivemos o gráfico abaixo. 
 
4.5.3 4PSK 
Para a simulação e transmissão, receção e a probabilidade de erro no desempenho foi desenvolvido o 
código abaixo. 
#################################################### 
############Importação de Bibliotecas############### 
from IPython import get_ipython 
get_ipython().magic('reset -sf') 
import pdb 
#################################################### 
import numpy as np 
import matplotlib.pyplot as plt 
from numpy.random import randn, randint 
import scipy.special 
import math 
from math import exp 
from math import pi 
#################################################### 
#####################Código Manchester #################### 
#################################################### 
qfunc = lambda x: (1/2)*(scipy.special.erfc(x/np.sqrt(2))) 
51 
 
 
EbNodB=np.arange(0,11,2) 
ebno=10.0**(EbNodB/10.0) 
print ('EbNo:', EbNodB) 
 
M=2 
k=int(np.log2(M)) 
print("M = {a:2d} simbolos -->> {b:1d} bit/simbolo".format(a=M,b=k)) 
 
eb=1 
N=1*10**6 
 
SIMS=10 
print('SIMS = ', SIMS) 
##################### DATA ############################## 
#sn=randint(0,2,size = N) 
 
##################### MODULATOR ######################### 
#sn=np.array([1,1,0,0],dtype=int)a = np.array([[1, 2], [3, 4]]) 
#>>> b = np.array([[5, 6]]) 
#manchester=randint(0,2,size = 2*N) 
#sm=randint(0,2,size = N) 
 
#sn=[1,1,0,0] 
sn=randint(0,1,size = 4) 
psk=[0,0,0,0] 
yn=randint(0,1,size = 8) 
yn1=randint(0,1,size = 4) 
sn=[0,0,0,1,1,0,1,1] 
 
j=0 
for i in range(0, 3): 
 if sn[i+j]==0 and sn[i+j+1]==0 : 
 psk[i]=np.angle(0.707+0.707*1.j) 
 j=j+1 
 if sn[i+j]==1 and sn[i+j+1]==1 : 
 psk[i]=np.angle(0.707-0.707*1.j) 
 j=j+1 
 if sn[i+j]==1 and sn[i+j+1]==0 : 
 psk[i]=np.angle(-0.707-0.707*1.j) 
 j=j+1 
 if sn[i+j]==0 and sn[i+j+1]==1 : 
 psk[i]=np.angle(-0.707+0.707*1.j) 
 j=j+1 
# j=j+1 
# 
print('sinal ', sn) 
print('psk ',psk) 
52 
 
sm=psk 
## 
## 
## 
############################################################ 
itr = len(EbNodB) 
ber = [None]*itr 
ber_t = [None]*itr 
##################################################################################### Simulação ######################### 
print("") 
j=0 
for n in range(0,len(EbNodB)): 
 erros=0 
 print('EbNo ', EbNodB[n],' -->>Erros = ', erros) 
 sigma = np.sqrt(eb/(2*ebno[n])) 
 
 for sims in range(1,SIMS+1,1): 
 yn1=sm +sigma*randn(1,4)*0 
 print(yn1) 
# 
# for i in range(0,3): 
# if yn1[i]==(-1-1.j): 
## yn[i+j+1]=0 
## yn[i+1]=0 
## if yn1[i]==1+1.j: 
## yn[i+j+1]=1 
## yn[i+1]=1 
## if yn1[i]==1-1.j: 
## yn[i+j+1]=1 
## yn[i+1]=0 
## if yn1[i]==-1+1.j : 
## yn[i+j+1]=0 
## yn[i+1]=1 
# 
####################### DEMODULATOR ######################## 
## # pdb.set_trace() 
############################################################## 
 sm_hat=yn>0*1 
 print(yn) 
############################################################ 
 erros= erros + (sn != sm_hat).sum() 
 print("Eb/No = {a:2d} dB -->> {b:8d} erros".format(a=EbNodB[n],b=erros)) 
 
 ber[n] = 1.0*erros/(N*SIMS) 
############################################################## 
####################### Teórica ############################## 
ber_t = qfunc(np.sqrt(ebno*2)) 
53 
 
############################################################### 
print("") 
print("ber_theory = [",', '.join('{:.2e}'.format(x) for x in ber_t),"]") 
#################### Gráfico ################################## 
plt.plot(EbNodB, ber, 'r',EbNodB, ber_t, 'bo') 
plt.axis([0, 10, 1e-6, 0.1]) 
plt.xscale('linear') 
plt.yscale('log') 
plt.xlabel('Eb/No(dB)') 
plt.ylabel('BER') 
plt.grid(True) 
plt.title('PSK') 
plt.show() 
################################################################# 
 
Com a base do código acima obtivemos o gráfico abaixo. 
 
 
54 
 
4.5.4 4QAM 
Para a simulação e transmissão, receção e a probabilidade de erro no desempenho foi desenvolvido o 
código abaixo. 
#################################################### 
############Importação de Bibliotecas############### 
from IPython import get_ipython 
get_ipython().magic('reset -sf') 
import pdb 
#################################################### 
import numpy as np 
import matplotlib.pyplot as plt 
from numpy.random import randn, randint 
import scipy.special 
#################################################### 
#####################Código Manchester #################### 
#################################################### 
qfunc = lambda x: (1/2)*(scipy.special.erfc(x/np.sqrt(2))) 
 
EbNodB=np.arange(0,11,2) 
ebno=10.0**(EbNodB/10.0) 
print ('EbNo:', EbNodB) 
 
M=2 
k=int(np.log2(M)) 
print("M = {a:2d} simbolos -->> {b:1d} bit/simbolo".format(a=M,b=k)) 
 
eb=1 
N=1*10**6 
 
SIMS=10 
print('SIMS = ', SIMS) 
##################### DATA ############################## 
#sn=randint(0,2,size = N) 
 
##################### MODULATOR ######################### 
#sn=np.array([1,1,0,0],dtype=int)a = np.array([[1, 2], [3, 4]]) 
#>>> b = np.array([[5, 6]]) 
#manchester=randint(0,2,size = 2*N) 
#sm=randint(0,2,size = N) 
 
#sn=[1,1,0,0] 
sn=randint(0,1,size = 4) 
qAM=[0,0,0,0] 
yn=randint(0,1,size = 8) 
yn1=randint(0,1,size = 4) 
sn=[0,0,0,1,1,0,1,1] 
 
55 
 
#j=0 
for i in range(0, 3): 
 if sn[i]==0 and sn[i+1]==0 : 
 qAM[i]=-1-1.j 
 if sn[i]==1 and sn[i+1]==1 : 
 qAM[i]=1+1.j 
 if sn[i]==1 and sn[i+1]==0 : 
 qAM[i]=1-1.j 
 if sn[i]==0 and sn[i+1]==1 : 
 qAM[i]=-1+1.j 
# j=j+1 
# 
# 
print('sinal ', sn) 
print('4QAM ',qAM) 
sm=qAM 
# 
# 
# 
########################################################### 
itr = len(EbNodB) 
ber = [None]*itr 
ber_t = [None]*itr 
########################################################### 
######################## Simulação ######################### 
print("") 
j=0 
for n in range(0,len(EbNodB)): 
 erros=0 
 print('EbNo ', EbNodB[n],' -->>Erros = ', erros) 
 sigma = np.sqrt(eb/(2*ebno[n])) 
 
 for sims in range(1,SIMS+1,1): 
 yn1=sm +sigma*randn(1,4)*0 
 print(yn1) 
 
# for i in range(0,3): 
# if yn1[i]==(-1-1.j): 
# yn[i+j+1]=0 
# yn[i+1]=0 
# if yn1[i]==1+1.j: 
# yn[i+j+1]=1 
# yn[i+1]=1 
# if yn1[i]==1-1.j: 
# yn[i+j+1]=1 
# yn[i+1]=0 
# if yn1[i]==-1+1.j : 
# yn[i+j+1]=0 
56 
 
# yn[i+1]=1 
 
###################### DEMODULATOR ######################## 
# # pdb.set_trace() 
############################################################# 
 sm_hat=yn>0*1 
# print(yn) 
########################################################### 
 erros= erros + (sn != sm_hat).sum() 
 print("Eb/No = {a:2d} dB -->> {b:8d} erros".format(a=EbNodB[n],b=erros)) 
 
 ber[n] = 1.0*erros/(N*SIMS) 
############################################################# 
###################### Teórica ############################## 
ber_t = qfunc(np.sqrt(ebno*2)) 
############################################################## 
#print("") 
print("ber_theory = [",', '.join('{:.2e}'.format(x) for x in ber_t),"]") 
################### Gráfico ################################## 
plt.plot(EbNodB, ber, 'r',EbNodB, ber_t, 'bo') 
plt.axis([0, 10, 1e-6, 0.1]) 
plt.xscale('linear') 
plt.yscale('log') 
plt.xlabel('Eb/No(dB)') 
plt.ylabel('BER') 
plt.grid(True) 
plt.title('4QAM') 
plt.show() 
################################################################ 
 
Com a base do código acima obtivemos o gráfico abaixo. 
 
57 
 
5 Conclusões 
No trabalho foi tirado como conclusão que nos impulsos retangulares quando menor for a duração do 
impulso maior numero de espectro terá o sinal. Foi verificado que na ilustração de modulação que a 
PAM modifica a amplitude de acordo com o sinal senoidal. Quando o senoidal está no pico o sinal 
modulado possui uma amplitude alta. Notou se que o PWM modifica a largura da duração do pulso de 
acordo com o sinal modulante. Notou-se que os códigos de linhas são completamente diferentes uma 
da outra 
Desempenho da probabilidade de erro no simulador e teoricamente são diferentes para AMI e 
diferencial, porém para NRZ são iguais. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
58 
 
6 Bibliografia 
Non Return Zero. (s.d.). Obtido de Wikipedia: https://en.wikipedia.org/wiki/Non-return-to-zero 
Sicipy.org. (s.d.). Obtido de https://docs.scipy.org/doc/scipy-
0.15.1/reference/generated/scipy.signal.square.html 
Torres, P. (2017). Apontamentos de Comunicação digital. Castelo Branco.