Teclador Automático para Radiogoniometría: Precisión, Facilidad y Fiabilidad

Componentes y suministros

Herramientas y máquinas necesarias

• Soldador (genérico)
• Estaño sin plomo
• Radioaficionado

Sobre este proyecto

Los entusiastas de la radioafición suelen mantener agudas sus habilidades de radiogoniometría practicando la localización de una radio oculta a distancia (llamada "zorro"). Estas habilidades son útiles para encontrar equipos y personas con un transmisor de radio que necesitan ser localizados.

Este proyecto utiliza un Arduino para activar la transmisión de la radio y enviar el indicativo de la estación (el distintivo del operador de radioaficionado) en código Morse. A continuación, se emite un tono largo. Mientras se transmite, se puede localizar la señal de radio.

Mi primera "caza del zorro" usando radiogoniometría fue en el Instituto de Profesores de la ARRL de 2011 y me encantó (aunque nuestro equipo encontró accidentalmente el "zorro" equivocado). Parecía una gran actividad para los estudiantes de secundaria a los que enseño en mis clases de ciencias. Desafortunadamente, construir uno parecía demasiado complicado o costaba más de lo que estaba dispuesto a gastar.

Recientemente me di cuenta de que con una radio económica de 2 metros y un microprocesador programable (como Arduino), podía hacer mi propio "zorro" a muy bajo costo y tener un divertido proyecto de aprendizaje para el verano.

Para este proyecto utilicé una radio Baofeng UV-3R, ya que es económica (y ya no la usaba), y un Arduino Uno. Asumo que usar una radio diferente con un conector distinto requeriría pasos similares para probar el conector y el micrófono, pero el circuito y el sketch de Arduino serían los mismos, salvo por el indicativo del operador.

Nota: El esquemático es menos complicado de lo que parece. Los condensadores de 0.01 microfaradios se añadieron para evitar que el circuito captara interferencias de radiofrecuencia (RFI) al transmitir. Sin ellos, el Arduino se comportaba de forma extraña e inconsistente (a menudo se reiniciaba) cuando la radio transmitía tan cerca del circuito. El otro condensador sirve para suavizar la onda cuadrada del Arduino y convertirla en una onda sinusoidal para que suene mejor.

Código

Teclador para Caza del Zorro

El Arduino que activa la radio para transmitir y envía el código Morse para identificarse.

/*Por Nelson Farrier. Activa la radio y envía tono. 
Activa la radio Baofeng UV-3R encendiendo y apagando el relé, 
luego se identifica y envía un tono de 5 segundos. */

// Pin 12 conectado a un relé.
// Pin 13 conectado a un circuito de tono.
// Modificado de: Mike Myers (https://mikemyers.me) @netnutmike
// Let's Make It Episodio 6 (https://tech-zen.tv/index.php/shows/let-s-make-it/episodes/59-sensor-fun-with-arduino-1-massive-failure-but-4-successes-let-s-make-it-episode-6)

// Definir el código Morse para el alfabeto y números
char* letras[] = {
  ".-",   // A
  "-...", // B
  "-.-.", // C
  "-..",  // D
  ".",    // E
  "..-.", // F
  "--.",  // G
  "....", // H
  "..",   // I
  ".---", // J
  "-.-",  // K
  ".-..", // L
  "--",   // M
  "-.",   // N
  "---",  // O
  ".--.", // P
  "--.-", // Q
  ".-.",  // R
  "...",  // S
  "-",    // T
  "..-",  // U
  "...-", // V
  ".--",  // W
  "-..-", // X
  "-.--", // Y
  "--.."  // Z
};

char* numeros[] = {
  "-----", // 0
  ".----", // 1
  "..---", // 2
  "...--", // 3
  "....-", // 4
  ".....", // 5
  "-....", // 6
  "--...", // 7
  "---..", // 8
  "----."  // 9
}; // --- fin del primer segmento de código prestado de Mike Myers

int rele = 12;
int pinTono = 13;
int frecuencia = 1000; // frecuencia del tono
int retrasoPunto = 70;  // duración del punto en código Morse, también el tiempo entre puntos y rayas
int retrasoCaracter = 500; // duración de la espera entre letras para método Farnsworth
int retrasoPalabra = 1100; // duración de la espera entre palabras para método Farnsworth
int retrasoCiclo = 15000; // LA MITAD de la duración porque el valor mayor es 16383

void setup() {
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);
  delay(2000); // retraso inicial tras encender
}

void loop() {
  digitalWrite(rele, HIGH); // activa el relé (HIGH es el nivel de voltaje)
  delay(1000);              // espera un segundo
  EnviarTexto("NF7Z ZORRO");
  delay(1000);              // espera un segundo
  tone(pinTono, frecuencia); // envía tono de 7 seg
  delay(7000);
  noTone(pinTono);
  delay(10000);             // 10 segundos transmitiendo sin tono
  digitalWrite(rele, LOW);  // desactiva el relé poniendo voltaje LOW
  delay(retrasoCiclo);      // espera tiempo de ciclo
  delay(retrasoCiclo);      // espera tiempo de ciclo
}

//=================================================================
// Función: secuenciaCodigoMorse
// Entrada: Array de caracteres de Puntos y Rayas a enviar
// Descripción: Toma como entrada un array de "." y "-" y llama a puntoORaya para cada elemento.
// Al final de la secuencia, hay un retraso de 3 veces la duración del punto.
//=================================================================
void secuenciaCodigoMorse(char* secuencia) {
  int i = 0;
  while (secuencia[i] != NULL) {
    puntoORaya(secuencia[i]); // Envía el punto o raya
    i++;
  }
  delay(retrasoCaracter); // espacio entre letras
}

//=================================================================
// Función: EnviarTexto
// Entrada: Array de caracteres de texto en inglés
// Descripción: Toma texto como entrada y envía código Morse para cada letra.
// Luego hay una pausa después de cada letra.
//=================================================================
void EnviarTexto(char* LetrasCodigoMorse) {
  int i = 0;
  char ch;
  while (LetrasCodigoMorse[i] != NULL) {
    ch = LetrasCodigoMorse[i];
    // ¿Es letra minúscula?
    if (ch >= 'a' && ch <= 'z') {
      secuenciaCodigoMorse(letras[ch - 'a']);
    } else if (ch >= 'A' && ch <= 'Z') // Letra mayúscula
      secuenciaCodigoMorse(letras[ch - 'A']);
    else if (ch >= '0' && ch <= '9') // Número
      secuenciaCodigoMorse(numeros[ch - '0']);
    else if (ch == ' ') // Espacio (espera 4 veces retrasoPunto)
      delay(retrasoPalabra); // espacio entre palabras
    i++;
  }
  delay(retrasoCaracter); // espacio entre letras
}

//=================================================================
// Función: puntoORaya
// Modificado de: Mike Myers (https://mikemyers.me) @netnutmike
// Entrada: Carácter que debe ser punto o raya
// Descripción: Enciende la salida, luego verifica si el carácter es "." 
// y si es así, retrasa retrasoPunto. Si no es ".", asume que es "-" 
// y mantiene la salida alta 3 veces la longitud de retrasoPunto.
// Después del tiempo de retardo, el pin se pone en bajo apagando el tono.
// Luego retrasa un tiempo retrasoPunto para que puntos y rayas no se junten.
//=================================================================
void puntoORaya(char puntoORaya) {
  tone(pinTono, frecuencia);
  if (puntoORaya == '.') {
    delay(retrasoPunto);
  } else // debe ser un -
    delay(retrasoPunto * 3);
  noTone(pinTono);
  delay(retrasoPunto); // espacio entre destellos
}

Esquemáticos