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° 63 - Micro BUG Morse

< Arduino N°  62

Achille De Santis

> Arduino N°  64

Fig. 1: BUG Morse, modulo programmato; 

Dopo varie sperimentazioni sul mio generatore di caratteri "Morse" ecco il risultato di tutto il lavoro, ottenuto dopo aver esaminato anche lo "stato dell'arte" dei prodotti commerciali.

Chi volesse ancora destreggiarsi con il Morse e con l'autocostruzione troverà in questo dispositivo un valido aiuto per realizzare un manipolatore automatico Morse "home made". 

Il dispositivo è realizzato attorno ad un microcontrollore ATMega168. Basta aggiungere i pochi componenti esterni e, soprattutto, una buona "chiave" a doppia paletta per la generazione dei caratteri.

Se non volete comprare una "chiave" professionale potete provare a costruirla. In alternativa, su internet potete trovare qualcuno che può farla per voi. 

 
Generatore elettronico automatico di caratteri Morse.

Micro BUG Morse "squeeze" in kit, per chi voglia cimentarsi nella costruzione di un manipolatore automatico Morse.

• Comando punti
• comando linee
• uscita codice Morse
• comando velocità UP
• comando velocità DOWN

Bastano 6 saldature con altrettanti fili ed otterrete un perfetto generatore di caratteri di nuova concezione, semplice ed economico.

Il circuito può essere completato con un "driver" a transistore per il pilotaggio del trasmettitore in modalità CW/SSB: un semplice BJT in configurazione di commutatore invertente dovrebbe andare bene nel 80 % dei casi. Infatti, normalmente il circuito associato alla modulazione Morse (CW) viene attivato portando a massa il relativo terminale, che a sua volta pilota il TX. 

Il dispositivo, alimentato a 5 volt,  può essere associato ad una "chiave" elettromeccanica a doppia paletta o, in mancanza di questo, ad una chiave a singola paletta. In quest'ultimo caso si perderà la caratteristica "Jambic/Squeeze" e la manipolazione sarà quella semplice di punti e linee, tipica di un tasto "orizzontale"  a paletta singola. 

A tutti, buona costruzione.

Per info potete contattarmi all'indirizzo: tecnatronATgmail.com

Simulazione: 

Argomenti correlati: 

Beacon CW

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

> Arduino N°  64

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° 61 - Modulo MP3 per Riproduzione Audio

< Arduino N° 60

Achille De Santis

> Arduino N° 62

Sketch per la gestione di un modulo MP3 di riproduzione audio.
   
   L'esempio può essere completato per realizzare un sistema più complesso di riproduzione audio, analogamente a quanto avveniva per i  Juke-Box di buona memoria.

/* ------------------------------ Inizio programma --------------------------------------------------------------------------------------------


*/ 

#include <SoftwareSerial.h>
#include <MP3.h>

MP3 mp3;                // Definisco un oggetto di tipo MP3

void setup()
{
  mp3.begin(MP3_SOFTWARE_SERIAL);   // Dichiaro attraverso SoftwareSerial l'istanza mp3                 
  mp3.volume(0x1F);                 // Definisco il volume (0x00 - 0x1F)
  mp3.set_mode(0x002);              // Definisco la modalità (0x002 per la ripetizione di tutti i file)
  mp3.play_sd(0x0002);              // Inizio la riproduzione dalla seconda canzone
}


void loop()
{
// Se voglio posso fare il salto di canzone in maniera manuale
        // mp3.next();

}

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

Simulazione: 


Argomenti correlati:

> Arduino N° 62

Arduino N° 60 - Stepper Position

< Arduino N°  59

Achille De Santis

> Arduino N°  61

Questo programma di esempio ci permette di familiarizzarci  con l'uso di un motore stepper.
I motori stepper si possono recuperare agevolmente da una stampante fuori uso.



