Machine Translated by Google

Haz un generador DTMF con una placa Arduino

Este artículo es para principiantes absolutos y describe el diseño y la construcción de un generador
DTMF. Los generadores DTMF a menudo se utilizan para enviar señales con equipos en el extremo remoto
de un enlace de RF. EMDRC los usa para controlar su repetidor y enlace ATV. La señalización DTMF se
explica en https://en.wikipedia.org/wiki/Dual-tone_multi-frequency_signaling

En los últimos años se ha visto la aparición de microordenadores muy baratos, pequeños y potentes. Arduino y Raspberry
Pi son solo 2 ejemplos. Si bien el hardware y el software asociados con estos sistemas pueden parecer abrumadores,
recomendaría probar algo basado en Arduino. Son mucho más simples que Raspberry Pi para programar.

El generador DTMF consta de 3 componentes principales.

1. Un teclado. Normalmente son una matriz de 4x3, emulando el teclado de un teléfono. También hay variantes 4x4
disponibles y hay tonos DTMF disponibles para el teclado 4x4.
2. Un microcontrolador. Se utiliza el Arduino UNO básico. Tiene entrada/salida más que suficiente
capacidad y poder de procesamiento.
3. Un pequeño altavoz para emitir los multitonos.

teclado

El teclado está dispuesto como una matriz, es decir, 12 teclas dispuestas en 4

filas y 3 columnas. Cada fila/columna está disponible en el conector de borde de 7
pines. No parece tener sentido el pinout: es lo que sea conveniente para el diseñador
de PCB. Presionar una tecla provocará un cortocircuito en la fila y la columna que se
cruzan. Para detectar una pulsación de tecla, todo lo que se requiere es escanear
cada combinación de fila/columna y detectar el cortocircuito.

Convenientemente, los pines IO en el Arduino se pueden configurar para que

sean ENTRADA o SALIDA. Y además, las ENTRADAS se pueden configurar
para que tengan una resistencia pullup interna. Esto significa que podemos manejar
las columnas como salidas y leer las filas con una entrada que normalmente es ALTA.
Esto se hace llevando cada columna a BAJO a su vez, y escaneando cada fila en
busca de una entrada que también sea BAJA. Si se encuentra uno, entonces se ha
presionado la tecla en la fila/columna de intersección.

Al igual que con cualquier sistema mecánico, existe la posibilidad de rebote de contacto, pero esto se elimina
fácilmente al requerir que la entrada de fila permanezca BAJA durante al menos 50 mS.

Microcontrolador (Arduino)

El microcontrolador ejecuta el código que realiza la función del generador DTMF. El lenguaje es "C". El código debe contener
2 módulos: "configuración", que se ejecuta una vez cuando se aplica energía, y
Machine Translated by Google

"bucle" que se ejecuta continuamente hasta que se corta la energía. El código es en su mayoría autodocumentado, pero algunos elementos

requieren una pequeña explicación adicional.

El Arduino tiene un generador de sonido, pero solo puede reproducir un sonido a la vez. Para ser un generador de DTMF, es

necesario reproducir 2 tonos simultáneamente. Los tonos requeridos son generados por dos temporizadores independientes. Cada

temporizador se ajusta a la mitad del período del tono requerido. Cuando expira cada temporizador, la salida de tono se invierte, generando

una onda cuadrada de la frecuencia requerida. Los dos tonos se mezclan mediante un par de resistencias de 240 ÿ. También se utiliza un

condensador de 4,7 mF para redondear las ondas cuadradas generadas.

El código fuente se muestra a continuación. Puedo enviártelo por correo electrónico si deseas construir este dispositivo.

Código Arduino (lo llaman boceto)

/* Codificador DTMF (generador de tono dual)

Creado por Marc Hillman, VK3OHM. 14-06-2017
Publicada en el dominio público.

CONFIGURACIÓN:

- Conecte una matriz de teclado de 4x3 (7 pines) o 4x4 (8 pines) entre D2-D9
- Conecte los pines 12 y 13 al terminal + del altavoz, cada uno a través de su propia resistencia de 240
ohmios
- Conectar un condensador de 4,7 uF entre los terminales + y - del
altavoz
- Conecte el altavoz GND a Arduino GND
*/
// Asignación de pines para columnas de teclado
#define Col1 4 // pin para Col 1
#define Col2 2 // pin para Col 2
#define Col3 6 // pin para Col 3
#define Col4 9 // pin para Col 4 (solo presente en teclado 4x4)
// Asignación de pines para filas de teclado
#define Row1 3 // pin para la fila 1
#define Row2 8 // pin para la fila 2
#define Row3 7 // pin para la fila 3
#define Row4 5 // pin para la fila 4
// asignaciones de pines para salidas de tono
#define tone1Pin 12 // pin para el tono 1
#define tone2Pin 13 // pin para el tono 2
#define NoKey 0xff // ninguna tecla presionada

