Viene presentato uno schema utile per coloro che amano sperimentare con Arduino. Questo è un semplice voltmetro digitale in grado di misurare in modo affidabile la tensione CC nell'intervallo 0 - 30 V. La scheda Arduino, come al solito, può essere alimentata da una batteria da 9V.
Come probabilmente saprai, gli ingressi analogici di Arduino possono essere utilizzati per misurare la tensione CC nell'intervallo 0 - 5V e questo intervallo può essere aumentato,
utilizzando due resistori come divisore 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.
Il sensore analogico sulla scheda Arduino rileva la presenza di tensione all'ingresso analogico e la converte in una forma digitale per l'ulteriore elaborazione da parte del microcontrollore. Nella figura, la tensione viene applicata all'ingresso analogico (A0) attraverso un semplice partitore di tensione costituito dai resistori R1 (100kΩ) e R2 (10kΩ).
Con questi valori di divisore, la scheda Arduino può essere alimentata con tensione da 0 a
55V. All'ingresso A0 abbiamo la tensione misurata divisa per 11, ovvero 55V / 11=5V. In altre parole, quando si misurano 55V all'ingresso Arduino, abbiamo il valore massimo consentito di 5V. In pratica è meglio scrivere l'intervallo “0 - 30V” su questo voltmetro per rimanere
Margine di sicurezza!
Appunti
Se le letture del display non corrispondono alle letture di un voltmetro industriale (da laboratorio), è necessario misurare la resistenza R1 e R2 con uno strumento accurato e inserire questi valori al posto di R1=100000.0 e R2=10000.0 nel programma codice. Quindi dovresti misurare la tensione reale tra i terminali 5V e "Ground" della scheda Arduino con un voltmetro da laboratorio. Il risultato sarà un valore inferiore a 5 V, ad esempio è risultato 4,95 V. Questo valore reale deve essere inserito in una 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 tensioni di ingresso elevate.Tuttavia, tieni presente che qualsiasi tensione superiore a 55V può danneggiare la scheda Arduino. Inoltre, questo design non fornisce altri tipi di protezione (da sovratensioni, da inversione di polarità o sovratensione).
Programma Voltmetro Digitale
/*
Voltmetro CC
Un DVM Arduino basato sul concetto di divisore di tensione
TK Hareendran
*/
#includere
LCD a cristalli liquidi (7, 8, 9, 10, 11, 12);
int analogicoInput = 0;
valore mobile = 0,0;
float vin = 0,0;
float R1 = 100000,0; // Resistenza di R1 (100K) -vedi testo!
float R2 = 10000,0; // Resistenza di R2 (10K) - vedi testo!
valore int = 0;
configurazione vuota()(
pinMode(ingresso analogico, INGRESSO);
lcd.begin(16, 2);
lcd.print("VOLTMETRO CC");
}
ciclo vuoto()(
// legge il valore sull'ingresso analogico
valore = analogRead(analogInput);
vout = (valore * 5,0) / 1024,0; // vedi testo
vin = vout / (R2/(R1+R2));
se (vin<0.09) {
vin=0.0;//istruzione per annullare la lettura indesiderata!
}
lcd.setCursor(0, 1);
lcd.print("INPUT V=");
stampa lcd(vin);
ritardo(500);
}
Diagramma schematico del voltmetro Arduino
Elenco dei componenti
Scheda Arduino Uno
Resistenza da 100 kΩ
Resistenza da 10 kΩ
Resistenza da 100 ohm
Resistenza trimmer da 10 kΩ
Display LCD 16×2 (Hitachi HD44780)
Con alcune aggiunte.
Una caratteristica poco nota di Arduino e di molti altri chip AVR è la capacità di misurare la tensione di riferimento interna di 1,1 V. Questa funzione può da usare per migliorare la precisione Funzioni Arduino - analogRead usando tensione di riferimento standard di 5 V (su piattaforme con tensione di alimentazione di 5 V) o 3,3 V (su piattaforme con tensione di alimentazione di 3,3 V).Può anche esserlo usato per misurare Vcc applicato al chip che fornisce mezzo di controllo voltaggio batteria senza uso preziose uscite analogiche.
Motivazione
Ci sono almeno almeno due ragioni per misurare tensione di alimentazione il nostro Arduino (Vcc). Uno di questi è il nostro progetto alimentato a batteria se vogliamo monitorare il livello di tensione della batteria. Inoltre, quando la potenza della batteria (Vcc) non può essere di 5,0 volt (ad es. 1,5 V di alimentazione a 3 celle) e vogliamo rendere le misurazioni analogiche più accurate, dobbiamo utilizzare un riferimento di tensione interno di 1,1 V o un riferimento di tensione esterno. Come mai?
Quando si utilizza analogRead() si presume comunemente che la tensione di alimentazione analogica del controller sia 5,0 volt, quando in realtà potrebbe non essere affatto così (ad esempio, l'alimentazione da 3 celle è 1,5 V). La documentazione ufficiale di Arduino potrebbe persino portarci a questa ipotesi errata. Il fatto è che l'alimentazione non è necessariamente 5,0 volt, indipendentemente dal livello di corrente, questa potenza viene fornita al Vcc del chip. Se la nostra potenza non è stabilizzata, o se stiamo funzionando a batteria, questa tensione può variare un po'. Ecco un esempio di codice che illustra questo problema:
Doppio Vcc = 5,0; // non necessariamente true int value = analogRead(0); / leggere letture da A0 doppio volt = (valore / 1023,0) * Vcc; // vero solo se Vcc = 5,0 volt Per misurare la tensione con precisione, è necessario un riferimento di tensione accurato. La maggior parte dei chip AVR fornisce tre riferimenti di tensione:
- 1,1 V da una sorgente interna, nella documentazione passa come riferimento di bandgap (alcuni sono 2,56 V, ad esempio ATMega 2560). La scelta viene effettuata dalla funzione analogReference() con il parametro INTERNAL: analogReference(INTERNAL) ;
- una fonte esterna di tensione di riferimento, si firma AREF sull'arduino. Scelta: analogReference(ESTERNO);
- Vcc è l'alimentazione del controller stesso. Scelta: analogReference(DEFAULT).
Con un Arduino, non puoi semplicemente andare avanti e collegare direttamente Vcc a un pin analogico: per impostazione predefinita AREF è legato a Vcc e otterrai sempre un valore massimo di 1023, indipendentemente dalla tensione che stai utilizzando. Salva la connessione all'AREF di una sorgente di tensione con una tensione stabile nota, ma questo è un elemento in più nel circuito.
Puoi anche connettere Vcc ad AREF tramite diodo: La caduta di tensione attraverso il diodo è nota in anticipo, quindi calcolare Vcc non è difficile. Tuttavia, con un tale circuito attraverso un diodo corrente in continuo movimento, accorciando la durata della batteria, che non ha molto successo.
Un riferimento di tensione esterno è il più accurato, ma richiede hardware aggiuntivo. ION interno stabile ma non accurato +/- 10% di deviazione. Vcc è completamente inaffidabile nella maggior parte dei casi. La scelta di un riferimento di tensione interno è economica e stabile, ma la maggior parte delle volte vorremmo misurare più di 1,1 V, quindi l'uso di Vcc è il più pratico, ma potenzialmente il meno accurato. In alcuni casi può essere molto inaffidabile!
Come farlo
Molti chip AVR, comprese le serie ATmega e ATtiny, forniscono un mezzo per misurare il riferimento di tensione interno. Perché è necessario? Il motivo è semplice: misurando la tensione interna, possiamo determinare il valore di Vcc. Ecco come:
- Imposta il riferimento di tensione predefinito: analogReference(DEFAULT); . Usiamo come fonte - Vcc.
- Leggere le letture dell'ADC per l'alimentazione interna da 1,1 V.
- Calcolare il valore di Vcc in base alla misura di 1,1 V utilizzando la formula:
Vcc * (lettura ADC) / 1023 = 1,1 V
Da quanto segue:
Vcc = 1,1 V * 1023 / (lettura ADC)
Mettendo tutto insieme e ottenendo il codice:
long readVcc() ( // Leggi il riferimento 1.1V rispetto ad AVcc // imposta il riferimento a Vcc e la misura al riferimento interno 1.1V #if definito(__AVR_ATmega32U4__) || definito(__AVR_ATmega1280__) || definito(__AVR_ATmega2560__) ADMUX = _BV (REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1); #elif definito (__AVR_ATtiny24__) || definito(__AVR_ATtiny44__) || definito(__AVR_ATtiny84__) ADMUX = _BV(MUX5) | _BV (MUX0); #elif definito (__AVR_ATtiny25__) || definito(__AVR_ATtiny45__) || definito(__AVR_ATtiny85__) ADMUX = _BV(MUX3) | _BV(MUX2); #else ADMUX = _BV(REFS0) | _BV(MUX3) | _BV( MUX2) | _BV(MUX1); #endif delay(75); // Attendi che Vref stabilisca ADCSRA |= _BV(ADSC); // Avvia la conversione mentre (bit_is_set(ADCSRA,ADSC)); // misura uint8_t low = ADCL; // deve prima leggere ADCL - quindi blocca ADCH uint8_t alto = ADCH; // sblocca entrambi i risultati lunghi = (alto<<8) | low; result = 1125300L / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000 return result; // Vcc in millivolts }Utilizzo
Controllo Vcc o tensione batteria
Puoi chiamare questa funzione readVcc() se vuoi monitorare Vcc. Un esempio potrebbe essere quello di controllare il livello della batteria. Puoi anche usarlo per determinare se sei collegato a una fonte di alimentazione o se stai utilizzando l'alimentazione a batteria.
Misura Vcc per tensione di riferimento
Puoi anche usarlo per ottenere il valore Vcc corretto da utilizzare con analogRead() quando usi la tensione di riferimento (Vcc). A meno che non si utilizzi un alimentatore regolato, non si può essere sicuri che Vcc = 5,0 volt. Questa funzione consente di ottenere il valore corretto. Anche se c'è un avvertimento ....
In uno degli articoli ho affermato che questa funzione potrebbe essere utilizzata per migliorare l'accuratezza delle misurazioni analogiche nei casi in cui Vcc non fosse esattamente 5,0 volt. Sfortunatamente, questa procedura non darà un risultato accurato. Come mai? Ciò dipende dalla precisione del riferimento di tensione interno. La specifica fornisce una tensione nominale di 1,1 volt, ma dice che può variare fino al 10%. Tali misurazioni potrebbero essere meno accurate del nostro alimentatore Arduino!
Migliorare la precisione
Sebbene le ampie tolleranze dell'alimentazione interna da 1,1 V limitino notevolmente la precisione di misurazione quando utilizzata nella produzione di massa, possiamo ottenere una maggiore precisione per i singoli progetti. Questo è facile da fare semplicemente misurando Vcc con un voltmetro e la nostra funzione readVcc(). Successivamente, sostituiamo la costante 1125300L con una nuova variabile:
costante_scala = internal1.1Ref * 1023 * 1000
internal1.1Ref = 1.1 * Vcc1 (lettura_voltmetro) / Vcc2 (letturaVcc()_lettura_funzione)
Questo valore calibrato sarà una buona indicazione per le misurazioni del chip AVR, ma potrebbe essere influenzato dalle variazioni di temperatura. Sentiti libero di sperimentare con le tue misurazioni.
Conclusione
Si può fare molto con questa piccola funzionalità. È possibile utilizzare un riferimento stabile vicino a 5,0 V senza avere effettivamente 5,0 V a Vcc. Puoi misurare la tensione della tua batteria o anche vedere se sei alimentato a batteria o stazionario.
Infine, il codice supporterà tutti gli Arduino, incluso il nuovo Leonardo, oltre ai chip della serie ATtinyX4 e ATtinyX5.
Ci sono momenti in cui vuoi controllare la tensione o un punto in un circuito, ma non hai un voltmetro o un multimetro a portata di mano? Corri a comprare? È lungo e costoso. Prima di farlo, che ne dici di creare il tuo voltmetro? In effetti, con componenti semplici, puoi realizzarlo da solo.
- Nel tutorial 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
- Breadboard - http://bit.ly/2slvfrB
- Più ponticelli
Prima di connetterci, capiamo prima come funziona.
Utilizzare la scheda SunFounder Uno per la parte principale dell'elaborazione dei dati del voltmetro, LCD1602 come schermo, un potenziometro per regolare il contrasto LCD e l'altro per dividere la tensione.
Quando si gira un 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 attraverso il pin A0 e Uno convertirà il segnale analogico ricevuto in forma digitale e scriverà sull'LCD. Quindi puoi vedere il valore della tensione alla resistenza della capacità attuale.
L'LCD1602 ha due modalità di funzionamento: 4 bit e 8 bit. Quando l'IO dell'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
Collegare il pin centrale del potenziometro al pin Vo sull'LCD1602 e uno qualsiasi degli altri pin a GND.
Collegare il pin centrale del potenziometro al pin A0 del SunFounder Uno e uno degli altri a 5V mentre l'altro è a GND.
Passaggio 6: caricamento del codice
Codice come questo:
#includere /*********************************************** ***** *****/ const int analogIn = A0;//potenziometro collegato a 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("Voltage Value:");//print "Voltage Value:" ) /************* ***** ************************************/ void loop() ( val = analogRead (A0);//Leggi il valore del potenziometro in 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 v al sull'LCD lcd.print("V");//Quindi stampa l'unità come V, abbreviazione di tensione sull'LCD delay(200); //Aspetta 200 ms )Ruotare il potenziometro per controllare la tensione sull'LCD1602 in tempo reale.
Eccone uno complicato. Dopo aver eseguito il codice, il display LCD ha mostrato dei simboli. Ho quindi regolato il contrasto dello schermo (cambiamento graduale da nero a bianco) ruotando il potenziometro in senso orario o antiorario fino a quando lo schermo non mostrava chiaramente i caratteri.
Prendi due batterie per misurare la loro tensione: 1,5 V e 3,7 V. Sganciare il collegamento 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 si cortocircuiterà la batteria. Il valore 0V è la connessione inversa.
Quindi, la tensione della batteria viene visualizzata sul display LCD. Potrebbe esserci un errore tra il valore e il valore nominale perché la batteria non è completamente carica. Ed è per questo che devo misurare la tensione per capire se posso usare la batteria o meno.
PS: In caso di problemi di visualizzazione, consultare questa FAQ per gli LCD: http://wiki.sunfounder.cc/index.php?title=LCD1602/I2C_LCD1602_FAQ.
Ehi Habr! Oggi voglio continuare il tema dell'"attraversamento" di arduino e android. In una precedente pubblicazione ne ho parlato, e oggi parleremo di un voltmetro bluetooth fai da te. Un altro dispositivo simile può essere chiamato voltmetro intelligente, voltmetro "intelligente" o semplicemente voltmetro intelligente, senza virgolette. Il cognome non è corretto dal punto di vista della grammatica della lingua russa, tuttavia si trova spesso nei media. La votazione su questo argomento sarà alla fine dell'articolo e propongo di iniziare dimostrando il funzionamento del dispositivo per capire di cosa tratterà l'articolo.
Disclaimer: l'articolo è destinato al fan medio di arduino, che di solito non ha dimestichezza con la programmazione Android, pertanto, come nell'articolo precedente, realizzeremo un'applicazione per smartphone utilizzando l'ambiente di sviluppo visivo di App Inventor 2 per applicazioni Android.
Per realizzare un voltmetro bluetooth fai da te, dobbiamo scrivere due programmi relativamente indipendenti: uno sketch per arduino e un'applicazione per android, iniziamo con uno sketch.
Per cominciare, dovresti sapere che ci sono tre opzioni principali per misurare la tensione usando arduino, indipendentemente da dove devi emettere informazioni: su una porta com, su uno schermo collegato ad arduino o su uno smartphone.
Primo caso: misure di tensione fino a 5 volt. Qui sono sufficienti una o due righe di codice e la tensione viene applicata direttamente al pin A0:
int value = analogRead(0);// legge le letture da A0
tensione = (valore / 1023,0) * 5; // vero solo se Vcc = 5,0 volt
Secondo caso: un partitore di tensione viene utilizzato per misurare tensioni superiori a 5 volt. Lo schema è molto semplice, anche il codice.
Schizzo
int analogicoInput = A0;
valore float = 0,0;
tensione di mantenimento = 0,0;
float R1 = 100000,0; //Vin batteria -> 100K -> A0
float R2 = 10000,0; //Battery Gnd -> Arduino Gnd e Arduino Gnd -> 10K -> A0
valore int = 0;
Configurazione nulla() (
Serial.begin(9600);
pinMode(ingresso analogico, INGRESSO);
}
ciclo vuoto() (
valore = analogRead(analogInput);
val = (valore * 4,7) / 1024,0;
tensione = val / (R2/(R1+R2));
Stampa seriale (tensione);
ritardo(500);
}
Arduino Uno
modulo bluetooth
Terzo caso. Quando è necessario ottenere una maggiore precisione sulla tensione, come tensione di riferimento, non è necessario utilizzare la tensione di alimentazione, che può variare leggermente se alimentata dalla batteria, ad esempio, ma la tensione dello stabilizzatore arduino interno è di 1,1 volt. Qui il circuito è lo stesso, ma il codice è leggermente più lungo. Non analizzerò in dettaglio questa opzione, visto che è già ben descritta negli articoli tematici, ma il secondo metodo mi basta abbastanza, dato che il mio alimentatore è stabile, dalla porta usb del portatile.
Quindi abbiamo capito la misurazione della tensione, ora passiamo alla seconda metà del progetto: creare un'applicazione Android. Realizzeremo l'applicazione direttamente dal browser nell'ambiente di sviluppo visivo per applicazioni Android di App Inventor 2. Andiamo sul sito appinventor.mit.edu/explore , accediamo utilizzando un account Google, premiamo il pulsante crea, nuovo progetto e semplicemente trascinando e rilasciando gli elementi creiamo qualcosa di simile a questo design:
Ho reso la grafica molto semplice, se qualcuno vuole una grafica più interessante, vi ricordo che per questo è necessario utilizzare al posto dei file .jpeg, file .png con uno sfondo trasparente.
Ora vai alla scheda Blocchi e crea lì la logica dell'applicazione in questo modo:
Se tutto ha funzionato, puoi fare clic sul pulsante Crea e salvare .apk sul mio computer, quindi scaricare e installare l'applicazione sul tuo smartphone, sebbene ci siano altri modi per caricare l'applicazione. qui è più conveniente per qualcuno. Di conseguenza, ho ottenuto questa applicazione:
Capisco che poche persone usano l'ambiente di sviluppo visivo di App Inventor 2 per le applicazioni Android nei loro progetti, quindi potrebbero sorgere molte domande sul lavoro in esso. Per rimuovere alcune di queste domande, ho realizzato un video dettagliato su come creare un'applicazione del genere da zero (è necessario andare su YouTube per visualizzarla):
PS Una raccolta di oltre 100 tutorial arduino per principianti e professionisti
Idea
Idea i dispositivi per misurare la tensione, la corrente, la capacità, la scarica e forse la carica sono nati molto tempo fa e non solo con me. Puoi trovare alcuni giocattoli chiamati USB Tester (Dottore) per testare vari dispositivi USB. Sono interessato a un dispositivo un po' più versatile, indipendente dall'interfaccia, ma progettato semplicemente per determinate tensioni e correnti. Ad esempio, 0 - 20.00v, 0 - 5.00a, 0 - 99.99Ah. Per quanto riguarda le funzioni, la vedo così
- Visualizzazione della tensione e della corrente attuali, ovvero un voltmetro. In linea di principio, puoi riflettere immediatamente il potere.
- Calcolo e visualizzazione della capacità accumulata. In ampere e molto probabilmente in wattora.
- Visualizzazione del tempo di processo
- E, molto probabilmente, soglie di spegnimento della tensione inferiore e superiore configurabili (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 semplice e popolare Atmega328 sarà il controller e sarà programmato nell'ambiente Arduino. Da un punto di vista ingegneristico, la scelta probabilmente non è delle migliori: il controller per l'attività è un po' grasso e il suo ADC non può essere chiamato misurante, ma... ci proveremo.
- Non salderemo molto in questo progetto. Come base, prenderemo il modulo Arduino Pro Mini già pronto, poiché i cinesi sono pronti a fornirli per $ 1,5 al dettaglio.
- Il dispositivo di visualizzazione sarà un display 1602 - $ 1,5 in più. Ho un'opzione con un modulo di interfaccia I2C, ma in questo progetto non è molto necessario ($ 0,7).
- Per lo sviluppo, abbiamo bisogno di una breadboard. Nel mio caso, questa è una piccola breadboard da $ 1.
- Naturalmente, avrai bisogno di cavi e un numero di resistori di diverse potenze. Per un display 1602 senza I2C, è necessaria anche la selezione del contrasto: viene eseguita con un resistore variabile di 2 - 20 kOhm.
- Per implementare un amperometro, è necessario uno shunt. In prima approssimazione, può essere un resistore da 0,1 ohm e 5 watt.
- Per implementare lo spegnimento automatico è necessario un relè con contatti predisposti per la corrente massima del dispositivo e una tensione pari alla tensione di alimentazione. Per controllare il relè, è necessario un transistor npn e un diodo di protezione.
- Il dispositivo sarà alimentato da un alimentatore esterno, ovviamente almeno 5V. Se l'alimentazione varia notevolmente, sarà necessario anche uno stabilizzatore integrale di tipo 7805, che determinerà la tensione del relè.
- quando Arduino Pro Mini richiederà un convertitore USB-TTL per eseguire il flashing del firmware.
- Avrai bisogno di un multimetro per configurarlo.
Voltmetro
Sto implementando un semplice voltmetro con un intervallo di circa 0 - 20v. Questa osservazione è importante, poiché 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 da una coppia di resistori e una sorta di uscita (il display è in una versione finita, una porta seriale può essere utilizzata per il debug).
Il principio della misurazione dell'ADC consiste nel confrontare la tensione all'ingresso analogico con il riferimento VRef. L'uscita dell'ADC è sempre intera - 0 corrisponde a 0V, 1023 corrisponde alla tensione VRef. La misura è implementata da una serie di letture successive della tensione e calcolando la media nel periodo tra gli aggiornamenti del valore sullo schermo. La scelta della tensione di riferimento è importante perché per impostazione predefinita è la tensione di alimentazione, che potrebbe non essere stabile. Questo non ci soddisfa affatto: prenderemo come base una sorgente di riferimento interna stabile con una tensione di 1,1 V, inizializzandola con una chiamata ad analogReference(INTERNAL). Quindi calibreremo il suo valore in base alle letture del multimetro.
Nel diagramma a sinistra - una variante con controllo diretto del display (è semplicemente controllato - vedere lo sketch standard LiquidCrystal\HelloWorld). Sulla destra c'è l'opzione I2C, che userò ulteriormente. I2C permette di risparmiare sui fili (che nella versione abituale sono 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 simboli sul modulo e regolare il contrasto: per questo è sufficiente visualizzare un testo qualsiasi dopo l'inizializzazione. Il contrasto è regolato dal resistore R1 o da un resistore simile del modulo I2C.
L'ingresso è un divisore 1:19, che permette, a Vref = 1.1, di ottenere una tensione massima di circa 20V (solitamente un condensatore + diodo zener è posto in parallelo all'ingresso di protezione, ma questo per noi non è ancora importante ). Le resistenze hanno uno spread, e anche il riferimento Vref del controller, quindi dopo il montaggio, è necessario misurare la tensione (almeno l'alimentazione) in parallelo con il nostro dispositivo e un multimetro di riferimento e selezionare Vref nel codice fino a quando le letture non corrispondono. Vale anche la pena notare che qualsiasi ADC ha una tensione di offset zero (che rovina le letture all'inizio dell'intervallo), ma non lo approfondiremo ancora.
Sarà anche importante separare la fornitura e il "terreno" di misurazione. Il nostro ADC ha una risoluzione leggermente peggiore di 1 mV, che può essere problematica se cablata in modo errato, specialmente su una breadboard. Poiché il cablaggio della scheda del modulo è già stato eseguito e ci resta una scelta di pin. Il modulo ha diversi pin di "massa", quindi dobbiamo assicurarci che l'alimentazione del modulo arrivi attraverso una "massa" e le misurazioni attraverso un'altra. In effetti, per le modifiche utilizzo sempre il pin di massa più vicino agli ingressi analogici.
Per il controllo I2C viene utilizzata una variante della libreria LiquidCrystal_I2C - nel mio caso viene indicata una specifica piedinatura del modulo I2C (i cinesi producono moduli con controlli diversi). Noto anche che I2C in Arduino prevede l'uso dei pin A4, A5 - sulla scheda Pro Mini non sono sul bordo, il che è scomodo per la prototipazione su BreadBoard.
