DMT

Jose Espinosa - [Link]@[Link]

Universidad de Cuenca, Ecuador

Abstract
El presente trabajo simulará un transmisor y receptor DMT utilizando el
programa Python, se implementará cada uno de los bloques que componen
un Tx/Rx DMT y se simulará la atenuación propia de un canal de tipo
par trenzado de cobre ADSL . Finalmente se utilizará este programa para
transmitir una secuencia de bits y observar el resultado.
Keywords: DMT, ADSL, Python, Transmisor, Receptor.

1. Objetivos
- Diseñar transmisor y receptor DMT.

2. Introducción
El multitono discreto (DMT) es un método para separar una señal de
lı́nea de abonado digital (DSL) de modo que el intervalo de frecuencia utiliz-
able se divida en 256 bandas de frecuencia (o canales) de 4.3125 KHz cada
una. DMT utiliza el algoritmo de transformada rápida de Fourier (FFT)
para la modulación y demodulación. Dentro de cada canal, DMT utiliza la
modulación de amplitud cuadrática (QAM). Al variar el número de bits por
sı́mbolo dentro de un canal, el módem puede adaptarse a la velocidad.

3. Marco Teórico
A continuación se detallara los software utilizados, y tambien se explicara
el funcionamiento de DMT.

Preprint submitted to Journal Name July 19, 2019

3.1. DMT
DMT divide el canal en varios subcanales, comunmente denominados
tonos, cada uno de los cuales está modulado en amplitud en cuadratura
(QAM) en una portadora separada. Estas frecuencias portadoras son múltiplos
de una frecuencia básica. Los rangos de espectro disponibles subsiguientes
van desde aproximadamente 20 kHz a 1.104 MHz, mientras que los bajos
de 20 kHz están reservados para POTS, que tienen un lı́mite más realista
de 4 kHz. El ruido y las condiciones de la lı́nea se miden constantemente
para cada tono por separado, con el fin de optimizar la transmisión en un
momento dado.

Figure 1: DMT

Para admitir canales bidireccionales, los sistemas ADSL dividen el ancho

de banda disponible por multiplexación por división de frecuencia (FDM),
donde se asignan bandas no superpuestas para los datos descendentes y as-
cendentes. La modulación DMT es en realidad una forma de FDM. El flujo
de datos de entrada se divide en N canales que tienen el mismo ancho de
banda pero una frecuencia central diferente. El uso de muchos canales con
un ancho de banda muy estrecho conlleva varias ventajas. La más significa-
tiva de estas ventajas es que todos los canales se vuelven independientes,
independientemente de las caracterı́sticas de la lı́nea y, por lo tanto, pueden
codificarse y decodificarse individualmente.

2
3.2. Python
Python es un lenguaje de programación interpretado cuya filosofı́a hace
hincapié en una sintaxis que favorezca un código legible.
Se trata de un lenguaje de programación multiparadigma, ya que soporta
orientación a objetos, programación imperativa y, en menor medida, progra-
mación funcional. Es un lenguaje interpretado, de tipado fuerte, dinámico y
multiplataforma.
Es administrado por la Python Software Foundation. Posee una licencia
de código abierto, denominada Python Software Foundation License, que es
compatible con la Licencia pública general de GNU a partir de la versión
2.1.1, e incompatible en ciertas versiones anteriores.

Python es un lenguaje de programación multiparadigma. Esto significa

que más que forzar a los programadores a adoptar un estilo particular de
programación, permite varios estilos: programación orientada a objetos, pro-
gramación imperativa y programación funcional. Otros paradigmas están
soportados mediante el uso de extensiones.
Python usa tipado dinámico y conteo de referencias para la adminis-
tración de memoria.
Una caracterı́stica importante de Python es la resolución dinámica de
nombres; es decir, lo que enlaza un método y un nombre de variable durante
la ejecución del programa (también llamado enlace dinámico de métodos).
Otro objetivo del diseño del lenguaje es la facilidad de extensión. Se
pueden escribir nuevos módulos fácilmente en C o C++. Python puede
incluirse en aplicaciones que necesitan una interfaz programable.
Aunque la programación en Python podrı́a considerarse en algunas situa-
ciones hostil a la programación funcional tradicional del Lisp, existen bas-
tantes analogı́as entre Python y los lenguajes minimalistas de la familia Lisp
como puede ser Scheme.

