Chaveador Automático para Radiodireção – Precisão, Facilidade e Confiabilidade

Componentes e Materiais

Ferramentas e Máquinas Necessárias

• Ferro de solda (genérico)
• Fio de solda, sem chumbo
• Rádio Amador

Sobre o Projeto

Entusiastas de radioamadorismo frequentemente mantêm suas habilidades de radiodireção afiadas praticando a localização de um rádio escondido em local distante (chamado de "raposa"). Essas habilidades são úteis para encontrar equipamentos e pessoas com transmissores de rádio que precisam ser localizados.

Este projeto utiliza um Arduino para acionar o rádio para transmitir e, em seguida, envia o ID da estação (o indicativo do operador de rádio amador) em código Morse. Um tom longo é então transmitido. Durante a transmissão, a localização do sinal de rádio pode ser identificada com precisão.

Participei da minha primeira "caça à raposa" usando radiodireção no Instituto de Professores da ARRL em 2011 e adorei a experiência (mesmo que nossa equipe tenha encontrado acidentalmente a "raposa" errada). Pareceu uma ótima atividade para os alunos do ensino médio que leciono em minhas aulas de ciências. Infelizmente, construir um parecia excessivamente complicado ou custava mais do que eu estava disposto a gastar.

Recentemente, percebi que com um rádio barato de 2 metros e um microprocessador programável (como o Arduino), eu poderia construir minha própria "raposa" por um custo muito baixo, criando um divertido projeto de aprendizado para o verão.

Para este projeto, utilizei um rádio Baofeng UV-3R, pois é barato (e eu não o usava mais), e um Arduino Uno. Assumo que usar um rádio diferente com um conector distinto exigiria passos semelhantes para testar o conector e o microfone, mas o circuito e o sketch do Arduino seriam os mesmos, exceto pelo indicativo do operador.

Nota: O esquema é menos complicado do que parece. Os capacitores de 0,01 microfarad foram adicionados para evitar que o circuito captasse RFI (interferência de radiofrequência) durante a transmissão. Sem eles, o Arduino comportava-se de forma incomum e inconsistente (frequentemente reiniciava) quando o rádio transmitia tão próximo ao circuito. O outro capacitor serve para suavizar a onda quadrada do Arduino e transformá-la em uma onda senoidal, melhorando a qualidade do áudio.

Código

Chaveador de Rádio para Caça à Raposa

O Arduino que aciona o rádio para transmitir e envia o código Morse para se identificar.

/* Por Nelson Farrier - Aciona rádio e envia tom
 * Aciona rádio Baofeng UV-3R ligando e desligando o relé,
 * depois envia o indicativo e um tom de 5 segundos.
 */
// Pino 12 conectado a um relé.
// Pino 13 conectado a um circuito de tom.
// Modificado de: Mike Myers (https://mikemyers.me) @netnutmike
// Let's Make It Episódio 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)

// Define o código Morse para o alfabeto e 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
};

int rele = 12;
int pinoTom = 13;
int frequencia = 1000; // frequência do tom
int atrasoPonto = 70;  // duração do ponto no código Morse, também o tempo entre pontos e traços
int atrasoChar = 500;  // duração da espera entre letras (método Farnsworth)
int atrasoPalavra = 1100; // duração da espera entre palavras (método Farnsworth)
int atrasoCiclo = 15000; // METADE da duração porque o maior valor é 16383

void setup() {
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);
  delay(2000); // atraso inicial após ligar
}

void loop() {
  digitalWrite(rele, HIGH); // liga o relé
  delay(1000);
  EnviaTexto("NF7Z RAPOSA");
  delay(1000);
  tone(pinoTom, frequencia); // envia tom de 7 seg
  delay(7000);
  noTone(pinoTom);
  delay(10000); // 10 segundos transmitindo sem tom
  digitalWrite(rele, LOW); // desliga o relé
  delay(atrasoCiclo);
  delay(atrasoCiclo);
}

//=================================================================
// Função: sequenciaCodigoMorse
// Entrada: Array de caracteres com pontos e traços a serem enviados
// Descrição: Percorre o array chamando pontoOuTraco para cada elemento.
// No final, há um atraso de 3 vezes a duração do ponto.
//=================================================================
void sequenciaCodigoMorse(char* sequencia) {
  int i = 0;
  while (sequencia[i] != NULL) {
    pontoOuTraco(sequencia[i]);
    i++;
  }
  delay(atrasoChar); // intervalo entre letras
}

//=================================================================
// Função: EnviaTexto
// Entrada: Array de caracteres com texto em inglês
// Descrição: Envia código Morse para cada letra. Pausa após cada letra.
//=================================================================
void EnviaTexto(char* TextoCodigoMorse) {
  int i = 0;
  char ch;
  while (TextoCodigoMorse[i] != NULL) {
    ch = TextoCodigoMorse[i];
    if (ch >= 'a' && ch <= 'z') { // letra minúscula?
      sequenciaCodigoMorse(letras[ch - 'a']);
    } else if (ch >= 'A' && ch <= 'Z') { // Letra maiúscula
      sequenciaCodigoMorse(letras[ch - 'A']);
    } else if (ch >= '0' && ch <= '9') { // Número
      sequenciaCodigoMorse(numeros[ch - '0']);
    } else if (ch == ' ') { // Espaço (espera 4 vezes atrasoPonto)
      delay(atrasoPalavra);
    }
    i++;
  }
  delay(atrasoChar); // intervalo entre letras
}

//=================================================================
// Função: pontoOuTraco
// Entrada: Caractere que deve ser ponto ou traço
// Descrição: Liga a saída, verifica se é "." (atrasoPonto) ou "-" (3x atrasoPonto).
// Desliga o tom e aguarda um atrasoPonto para separar.
//=================================================================
void pontoOuTraco(char pontoOuTraco) {
  tone(pinoTom, frequencia);
  if (pontoOuTraco == '.') {
    delay(atrasoPonto);
  } else { // deve ser um traço
    delay(atrasoPonto * 3);
  }
  noTone(pinoTom);
  delay(atrasoPonto); // intervalo entre sinais
}

Esquemático