/*
 Stepper Motor Control -
 This program drives a unipolar or bipolar stepper motor.
 The motor is attached to digital pins 8,9,10,11 of the Arduino.
 The motor should revolve in one direction, then in the other direction.
 Modified 24-06-2020 by Achille De Santis
*/

#include <Stepper.h>

const int stepsPerRevolution = 200;      // number of steps per revolution for your motor

#define P1 8
#define P2 9
#define P3 10
#define P4 11

Stepper myStepper(stepsPerRevolution, P1, P2, P3, P4);    // initialize the stepper library on pins 8 through 11:

void avanti(int p) { myStepper.step(p); }       // step in one direction:
void indietro(int p) { myStepper.step(-p); }   // step in the other direction:

void setup()
  { 
    myStepper.setSpeed(60);    // set the speed at 60 rpm 
    Serial.begin(9600);             // initialize the serial port
  }

void loop()
  {
    Serial.println("clockwise");
    avanti(1);                           //  one step in one direction
    delay(500);

    Serial.println("counterclockwise");
    indietro(1);                       //  one step in the other direction
    delay(500);
  }



Simulazione: 


Argomenti correlati:  Arduino N° 59 - Pilotaggio Stepper Motor

> Arduino N°  61

Arduino N° 59 - Pilotaggio Stepper Motor

< Arduino N° 58

Achille De Santis

> Arduino N°  60

Pilotaggio di un motore "a passo" (detto anche "passo-passo" o "stepper motor") attraverso un sensore di posizione.

Un potenziometro, comandato esternamente, segnala la posizione del cursore ad un ingresso analogico. La scheda Arduino, comandata da questo sketch, fa tutto il resto.

Lo spostamento angolare del motore è relativo a quello operato sulla manopola del potenziometro.

Importante è la determinazione del valore iniziale di posizione del motore.

Per il pilotaggio del motore a passo occorre una interfaccia che nel nostro caso può essere rappresentata dal modulo di pilotaggio motori con L298. Il modulo in questione è in grado di pilotare due motori in continua o un motore passo-passo.   

Nel caso di alimentazione "esterna" del modulo L298 è necessario predisporre il relativo ponticello (jumper) in modo opportuno.

/* ------------------------------ Inizio programma ---------------------------------------------------
 * Stepper Motor Knob
 * A stepper motor follows the turns of a potentiometer
 * (or other sensor) on analog input 0.
 *
 * http://www.arduino.cc/en/Reference/Stepper 
 * This example code is in the public domain.
 * Modified by Achille De Santis - 13-06-2020
 */

#include <Stepper.h>
#define STEPS 200         // dai "dati di targa" del motore; in questo caso: 1.8 DEG/step.
// questo parametro determina la "precisione" della movimentazione, cioè l'angolo di un passo.
                          
// ---------- I/O ---------------------------------
#define P1    7     // abilitazione alla partenza
#define POT   0     // A0  ingresso analogico, collegato al potenziometro di posizione
#define A     8
#define B     9
#define C     10
#define D     11
// ------------------------------------------------

Stepper stepper(STEPS,A,B,C,D); // presenta una istanza della classe stepper, specificando  
                                // il numero di passi del motore ed i piedini ad esso collegati.

bool m;                 // variabile di stato, consenso alla partenza del motore (0)
const int vel=30;       // predispone la velocità del motore a 30 giri/min

int previous;           // valore precedente di lettura dall'ingresso analogico.
int val;                // valore analogico

void intestazione()
{ Serial.println(" ---------------------------------------------- ");
  Serial.println(" - Tecnatron - ing. Achille De Santis         - ");
  Serial.println(" - Stepper MotorKnob                          - "); 
  Serial.println(" -     V. 3.1 del 25-06-2020                  - "); 
  Serial.println(" ---------------------------------------------- ");
}


