Galleria fotografica della realizzazione di un orologio a tubi Nixie, funzionante con Arduino Nano e RTC (link articolo)
È stata realizzata una scheda elettronica su cui montare tutti i componenti necessari e una scatola di legno per nascondere i circuiti:
Schema elettrico del circuito
Si noti l’Arduino Nano come cuore del circuito, e le connessioni verso l’esterno per RTC e alimentazioni a 5V e 170V.
Gli integrati a sinistra sono drivers appositamente realizzati per i tubi Nixie, ricevono un input digitale a 4 bit 5 Volt, alimentazione sempre a 5V e mettono il pin selezionato a massa (motivo per cui tutto il circuito ha masse comuni tra alta e bassa tensione).
Mentre i vari catodi dei tubi vengono tenuti scollegati oppure messi a massa a seconda della cifra da accendere, la cassa dell’anodo o potenziale comune è collegato a 170V tramite 10kΩ di resistenza di protezione.
Creazione della scheda
Inizio sbroglioCollegamenti disegnati a manoFine progettazione
Il disegno dello schema elettrico e della scheda stampata sono stati realizzati su EasyEDA gratuitamente. Successivamente è stata acquistata per riceverla a casa.
Particolare dei drivers
Fase di montaggio dei componenti. Gli integrati sono drivers con cui i pin digitali di Arduino pilotano i catodi dei tubi. Questo non può essere fatto direttamente perché mentre il microcontrollore lavora a 5V, i display si alimentano a 170V.
Scheda completataUltimi collegamenti
Scheda inserita nella sua scatola insieme ai due alimentatori switching step-up e step-down, che forniscono le due alimentazioni a 5V e 170V partendo dal jack che fornisce 24V.
Prodotto finito, cavo di alimentazione nascosto dietro
In questo articolo vedremo un componente elettronico che può essere usato insieme a un microcontrollore per misurare il tempo, un real time clock (RTC).
Questo vi permetterà di costruire orologi accurati in grado di restare a punto anche mentre il vostro progetto è spento.
In particolare ora vedremo come programmare e usare il DS3231 con una scheda Arduino, usando la libreria di Adafruit “RTClib 1.10.0”.
Se siete amanti dei delay(1000); levatevi di torno.
DS3231 sulla sua breakout board
Il componente si presenta su una scheda di supporto con altri componenti necessari come regolatori di alimentazione e una batteria montata sul lato inferiore, questa entra in funzione quando il resto del circuito si spegne e l’alimentazione a 5V viene a mancare, dato che nessun sistema può contare il tempo senza una fonte di energia.
Nella figura si notano anche i due contatti per comunicazione seriale I2C, che andranno direttamente all’Arduino, e anche due uscite da 32kHz e 1Hz, utilizzabili ma non necessarie per costruire un orologio.
Programmazione:
DateTime viene usata sia come funzione sia come variabile:
– Usata come variabile, è una struttura in grado di contenere una data;
– Usata come funzione, calcola una data prendendo in input dati di tempo, inseriti dal più significativo al più preciso, cioè in ordine di anni, mesi, giorni, ore, minuti e secondi, per poi salvarli su una struttura DateTime.
Dove X è una variabile di tipo DateTime che indica l’istante un secondo prima di capodanno 2021.
In alternativa si possono usare due funzioni dell’applicazione di Arduino, ossia __DATE__ per la data e __TIME__ per l’orario, questi due ” #define speciali ” al momento della compilazione dello sketch vengono sostituiti con data e ora del computer in uso.
Esempio:
DateTime Y = ( DateTime( F(__DATE__) , F(__TIME__) ) );
Dove Y è una variabile di tipo DateTime che indica l’istante in cui è stata lanciata la compilazione del codice.
Suggerisco di eseguire la sincronizzazione dell’orologio del computer prima di lanciare la compilazione.
Un’altra funzione è TimeSpan e serve per “spostarsi” avanti o indietro nel tempo a partire da un punto di riferimento, definito da un’altra variabile DateTime. Questa funzione prende in ingresso 4 valori, cioè giorni, ore, minuti e secondi, (non mesi o anni dato che hanno durata irregolare/indefinita).
Esempio:
DateTime Z = ( X + TimeSpan( 0 , -1 , 0 , 10 ) );
Dove Z è una variabile di tipo DateTime che indica l’istante 59 minuti e 51 secondi prima di capodanno 2021, cioè 59 minuti e 50 secondi prima di X.
DateTime K = ( X + TimeSpan( 0 , -1 , 60 , 0 ) );
Modo inutilmente complicato per creare una copia di X.
Messa a punto iniziale tramite Arduino:
Per mettere in funzione la scheda bisogna prima scrivere un codice di messa a punto e realizzare un semplice circuito con 4 fili tra TRC e Arduino (5V, gnd, SCL, SDA), collegarli al computer tramite USB, inserire una batteria nel retro dell’RTC e assicurarsi che l’orario del computer sia a punto.
Per sapere quali pin dell’Arduino corrispondono a SCL e SDA consultare il datasheet (variano tra Uno, Mega, Nano e Micro).
Codice per la programmazione. Ricorda di scollegare l’RTC per evitare che venga riprogrammato con il vecchio orario quando l’Arduino si riavvia.
Utilizzo:
Ovviamente il codice dipenderà dal vostro progetto, ma qui sotto potete trovare un esempio di chiamata per la lettura del dato dall’RTC.
Comandi per stampare su monitor seriale tutte le letture in un’unica frase.
Come potete osservare, il componente dispone anche di un termometro. Questa funzione è presente per via della grossa dipendenza della frequenza di oscillazione del quarzo dalla sua temperatura. Il DS3231 è provvisto di un meccanismo di bilanciamento automatico, che lo rende un orologio più preciso di molti altri digitali moderni. È molto più preciso del mio portatile.
Vettori di stringhe usati per completare la frase a monitor seriale.
L’RTC restituisce i mesi e i giorni della settimana come numeri interi. Per sostituirli con le parole italiane corrispondenti, invece di fare maree di if, si può fare in modo che il valore ricevuto in seriale sia indice di un vettore che contiene le parole desiderate.
Nota:
Il circuito non gradisce letture troppo frequenti, consiglio un minimo di qualche decimo di secondo tra una lettura e l’altra.
Fusi orari:
Dopo aver detto tutto questo bisogna far presente che il DS3231 non calcola automaticamente i passaggi tra orari legale e solare, quindi per evitare di dover mettere a punto il vostro progetto due volte all’anno potete adottare varie possibili soluzioni, come ad esempio lasciare l’RTC a punto con l’orario solare tutto l’anno, ma riportando un’ora in più in uscita se il microcontrollore calcola di essere in estate.
Cambio di orario in Italia:
Alle 2 di notte dell’ultima Domenica di Marzo, si spostano gli orologi un’ora avanti e si ha quindi un giorno di 23 ore.
Per tutta l’estate è in vigore l’orario LEGALE. (Coordinated Universal Time + 2 ore)
Alle 2 di notte dell’ultima Domenica di Ottobre, si spostano gli orologi un’ora indietro e si ha un giorno di 25 ore.
Per tutto l’inverno è in vigore l’orario SOLARE. (Coordinated Universal Time + 1 ora)
Se ipotizziamo che il nostro RTC resti impostato sull’orario solare tutto l’anno, allora Arduino, a ogni lettura, prima di mandarla in output dovrà calcolare se aggiungere un’ora extra oppure no.
Per fare ciò occorrerà una serie di if-else in cascata per restringere il campo attorno alle date di cambio orario, fino al livello di precisione che si vuole ottenere.
Altro:
-Pin “32K”, attivo di default (onda quadra 32000 Hz):
rtc.disable32K(); Per disattivare il pin
rtc.enable32K(); Per riattivare il pin
Serial.println( rtc.isEnabled32K() ); Restituisce 0 se spento o 1 se acceso
-Pin “SQW”, disattivo di default (onda quadra 1 Hz):
rtc.writeSqwPinMode( DS3231_OFF ); Per disattivare il pin
rtc.writeSqwPinMode( DS3231_SquareWave1Hz ); Per attivare il pin
Qualora si voglia realizzare in autonomia un veicolo, velivolo o a qualsiasi altra macchina con Arduino può essere bello realizzarlo a controllo remoto con un proprio radiocomando. Il vantaggio di realizzare un radiocomando con Arduino è principalmente quello di poterselo personalizzare. Arduino per quanto semplice è anche molto personalizzabile e può essere stimolante progettare un radio comando specifico per le proprie applicazioni.
In questo caso verrà realizzato un radiocomando utile per più scopi
Cosa serve?
*Qui elencherò le componenti da utilizzare, a seconda di come andrete a personalizzare il vostro radiocomando togliere e aggiungerete parti.
Componenti
Arduino Nano
2 potenziometri
2 joystick
Cavetti vari (sono più pratici quelli con pin maschio e/o femmina per applicazioni come le schede Arduino)
4 tasti
Antenna NRF24L01 + PA +LNA
Interruttore
Batteria (facoltativo, il radiocomando potrebbe essere comandato anche via cavo con la corrente domestica con appositi alimentatori)
Strumenti
1 cavetto per collegare la scheda Arduino al computer (in questo caso da USB-B a Mini USB-B)
Computer per programmare la scheda con Arduino IDE installato
Saldatrice per stagno (non indispensabile se si usano componenti con dei pin appositi)
Stampante 3D per il case (sostituibile ad esempio con del legno o del plexiglass, basta un po’ di inventiva, vedi sotto)
Design del radiocomando
Oltre che all’ergonomia per l’impugnatura bisogna pensare agli spazi occupati dalle componenti e dalla cavetteria. Il consiglio è quello di realizzarsi uno schema con i vari componenti così da rendersi conto dell’ingombro generale.
Ovviamente la disposizione delle componenti dipende dai vostri gusti.
Per mantenere le dimensioni compatte ho scelto un Arduino Nano. Per comodità personale ho rivolto il connettore mini USB-B verso sinistra, ma in generale sarebbe più pratico averlo prossimo alla superficie esterna. L’antenna conviene sempre metterla quanto più esterna possibile, la batteria con l’interruttore di accensione dovranno essere di facile accesso.
Il radiocomando finito sarà pressappoco così:
Ovviamente nelle parti cave saranno presenti i joystick, l’interruttore, ecc…
Se si volesse usare più semplicemente del legno o del plexiglass basta sagomare due strati distanziati con in mezzo le componenti.
Programmazione radiocomando
Prima di tutto è necessario avere le librerie dei vari componenti, in questo caso è importante avere la libreria dell’antenna usata.
Clicca il bottone qui sotto per scaricare quella usata qui.
//Prima di tutto si devono inserire nello sketch le libreria che si
andranno ad usare
#include <SPI.h>
#include <nRF24L01.h>
#include <printf.h>
#include <RF24.h>
#include <RF24_config.h>
#include <Wire.h>
//Si definiscono le variabili per i segnali digitali, nel nostro caso
i bottoni o eventuali interruttori
int b1 = 12;
int b2 = 10;
int b3 = 5;
int b4 = 6;
//Ora bisogna impostare i canali radio per l'antenna, si assegnano a D6 e D7
i pin CE e CSN dell'antenna (come da sketch) e si imposta il canale (in questo caso 01998)
RF24 radio (8, 9);
const byte address[9] = "01998";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;
//Si crea una struttura di dati. Qui si è indicato con Pot i potenziometri,
con button i pulsanti e con j i joystick, ognuno con 2 potenziometri
struct Pacchetto_Dati {
byte Pot1;
byte Pot2;
byte button1;
byte button2;
byte button3;
byte button4;
byte j1PotV;
byte j2PotV;
byte j1PotL;
byte j2PotL;
};
Pacchetto_Dati data;
void setup() {
//Si inizializza il seriale
Serial.begin(9600);
//I seguenti comandi attivano l'antenna in base alla libreria inserita
radio.begin();
radio.openWritingPipe(address);
radio.setAutoAck(false);
radio.setDataRate(RF24_250KBPS);
radio.setPALevel(RF24_PA_LOW);
//Si inizializzano i pulsanti (e eventuali interruttori)
pinMode(b1, INPUT_PULLUP);
pinMode(b2, INPUT_PULLUP);
pinMode(b3, INPUT_PULLUP);
pinMode(b4, INPUT_PULLUP);
//Qui si impostano i valori iniziali ai vari potenziometri/pulsanti.
Quando il potenziometro sarà in posizione neutra avrà valore 127, i pulsanti
avranno valore 1 (si spiega al prossimo passaggio perché)
data.j1PotV = 127;
data.j2PotV = 127;
data.j1PotL = 127;
data.j1PotL = 127;
data.Pot1 = 127;
data.Pot2 = 127;
data.button1 = 1;
data.button2 = 1;
data.button3 = 1;
data.button4 = 1;
}
void loop() {
//I valori letti da Arduino per i potenziometri vanno da 0 a 1023,
ossia 1024 bit, l'antenna però non è in grado di supportare una struttura
superiore a 32 byte, ossia 256 bit. Per questo bisogna "rimappare" i
valori da 0 a 255.
data.j1PotV =map(analogRead(A0), 0,1023, 0,255);
data.j2PotV =map(analogRead(A2), 0,1023, 0,255);
data.j1PotL =map(analogRead(A1), 0,1023, 0,255);
data.j1PotL =map(analogRead(A3), 0,1023, 0,255);
data.Pot1 =map(analogRead(A4), 0,1023, 0,255);
data.Pot2 =map(analogRead(A5), 0,1023, 0,255);
//Si leggono i valori dei vari bottoni che normalmente sono a valore alto (=1)
mentre quando vengono premuti vengono letti a valore basso (=0)
data.button1 = digitalRead(b1);
data.button2 = digitalRead(b2);
data.button3 = digitalRead(b3);
data.button4 = digitalRead(b4);
}
Come fatto notare prima bisogna rispettare una dimensione massima per la struttura di dati di 32 byte supportati dall’antenna.
Chi comunica con il radiocomando?
Per ricevere questo segnale la cosa più semplice da fare è mettere sulla macchina una scheda Arduino con la stessa antenna. Questa prenderà il segnale, analizzerà la struttura dati, e in base ai comandi imposti al radiocomando potrà eseguire determinate azioni.
La prima parte del codice sarà abbastanza simile in quanto si andrà a inizializzare i vari input e l’antenna. La seconda metà invece dovrà prendere i dati e usarli. Successivamente questi dati verranno resettati e si ripartirà con i dati successivi.
Si riporta un esempio esemplificato. In futuro verrà riportato un esempio pratico.
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(10, 9); // nRF24L01 (CE, CSN)
const byte address[6] = "01998";
//l'indirizzo dovrà essere lo stesso
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;
struct Data_Package {
byte j1PotV;
byte j1PotL;
byte j2PotV;
byte j2PotL;
byte Pot1;
byte Pot2;
byte button1;
byte button2;
byte button3;
byte button4;
};
Data_Package data; //Create a variable with the above structure
void setup() {
Serial.begin(9600);
radio.begin();
radio.openReadingPipe(0, address);
radio.setAutoAck(false);
radio.setDataRate(RF24_250KBPS);
radio.setPALevel(RF24_PA_LOW);
radio.startListening(); // Set the module as receiver
resetData();
}
void loop() {
// controlla la presenza di un emettitore
//Nel nostro caso il radiocomando
if (radio.available()) {
radio.read(&data, sizeof(Data_Package));
// Legge i dati in "data"
lastReceiveTime = millis();
// Ora si hanno effettivamente i dati
}
currentTime = millis();
if ( currentTime - lastReceiveTime > 1000 ) {
//Si esegue un controllo dei tempi di ricezione
// Se "currenttime" è più di 1 secondo dal segnale precedente
allora non si è più connessi
resetData();
//Quindi si resettano i dati per evitare problemi
}
// Print the data in the Serial Monitor
Serial.print("j1PotV: ");
Serial.print(data.j1PotV);
Serial.print("; j1PotL: ");
Serial.print(data.j1PotL);
Serial.print("; button1: ");
Serial.print(data.button1);
Serial.print("; j2PotV: ");
Serial.println(data.j2PotL);
}
void resetData() {
// Reset the values when there is no radio connection - Set initial default values
data.j1PotX = 127;
data.j1PotY = 127;
data.j2PotX = 127;
data.j2PotY = 127;
data.j1Button = 1;
data.j2Button = 1;
data.pot1 = 1;
data.pot2 = 1;
data.tSwitch1 = 1;
data.tSwitch2 = 1;
data.button1 = 1;
data.button2 = 1;
data.button3 = 1;
data.button4 = 1;
}
*Makers ITIS Forlì non si assumono alcuna responsabilità per danni a cose, persone o animali derivanti dall’utilizzo delle informazioni contenute in questa pagina. Tutto il materiale contenuto in questa pagina ha fini esclusivamente informativi.
Quante volte ti capita di essere seduto comodamente sul divano a riposarti, dopo una lunga giornata di lavoro, ma la velocità del ventilatore non è quella giusta e ti tocca alzarti !!! Dopo questa lettura risolverai il tuo problema.
Prototipo iniziale :
Un primo prototipo del progetto è stato realizzato da Davide Di Stasio, utilizzando un ventilatore, Arduino UNO, un vecchio trasformatore e un telecomando della tv.
Scatola, progettata e stampata in 3D in PLA grigio
Viti di fissaggio
Realizzazione circuito elettrico
Per realizzare la parte di controllo del ventilatore tramite un telecomando per esempio della televisione, ho utilizzato componenti poco costosi e di facile utilizzo. Qui di sotto riporto i collegamenti fatti tra il ventilatore e il controllore.
Circuito di controllo del ventilatore
Per alimentare Arduino UNO ho riciclato un vecchio alimentatore da 9V e 0,5 A. Il motore del ventilatore ha 3 fili che gestiscono le velocità e vanno collegati ai 3 Moduli relè, 2 fili vanno collegati al condensatore di spunta e l’ultimo al neutro. Il quarto relè serve come interruttore generale del progetto ovvero accende o spegne il ventilatore. Il sensore IR serve per la ricezione del segnale a infrarosso del telecomando. Per alimentarlo servono i 5V presi da Arduino UNO, un piedino di massa (GND) e il pin digitale 9 di Arduino UNO.
Programma per il controllo del ventilatore con telecomando
Per la realizzazione del codice di controllo del ventilatore, ho adottato una tecnica molto efficace ed affidabile: Automa a Stati. Permette di avere uno stato per ogni fase di lavoro del ventilatore, ovvero quando si clicca un pulsante si determina una velocità. Ovviamente l’algoritmo deve essere estremamente sicuro, ovvero senza bugs, cioè quando si attiva una velocità, le altre velocità del motore devono essere spente perchè si rischia di bruciare* il tutto. A maggior ragione, quando si vuole spegnere il ventilatore con il telecomando, bisogna poterlo fare in ogni istante del suo funzionamento. La libreria da scaricare e installare su IDE di Arduino, serve per il controllo del sensore IR.
Dato che ogni telecomando ha una serie di codici associati ad ogni tasto, bisognerà utilizzare l’esempio IRrecord.ino contenuto nella libreria IRremote.h per codificare il proprio telecomando.
Progettazione scatola stampata in 3D con il PLA grigio
La scatola per contenere tutta l’elettronica di controllo del ventilatore è stata progettata al CAD con Inventor e poi stampata in 3D con il PLA grigio perchè non sono richieste proprietà meccaniche.
Per scaricare i file, cliccare il pulsante qui sotto.
Una volta che avete capito come realizzare il Circuito Elettrico, il programma caricato su Arduino e aver stampato la scatola per i componenti, è il momento di assemblare i vari pezzi.
Smontare il selettore delle velocità del ventilatore, ovviamente assicuratevi di staccare la spina dalla 220V !!!
Sfruttando i fori presenti nel ventilatore, montare la scatola stampata in 3D in PLA grigio, come mostra la foto qui di seguito:
Collegare i 4 relè con i fili delle velocità del motore e il suo condensatore di spunta, come mostra la foto qui di seguito:
Prendere il primo coperchio, dove va alloggiato l’alimentatore e Arduino UNO, fissatelo con 4 viti.
Collegare poi alimentatore, i pin di controllo dei relè e il sensore IR ad Arduino UNO. Il sensore IR andrà posizionato nella parte frontale del ventilatore.
Per finire prendere il secondo coperchio e fissarlo con due viti.
*Makers ITIS Forlì non si assumono alcuna responsabilità per danni a cose, persone o animali derivanti dall’utilizzo delle informazioni contenute in questa pagina. Tutto il materiale contenuto in questa pagina ha fini esclusivamente informativi.
