AIR - RADIORAMA: ARDF - Beacon non modulato, con AtTiny13

AIR - RADIORAMA: ARDF - Beacon non modulato, con AtTiny13: Più piccolo di così diventa difficile!   Introduzione Un semplice timer può essere assemblato con varie tecniche costruttive, dal BJ...

AIR - RADIORAMA: ARDF - Beacon modulato, con AtTiny25/45/85

AIR - RADIORAMA: ARDF - Beacon modulato, con AtTiny25/45/85:   Più piccolo di così diventa difficile!   Introduzione Dopo la pubblicazione del beacon NON modulato con AtTiny13 (per motivi di dimensione...

Arduino N° 66 - Beacon multiplo sequenziale

< Arduino N°  65

Achille De Santis

> Arduino N°  67

Fig. 1: Beacon multiplo sequenziale;

Ultimato il beacon multiplo sequenziale.

Può pilotare 5 TX beacon, in sequenza, dando la possibilità di riceverne uno solo per volta sequenzialmente.

In questo modo, dal lato ricevitore, è possibile valutare la propagazione del segnale a RF sulle varie bande e la "apertura" di propagazione DX.

Nella tabella, è possibile vedere come è organizzata la trasmissione dei testi beacon con i call specifici, per ogni banda.

Simulazione: 


Argomenti correlati: 

Beacon Morse, Beacon per caccia alla volpe, Micro BUG Morse

Arduino N° 50 - Modulo di prova per 6 uscite digitali

> Arduino N°  67

Arduino N° 64 - Beacon per caccia alla volpe

< Arduino N°  63

Achille De Santis

> Arduino N°  65

Fig.1: Collaudo del modulo beacon con un cicalino;

Un "beacon" è un radiofaro che trasmette ciclicamente alcune informazioni. 

Un beacon per "caccia alla volpe" non è un dispositivo per uso cruento sul povero animale ma semplicemente un piccolo radiotrasmettitore utilizzato per il "Radio-orienteering" o per la cosiddetta caccia al segnale RF (RDF: Radio Direction Finding).

Con questo sistema vengono normalmente organizzate delle gare di ricerca.

Il trasmettitore può essere "anonimo" o può contenere il suo nominativo specifico, comodo soprattutto nel caso di presenza contemporanea di più microtrasmettitori dislocati sul campo di gara.

Quello che viene qui presentato è un modulatore beacon, con tanto di nominativo, da associare ad un microtrasmettitore a bassissima potenza.

 

Simulazione: Beacon per caccia alla volpe


Argomenti correlati: 

Beacon Morse

> Arduino N°  65

Arduino N° 62 - Beacon CW

< Arduino N° 61

Achille De Santis

> Arduino N°  63

Fig. 1: Il modulatore beacon su Arduino Pro-Mini;

Su richiesta di Carlo, IZ0EGC, ho realizzato questo generatore di beacon Morse.

Nel testo beacon sono comprese le informazioni di trasmissione: call, locator, report ecc...

La velocità telegrafica è volutamente lenta, coerente con applicazioni beacon in QRSS.

Di seguito, le caratteristiche del beacon (v. tabella 1).

La nota generata è di 800 Hz.

Il comando di PTT può essere scelto sui piedini 8 o 9, in alternativa, a seconda del tipo di comando desiderato, diretto o invertito. Molti trasmettitori utilizzano il comando di PTT a logica negata ma, nel caso, potete optare anche per un comando a logica diretta.

Per il comando di PTT, occorre prevedere uno stadio separatore, a BJT, per adattare la logica di controllo (5 volt) all’alimentazione del TX (normalmente 12 volt). Anche in questo caso avete due alternative e potete scegliere quella per voi più comoda.

Tabella 1: Caratteristiche del beacon;

Tono di BF generato	pin D13	800 Hz
Durata di TX		120 secondi
Durata pausa		90 secondi
Tempo totale di ciclo		210 secondi
Duty cycle di TX		57,14 %
PTT diretto	pin D8	Blu (attivo alto)
PTT complementare	pin D9	Marrone (attivo basso)
Reset per pulsante a pannello	pin RST	Verde, opzionale, chiuso su GND.

  Sullo zoccolo di fissaggio ci sono 6 piedini ma soltanto due vanno collegati: Vcc e GND. Gli altri restano appesi.

L’uscita BF è sul piedino 13, dove è già collegato un condensatore separatore.

Il testo beacon è predisposto come segue:

V V V   DE       <CALL CALL CALL>              <LOCATOR LOCATOR LOCATOR>

 PSE    QSL     REPORT VIA  QRZ.COM       SK

Naturalmente, le parole tra virgolette vanno sostituite con il CALL e con il LOCATOR specifici.

Per regolare l'iniezione del segnale al giusto livello di BF basta inserire un potenziometro (o un trimmer) sull'uscita BF prelevando poi il segnale dal cursore.

In UHF/LPD è possibile utilizzare gli economici moduli TX per trasmissione dati in ambito IoT. In questo caso non serve collegare il comando di PTT in quanto il TX si attiva automaticamente.

Nota:
A causa di qualche maldestro scopiazzatore mi vedo costretto a non pubblicare il FW, che comunque è disponibile al mio indirizzo sotto forma di scheda programmata.

Simulazione: 

Argomenti correlati:

Arduino N° 37 - Beacon Fonia/CW per Trasmettitore LPD

Arduino N° 3 - Beacon CW OOK Arduino N° 1 - Semplice beacon per caccia alla volpe Beacon ARDF – UHF - conversione di RS41-SG

Achille De Santis

> Arduino N°  63

Arduino N° 37 - Beacon Fonia/CW per Trasmettitore LPD

Arduino n° 36

Achille De Santis

> Arduino n° 38

I piccoli moduli per applicazioni IoT a corto raggio funzionano con una particolare tecnica di trasmissione in cui la portante viene attivata dalla stessa modulante.

Un problema è rappresentato dal valore a riposo della modulante: diretto o invertito.
In considerazione delle caratteristiche circuitali, molto spesso si trovano in commercio moduli trasmittenti con modulante inversa, cioè con tensione alta a riposo, un po' come avviene per la codifica di canale per quanto riguarda i segnali di Mark e Space.

Un altro problema è rappresentato dal "ritmo" dei bit di dati che si susseguono nella modulante. Infatti, mancando il comando di PTT, la portante deve essere abilitata dal ritmo di modulazione, che deve avere un determinato duty-cycle, compatibile con il mantenimento in trasmissione. Lunghe sequenze di "zero" tenderebbero a far disabilitare la portante.

Il programma qui proposto lavora a modulante inversa ed è adatto a molti moduli in commercio che usano questa tecnica.


/* --------------------------- Inizio programma -------------------------------------------------
  Achille De Santis V2.0 del 12-12-2014 V3.0 del 13-12-2015
  V4.0 del 13-12-2016. V5 del 28-10-2019
  Beacon RDF CW Multiplo, con 5 messaggi pre-selezionabili.
  1 linea di uscita per la spia di TX;
  1 linea di uscita per il testo CW_BF, invertita.
  5 testi beacon, in uscita, selezionabili alternativamente;
  pin 13: uscita del testo beacon;
  pin 12: spia di portante;
  senza comando di PTT.
*/

// ------------------- I/O -----------------------------------------------
#define U     13        // Uscita testo beacon sul piedino 13.
#define ptt   12        // comando PTT sul piedino 12.
// -----------------------------------------------------------------------
// ------------------ Selezione del beacon --------------------------
#define beaconset1    11
#define beaconset2    10
#define beaconset3    9
#define beaconset4    8
#define beaconset5    7
// ----------------------------------------------------------------------

const int freq = 800;
const int T = 100;            // base tempi.
const int T2=2*T;
const int T3=3*T;
const int T4=4*T;
const int T5=5*T;
const int T6=6*T;
const int T7=7*T;

void intestazione()
  { // Serial.begin(9600);        // velocità seriale
    Serial.println(" ________ Tecnatron Creation ___________");
    Serial.println(" Beacon Fonia/CW per Trasmettitore LPD  --");
    Serial.println(" prof. Achille De Santis - 27-10-2019 ----------");
  }
 
void genera(int T1)   { tone(U, freq); delay(T1);   noTone(U); delay(T);  }
void punto()          { genera(T); }
void linea()          { genera(T3); }

void AR() { punto();linea();punto();linea();punto();delay(T6); }  // AR - messaggio iniziale di accensione Beacon

void MO()
{
  linea(); linea();                 delay (T2);            // M
  linea(); linea(); linea();    delay (T2);            // O
}

void beacon1()  { punto(); linea(); linea(); linea(); linea(); delay (T4); }   // 1
void beacon2()  { punto(); punto(); linea(); linea(); linea(); delay (T4); }   // 2
void beacon3()  { punto(); punto(); punto(); linea(); linea(); delay (T4); }   // 3
void beacon4()  { punto(); punto(); punto(); punto(); linea(); delay (T4); }   // 4
void beacon5()  { punto(); punto(); punto(); punto(); punto(); delay (T4); }   // 5

void setup()
{
 Serial.begin(9600);            // serial monitor output
 intestazione();

 pinMode (U, OUTPUT),   // uscita tono
         (ptt, OUTPUT);         // uscita PTT

 pinMode (beaconset1, INPUT_PULLUP),  // set di messaggi
         (beaconset2, INPUT_PULLUP),
         (beaconset3, INPUT_PULLUP),
         (beaconset4, INPUT_PULLUP),
         (beaconset5, INPUT_PULLUP);

 digitalWrite(U, HIGH);     delay (T7);
 AR();                           // - messaggio iniziale di accensione Beacon
 digitalWrite(U, HIGH);     delay (T3);
}

void loop()
{
  digitalWrite(ptt, HIGH);      // indicatore di trasmissione, opzionale
                                // digitalWrite(U, HIGH);     delay (T5);
  MO();
  if (digitalRead(beaconset1)==LOW)   {beacon1();  }
    else if (digitalRead(beaconset2)==LOW)   {beacon2();  }
           else if (digitalRead(beaconset3)==LOW)   {beacon3();  }
                 else if (digitalRead(beaconset4)==LOW)   {beacon4();  }
                     else if (digitalRead(beaconset5)==LOW)   {beacon5();   } 
  delay (T4);
  digitalWrite(ptt, LOW);
  digitalWrite(U, HIGH); 
  delay (50*T);
 }
// ----------------------------- Fine programma --------------------------------------------------

Simulazione: 

Beacon per ARDF - selezionabile - modulante inversa

Argomenti correlati:

Arduino N° 3 - Beacon CW OOK Arduino N° 1 - Semplice beacon per caccia alla volpe Beacon ARDF – UHF - conversione di RS41-SG

> Arduino n° 38

Arduino N° 12 - Beacon per ARDF - selezionabile

< Arduino N° 11

Achille De Santis

> Arduino N° 13

Foto 1: il modulo beacon su 
Arduino Nano;

Beacon  selezionabile - 5 banchi di memoria.

Questo identificatore telegrafico trasmette una nota di bassa frequenza, direttamente ricevibile con Apparati in AM o FM a banda stretta.
I messaggi impostati per la radiocaccia sono MO1... MO5, selezionabili a piacere.
La selezione del beacon si opera mettendo a massa, con un dip-switch, il piedino associato (beaconsetX).
In questo caso, la selezione della memoria può essere fatta anche "a caldo", senza bisogno di resettare il modulo. Viene terminato il beacon in riproduzione ed inserito in loop il nuovo beacon.
La temporizzazione è calcolata in modo da avere sempre un rapporto 1-3-5, come da standard del codice Morse.

/* --------------- Inizio programma --------------------------
  Achille De Santis V2.0 del 12-12-2014 V3.0 del 13-12-2015
  Beacon RDF CW Multiplo, con 5 messaggi pre-selezionabili.
  1 linea di uscita per il comando di PTT
  1 linea di uscita per il testo CW_BF
  5 testi beacon, in uscita, selezionabili alternativamente;
  il pin 13 è l'uscita del testo beacon;
  il pin 12 è il comando di PTT.
*/

// --------------------------- I/O ------------------------------------------
#define pin 13                 // Uscita testo beacon sul piedino 13.
#define ptt 12                 // comando ptt sul piedino 12.
#define beaconset1 11
#define beaconset2 10
#define beaconset3 9
#define beaconset4 8
#define beaconset5 7
// ------------------------------------------------------------------------

const int T = 100;   // Definizione costante base tempi T.
const int T3=3*T;
const int T4=4*T;
const int T10=10*T;
const int freq = 1000;

void genera(int T1)
{
  tone(pin, freq); delay(T1);
  noTone(pin);     delay(T);
}

void punto()  {   genera(T);   }
void linea()  {   genera(T3);   }

void MO()
{
  linea(); linea();                 delay (4*T);            // M
  linea(); linea(); linea();        delay (4*T);         // O
}

void beacon1()    {    MO();    punto(); linea(); linea(); linea(); linea(); delay (T4);     }   //MO1   
void beacon2()    {    MO();    punto(); punto(); linea(); linea(); linea(); delay (T4);    }   //MO2 
void beacon3()    {    MO();    punto(); punto(); punto(); linea(); linea(); delay (T4);   }   //MO3 
void beacon4()    {    MO();    punto(); punto(); punto(); punto(); linea(); delay (T4);  }   //MO4 
void beacon5()    {    MO();    punto(); punto(); punto(); punto(); punto(); delay (T4); }   //MO5
void setup()
{
 pinMode(pin, OUTPUT);                            //Variabile di uscita tono
 pinMode(ptt, OUTPUT);                             //Variabile di uscita PTT
 pinMode(beaconset1, INPUT_PULLUP);
 pinMode(beaconset2, INPUT_PULLUP);
 pinMode(beaconset3, INPUT_PULLUP);
 pinMode(beaconset4, INPUT_PULLUP);
 pinMode(beaconset5, INPUT_PULLUP);
}

void loop()
{ digitalWrite(ptt, 1);     delay (T);     // attiva PTT
  if (digitalRead(beaconset1)==0)                  { beacon1();  // delay (T3);   }
    else if (digitalRead(beaconset2)==0)                { beacon2();   // delay (T3);         }
           else if (digitalRead(beaconset3)==0)                 { beacon3();   // delay (T3);     }
                 else if (digitalRead(beaconset4)==0)                    { beacon4();  // delay (T3);   }
                     else if (digitalRead(beaconset5)==0)                         {beacon5();  // delay (T3);       } 

  digitalWrite(ptt, 0);    // disattiva PTT
  delay (T10);
 }

// ---------------- Fine programma ---------------------------------

Nota: inserendo il comando di "portante" all'interno del beacon scelto si evita di far partire la trasmissione se non c'è alcun messaggio beacon selezionato.
In questo modo si ha anche una indicazione, sullo stesso LED, dell'attivazione di un qualunque messaggio beacon. Nel primo caso, comandando la portante "a priori" e non selezionando lo specifico messaggio si avrebbe l'emissione della sola portante non modulata (che può avere comunque un significato, n.d.a.).

Simulazione:

Beacon per ARDF - selezionabile
Esempio di beacon modulato in BF

Argomenti correlati:

Arduino N° 4 - Beacon CW modulato in BF


> Arduino N° 13

Arduino N° 4 - Beacon CW modulato in BF

< Arduino N°3

Achille De Santis

> Arduino N°5

Eccoci alla quarta puntata di applicazioni con Arduino.

Questo beacon modula la portante con un segnale fonico (in bassa frequenza).

E', altresì, dotato di due comandi complementari per l'attivazione del PTT del trasmettitore. Si può scegliere l'uno o l'altro, secondo la necessità.

Se la nota modulante è troppo robusta si può attenuare.
E' conveniente inserire un condensatore all'uscita della modulante.
Buon lavoro!

* Questo sketch non è adatto per Arduino DUE!

/*----------------------------- Inizio Programma --------------------------------
 *  Achille De Santis 20-06-2019
 *  Beacon CW  Fonia - IU0EUF.
 *  - 2 linee di uscita per il comando di PTT (complementari)
 *  - 1 linea di uscita per il testo CW_BF
 *  - Testo beacon1:                                    IU0EUF / JN61KL      (da modificare!)
 *  il messaggio di identificazione viene trasmesso ciclicamente in audio Morse ogni 10 minuti;
 *  pin 13 = uscita del testo beacon;
 *  pin 3, 11 = uscite per il comando di PTT,
 *  -------------------------------------------------
*/

// -------------------------------- Parametri ----------------------------------------
#define   pin   13         // Uscita testo beacon sul piedino 13.
#define   ptt1   3         //  Uscita comando ptt1 sul piedino 3.
#define   ptt2  11        // Uscita comando ptt2 ausiliario.

const int TA= 10;          // 10 minuti di pausa
const int freq = 800;     // frequenza della nota di bassa frequenza (audio)
const int T = 100;         // base tempi T.

// ---------------------------- Fine parametri --------------------------------------

const int T2 = 2*T;
const int T3 = 3*T;
const int T4 = 4*T;
const int TS= 60*1000*TA;

void genera(int T1)
    {
       tone(pin, freq);  delay(T1);
       noTone(pin);      delay(T);
    }

void punto()         {genera(T);}
void linea()         {genera(T3);}

void DE()
    {
       linea(); punto(); punto();   delay(T2);                        // D
       punto();                             delay(T4);                        // E
    }

void K()
    {       linea(); punto(); linea(); delay(T4);     }              // K

void CALL()
  {
    // ----------------------- Da modificare -------------------------
    punto(); punto();                                      delay(T2);    // I
    punto(); punto(); linea();                         delay(T2);    // U
    linea(); linea(); linea(); linea(); linea();   delay(T2);    // 0
    punto();                                                    delay(T2);    // E
    punto(); punto(); linea();                         delay(T2);    // U
    punto(); punto(); linea(); punto();           delay(T4);     // F
    // -------------------------------------------------------------------
 }

  void LOCATOR()
  { 
    linea(); punto(); punto(); linea(); punto();  delay(T4);        //   /  (barra!)

    // ------------------- LOCATOR -------------- da Modificare -----------------
    punto(); linea(); linea(); linea();                   delay(T2);     // J
    linea(); punto();                                            delay(T2);     // N
    linea(); punto(); punto(); punto(); punto();  delay(T2);     // 6
    punto(); linea(); linea(); linea(); linea();      delay(T2);     // 1
    linea(); punto(); linea();                               delay(T2);     // K
    punto(); linea(); punto(); punto();                delay(T4);     // L
    // -----------------------------------------------------------------------------------
}

void PORTANTE(boolean p)
  {
    digitalWrite (ptt1, p);                      // ptt1
    digitalWrite (ptt2, !p);                    // ptt2 ausiliario.
    delay(100);
  }

void setup()
{
 // pinMode (pin, OUTPUT);            //Variabile di uscita testo
 pinMode (ptt1, OUTPUT);             //Variabile di uscita 1 PTT
 pinMode (ptt2, OUTPUT);            //Variabile di uscita 2 PTT
}

void loop()
{
    PORTANTE(1);
    DE();
    CALL();
    LOCATOR();
    K();
    PORTANTE(0);
    delay(TS);  // --
}

// ----------------------------- Fine programma ----------------------------------------------

> Arduino N°5

Arduino N° 3 - Beacon CW OOK

< Arduino N°2

Achille De Santis

> Arduino N° 4

Questo beacon funziona ad interruzione di portante.
Potete cambiare il piedino di uscita e la pausa tra messaggi nelle prime due righe di programma
Cambiate il CALL usando la stessa sintassi, inserendo "punto(); " o "linea(); ",  ove necessario, secondo il codice Morse.
Non modificate il resto!
Per prova, collegate un cicalino da 5 volt (NON un altoparlante!!) tra il piedino di uscita e  GND.
Buon divertimento!






// ------------------------- inizio programma ---------------------------
/*
Achille De Santis - 20-06-2019, V3.0
Beacon CW singolo.
*/
// ------------------------ I/O ---------------------------------------------
#define pin  13      // Definizione "uscita" sul piedino 13.
// --------------------------------------------------------------------------

const int TS=10;   // attesa IN SECONDI!; fine messaggio
const int T =100;  // base tempi.
const int T2=2*T;
const int T3=3*T;
const int T4=4*T;
const int TA=1000*TS;

void genera(int T1)
{
  digitalWrite(pin, HIGH);    delay(T1);
  digitalWrite(pin, LOW);     delay(T);
}

void punto() {  genera(T); }
void linea() {  genera(T3); }

void setup ()
  {pinMode (pin, OUTPUT); }   //Variabile di uscita

void loop ()
  {       
    linea(); punto(); punto();   delay (T2);   // D
    punto();                             delay (T4);   // E

//  ------------------------- call ----------------------------------------
    punto(); punto();                                    delay (T2);  // I
    linea(); linea(); punto(); punto();           delay (T2);  // Z
    linea(); linea(); linea(); linea(); linea(); delay (T2);  // 0
    linea(); linea();                                      delay (T2);  // M
    punto(); punto(); punto(); linea();         delay (T2);  // V
    linea(); punto();                                     delay (T4);  // N
//  ----------------------- fine call ------------------------------------------------------
    linea(); punto(); linea();                       delay (T2);   // K - fine messaggio
//  ----------------------------------------------------------------------------------------
    delay(TA); 
 }
 // --------------------- fine programma -----------------------------------



Beacon CW OOK

> Arduino N° 4

Arduino N° 1 - Semplice beacon per caccia alla volpe

< Arduino N°0

Achille De Santis

> Arduino N°2

fig. 1: il beacon con Arduino Nano

Iniziamo con qualche pillola di Arduino. Viene presentato un semplice beacon per RDF,  CW (AM/FM)

1. La frequenza della nota audio è di 600 Hz; il piedino di uscita è il pin digitale D2.
2. Inserite in serie un condensatore ed una resistenza da 100 Ohm prima dell'altoparlante.

In figura (1) potete vedere come è stato "arrangiato" il Nano su supporto con morsetti a vite, per un facile assemblaggio, e sistemato in un contenitore in plastica, di recupero.
Per l'alimentazione potete usare:

• presa USB da PC;
• presa USB da Power bank
• alimentazione a 5 volt

Copiate "lo sketch" e caricatelo sull'IDE di Arduino. Verificate la correttezza del programma, caricate su Arduino. Aggiungete i pochi componenti esterni e provate!
Buon divertimento!


/* ---- Inizio Programma ----
 * Semplice beacon per caccia alla volpe
 * Achille De Santis V2.0
 * Il beacon trasmette una nota modulata a 600 Hz
 * E' possibile trasmettere la lettera T (-), M (--), O (---) ecc...
 */

#define pin  2        // Pin scelto come uscita (micro-TX 433 MHz)

int nota = 600;       // frequenza della NOTA

void setup()
{  }   

void da()             //  Configurazione della NOTA DA (-)
  {
    tone(pin, nota);  delay(1500);
    noTone(pin);      delay(500);
  }

void loop()
  {
    // for (int i=0; i<=1; i++)
    {      da();    }          //  Trasmette la NOTA DA (-)
    delay(1000);               //  Tempo in RX del beacon
  }

// --------------- Fine Programma ---------------------

Beacon semplice per ARDF

> Arduino N°2

Beacon ARDF – UHF - conversione di RS41-SG

RadioRama  n° 93 pag. 82 giugno

Beacon ARDF – UHF - conversione di RS41-SG

ing. Achille De Santis

Fig. 1: Radiosonda RS41

La RS41 riprogrammata può essere utilizzata come beacon UHF in banda amatoriale. Bisogna, però, scegliere: APRS, RTTY, CW. E' vero che la trasmissione è indipendente sui tre modi ma è anche vero che con l'alimentazione a batteria l'autonomia è molto limitata. Diverso è se si usa una alimentazione esterna. L'uso immediato che si può prevedere è quello come beacon “solo CW” per radiocaccia ARDF in banda UHF. Io pensavo di utilizzarne due o tre durante le mostre-mercato, per attirare i giovanissimi nel mondo dell'ARDF. Le antenne possono essere di dimensioni ridotte ed il materiale di ricerca potrebbe essere messo a disposizione. Tre beacon, con CALL diversi, con diversa velocità WPM e diverso tempo di ciclo, possono essere utili allo scopo. In mancanza d’altro ne basta anche uno soltanto.

Una volta che le sonde siano state riprogrammate vanno inseriti su ognuna gli opportuni parametri, sia per inserire il call, sia per stabilire la frequenza di lavoro, sia per le modalità di trasmissione.

Parametri comuni ai tre “modi”

LED off - I LED si spengono dopo 10 minuti, risparmiando sulle batterie.
TXD n - ritardo di modulazione, n = da 10 a 500 (mSec) (tipico=200)
TTEXT stringa - testo di coda (fino a 100 caratteri)
HOLDOFF n - intervallo di tempo tra due messaggi (qualche secondo)

Parametri per il CW

CWID on - abilita l’invio di messaggi CWIDMESS (identificatore CW)
CWID_EVERY n - intervallo di tempo tra i messaggi CW: è n x holdoff
CW_SPEED n - imposta velocità; n = velocità CW in wpm (consigliato 40)
CWIDMESS stringa - messaggio CW (fino a 25 caratteri)


Ne risulta una programmazione per i tre beacon come da tabella (1), dove si può notare che per i tre dispositivi cambia il CALL, la potenza di emissione e il tempo di ciclo; di conseguenza, cambia la difficoltà nella ricerca in campo del beacon. Il canale RF di trasmissione è unico. I tempi di trasmissione sono “interallacciati” e non dovrebbero esserci sovrapposizioni di segnali.

Tabella 1: predisposizione dei parametri per i beacon;

Beacon ARDF	frequenza TX	CALL	Beacon_every	Power *	Note
1	433.225	MO1	2  secondi	7	Difficoltà bassa
2	433.225	MO2	5  secondi	5	Difficoltà media
3	433.225	MO3	7  secondi	3	Difficoltà alta

* Il numero è soltanto un coefficiente, non la potenza di uscita in watt o milliwatt.

Beacon per ARDF

Parliamo di Radiocaccia o Caccia alla Volpe o Radio-Orienteering, attività sportiva che si è sviluppata e diffusa negli ultimi anni anche in Italia.

La radio-caccia è basata sulla ricerca di uno o più microtrasmettitori opportunamente predisposti ed occultati in una zona di ricerca, normalmente ben definita.

Analogamente a quanto avveniva nella caccia alla volpe tradizionale, il trasmettitore beacon da scovare viene chiamato “Volpe”. In altri casi il beacon viene chiamato “Civetta” mutuando il termine dalla caccia che questa volta fa la volpe per trovare la civetta, che rappresenta la sua preda.

In ogni caso, che si tratti di volpe o di civetta, la radio caccia è assolutamente innocua e adatta anche a partecipanti molto giovani, da introdurre nel mondo delle radiotrasmissioni.

Sul n° 80 di Radiorama verrà presentato il progetto di un beacon per ARDF. Gli interessati possono prendervi spunto per realizzare uno o più civette per radio caccia ARDF.

Quello che viene presentato è la logica di controllo di un semplice beacon per radio caccia, o volpe o civetta che dir si voglia. Manca soltanto la parte a radiofrequenza, che ognuno potrà adattare alle proprie esigenze, sia di banda di trasmissione che di potenza (VHF, generalmente non superiore ad 1 watt, UHF in banda LPD, minore di 10 mWatt e, infine, banda 80 metri).

L’uscita del modulatore-beacon prevede la trasmissione ciclica di una “linea”, modulata in audio a 600 Hz. Il “modulatore” può essere adattato sia per CW che per FM/AM.

Per il firmware, da caricare su una scheda a microcontrollore Arduino, chiedere all’autore.

Per essere il più semplice possibile e per invogliare a sperimentare nel campo dei microcontrollori, il beacon non prevede la trasmissione di un nominativo e va usato, durante le gare o esercitazioni, come trasmettitore “singolo”; è possibile anche usare contemporaneamente più di una civetta ma in questo caso, per evitare interferenze, esse andranno predisposte su frequenze diverse.

Il materiale del “cacciatore” sarà quindi:

• radioricevitore,
• piccola antenna direttiva (una Moxon), 
• attenuatore RF (a scatti o meglio continuo), 
• cuffia audio, 
• eventuale bussola. 

Non resta che caricare il programma sulla scheda, collegare l’uscita al trasmettitore e provare.

___________________________________________________________________________

Achille De Santis - Beacon per civetta ARDF V2.0
___________________________________________________________________________