3
4. Implementacion en Python
Para la parte en Python se procedio a implementar cada uno de los bloque
que conforman un transmisor y receptor DMT. El transmisor y receptor se
basan en los mismos bloques pero realizan funciones contrarios.

Transmisor DMT

• Convertir los bits a sı́mbolos.

• Definir el número de portadoras.

• Modulación.

• Pasar de banda base a pasa banda.

• Transmisión.

Receptor DMT

• Recepción.

• Pasar de pasa banda a banda base.

• Demodulación.

• Convertir sı́mbolos a bits.

Figure 2: Diagrama de bloques DMT

4
5. Funcionamiento

Figure 3: DMT en canal ideal

Figure 4: DMT en canal no ideal

5
6. Código
import [Link] as plt
import numpy as np
import random
import math
from scipy import signal

#Para cada uno de los N canales asigna un numero de bits y

#generación del flujo de datos, tal que la suma de todos
#(bits / subcanal) = la longitud de los datos.

dato = int(input("Escriba el numero de portadoras: \n"))

N=dato; #Numero de sub canales

v=5; # Longitud del prefijo cı́clico
h1=[1, 0.5, 0.3, 0.2, -0.1, 0.02, 0.05, 0.08, 0.01] #Respuesta
#al impulso del canal

opcion = int(input("Escriba el numero de la opcion que desea:

\n 1 Canal ideal \n 2 Canal no ideal \n"))

if (opcion==1):
h = [h1[0]]

elif (opcion==2):
h = h1

######################################################
#Asignación de bits y generación de datos.
######################################################
bit_channel = []
for i in range(N-1):
bit_channel.append([Link](1,15))

fig = [Link](figsize=(80, 70))

[Link]('DMT', fontsize=16)
[Link](331)

6
p1 = [Link]([Link](N-1),bit_channel)

#Dato asignado a cada canal

data = []
for i in range(N-1):
data_channel = []
#data_channel es el dato particular asignado al subcanal.
for j in range(bit_channel[i]):
val = [Link](2)
data_channel.append(val)
[Link](data_channel)

i_comp = []
q_comp = []
complex_symbol = []

p2 = [Link]([Link](N-1),bit_channel, 'r')
[Link]("bits/canal")
[Link]("Distribucioin de bits en el canal")

#####################################################
#Codificacion de la se~
nal
#####################################################

#Calculo del espaciado entre sı́mbolos (basado en una

#energı́a de sı́mbolo de transmisión de 1).
for i in range(N-1):
d = [Link](6/((2**bit_channel[i])-1))
#La cantidad de bits enviados a los DAC superiores
#e inferiores
bits_top = [Link](bit_channel[i]/2)
bits_bot = [Link](bit_channel[i]/2)
#Los datos binarios reales enviados a los DAC
#superiores e inferiores
data_top = data[i][0:bits_top]
data_bot = data[i][bits_top:bit_channel[i]]

7
 #El valor decimal de los datos en los DAC superiores
#e inferiores
v_top = 0
for j in range(bits_top):
val = data_top[j]*(2**j)
v_top = v_top + val

v_bot = 0
for j in range(bits_bot):
val = data_bot[j]*(2**j)
v_bot = v_bot + val

#Los valores de salida de los DACs superior e inferior

d_top = (v_top * d)-(((2**bits_top - 1)/2)*d)
d_bot = (v_bot * d)-(((2**bits_bot - 1)/2)*d)

#Dado que la salida DAC superior es la amplitud de la onda

#coseno y la salida DAC inferior es la amplitud de la onda
#sinusoidal, podemos considerar que son las componentes en
#fase y en cuadratura del complejo sı́mbolo QAM.

i_comp.append(d_top)
q_comp.append(d_bot)
complex_symbol.append(i_comp[i] + q_comp[i]*(1j))

[Link](334)
P3 = [Link]([Link](complex_symbol), use_line_collection=True)
[Link]("Se~
nal codificada compleja")
[Link]("Parte real")

P4 = [Link](337)
[Link]([Link](complex_symbol), use_line_collection=True)
[Link]("Canal/Frecuencia")
[Link]("Parte imaginaria")

8
######################################################
#CalculO de la IFFT del sı́mbolo complejo codificado.
######################################################
rev_complex_symbol = complex_symbol[::-1]
complex_symbol.insert(0,1)
complex_symbol.append(1)

x_tx = complex_symbol + rev_complex_symbol

x_mod = [Link](x_tx,2*N)
x1_mod = [Link](x_mod,2*N)

######################################################
#Prefijo ciclio.
######################################################
x = list(x_mod[2*N-v:2*N]) + list(x_mod)

######################################################
#Transmisión ade la se~
nal.
######################################################
w, h3 = [Link](h)

[Link](335)
p5 = [Link]('Respuesta de frecuencia del canal')
p6 = [Link](w, 20 * np.log10(abs(h3)), 'r')
[Link]('Amplitud [dB]')
[Link]('Frecuencia [rad/muestra]')
[Link]()
[Link](338)
angles = [Link]([Link](h3))
p7 = [Link](w, angles, 'b')
[Link]('Angulo (radianes)')
[Link]()
[Link]('tight')

y = [Link](x,h)

9
######################################################
#Recepción de la Se~
nal
######################################################
#Eliminación del Prefijo Cı́clico
y_mod = y[v:2*N+v]
#Debido al prefijo cı́clico, la convolución se traduce en una
#convolución circular y, por lo tanto, el sı́mbolo complejo
#codificado con su conjugado se recibe después de la demodulación
#FFT.
x_recd = [Link]([Link](y_mod))/[Link]([Link](h,2*N))
#Se remueve la parte conjugada
complex_recd_symbol = x_recd[1:N];

[Link](336)
p8 = [Link]([Link](complex_recd_symbol), use_line_collection=True)
[Link]("Decodificacion y eliminación de datos reflejados")
[Link]("Parte real")
[Link](339)
p9 = [Link]([Link](complex_recd_symbol), use_line_collection=True)
[Link]("Canal/Frecuencia")
[Link]("Parte imaginaria")

#######################################################
#Decodificación de la Se~
nal
#######################################################
i_comp = []
q_comp = []

data_recd = []
for i in range(N-1):
i_comp.append([Link](complex_recd_symbol[i]))
q_comp.append([Link](complex_recd_symbol[i]))
#Calculo el espaciado entre sı́mbolos (basado en una energı́a
#de sı́mbolo de transmisión de 1).
d = [Link](6/((2**bit_channel[i])-1))
#La cantidad de bits enviados a los DAC superiores e inferiores
l_top = [Link](bit_channel[i]/2)
l_bot = [Link](bit_channel[i]/2)

10
 d_top = i_comp[i]
d_bot = q_comp[i]

v_top = round((d_top/d)+((2**l_top-1)/2))
v_bot = round((d_bot/d)+((2**l_bot-1)/2))

b_top = []
for j in range(l_top):
b_top.append([Link](v_top,2))
v_top = [Link](v_top/2)

b_bot = []
for j in range(l_bot):
b_bot.append([Link](v_bot, 2))
v_bot = [Link](v_bot/2);

data_recd.append(b_top+b_bot)

#######################################################
# Calculo del error
#######################################################
complex_symbol.pop()
complex_symbol.pop(0)

err = complex_recd_symbol-complex_symbol

num_err = 0
errors = []
num_bits = 0
for i in range(len(data_recd)):
for j in range(len(data_recd[i])):
[Link](data_recd[i][j]-data[i][j])
num_bits = num_bits +1
if (data_recd[i][j] != data[i][j]):
num_err = num_err + 1

print("Número de bits de información: ", num_bits)

11
print("Número de errores: ", num_err)

[Link](333)
[Link](errors, use_line_collection=True)
p10 = [Link]("Errores en los Datos")
[Link]()

7. Conclusiones
La principal ventaja de DMT es su capacidad de usar las sub-portadoras
con mejor respuesta para enviar mayora cantidad de informacion, si des-
preciar las bandas que son medianamente buenas y apenas utilizando las
sub-portadoras que son de mala calidad.
El resultado son recibir datos con pocos errores y un uso mas eficiente del
ancho de banda disponible en esta para ADSL.

8. Bibliografı́a
[1] Computer Networking: A Top Down Approach 6th edition Jim Kurose,
Keith RossAddison-WesleyMarch 2012

12