Monitor serie Arduino
Este proyecto de Baliza Morse Arduino, si bien es útil, no es más que un trivial generador de código Morse que entrega el mensaje de baliza predefinido a través de la salida D13 del Arduino. El siguiente sketch (con una función de tabla Morse) es en realidad una adaptación de un trabajo de código abierto realizado por el radioaficionado Mark VandeWettering (K6HX). Simplemente pone un estado lógico alto (H) en la salida D13 siempre que el (supuesto) manipulador morse (“keyer”) se pulsa (cuando se transmite un punto o una raya), y un estado lógico bajo (L) cuando es liberado.
A continuación, el código software (o “sketch”) para esta baliza (descargable aquí).
/*
An Arduino Morse Beacon
Adaptation of a work by Mark VandeWettering K6HX
Prepared for www.electroschematics.com
Authored & Tested by T.K.Hareendran
*/
/////////////// Simple Arduino CW Beacon /////////////////
//
// Written by Mark VandeWettering K6HX
//
//////// CW section ////////
struct t_mtab { char c, pat; } ;
struct t_mtab morsetab[ ] = {
{'.', 106},
{',', 115},
{'?', 76},
{'/', 41},
{'A', 6},
{'B', 17},
{'C', 21},
{'D', 9},
{'E', 2},
{'F', 20},
{'G', 11},
{'H', 16},
{'I', 4},
{'J', 30},
{'K', 13},
{'L', 18},
{'M', 7},
{'N', 5},
{'O', 15},
{'P', 22},
{'Q', 27},
{'R', 10},
{'S', 8},
{'T', 3},
{'U', 12},
{'V', 24},
{'W', 14},
{'X', 25},
{'Y', 29},
{'Z', 19},
{'1', 62},
{'2', 60},
{'3', 56},
{'4', 48},
{'5', 32},
{'6', 33},
{'7', 35},
{'8', 39},
{'9', 47},
{'0', 63}
} ;
#define N_MORSE (sizeof(morsetab)/sizeof(morsetab[0]))
#define SPEED (12)
#define DOTLEN (1200/SPEED)
#define DASHLEN (3.5*(1200/SPEED))
////////////// ARDUINO PINS CONFIGURATION ////////////////
int SIGpin = 13 ; // Pin for Keyer
//////////////// CW GENERATION ROUTINES //////////////////
void dash() {
digitalWrite(SIGpin, HIGH) ;
delay(DASHLEN);
digitalWrite(SIGpin, LOW) ;
delay(DOTLEN) ;
}
////////////////////////////
void dit() {
digitalWrite(SIGpin, HIGH) ;
delay(DOTLEN);
digitalWrite(SIGpin, LOW) ;
delay(DOTLEN);
}
/////////////////////////////
void send(char c) {
int i ;
if (c == ' ') {
Serial.print(c) ;
delay(7*DOTLEN) ;
return ;
}
for (i=0; i<N_MORSE; i++) {
if (morsetab[i].c == c) {
unsigned char p = morsetab[i].pat ;
Serial.print(morsetab[i].c) ;
while (p != 1) {
if (p & 1)
dash() ;
else
dit() ;
p = p / 2 ;
}
delay(2*DOTLEN) ;
return ;
}
}
/* if we drop off the end, then we send a space */
Serial.print("?") ;
}
/////////////////////////////
void sendmsg(char *str) {
while (*str)
send(*str++) ;
Serial.println("");
}
////////////////////// S E T U P //////////////////////////
void setup() {
pinMode(SIGpin, OUTPUT) ; // Signal Output Pin
Serial.begin(9600) ;
Serial.println("An Arduino Morse Beacon") ;
Serial.println("www.electroschematics.com") ;
Serial.println("") ;
}
////////////////////// L O O P ////////////////////////////
void loop() {
sendmsg("ESCOM BEACON") ; // Custom Message (in capital letters)
delay(5000) ; // Delay in miliseconds
}
NOTAS:
CW_SPEED : Velocidad de transmisión morse (en palabras por minuto)
DOTLEN : Longitud de los puntos (dots)
DASHLEN : Longitud de las rayas (dash) : 3,5 veces la de un punto
Custom Message : Mensaje a transmitir (poner en letras mayúsculas)
delay(n) : Pausa (en milisegundos) antes de una nueva transmisión
Si tiene conectada la placa Arduino al PC con la IDE Arduino en funcionamiento, en el monitor serie de la IDE podrá comprobar el funcionamiento de la baliza:
Si usted es un radioaficionado, es fácil interconectar la salida de señal de baliza con su equipo de radio (a través de un sencillo circuito de conmutación) para manipular el equipo en el modo CW (Telegrafía). También se incluye aquí el esquema del hardware de conmutación complementario (circuito comprobado por mí).
Conectando la baliza Morse Arduino (izquierda) a un equipo transmisor de radio (derecha)
El circuito conmutador-manipulador morse es sólo un pequeño relé de láminas (relé Reed, RL1) accionado por un transistor NPN ordinario (T1) que actúa con los impulsos de entrada recibidos de la salida D13 del Arduino. Puesto que se utiliza un relé electromagnético aislado, este diseño básico puede ser usado para la operación de CW con casi todos los transmisores de CW (de alta tensión o de baja tensión). Sólo tiene que conectar los contactos de relé (CW_SW) a los terminales de entrada de conexión del manipulador Morse ("key") existente en su transmisor, como se muestra en el esquema de cableado.
Por T.K. Hareendran (India),
publicado en Electro Schematics
01-06-2016
(Original: Build Your Own Radio Beacons)
La anterior baliza morse simplemente se comporta como un manipulador o llave telegráfica (Keyer), que ha de ser conectada (con un circuito adaptador) a una toma específica para llave telegráfica del transmisor de radio, si éste dispone de tal entrada. No todos los transceptores de radio disponen de una toma para llave telegráfica, como por ejemplo, la mayoría de los transceptores para CB (Banda Ciudadana).
Con muy pocas líneas más de código, se consigue habilitar la placa Arduino como una baliza Morse más versátil, y en este caso, ha sido habilitada para que tambien transmita simultáneamente las señales morse como tono de audio (que pueden ser aplicadas a la entrada de micrófono de un transceptor de radio) y además envié una señal de activación del PTT (control transmisión-recepción) del transceptor. El sketch modificado se muestra a continuación, y lo puede descargar aquí.
/*
An Arduino Morse Beacon
Adaptation of a work by Mark VandeWettering
Prepared for www.electroschematics.com
Authored & Tested by T.K.Hareendran
Modified: Fernando Fernandez de Villegas (EB3EMD)
*/
/////////////// Simple Arduino CW Beacon /////////////////
//
// Written by Mark VandeWettering K6HX
//
//////// CW section ////////
struct t_mtab { char c, pat; } ;
struct t_mtab morsetab[ ] = {
{'.', 106},
{',', 115},
{'?', 76},
{'/', 41},
{'A', 6},
{'B', 17},
{'C', 21},
{'D', 9},
{'E', 2},
{'F', 20},
{'G', 11},
{'H', 16},
{'I', 4},
{'J', 30},
{'K', 13},
{'L', 18},
{'M', 7},
{'N', 5},
{'O', 15},
{'P', 22},
{'Q', 27},
{'R', 10},
{'S', 8},
{'T', 3},
{'U', 12},
{'V', 24},
{'W', 14},
{'X', 25},
{'Y', 29},
{'Z', 19},
{'1', 62},
{'2', 60},
{'3', 56},
{'4', 48},
{'5', 32},
{'6', 33},
{'7', 35},
{'8', 39},
{'9', 47},
{'0', 63}
} ;
#define N_MORSE (sizeof(morsetab)/sizeof(morsetab[0]))
#define SPEED (7)
#define DOTLEN (1200/SPEED)
#define DASHLEN (3*(1200/SPEED))
////////////// ARDUINO PINS CONFIGURATION ////////////////
int SIGkey = 13 ; // Keyer
int SIGptt = 12 ; // PTT control
int SIGtone = 11 ; // CW Tone
int freq = 1200 ; // Tone Frequency
//////////////// CW GENERATION ROUTINES //////////////////
void dash() {
digitalWrite(SIGkey, HIGH) ;
tone(SIGtone, freq);
delay(DASHLEN);
digitalWrite(SIGkey, LOW) ;
noTone (SIGtone);
delay(DOTLEN) ;
}
////////////////////////////
void dit() {
digitalWrite(SIGkey, HIGH) ;
tone(SIGtone, freq);
delay(DOTLEN);
digitalWrite(SIGkey, LOW) ;
noTone (SIGtone);
delay(DOTLEN);
}
////////////////////////////
void send(char c) {
int i ;
if (c == ' ') {
Serial.print(c) ;
delay(7*DOTLEN) ;
return ;
}
for (i=0; i<N_MORSE; i++) {
if (morsetab[i].c == c) {
unsigned char p = morsetab[i].pat ;
Serial.print(morsetab[i].c) ;
while (p != 1) {
if (p & 1)
dash() ;
else
dit() ;
p = p / 2 ;
}
delay(2*DOTLEN) ;
return ;
}
}
/* if we drop off the end, then we send a space */
Serial.print("?") ;
}
////////////////////////////
void sendmsg(char *str) {
while (*str)
send(*str++) ;
Serial.println("");
}
////////////////////// S E T U P //////////////////////////
void setup() {
pinMode(SIGkey, OUTPUT) ; // Signal Output CW Pin
pinMode(SIGptt, OUTPUT) ; // Signal control PTT Pin
Serial.begin(9600) ;
Serial.println("An Arduino Morse Beacon") ;
Serial.println("") ;
}
////////////////////// L O O P ////////////////////////////
void loop() {
delay (1500); // Not inmediate transmission after a power-on or reset
digitalWrite(SIGptt, HIGH); // PTT ON
delay (150);
for (int j = 0; j < 4; j++){ // Send advertiment for CW Tone transmision
tone(SIGtone, 1200);
delay (150);
tone(SIGtone, 1000);
delay (150);
}
noTone (SIGtone);
delay (700);
sendmsg("ESCOM BEACON") ; // Custom Message, in capital letters (Send Message)
digitalWrite(SIGptt, LOW); // PTT OFF
digitalWrite(SIGkey, LOW); // Ensure Keyer OFF
delay(212000) ; // Delay in miliseconds
}
Se mantiene la línea digital D13 de Arduino como salida de “keyer” o manipulador telegráfico, y se habilitan las salidas D12 y D11 respectivamente como control de PTT (por nivel alto) y salida de tonos telegráficos (CW Tone). En el sketch se puede establecer la frecuencia del tono telegráfico (Tone Frequency), aquí ha sido fijada a 1200 Hz.
Si usa la baliza en la modalidad manipulador telegráfico, se usará únicamente la salida D13 (Keyer) y se conectará al transmisor de radio tal como se indicó en la versión anterior de la baliza.
Si usa la baliza en la modalidad PTT + Tonos telegráficos, puede conectar la baliza Arduino al transceptor de radio a través de un circuito adaptador adecuado. En mis pruebas la he conectado a un transceptor de Banda Ciudadana (CB) empleando el interface descrito más adelante.
El mensaje grabado en el squetch (ESCOM BEACON) puede cambiarlo por cualquier otro, siempre escrito con letras mayúsculas. El mensaje es enviado periódicamente cada 4 minutos aproximadamente (240000 milisegundos), si bien en la instrucción delay(n) (en la sección LOOP) deberá especificar un valor algo menor para tener en cuenta el tiempo que tarda la baliza en transmitir el mensaje (en el sketch se ha fijado a 212000 milisegundos, esto es, 3 minutos y 32 segundos, asumiendo que el mensaje grabado tarda los 28 segundos restantes en ser transmitido, para una periodicidad de la baliza de 4 minutos).
Se ha incluido en el sketch la generación de un “preámbulo” o aviso de inicio de transmisión que genera una señal bitonal alternante (1200/1000 Hz) de algo más de un segundo, que es transmitida antes del mensaje morse de la baliza, y cuya función es alertar a posibles oyentes de esta transmisión (y puedan prestar atención al mensaje morse transmitido para poder decodificarlo). Esta alerta no tiene ningún efecto en el modo Keyer de la baliza.
Por supuesto, desde la IDE Arduino se pueden cambiar los parámetros de funcionamiento de la baliza (mensaje morse a transmitir, velocidad de transmisión morse, tiempo de repetición de la baliza, frecuencia del tono telegráfico, etc...), según las necesidades de cada uno.
El siguiente esquema muestra un ejemplo de interfaz para conectar esta baliza a un transmisor de radio, en este caso a un transceptor de CB (Banda Ciudadana) clásico, o con pequeñas modificaciones, a cualquier otro tipo de transceptor, por ejemplo de radioaficionado:
 |