const byte columnas[] = {Col1, Col2, Col3}; // lista de todas las columnas
const byte filas[] = {Fila1, Fila2, Fila3, Fila4}; // lista de todas las filas
const byte NumCols = tamaño de (columnas) / tamaño de (byte); // calcular el numero de columnas

const byte NumRows = tamaño de (filas) / tamaño de (byte); // calcular el numero de

filas

byte Última clave = Sin clave; // ultima tecla presionada

// frecuencias adoptadas de: https://en.wikipedia.org/wiki/Dual-tone_multi Frequency_signaling

int DTMF[][2] = {

{697, 1209}, // frecuencias para la clave 1

{770, 1209}, // frecuencias para la tecla 4
{852, 1209}, // frecuencias para la tecla 7
{941, 1209}, // frecuencias para clave *

{697, 1336}, // frecuencias para la clave 2

{770, 1336}, // frecuencias para la tecla 5
{852, 1336}, // frecuencias para la tecla 8
Machine Translated by Google

{941, 1336}, // frecuencias para la clave 0

{697, 1477}, // frecuencias para la tecla 3

{770, 1477}, // frecuencias para la tecla 6
{852, 1477}, // frecuencias para la tecla 9
{941, 1477}, // frecuencias para clave #

{697, 1633}, // frecuencias para la tecla A

{770, 1633}, // frecuencias para la tecla B
{852, 1633}, // frecuencias para la tecla C
{941, 1633}, // frecuencias para la tecla D
};

int LeerTeclado()
{
/*
Lee la primera tecla presionada. Si no se presiona ninguna tecla, devuelve 0xff

El teclado está cableado para que D2-D5 se pueda usar para conducir
columnas (Col1-Col4),
mientras que cualquier tecla presionada se puede leer en la fila (Row1-Row4) en D6-D9.

El valor devuelto será (columna-1) * 4 + (fila-1), es decir, un número 0-

15.

La siguiente tabla muestra el diseño del teclado, con el valor devuelto entre paréntesis.

+--------------+---------+---------+---------+-------- +
| | columna 1 | columna 2 | columna 3 | columna 4 |
+--------------+---------+---------+---------+-------- +
| Fila 1 | 1 (0) | 2 (4) | 3 (8) | (12) |
+--------------+---------+---------+---------+-------- +
| Fila 2 | 4 (1) | 5 (5) | 6 (9) | segundo (13) |
+--------------+---------+---------+---------+-------- +
| Fila 3 | 7 (2) | 8 (6) | 9 (10) | C (14) |
+--------------+---------+---------+---------+-------- +
| Fila 4 | * (3) | 0 (7) | # (11) | D (15) |
+--------------+---------+---------+---------+-------- +
*/
resultado de byte = NoKey; // ninguna tecla presionada
for (int c = 0; c < NumCols; c++) digitalWrite(columnas[c], ALTA); // establecer
todas las columnas ALTO
for (int c = 0; c < NumCols; c++) { // escanear cada columna
digitalWrite(columnas[c], BAJO); // establece la columna BAJA
for (int r = 0; r < NumRows; r++) { // escanear cada fila para LOW en cualquier fila
si (lectura digital (filas [r]) == BAJO) {
retraso (50); // en caso de rebote
si (lectura digital (filas [r]) == BAJO) devuelve c * 4 + r;
}
}
digitalWrite(columnas[c], ALTO);
}
resultado devuelto;
}

configuración vacía ()
{
// inicializa los lectores de filas
for (int i = 0; i <NumRows; i++) pinMode(rows[i], INPUT_PULLUP); // Establecer
controladores de fila a ENTRADA

// inicializa los controladores de columna

Machine Translated by Google

for (int i = 0; i < NumCols; i++) {

pinMode(columnas[i], SALIDA); // Establecer controladores de columna en SALIDA
digitalWrite(columnas[i], ALTO);
}
pinMode(tono1Pin, SALIDA); // Salida para Tono 1
pinMode(tone2Pin, SALIDA); // Salida para Tono 2
Serial.begin(9600); // Establecer la velocidad del puerto serie
}