void setup() 
  {
    Serial.begin(9600);         // setto la velocità di comunicazione
    intestazione();             // intestazione, inviata alla seriale
    
    pinMode(P1, INPUT_PULLUP);
    stepper.setSpeed(vel);     // stabilisce la velocità del motore
    val = analogRead(POT);     // legge inizialmente il sensore
    previous = val;            // e stabilisce la posizione iniziale.
  }

void loop() 
  {
    val = analogRead(POT);          // legge il sensore 
    m = digitalRead(P1);            // legge il valore di abilitazione
    if (m==0)
    { 
      stepper.step(val - previous); // esegue i passi da fare, positivi o negativi. 
      previous = val;               // aggiorna il valore alla posizione attuale.
      Serial.print("valore attuale: ");   Serial.println(val); // stampa la posizione attuale
    }
  }
    // -------------------- Fine programma --------------------------------------------------------



Simulazione: 

Argomenti correlati:  Arduino N° 57 - Controllo Motore passo-passo - esempio

> Arduino N°  60

Arduino N° 58 - Pilotaggio intermittente di una uscita digitale

      

< Arduino N°  57

Achille De Santis

> Arduino N°  59

Fig. 1: Modulo di prova;

Pilotaggio intermittente di una uscita digitale, con segnalazione della commutazione attraverso un breve impulso che pilota un cicalino (buzzer).

Il ciclo di commutazione viene abilitato portando a massa il piedino S (switch).

Non occorre resistenza di pull-up, già prevista internamente. 

Il dispositivo non rappresenta nulla di nuovo ma è un esempio di come si possano elaborare nuove applicazioni da cose già note: l'intermittente (o lampeggiatore) , il "buzzer" attivo (o "cicalino"), il circuito universale di prova, il relay.

/* ----------------- Inizio Programma -------------------------------------------
 * Pilotaggio intermittente di un Relay con Arduino
 * Segnalazione tramite Buzzer
 * Uso delle routines per le operazioni elementari ripetitive.
 * Aggiungere il piedino di attivazione del comando!!!!!!!!
 * Se non è necessario il relay, come separatore galvanico, 
 * si può sostituire con un transistore di adeguata potenza.  
 * Achille De Santis - V5.0 del 09-06-2020
 * 
 */
// --------------- I/O -------------------------------
 #define S    6      // ingresso switch
 #define R    13     // Uscita comando relay
 #define B    12     // Uscita comando buzzer
// ---------------------------------------------------

 const int  T1=200, T2=1000;

void intestazione()
{ Serial.println("\n ------------------------------------------------- ");
  Serial.println(" - Tecnatron - ing. Achille De Santis        - ");
  Serial.println(" - Comando uscita intermittente     V. 1.0 - "); 
  Serial.println(" - Segnalazione con buzzer                       -"); 
  Serial.println(" --------------------------------------------------\n");
}

void buzz()
{
  digitalWrite(B,HIGH);     // comanda B alto 
  delay(T1);                // attende T1 millisecondi
  digitalWrite(B, LOW);     // comanda B basso 
}

void setup()
{
  pinMode (R,OUTPUT);          // Relay: viene settato il pin R come uscita
  pinMode (B,OUTPUT);          // Buzzer: viene settato il pin B come uscita
  pinMode (S,INPUT_PULLUP);    // Switch: ingresso
  Serial.begin(9600);         // predispongo la velocità di comunicazione
  intestazione();             // intestazione, inviata alla seriale
}

void loop()
{ 
  while (digitalRead(S)==0)
  { 
    digitalWrite(R,1);  buzz(); 
    delay(T2);
    digitalWrite(R,0);
    delay(T2);                  // ritardo, poi il ciclo si ripete
  }
}
// ---------------------- Fine Programma ----------------------------------------

Simulazione: 

Comando relay con buzzer

Argomenti correlati:

Lampeggiatore, 
Intermittente, 
Lampeggiatore modulato

Arduino N° 30 - Lampeggiatore per indicatori di direzione
Arduino N° 50 - Modulo di prova per 6 uscite digitali



> Arduino N° 59