| Circuito adaptador para la baliza a un transceptor clásico de CB. El juego de contactos del relé aquí representado emula los contactos del pulsador o conmutador PTT de un transceptor de CB clásico. (Clic en la imagen para ampliarla). |
Este interface está constituido por dos partes, una destinada a tratar la señal de audio que genera la baliza, y otra para el control del PTT (control de transmisión-recepción) del transceptor.
Muchas balizas construidas por aficionados suelen generar un tono de audio con algún tipo de oscilador realizado con algún circuito integrado digital de tecnología TTL (series 74xx) o CMOS (series 40xx) o con el clásico y omnipresente chip temporizador 555, y en nuestro caso, con la placa Arduino. Las señales generadas son de muy alto valor, de varios voltios de amplitud, y deben ser notablemente reducidas de nivel antes de aplicarlas a la entrada de micrófono del transceptor de radio, ya que la entrada de micrófono admite señales de sólo unas decenas de milivoltios para una correcta modulación. Señales más altas en la entrada de micrófono causarán sobremodulaciones y fuertes distorsiones de la señal, y además puede provocar emisiones parásitas (“espúreas”) en canales de radio vecinos.
Además, la forma de onda de la señal de audio que generan estas balizas dista bastante de ser “armónica pura” (o senoidal), son formas de onda cuadradas, que además de la frecuencia del tono generado, va cargada de frecuencias armónicas, que aumentan el ancho da banda de las transmisiones (causando espúreas en canales vecinos), y que hace que el tono generado sea “chirriante”, por lo que se debe reducir la presencia de estas frecuencias armónicas (muchos transceptores de CB ya lo hacen por sí mismos, al incluir algún filtro paso-bajo para las señales de micrófono).
La señal de audio generada por la baliza la conectaremos a la “Entrada de señal de la baliza” de este adaptador. La red R1-R2-R3-C1-C2-C3 realiza el “suavizado” de la forma de onda de la señal, ya que es un filtro paso-bajo con una frecuencia de corte en torno a 3 kHz. Este “suavizado” de la forma de la onda de la señal de audio elimina en gran parte las indeseadas frecuencias armónicas.
R4 y P1 (potenciómetro ajustable) regulan el nivel de salida de la señal de baliza que se aplicará a la entrada de micrófono del transceptor CB. Es decir, reducen el nivel de la señal de la baliza de varios voltios de amplitud a un nivel de varios milivoltios, que es lo que requiere la entrada de micrófono del tranceptor.
R5 proporciona una impedancia de carga mínima a la entrada de micrófono del transceptor y C5 (1 nF cerámico) elimina la presencia de RF en la entrada de micrófono durante la transmisión. Con ello, a la salida de C5 ya tenemos la señal de audio de la baliza convenientemente filtrada de armónicos y regulada de nivel.
El ajuste del nivel de señal de la baliza se realiza mediante el potenciómetro ajustable P1, regulándolo de manera que la señal de la baliza no sobremodule la portadora de radio cuando la baliza active la transmisión, ni que se causa importantes interferencias en canales vecinos. El valor de la resistencia R4 puede ser necesario ser ajustado a un valor adecuado para conseguir un rango de ajuste de P1 más cómodo.
Con el valor de R4 indicado (10 K), el nivel de señal de la baliza en la salida del circuito ya es del orden de milivoltios (ello para una impedancia de carga de unos 500-600 ohmios para la toma de señal de micrófono del transceptor de CB). No obstante, debido a la distinta sensibilidad e impedancia de la entrada de micrófono de los diversos transceptores de CB, la señal proporcionada por la baliza podría ser en algún caso insuficiente para modular suficientemente la portadora de radio en transmisión (con P1 regulado al máximo), por lo que se ha dispuesto el jumper JP2 para cortocircuitar R4 para aumentar el nivel de salida de la señal de baliza, si así fuera requerido por el transceptor de CB.
En cuanto al control de PTT (transmisión-recepción), si la baliza transmite junto con el tono que genera una señal de control de PTT (como es en nuestro caso), esta señal la conectaremos a la toma “Control PTT” de este circuito adaptador. El control de PTT de este adaptador puede ser configurado mediante el jumper JP1 para que se active la transmisión por una señal de control de nivel alto (conectar el jumper JP1 en la posición HI) o por nivel bajo (conectar JP1 en la posición LO). Para nuestra baliza Arduino, la señal de control de PTT es por nivel alto, por lo que conectaremos el jumper en la posición HI.
Este control lo que hace es gobernar un relé a través del transistor TR1, relé que a través de sus contactos maneja los cambio emisión-recepción del transceptor de CB. Un segundo transistor, TR2, se ha introducido en este circuito para permitir el control del PTT por señal de control de nivel bajo. TR2, R7 y R8 pueden ser eliminados si vamos a trabajar este circuito sólo con la baliza Arduino.
El transistor TR1 de control del relé puede ser cualquier transistor bipolar NPN de baja señal y unos 500 mW de potencia mínima, en el ejemplo se ha elegido un 2N2222. Similarmente para el transistor TR2, aunque en este caso es un transistor bipolar PNP, y en este ejemplo se ha elegido el BC557. En cualquier caso, puede probar con otros transistores.
Las resistencias de polarización R7 y R9 garantizan que los dos transistores quedan en corte (no conducción) cuando no hay señal de control de PTT a la entrada de este circuito, y no queden en un estado “indeterminado”.
El relé empleado es un relé de bobina para 12 voltios si el adaptador lo alimentamos con los mismos 12 voltios con que funciona el transceptor de radio que utilicemos. El juego de contactos del relé utilizado se elegirá y cableará adecuadamente para emular el juego de contactos del mando de PTT requerido para gobernar la emisora o transceptor de radio desde el micrófono de mano. En el esquema se han representado dos juegos de contactos de conmutación, para gobernar un tranceptor clásico de CB.
El diodo D1 puede ser cualquier diodo de silicio de baja señal y su función es cortocircuitar las sobretensiones autoinducidas que genera la bobina del relé durante las conmutaciones de éste (protegiendo al transistor TR1 de estas sobretensiones). El diodo D2 es un diodo LED de 3,5 mm, cuya única función es proporcionar una indicación visual de que el relé se ha activado, y con ello, ha activado la transmisión de la señal de la baliza. No es estrictamente necesario para el funcionamiento de este circuito (puede eliminar D2 y R10 si así lo desea).
Dado que el relé no manejará señales eléctricas de potencia en sus contactos, puede usarse un relé adecuado con bobina de 12 voltios tipo miniatura DIL para circuito impreso, con dos juegos de contactos de conmutación.
Este circuito adaptador es bastante sencillo y puede ser realizado en un trozo de clásica placa de circuito impreso tipo “perfboard” (esas que son todo agujeros rodeados de isletas metálicas para la soldadura de componentes).
Si desea realizar una baliza definitiva (y no solamente para experimentar durante algún tiempo), destinar toda una placa Arduino Uno para realizar la baliza no es la mejor solución práctica, es desaprovechar la placa Arduino, por lo que recomendaría emplear alguna otra placa de la familia Arduino mucho más pequeña pero compatible con la Arduino Uno, como puede ser la Arduino Micro o la Arduino Nano.
Otra opción más económica es programar un chip microcontrolador ATTiny 25, 45 u 85 de la familia Atmega con el segundo sketch empleado aquí (con ligeras modificaciones). Los ATtiny x5 son chips microcontroladores de 8 patillas y muy bajo consumo que algunos consideran como una especie de mini-Arduinos, útiles para sencillos proyectos que sólo requieren unas pocas patillas I/O (de entrada/salida, hasta 5 en los ATTiny x5) y que por tanto, para los cuales utilizar una placa Arduino es excesivo.
La IDE Arduino no contempla el uso de esta familia de pequeños microcontroladores Atmega que por otro lado, a nivel de software son bastante compatibles con los sketchs escritos para Arduino. Sin embargo, existen varios “core ATtiny” disponibles en Internet que permiten integrar estos chips ATtiny en la IDE Arduino, apareciendo entonces como placas alternativas a las placas Arduino en el menú de “Herramientas > Placa” de la IDE Arduino.
Pero para poder manejar y programar estos chips desde la IDE Arduino, se necesita un programador adecuado. Por suerte, en las IDE Arduino actuales, en el menú “Archivo > Ejemplos”, hay una opción “ArduinoISP”, que le permitirá programar su placa Arduino como programador ISP de microcontroladores de la familia Atmega, y por tanto, de chips microcontroladores ATtyni x5.
Sin entrar en mucho detalle, el proceso para utilizar un chip ATtiny x5 para una baliza de este tipo (o cualquier otro sketch desarrollado para Arduino) sería el siguiente:
Incluir los chips ATtiny en el entorno de programación Arduino, para que aparezcan como placas seleccionables en menú “Herramientas > Placa” de la IDE Arduino. Por ejemplo, puede incluirlos usando el AttinyCore de Spence Konde (compruebe que el ATtiny Core es compatible con la versión de la IDE Arduino que usted utilice).
Conecte su placa Arduino al ordenador, y desde la IDE Arduino, selecciónela en “Herramientas > Placa”, y a continuación vaya a “Archivo > Ejemplos” y seleccione “ArduinoISP”. Suba (cargue) el sketch correspondiente a la placa Arduino. Ésta quedará ahora configurada como programador ISP (In-System Programming).
Conecte el chip ATtiny a la placa Arduino mediante una conexión de programación ISP. Esta conexión conecta I/O (entradas/salidas) de la placa Arduino a las I/O del chip ATtiny con la misma función. Para los chips ATtiny 25/45/85, esta conexión es la siguiente:
| Pin Arduino | Señal | Pin ATtiny85 |
|---|---|---|
| 5 V | Vcc | 8 |
| GND | GND | 4 |
| Digital 10 | –Reset | 1 |
| Digital 11 | MOSI | 5 |
| Digital 12 | MISO | 6 |
| Digital 13 | SCK | 7 |
 |
