Presentata diagramma utile per chi ama sperimentare con Arduino. Si tratta di un semplice voltmetro digitale in grado di misurare in modo affidabile la tensione CC nell'intervallo 0 - 30 V. La scheda Arduino, come di consueto, può essere alimentata da una batteria da 9V.
Come probabilmente saprai, gli ingressi analogici di Arduino possono essere utilizzati per misurare Tensione CC nell'intervallo 0 – 5 V e questo intervallo può essere aumentato,
utilizzando due resistori come partitore di tensione. Il divisore ridurrà la tensione misurata al livello degli ingressi analogici di Arduino. E poi il programma calcolerà il valore reale della tensione.
Un sensore analogico sulla scheda Arduino rileva la presenza di tensione sull'alimentazione Ingresso analogico e lo converte in forma digitale per l'ulteriore elaborazione da parte del microcontrollore. Nella figura la tensione viene fornita all'ingresso analogico (A0) tramite un semplice partitore di tensione costituito dai resistori R1 (100 kOhm) e R2 (10 kOhm).
Con questi valori del divisore la scheda Arduino può essere alimentata con tensione da 0 a
55 V. All'ingresso A0 abbiamo la tensione misurata divisa per 11, cioè 55V / 11=5V. In altre parole, misurando 55V all'ingresso di Arduino abbiamo il massimo valore ammissibile 5 V. In pratica è meglio scrivere su questo voltmetro l'intervallo “0 - 30 V” in modo che rimanga
Margine di sicurezza!
Appunti
Se le letture del display non coincidono con le letture di un voltmetro industriale (da laboratorio), è necessario misurare il valore delle resistenze R1 e R2 con uno strumento accurato e inserire questi valori al posto di R1=100000.0 e R2=10000.0 nel codice del programma. Successivamente dovresti misurare la tensione reale tra i pin 5V e “Ground” della scheda Arduino con un voltmetro da laboratorio. Il risultato sarà un valore inferiore a 5 V, ad esempio sarà 4,95 V. Questo valore reale dovrebbe essere inserito nella riga di codice
vout = (valore * 5.0) / 1024.0 invece di 5.0.
Inoltre, prova a utilizzare resistori di precisione con una tolleranza dell'1%.
I resistori R1 e R2 forniscono una certa protezione contro l'aumento della tensione di ingresso. Tuttavia, ricorda che qualsiasi tensione superiore a 55 V può danneggiare la scheda Arduino. Inoltre, questa progettazione non fornisce altri tipi di protezione (contro picchi di tensione, inversione di polarità o sovratensione).
Programma voltmetro digitale
/*
Voltmetro CC
Un DVM Arduino basato sul concetto di partitore di tensione
T.K.Hareendran
*/
#includere
LCD a cristalli liquidi (7, 8, 9, 10, 11, 12);
int ingresso analogico = 0;
float vout = 0,0;
galleggiante vin = 0,0;
float R1 = 100000,0; // resistenza di R1 (100K) -vedi testo!
float R2 = 10000,0; // resistenza di R2 (10K) – vedi testo!
valore intero = 0;
configurazione nulla())(
pinMode(ingresso analogico, INPUT);
lcd.inizio(16, 2);
lcd.print("VOLTMETRO CC");
}
ciclo vuoto()
// legge il valore sull'ingresso analogico
valore = analogRead(analogInput);
vout = (valore * 5,0) / 1024,0; // vedi il testo
vin = vout / (R2/(R1+R2));
se (vin<0.09) {
vin=0.0;//istruzione per annullare la lettura indesiderata!
}
lcd.setCursore(0, 1);
lcd.print("INPUT V= ");
lcd.print(vin);
ritardo(500);
}
Diagramma schematico del voltmetro Arduino
Elenco dei componenti
Scheda ArduinoUno
Resistenza da 100 kOhm
Resistenza da 10 kOhm
Resistenza da 100 ohm
Resistenza trimmer da 10kOhm
Display LCD 16?2 (Hitachi HD44780)
Ci sono momenti in cui vuoi controllare la tensione o qualche punto in un circuito, ma non hai un voltmetro o un multimetro a portata di mano? Correre a comprare? È lungo e costoso. Prima di farlo, che ne dici di costruire tu stesso un voltmetro? Infatti con ingredienti semplici potete farcela da soli.
- Nella lezione abbiamo utilizzato una scheda compatibile con Arduino - SunFounder Uno/Mars (http://bit.ly/2tkaMba)
- Cavo dati USB
- 2 potenziometri (50k)
- LCD1602 - http://bit.ly/2ubNEfi
- Scheda di sviluppo - http://bit.ly/2slvfrB
- Ponticelli multipli
Prima di connetterci, diamo un'occhiata a come funziona.
Utilizza la scheda SunFounder Uno per la parte principale dell'elaborazione dei dati del voltmetro, LCD1602 come schermo, un potenziometro per regolare il contrasto del display LCD e un altro per dividere la tensione.
Quando si ruota il potenziometro collegato alla scheda Uno, la resistenza del potenziometro cambia, modificando così la tensione ai suoi capi. Il segnale di tensione verrà inviato alla scheda Uno tramite il pin A0 e Uno convertirà il segnale analogico ricevuto in forma digitale e lo registrerà sul display LCD. In questo modo puoi vedere il valore della tensione sulla resistenza capacitiva attuale.
LCD1602 ha due modalità operative: 4 bit e 8 bit. Quando l'IO MCU è insufficiente, è possibile scegliere la modalità a 4 bit, che utilizza solo i pin D4~D7.
Segui la tabella per collegarli.
Passaggio 4: collegare il potenziometro a LCD1602
Collega il pin centrale del potenziometro al pin Vo sull'LCD1602 e qualsiasi altro pin a GND.
Collega il pin centrale del potenziometro al pin A0 del SunFounder Uno e uno degli altri a 5 V mentre l'altro a GND.
Passaggio 6: carica il codice
Questo codice:
#includere /*********************************************** ******* *****/ const int analogIn = A0;//collegare il potenziometro ad A0 LiquidCrystal lcd(4, 6, 10, 11, 12, 13);//lcd(RS,E,D4 ,D5,D6.D7) float val = 0;// definisce la variabile come valore=0 /**************************** ******* *****************/ void setup() ( Serial.begin(9600);//Inizializza il seriale lcd.begin(16, 2) ;//imposta la posizione dei caratteri sul display LCD come Riga 2, Colonna 16 lcd.print("Valore tensione:");//print "Valore tensione:" ) /*********** ******* **********************************/ void loop() ( val = analogRead (A0);//Leggi il valore del potenziometro su val val = val/1024*5.0;// Converti i dati nel valore di tensione corrispondente in modo matematico Serial.print(val);//Stampa il numero di val sul monitor seriale Serial.print ("V"); // stampa l'unità come V, abbreviazione di tensione sul monitor seriale lcd.setCursor(6,1);//Posiziona il cursore sulla riga 1, colonna 6. Da qui devono essere visualizzati i caratteri lcd.print(val);//Stampa il numero di val sul display LCD lcd.print("V");//Quindi stampa l'unità come V, abbreviazione di tensione sul display LCD delay( 200); //Attendere 200ms)Ruotare il potenziometro per controllare la tensione sull'LCD1602 in tempo reale.
Ecco una cosa complicata. Dopo aver eseguito il codice, il display LCD ha mostrato i caratteri. Ho quindi regolato il contrasto dello schermo (passaggio graduale dal nero al bianco) ruotando il potenziometro in senso orario o antiorario finché lo schermo non ha visualizzato chiaramente i caratteri.
Prendi due batterie per misurarne la tensione: 1,5 V e 3,7 V. Sgancia la connessione del secondo potenziometro al pin A0 e GND, il che significa rimuovere il potenziometro dal circuito. Fissare l'estremità del filo A0 all'anodo della batteria e il circuito GND al catodo. NON ricollegarli o cortocircuiterete la batteria. Un valore di 0 V è una connessione inversa.
Quindi, la tensione della batteria viene visualizzata sul display LCD. Potrebbe esserci qualche errore tra il valore e il valore nominale perché la batteria non è completamente carica. Ed è per questo che ho bisogno di misurare la tensione per capire se posso usare la batteria oppure no.
PS: Se riscontri problemi con la visualizzazione sul display, consulta queste domande frequenti sui display LCD: http://wiki.sunfounder.cc/index.php?title=LCD1602/I2C_LCD1602_FAQ.
Ingressi analogici della scheda Arduino.
La scheda Arduino UNO contiene 6 ingressi analogici progettati per misurare segnali di tensione. Sarebbe più corretto dire che i 6 pin della scheda possono funzionare sia in modalità di uscita discreta che di ingresso analogico.
Questi pin sono numerati da 14 a 19. Inizialmente sono configurati come ingressi analogici ed è possibile accedervi utilizzando i nomi A0-A5. Possono essere configurati in modalità di uscita discreta in qualsiasi momento.
modalità pin(A3, USCITA); // impostazione della modalità di uscita discreta per A3
scrittura digitale(A3, BASSO); // impostando l'uscita A3 bassa
Per tornare alla modalità di ingresso analogico:
modalità pin(A3, INPUT); // impostazione della modalità di ingresso analogico per A3
Ingressi analogici e resistenze pull-up.
I resistori pull-up sono collegati ai pin di ingresso analogico, nonché ai pin discreti. Questi resistori vengono attivati utilizzando il comando
scrittura digitale(A3, ALTA); // accendere la resistenza pull-up sull'ingresso A3
Il comando deve essere applicato ad un pin configurato in modalità input.
Va ricordato che il resistore può influenzare il livello del segnale di ingresso analogico. La corrente proveniente dall'alimentatore da 5 V, attraverso il resistore pull-up, causerà una caduta di tensione attraverso la resistenza interna della sorgente del segnale. Quindi è meglio scollegare la resistenza.
Convertitore analogico-digitale della scheda Arduino.
La misurazione effettiva della tensione sugli ingressi viene effettuata da un convertitore analogico-digitale (ADC) con un interruttore per 6 canali. L'ADC ha una risoluzione di 10 bit, che corrisponde al codice all'uscita del convertitore 0...1023. L'errore di misurazione non è superiore a 2 unità della cifra meno significativa.
Per mantenere la massima precisione (10 bit), è necessario che la resistenza interna della sorgente del segnale non superi 10 kOhm. Questo requisito è particolarmente importante quando si utilizzano partitori resistivi collegati agli ingressi analogici della scheda. La resistenza dei resistori divisori non può essere troppo alta.
Funzioni software di ingresso analogico.
int analogRead(porta)
Legge il valore della tensione sull'ingresso analogico specificato. La tensione di ingresso varia da 0 al livello della tensione di riferimento (spesso 5 V) convertita in un codice da 0 a 1023.
Con una tensione di riferimento di 5 V, la risoluzione è di 5 V / 1024 = 4,88 mV.
La conversione dura circa 100 μs.
int inputCod; // codice della tensione di ingresso
ingresso floatVoltaggio; // tensione di ingresso in V
inputCod=analogicoLeggi(A3); // lettura della tensione sull'ingresso A3
inputVoltage= ((float)inputCod * 5. / 1024.); // conversione del codice in tensione (V)
void analogicoRiferimento(tipo)
Imposta la tensione di riferimento per l'ADC. Definisce la massima tensione di ingresso analogico che l'ADC può convertire correttamente. Il valore della tensione di riferimento determina anche il fattore di conversione da codice a tensione:
Tensione di ingresso = codice ADC * tensione di riferimento / 1024.
L'argomento type può assumere i seguenti valori:
- DEFAULT – la tensione di riferimento è uguale alla tensione di alimentazione del controller (5 V o 3,3 V). Per Arduino UNO R3 – 5 V.
- INTERNO – tensione di riferimento interna 1,1 V per schede con controller ATmega168 e ATmega328, per ATmega8 – 2,56 V.
- INTERNAL1V1 – tensione di riferimento interna da 1,1 V per i controller Arduino Mega.
- INTERNAL2V56 – tensione di riferimento interna da 2,56 V per i controller Arduino Mega.
- ESTERNO – sorgente di tensione di riferimento esterna, collegata all'ingresso AREF.
riferimento analogico(INTERNO); // la tensione di riferimento è 1,1 V
Voltmetro a due canali su Arduino.
Come esempio di utilizzo delle funzioni di ingresso analogico, creiamo un progetto per un semplice voltmetro digitale su Arduino. Il dispositivo deve misurare le tensioni su due ingressi analogici della scheda e trasmettere i valori misurati al computer tramite una porta seriale. Utilizzando questo progetto come esempio, mostrerò i principi per creare semplici sistemi di misurazione e raccolta di informazioni.
Decidiamo che il voltmetro debba misurare la tensione nell'intervallo almeno 0...20 V e sviluppiamo un circuito per collegare gli ingressi del voltmetro alla scheda Arduino UNO.
Se impostiamo la tensione di riferimento su 5 V, gli ingressi analogici della scheda misureranno la tensione entro 0...5 V. E abbiamo bisogno di almeno 0...20 V. Ciò significa che dobbiamo utilizzare un partitore di tensione.
La tensione all'ingresso e all'uscita del divisore è correlata dalla relazione:
Uuscita = (Uingresso / (R1 + R2)) * R2
Rapporto di trasmissione:
K = Uuscita / Uentrata = R2 / (R1 + R2)
Abbiamo bisogno di un rapporto di trasferimento di 1/4 (20 V * 1/4 = 5 V).
Per mantenere la massima precisione (10 bit), è necessario che la resistenza interna della sorgente del segnale non superi 10 kOhm. Pertanto, scegliamo il resistore R2 pari a 4,22 kOhm. Calcoliamo la resistenza del resistore R1.
0,25 = 4,22 / (R1 + 4,22)
R1 = 4,22 / 0,25 – 4,22 = 12,66 kOhm
Ho trovato resistori con una resistenza di 15 kOhm con il valore più vicino. Con resistori R1 = 15 kOhm e R2 = 4,22:
5 / (4,22 / (15 + 4,22)) = 22,77 V.
Il circuito voltmetro basato su Arduino sarà simile a questo. 
Due partitori di tensione sono collegati agli ingressi analogici A0 e A1. I condensatori C1 e C2, insieme ai resistori divisori, formano filtri passa-basso che rimuovono il rumore ad alta frequenza dai segnali.
Ho assemblato questo circuito su una breadboard.
Ho collegato il primo ingresso del voltmetro ad una fonte di alimentazione regolata e il secondo all'alimentatore da 3,3 V della scheda Arduino. Per monitorare la tensione, ho collegato un voltmetro al primo ingresso. Non resta che scrivere il programma.
Un programma per misurare la tensione utilizzando una scheda Arduino.
L'algoritmo è semplice. Necessario:
- leggere il codice ADC due volte al secondo;
- convertirlo in tensione;
- inviare i valori misurati tramite porta seriale a un computer;
- programma di monitoraggio delle porte IDE di Arduino visualizzare i valori di tensione ottenuti sullo schermo del computer.
Ti darò subito uno schizzo completo del programma.
// programma di misurazione della tensione
// sugli ingressi analogici A0 e A1
#includere
tempo del periodo di misurazione
#define R1 15. // resistenza del resistore R1
#define R2 4.22 // resistenza del resistore R2
float u1, u2; // tensioni misurate
configurazione nulla() (
Serial.begin(9600); //
MsTimer2::start(); // abilitazione interruzione
}
ciclo vuoto() (
// periodo 500 ms
if (timeCount >= MEASURE_PERIOD) (
conteggiotempo= 0;
//
// lettura del codice del canale 2 e conversione in tensione
u2= ((float)analogRead(A1)) * 5. / 1024. / R2 * (R1 + R2);
// trasferimento dati tramite porta seriale
Serial.print("U1 = "); Stampa.seriale(u1, 2);
Serial.print(" U2 = "); Serial.println(u2, 2);
}
}
// elaborazione dell'interruzione 1 ms
void timerInterrupt() (
conteggiotempo++;
}
Lasciatemi spiegare la riga in cui il codice ADC viene convertito in tensione:
// lettura del codice del canale 1 e conversione in tensione
u1= ((float)analogRead(A0)) * 5. / 1024. / R2 * (R1 + R2);
- Viene letto il codice ADC: analogRead(A0) .
- Convertito esplicitamente in formato a virgola mobile: (float) .
- Convertito in tensione sull'ingresso analogico: * 5. / 1024. Il punto alla fine dei numeri indica che si tratta di un numero in virgola mobile.
- Viene preso in considerazione il coefficiente di trasmissione del divisore: / R2 * (R1 + R2).
Carichiamo il programma sulla scheda e avviamo il monitor della porta seriale.
Due barre correnti mostrano i valori delle tensioni misurate. Tutto funziona.
Misurazione del valore medio del segnale.
Colleghiamo il primo canale del nostro voltmetro a una sorgente di tensione con un livello di ondulazione elevato. Vedremo questa immagine sul monitor.
I valori di tensione del primo canale sullo schermo del monitor si muovono e saltano costantemente. E le letture del voltmetro di controllo sono abbastanza stabili. Questo perché il voltmetro di riferimento misura il valore medio del segnale, mentre la scheda Arduino legge i singoli campioni ogni 500 ms. Naturalmente cade il momento della lettura dell'ADC punti diversi segnale. E quando alto livello L'ampiezza della pulsazione in questi punti è diversa.
Inoltre, se leggi il segnale in campioni rari separati, allora qualsiasi rumore impulsivo possono introdurre errori significativi nella misurazione.
La soluzione è prelevare diversi campioni frequenti e calcolare la media del valore misurato. Per questo:
- nel gestore degli interrupt leggiamo il codice ADC e lo sommiamo con i campioni precedenti;
- contare il tempo di media (numero di campioni di media);
- quando viene raggiunto il numero di campioni specificato, salviamo il valore totale dei codici ADC;
- Per ottenere il valore medio, dividere la somma dei codici ADC per il numero di campioni medi.
Problema da un libro di testo di matematica di terza media. Ecco uno schizzo del programma, un voltmetro a valore medio a due canali.
// programma di misura di media tensione
// sugli ingressi analogici A0 e A1
#includere
#define MEASURE_PERIOD 500 // tempo del periodo di misurazione
#define R1 15. // resistenza del resistore R1
#define R2 4.22 // resistenza del resistore R2
int conteggiotempo; // contatore del tempo
sommaU1 lunga, sommaU2; // variabili per sommare i codici ADC
lungo medioU1, medioU2; // somma dei codici ADC (valore medio * 500)
flag booleanoPronto; // indicatore di disponibilità dei dati di misurazione
configurazione nulla() (
Serial.begin(9600); // inizializzare la porta, velocità 9600
MsTimer2::set(1, timerInterupt); // interruzioni del timer, periodo 1 ms
MsTimer2::start(); // abilitazione interruzione
}
ciclo vuoto() (
if (flagReady == true) (
flagPronto=falso;
// conversione in tensione e trasferimento al computer
Serial.print("U1 = ");
Serial.print((float)avariaU1 / 500. * 5. / 1024. / R2 * (R1 + R2), 2);
Serial.print(" U2 = ");
Serial.println((float)avarageU2 / 500. * 5. / 1024. / R2 * (R1 + R2), 2);
}
}
// elaborazione dell'interruzione 1 ms
void timerInterrupt() (
conteggiotempo++; // +1 contatore di campioni di media
sommaU1+= analogRead(A0); // sommando i codici ADC
sommaU2+= analogRead(A1); // sommando i codici ADC
// verifica del numero di campioni medi
if (timeCount >= MEASURE_PERIOD) (
conteggiotempo= 0;
mediaU1= sommaU1; // sovraccarico del valore medio
mediaU2= sommaU2; // sovraccarico del valore medio
sommaU1= 0;
sommaU2= 0;
flagPronto= vero; // Il risultato della misurazione del segno è pronto
}
}
Nella formula per convertire il codice ADC in tensione, è stato aggiunto /500, il numero di campioni. Carica, avvia il monitor della porta (Cntr+Shift+M).
Ora, anche con un livello significativo di pulsazione, le letture cambiano di centesimi. Questo è solo perché la tensione non è stabilizzata.
Il numero di campioni deve essere scelto tenendo conto:
- il numero di campioni determina il tempo di misurazione;
- Come numero maggiore campioni, minore sarà l’influenza del rumore.
La principale fonte di interferenza in segnali analogiciè una rete a 50 Hz. Pertanto è consigliabile scegliere un tempo medio che sia un multiplo di 10 ms – il tempo di semiciclo di una rete a 50 Hz.
Ottimizzazione dei calcoli.
I calcoli in virgola mobile consumano semplicemente le risorse di un microcontrollore a 8 bit. Qualsiasi operazione in virgola mobile richiede la denormalizzazione della mantissa, l'operazione in virgola fissa, la normalizzazione della mantissa, la correzione dell'ordine... E tutte le operazioni con numeri a 32 bit. Pertanto, è necessario ridurre al minimo l'uso dei calcoli in virgola mobile. Ti dirò come fare nelle lezioni successive, ma ottimizziamo almeno i nostri calcoli. L'effetto sarà significativo.
Nel nostro programma, la conversione del codice ADC in tensione è scritta come segue:
(flottante)mediaU1 / 500. * 5. / 1024. / R2 * (R1 + R2)
Ci sono così tanti calcoli qui, tutti in virgola mobile. Ma la maggior parte dei calcoli sono operazioni con costanti. Parte della linea:
/ 500. * 5. / 1024. / R2 * (R1 + R2)
(float)mediaU1 * 0,00004447756
Gli stessi compilatori intelligenti riconoscono i calcoli con costanti e li calcolano in fase di compilazione. Ho una domanda su quanto sia intelligente il compilatore di Andruino. Ho deciso di verificarlo.
Ho scritto un breve programma. Esegue un ciclo di 10.000 passaggi e quindi trasmette al computer il tempo di esecuzione di quei 10.000 cicli. Quelli. permette di vedere il tempo di esecuzione delle operazioni poste nel corpo del ciclo.
// verifica dell'ottimizzazione dei calcoli
interox=876;
fluttuare y;
conteggio degli interi senza segno;
senza segno lungo timeCurrent, timePrev;
configurazione nulla() (
Serial.begin(9600);
}
ciclo vuoto() (
conta++;
// y= (float)x / 500. * 5. / 1024. / 4.22 * (15. + 4.22);
// y= (float)x * 0.00004447756 ;
if (conteggio >= 10000) (
conteggio= 0;
tempoCorrente= millis();
Serial.println(timeCurrent - timePrev);
tempoPrec= tempoCorrente;
}
}
Nella prima opzione, quando le operazioni in virgola mobile nel ciclo vengono commentate e non eseguite, il programma produce un risultato di 34 ms.
Quelli. In 34 ms vengono completati 10.000 cicli vuoti.
Poi ho aperto la riga:
y= (virgola mobile)x / 500. * 5. / 1024. / 4.22 * (15. + 4.22);
ripete i nostri calcoli. Risultato di 10.000 passaggi in 922 ms o
(922 – 34) / 10.000 = 88,8 µs.
Quelli. il completamento di questa riga di calcoli in virgola mobile richiede 89 µs. Pensavo che ce ne sarebbero stati di più.
Adesso ho chiuso questa riga con un commento e ho aperto quella successiva, moltiplicando per una costante precalcolata:
y= (virgola mobile)x * 0.00004447756 ;
Risultato di 10.000 passaggi in 166 ms o
(166 – 34) / 10.000 = 13,2 µs.
Risultato sorprendente. Abbiamo risparmiato 75,6 μs per linea. L'abbiamo completato quasi 7 volte più velocemente. Abbiamo 2 linee di questo tipo, ma potrebbero essercene molte di più nel programma.
Conclusione: i calcoli con costanti devono essere eseguiti da soli su una calcolatrice e utilizzati nei programmi come coefficienti già pronti. Il compilatore Arduino non li calcolerà in fase di compilazione. Nel nostro caso dovremmo fare questo:
#define ADC_U_COEFF 0.00004447756 // fattore di conversione del codice ADC in tensione
Serial.print((float)avariaU1 * ADC_U_COEFF, 2);
L'opzione ottimale per le prestazioni è trasferire il codice ADC al computer e con esso tutti i calcoli in virgola mobile. In questo caso, il computer deve ricevere dati programma specializzato. Il monitor della porta dell'IDE di Arduino non funzionerà.
Parlerò di altri modi per ottimizzare i programmi Arduino nelle lezioni future, se necessario. Ma senza risolvere questo problema è impossibile svilupparsi programmi complessi su un microcontrollore a 8 bit.
Un'altra lezione è apparsa sul sito (
Gli assemblaggi Arduino multifunzionali sono di grande interesse per gli appassionati di dispositivi programmabili elettronicamente fatti in casa, poiché consentono loro di dare vita a idee interessanti.
Il vantaggio principale del già pronto Circuiti Arduino risiede nell'esclusivo principio modulare a blocchi: ogni scheda può essere dotata di interfacce aggiuntive, espandendo all'infinito le possibilità di creare vari progetti.
Moduli Arduino costruito su un microcontrollore universale con il proprio bootloader, che semplifica il flashing con il necessario codice del programma, senza uso dispositivi aggiuntivi. La programmazione viene eseguita in linguaggio C++ standard.
Uno degli esempi più semplici utilizzandoArduino Sulla base di questo assemblaggio è possibile realizzare un voltmetro CC ad alta precisione con un campo di misurazione da 0 a 30 V.
Gli ingressi analogici di Arduino sono progettati per una tensione costante non superiore a cinque volt, pertanto è possibile utilizzarli a tensioni superiori a questo valore con un partitore di tensione.
Schema di collegamento dell'Areduino tramite partitore di tensione Un partitore di tensione è costituito da due resistenze collegate in serie. Si calcola utilizzando la formula:
Connettore USB esterno nell'autoradio 
Idea
Idea i dispositivi per misurare tensione, corrente, capacità, scarica e forse carica sono nati molto tempo fa e non solo per me. Puoi trovare molti giocattoli chiamati USB Tester (Dottore) per i test vari dispositivi da USB. Sono un po' più interessato dispositivo universale, indipendente dall'interfaccia, ma progettato semplicemente per determinate tensioni e correnti. Ad esempio, 0 - 20,00 V, 0 - 5,00 A, 0 - 99,99 Ah. Per quanto riguarda le funzioni, la vedo così
- Visualizza la tensione e la corrente attuali, ovvero un volt-amperometro. In linea di principio, puoi riflettere immediatamente il potere.
- Conteggio e visualizzazione della capacità accumulata. In ampere-ora e molto probabilmente in watt-ora.
- Visualizzazione del tempo di processo
- E, molto probabilmente, soglie di interruzione della tensione inferiore e superiore regolabili (limiti di scarica e carica)
Sviluppo
Per implementare calcoli e misurazioni abbiamo bisogno di un controller. Ho ricordato questa idea come parte della mia conoscenza con Arduino, quindi il controller sarà un semplice Atmega328 popolare e sarà programmato nell'ambiente Arduino. Da un punto di vista ingegneristico, la scelta probabilmente non è la migliore: il controller è un po' grosso per il compito, e il suo ADC non può essere definito di misurazione, ma... ci proveremo.
- Non salderemo molto in questo progetto. Come base, prenderemo un prodotto già pronto Modulo Arduino Pro Mini, fortunatamente i cinesi sono pronti a fornirli a 1,5 dollari al dettaglio.
- Il dispositivo di visualizzazione sarà un display 1602 - altri $ 1,5. Ho un'opzione con un modulo di interfaccia I2C, ma in questo progetto non è realmente necessario ($ 0,7).
- Per lo sviluppo abbiamo bisogno tagliere per il pane. Nel mio caso, questo è un piccolo BreadBoard da $ 1.
- Naturalmente avrai bisogno di fili e di un numero di resistori di valori diversi. Per un display 1602 senza I2C è necessario selezionare anche il contrasto: questo è fatto resistore variabile a 2 - 20 kOhm.
- Per implementare un amperometro avrai bisogno di uno shunt. In prima approssimazione potrebbe trattarsi di una resistenza da 0,1 Ohm, 5 W.
- Per implementare lo spegnimento automatico, sarà necessario un relè con contatti progettati per la corrente massima del dispositivo e una tensione pari alla tensione di alimentazione. Per controllare il relè di cui hai bisogno transistor npn e un diodo protettivo.
- Il dispositivo sarà alimentato da fonte esterna alimentazione, ovviamente, almeno 5 V. Se l'alimentazione varia notevolmente, sarà necessario anche uno stabilizzatore integrato tipo 7805 che determinerà la tensione del relè.
- Quando ArduinoPro Mini richiederà un convertitore USB-TTL per caricare il firmware.
- Per la configurazione avrai bisogno di un multimetro.
Voltmetro
Sto implementando un semplice voltmetro con un intervallo di circa 0 - 20 V. Questa nota è importante perché l'ADC del nostro controller ha una capacità di 10 bit (1024 valori discreti), quindi l'errore sarà di almeno 0,02 V (20/1024). Per implementare l'hardware, abbiamo bisogno di un ingresso analogico del controller, un divisore composto da una coppia di resistori e una sorta di uscita (un display nella versione finita, una porta seriale può essere utilizzata per il debug).
Il principio della misurazione ADC è confrontare la tensione sull'ingresso analogico con il riferimento VRef. L'uscita dell'ADC è sempre intera: 0 corrisponde a 0 V, 1023 corrisponde alla tensione VRef. La misurazione viene effettuata per serie letture sequenziali tensione e media nel periodo tra gli aggiornamenti del valore sullo schermo. La scelta della tensione di riferimento è importante perché per impostazione predefinita viene utilizzata la tensione di alimentazione, che potrebbe non essere stabile. Questo non ci soddisfa affatto: prenderemo come base una fonte di riferimento interna stabile con una tensione di 1,1 V, inizializzandola chiamando analogReference(INTERNAL). Calibreremo quindi il suo valore utilizzando le letture del multimetro.
Il diagramma a sinistra mostra una variante con controllo diretto del display (è semplicemente controllato - vedere lo schizzo standard LiquidCrystal\HelloWorld). Sulla destra c'è l'opzione I2C, che utilizzerò ulteriormente. I2C consente di risparmiare sui cavi (di cui la solita versione- 10, senza contare la retroilluminazione). Ma ciò richiede un modulo aggiuntivo e un'inizializzazione più complessa. In ogni caso è necessario prima controllare la visualizzazione dei caratteri sul modulo e regolarne il contrasto: per fare ciò è sufficiente visualizzare l'eventuale testo dopo l'inizializzazione. Il contrasto viene regolato dal resistore R1 o da un resistore simile del modulo I2C.
L'input è un divisore 1:19, che ti permette di ottenere tensione massima circa 20V (di solito un condensatore + diodo zener viene posto in parallelo all'ingresso per protezione, ma per ora questo non è importante per noi). I resistori hanno uno spread, così come il riferimento Vref del controller, quindi dopo il montaggio dobbiamo misurare la tensione (almeno l'alimentazione) in parallelo con il nostro dispositivo e un multimetro di riferimento e selezionare Vref nel codice finché le letture non corrispondono. Vale anche la pena notare che qualsiasi ADC ha una tensione di offset pari a zero (che rovina le letture all'inizio dell'intervallo), ma per ora non entreremo in questo argomento.
Sarà anche importante separare la fornitura e la misurazione del terreno. Il nostro ADC ha una risoluzione leggermente peggiore di 1mV, il che può creare problemi se il cablaggio non è corretto, soprattutto su breadboard. Poiché il layout della scheda del modulo è già stato eseguito e dobbiamo solo selezionare i pin. Il modulo ha diversi pin di “massa”, quindi dobbiamo assicurarci che l’alimentazione entri nel modulo attraverso una “massa” e le misurazioni attraverso l’altro. Per apportare modifiche, infatti, utilizzo sempre il pin di terra più vicino agli ingressi analogici.
Per controllare I2C viene utilizzata una versione della libreria LiquidCrystal_I2C - nel mio caso è indicata la piedinatura specifica del modulo I2C (i cinesi producono moduli con controlli diversi). Noto anche che I2C in Arduino prevede l'uso dei pin A4, A5 - on Scheda professionale Mini, non si trovano sul bordo, il che è scomodo per la prototipazione sul BreadBoard.
