Da qualche anno fa parlare di se una piccola scheda con nicrocontrollore ATMEL. La scheda, progettata interamente in Italia, si chiama ARDUINO.
Non staro' qui a soffermarmi troppo su cosa essa sia e sul perche' sia diventata di fatto uno standard di riferimento mondiale per quanti intendano con poca spesa e relativamente modesto impegno dedicarsi alla progettazione e realizzazione dei piu' disparati circuiti elettronici. Potete trovarte ottimo materiale divulgativo su wikipedia e sul sito ufficiale di Arduino .
Qui si vuole descrivere, in maniera piu' possibile didattica, la realizzazione di un semplice keyer utilizando una scheda Arduino UNO.
Un keyer e’ un circuito elettronico di supporto ad un manipolatore cosidetto “iambic” formato da due palette azionanti due switchs. L’insieme manipolatore-keyer inviera’ al trasmettitore una sequenza alternata di punti e di linee in relazione a quale delle due palette venga premuta o alla depressione contemporanea delle medesime (squeeze).
Un operatore non mancino, utilizzera’ il manipolatore premendo con il pollice la paletta sinistra (producendo in tal modo una serie di punti) e premendo con l’indice la paletta destra (producendo una serie di linee).
Fig 1 Esempio di tasto a due palette
La depressione contemporanea delle due palette produrra’ una serie di punto-linea o linea-punto in relazione a quale delle due palette viene premuta per prima. Alcuni tasti sono dotati di una singola paletta che aziona lo switch dei punti se spostata con il pollice verso destra e lo switch delle linee se spostata con l’indice verso sinistra. E’ chiaro che questo tipo di manipolatore non potra’ essere utilizzato per la manovra di squeeze (produzione di sequenze automatiche di pinto-linea).
Fig 2 esempio di tasto a singola paletta.
Vediamo ora come realizzare un keyer con Arduino.
E’ evidente che avremo bisogno di 2 ingressi digitali ed una uscita digitale. Chiameremo il primo ingresso “pp” (paletta-punto) ed il secondo ingresso” pl” (paletta- linea). L’uscita la chiameremo semplicemente “uscita”. Metteremo inoltre a livello logico 1 i due ingressi mediante delle resitenze di pull-up verso il positivo dei 5 V. Con questa configurazione collegando il manipolatore ai due ingressi ed alla massa (negativo della scheda) manderemo a 0 logico “pp” e/o “pl” premendo le palette. Sara’ necessario tenere conto di questo nella stesura del programma di funzionamento.
L’uscita sara’ invece a livello logico 0 in condizioni di riposo ed a livello logico 1 quando attiva. Questo ci permettera’ di simulare la trasmissione di punti o linee visualizzando il lampeggiamento del LED di sistema posizionato sul pin 13 del connettore di Arduino. Se vogliamo utilizzare questa uscita per pilotare un RTX dovremo interporre un rele’ oppure un transistor NPN.
Nella logica del programma utilizzeremo tre variabili:
vel = variabile che conterra’ il valore di velocita’ di trasmissione in car/min
dp = variabile durata-punto che conterra’ la durata in ms del punto
dl = variabile durata –linea che conterra’ la durata in ms della linea (normalmente 3 volte il punto).
Adesso e’ necessaria una analisi dei dati di funzionamento per stabilire la durata del punto e della linea in relazione alla voluta velocita’ di trasmissione.
Partiamo dai seguenti presupposti:
·la durata del punto e’ uguale ad un Bit
·la durata della linea e’ uguale a 3 Bit
·la durata dello spazio tra i singoli elementi di un carattere e’ uguale a 1 punto = 1 Bit
·la durata dello spazio tra i singoli caratteri e’ uguale ad una linea = 3 Bit
·la durata dello spazio tra le parole e’ uguale 7 Bit
Per la determinazione della velocita’ di trasmissione faremo riferimento allo standard PARIS nel quale la durata media del singolo carattere viene determinata analizzando appunto la parola PARIS con le relative spaziature.
Quindi
P
di da da di
1 1 3 1 3 1 1 + (3) = 14 Bit
A
di da
1 1 3 + (3) = 8 Bit
R
di da di
1 1 3 1 1 + (3) = 10 Bit
I
di di
1 1 1 + (3) = 6 Bit
S
di di di
1 1 1 1 1 + [7] = 12 Bit
Total = 50 elements
Nello schema precedente si assume:
() = spazio tra carattere
[] = spazio tra parole
Quindi abbiamo determinato che per trasmettere la parola PARIS occorrono 50 Bit. Essendo la parola PARIS composta da 5 caratteri diremo che mediamente ogni carattere avra’ una lunghezza di 10 Bit (o punti che dir si voglia)
Per trasmettere un carattere al minuto dovremo spedire 10 punti, per cui ogni punto avra’ una durata, in secondi 60/10 ovvero in ms 60000/10 ovvero 6000 ms. Generalizzando possiamo dire che la durata di un punto alla velocita’ di n car/min sara’ uguale, in ms, a 6000/n. Per esempio alla velocita’ di 60 car/min la durata di un punto sara’ uguale a 100 ms.
Bene ora abbiamo tutti gli elementi per scrivere il nostro programma:
Disegnamo per prima cosa il flowchart.
Adesso traduciamo in “Arduinese”:
/* Arduino keyer
Autore: Mariano Mezzetti iw0dvv
Revisione: 1.0
Scopo: Semplice keyer: il programma controlla ingresso punto ed ingresso linee
e genera uscita punti e linee ripetuti fino al rilascio chiave
Il calcolo della velocita' e' basato sullo standard PARIS
*/
#define pp 2 //paletta punti ingresso 2
#define pl 3 //paletta linee ingresso 3
#define uscita 13 //piedino uscita 13
int vel = 40;//variabile contenente valore car.min
int dp = 0 ; //variabile durata punto in ms
int dl = 0 ; //variabile durata linea in ms
void setup() {
pinMode(pp,INPUT);
pinMode(pl,INPUT);
pinMode(uscita,OUTPUT);
dp = 6000/vel; //calcola durata punto
dl = dp * 3 ; // calcola durata linea
}
void loop() {
if(!digitalRead(pp)) {
digitalWrite(uscita,HIGH);
delay(dp);
digitalWrite(uscita,LOW);
delay(dp);
}
if(!digitalRead(pl)) {
digitalWrite(uscita,HIGH);
delay(dl);
digitalWrite(uscita,LOW);
delay(dp);
}
}
Nell'esempio che segue le istruzioni per generare i punti e le linee sono raggruppati in due funzioni( routine) chiamate rispettivamente punto() e linea(). Nel loop pricipale in questo caso basta richiamare le due funzioni in sequenza. Altra particolarita' e' che non sono dichiarati gli ingressi e le uscite (pinMode) in quanto non strettamente necessario assegnando il compilatore autonomamente il modo di funzionamento.
/* Arduino keyer
Autore: Mariano Mezzetti iw0dvv
Revisione: 1.0
Scopo: Semplice keyer: il programma controlla ingresso punto ed ingresso linee
e genera uscita punti e linee ripetuti fino al rilascio chiave
Il calcolo della velocita' e' basato sullo standard PARIS
*/
#define pp 2 //paletta punti ingresso 2
#define pl 3 //paletta linee ingresso 3
#define uscita 13 //piedino uscita 13
int vel = 40; //variabile contenente valore car.min
int dp = 0 ; //variabile durata punto in ms
int dl = 0 ; //variabile durata linea in ms
void setup() {
dp = 6000/vel; //calcola durata punto
dl = dp * 3 ; // calcola durata linea
}
void loop() {
if(!digitalRead(pp)) punto();
if(!digitalRead(pl)) linea();
}
void punto(){
digitalWrite(uscita,HIGH);
delay(dp);
digitalWrite(uscita,LOW);
delay(dp);
}
void linea(){
digitalWrite(uscita,HIGH);
delay(dl);
digitalWrite(uscita,LOW);
delay(dp);
}
Tuttavia nei due esempi precedenti la velocita' di trasmissione viene definita una volta per tutte al seup nella riga di comando
val= 40;
Quindi per modificare la velocita' occorera' modificare tale valore e successivamente ricompilare il tutto: piuttosto scomodo!
Allora, visto che abbiamo abbondanza di linee di input-output decidiamo di utilizzarne 4 per implementare un controllo di velocita' digitale mediante un contraves binario.
Utilizziamo le linee 4, 5, 6,7 per collegare il contraves con il comune a massa. Anche in questo caso saranno necessarie delle resitenze di pull-up verso il positivo dell'alimentazione.
Il listato che ne consegue e' il seguente:
/* Arduino keyer
Autore: Mariano Mezzetti iw0dvv
Revisione: 1.0
Scopo: Semplice keyer: il programma controlla ingresso punto ed ingresso linee
e genera uscita punti e linee ripetuti fino al rilascio chiave
Il calcolo della velocita' e' basato sullo standard PARIS
*/
#define pp 2 //paletta punti ingresso 2
#define pl 3 //paletta linee ingresso 3
#define uscita 13 //piedino uscita 13
int vel = 40; //variabile contenente valore car.min
int dp = 0 ; //variabile durata punto in ms
int dl = 0 ; //variabile durata linea in ms
void setup() {
vel=(!digitalRead(4)+ !digitalRead(5)*2 +!digitalRead(6)*4 +!digitalRead(7)*8)*10;
dp = 6000/vel; //calcola durata punto
dl = dp * 3 ; // calcola durata linea
}
void loop() {
if(!digitalRead(pp)) punto();
if(!digitalRead(pl)) linea();
}
void punto(){
digitalWrite(uscita,HIGH);
delay(dp);
digitalWrite(uscita,LOW);
delay(dp);
}
void linea(){
digitalWrite(uscita,HIGH);
delay(dl);
digitalWrite(uscita,LOW);
delay(dp);
}
Come si puo' chiaramente vedere la velocita' viene letta come somma pesata su potenza di due delle letture negate degli ingressi 4,5,6,7, dove il contraves pone a massa i pin relativi al numero binario.
Utilizando un solo contraves, la somma viene poi moltiplicata per 10. In questo modo sono possibili velocita' da 10 a 90 car/min (volendo fino a 100 utilizzando in valore zero come se fosse 10,,,,). in passi da 10.
Per il momento e' tutto.
Spero di essere stato utile e di aver introdotto argomenti su cui sperimentare.
73 de iw0dvv Mariano