bucle vacío ()
{
clave de bytes = ReadKeyPad(); // lee cualquier tecla que se presione
if (tecla != ÚltimaTecla) cambiar // la clave ha cambiado
(tecla) {
caso NoKey: romper; defecto: // Nada que hacer
// reproducir tonos
Serial.print("Presionado"); Serial.println(clave); // Solo depurar
reproducirDTMF(tecla, 500);
descanso;
}
ÚltimaClave = clave; // recuerda la ultima tecla presionada
}

void playDTMF (dígito de byte, larga duración sin firmar) {

// Reproducir el dígito DTMF durante milisegundos de duración
retraso de tono 1 largo sin firmar = (500000 / DTMF [dígito] [0]) - 10; // calcula el retraso (en microsegundos) para el tono 1 (la mitad
del período de un ciclo). 10 es un factor de elusión para aumentar la frecuencia debido a la lentitud del tiempo.

tone2delay largo sin firmar = (500000 / DTMF[dígito][1]) - 10; // calcular el retraso (en microsegundos) para el tono 2 (la mitad del
período de un ciclo). 10 es un factor de elusión para aumentar la frecuencia debido a la lentitud del tiempo.

unsigned long tone1timer = micros();

unsigned long tone2timer = micros();
temporizador largo sin firmar = millis(); // para la duración del tiempo de un solo tono

while (milis() - temporizador < duración) {

if (micros() - temporizador de tono1 > retraso de tono1) {
tono1temporizador = micros(); // restablecer el temporizador
si (lectura digital (tono1Pin) == ALTO) digitalWrite (tono1Pin, BAJO); más
digitalWrite(tono1Pin, ALTO); // alternar salida de tono
}
if (micros() - tone2timer > tone2delay) {
tono2timer = micros(); // restablecer el temporizador
si (lectura digital (tono2Pin) == ALTO) digitalWrite (tono2Pin, BAJO); más digitalWrite(tono2Pin, ALTO); // alternar salida de
tono
}
}
digitalWrite(tono1Pin, BAJO);
escritura digital (tono 2 pines, BAJO);
}

Construcción
El Arduino tiene una serie de encabezados en cada lado. Estos están diseñados para acomodar tableros de
complementos llamados "escudos". Para obtener un resultado agradable, si solo está conectando componentes
discretos, se recomienda usar cables de puente de enchufe a enchufe, generalmente con un extremo retirado.

En el extremo izquierdo, notará que las primeras 2 posiciones de encabezado (0 y 1) no se utilizan. Estos están
reservados para E/S en serie. Aunque no los usamos en este proyecto, se usan con fines de depuración, por lo que es
mejor evitarlos.

Usando 7 cables de puente, haga un cable de interfaz al teclado. Los extremos de Arduino se pueden pegar juntos
para hacer un solo enchufe. Los extremos del teclado están soldados. Enchufe los 7 cables en los pines 2 a 8.
Machine Translated by Google

Cortando dos de los extremos del enchufe de corte, inserte una resistencia de 240 ÿ en ambos y tuerza los extremos
voladores para unirlos. Use un tercer puente para hacer un cable de tierra. Suelde un condensador de 4,7 mF a través del
altavoz (-ve a tierra) y conecte el altavoz a las resistencias/GND usando los pines 11, 12 y 13.

Cargar el software en el Arduino es la simplicidad misma. Descargue el IDE de Arduino desde https://
www.arduino.cc/en/main/software. Hay versiones para Windows, Mac y Linux. Instale, conecte el cable USB y luego cargue
el boceto anterior. El boceto ahora está cargado 'permanentemente' en el tablero. Todo lo que necesita hacer es aplicar
energía a la placa y tendrá un generador DTMF en funcionamiento.

Para que se vea bonito, puedes ponerlo en una caja de proyecto. Me pondré en eso algún día ÿ
Machine Translated by Google

Pruebas

Hay una aplicación de teléfono inteligente "Decodificador DMF". Reproduzca el generador en su teléfono inteligente y verifique que las teclas

generen los tonos correctos.

Lista de partes

Artículo N.º de pieza de Jaycar

Matriz de teclado 4x3 LF-1290

Duinotech UNO r3 XC-4410

Duinotech Cables de puente de enchufe a enchufe de 150 mm WC-6024

2 resistencias de 240 ÿ RR-0557

Altavoz de condensador RY-6806

de 4,7 mF
Cable USB B WC-7700

Nota posterior a la compilación: alguien me ha señalado que hay una aplicación gratuita para teléfonos inteligentes que hace lo mismo. Sí, lo hay,

pero fue divertido construirlo de todos modos.

marc hillman

VK3OHM/VK3IP
junio 2017