| Configuración de la placa Arduino Uno (u otra placa Arduino que no sea la Arduino Mega) como programador ISP de chips Attiny 85/45/25. Hay que conectar las señales Slave RESET, MOSI, MISO, SCK, además de la tensión de alimentación (5 V, GND) de la placa Arduino a las correspondientes del chip Attiny. |
Seleccione ahora en “Herramientas > Placa” el chip ATtiny que vaya a programar, compruebe también en “Herramientas” que la frecuencia de reloj del chip es de 1 MHz (frecuencia de reloj por defecto de funcionamiento de estos chips), y que el programador ISP está preparado para chips de la serie ATtiny (seleccione estas opciones si fuera necesario).
Cargue el sketch de la baliza en la IDE, y modifíquelo adecuadamente. Deberá reasignar la líneas digitales empleadas por Arduino (D11, D12 y D13) por las que emplee en el chip ATtiny (Pin 0... Pin 4).
Suba el sketch al chip Attiny. La placa Arduino ahora sólo funciona como intermediario (programador) entre la IDE Arduino y el chip ATtiny.
Con esto, habrá quedado programado el chip ATtiny con el software de la baliza. Cuando conecte el chip al interface con el equipo de radio (como por ejemplo, el anteriormente mostrado), recuerde que estos chips ATtiny requieren una tensión de alimentación de 5,5 V como máximo (si el interface funciona con 12 V, puede alimentar el chip con un reductor de tensión adecuado, como puede ser un regulador de tensión 78L05, o una resistencia serie de 1 K y un zéner de 5,1 V o 4,7 V, y algún condensador de filtrado a masa).
Por ejemplo, este sketch es el sketch mostrado anteriormente (con alguna ligera modificación) adaptado para su carga en un chip microcontrolador ATtiny85.
Varias cosas se observan en este sketch:
Se han suprimido las instrucciones referidas a la impresión en el monitor serie de la IDE, ya que no tienen sentido con estos chips ATtiny, y su inclusión podría dar algún problema de funcionamiento del chip.
Se encontraron problemas de correcto funcionamiento físico del control PTT si era asignado a la patilla 6 del chip (pin 1), y además afectaba a la velocidad de transmisión del código morse, por lo que el control PTT fue asignado a la patilla 3 (pin 4). De momento, no he encontrado explicación a este extraño comportamiento del chip.
El control de PTT queda, pues, asignado a la patilla 3 (pin 4). La salida de Keyer se ha asignado a la patilla 5 (pin 0) y la salida de tonos a la patilla 7 (pin 2).
Por algún problema en el sketch inicialmente probado, el keyer (manipulador telegráfico), quedaba activado entre palabras en mensajes con varias palabras. Aunque está ya solucionado, por si acaso, al final de la transmisión del mensaje, se asegura el estado bajo del PTT y del Keyer por seguridad.
Como el fabricante recomienda que las patillas I/O no usadas del chip sean fijadas a algún estado lógico concreto (para que no queden en estado flotante, ya que pueden dar problemas en el fncionamiento de otras I/O en algunas circunstancias), las dos patillas no utilizadas del chip (patillas 2 y 6; pins 3 y 1) han sido configuradas en la sección SETUP como pins de entrada y puestas a nivel alto.
Aunque las dos patillas no utilizadas no son usadas, podrían ser utilizadas en el futuro para posibles ampliaciones de la baliza, por ejemplo, para seleccionar uno de varios mensajes telegráficos o secuencias de tonos a transmitir (sonido de sirena, alguna melodía musical, etc..). La selección del comportamiento de la baliza podría realizarse según sean puestas estas patillas a nivel alto o bajo mediante un par de microinterruptores externos (lo que permitiría seleccionar 4 posibles comportamientos de la baliza), o bien conectando un pulsador a masa y a una de las patillas no usadas y realizar la selección en función del número de veces que sea pulsado dicho pulsador dentro de un intervalo de tiempo dado (p.ej, 5 segundos) o antes de detectar una pausa de dos o tres segundos tras la última pulsación.
El siguiente diagrama muestra cómo queda cableada la baliza con el chip ATtiny85. Se añade un pulsador de reset para reiniciar la baliza en un momento dado (el reset del ATtiny85 opera por nivel bajo) y otro pulsador preparado para seleccionar futuras opciones de la baliza (de momento, no tiene uso alguno). Los diodos colocados en las salidas para PTT y Keyer no son estrictamente necesarios, pero se han equipado como medida de protección frente a tensiones externas, si estas salidas son conectadas a circuitos con tensiones de alimentación superiores a los 5,5 V (que es la tensión máxima de alimentación del ATtiny85).
Por Fernando Fernández de Villegas (EB3EMD) (Barcelona - España),
Actualizado: 6 Abril 2023