Ci sono momenti in cui vuoi controllare una 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 un voltmetro da solo? In effetti, con componenti semplici, puoi farlo 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
- Scheda di sviluppo - http://bit.ly/2slvfrB
- Più ponticelli
Prima di connetterci, diamo un'occhiata a come funziona.
Utilizzare la scheda SunFounder Uno per la parte principale dell'elaborazione dei dati del voltmetro, LCD1602 come schermo, il potenziometro per regolare il contrasto LCD e l'altro per separare la tensione.
Quando si ruota un potenziometro collegato alla scheda Uno, il resistore 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 digitalizzerà il segnale analogico ricevuto e scriverà sul display LCD. Quindi puoi vedere il valore della tensione alla resistenza attuale del condensatore.
LCD1602 ha due modalità di funzionamento: 4-bit e 8-bit. Quando l'IO dell'MCU è insufficiente, puoi 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 di SunFounder Uno e uno degli altri a 5V, mentre l'altro a GND.
Passaggio 6: caricare il codice
Codice in questo modo:
#include / ********************************************** * **** / 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 la seriale lcd.begin (16, 2); // imposta la posizione del caratteri sul display LCD come Riga 2, Colonna 16 lcd.print ("Valore di tensione:"); // stampa "Valore di tensione:") / ******************** *********************************** / void loop () (val = analogRead (A0); // Read 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 sul display LCD lcd.print ("V"); // Quindi stampa l'unità come V, abbreviazione di tensione sul ritardo LCD (200); // Attendi 200 ms)Ruotare il potenziometro per controllare la tensione sull'LCD1602 in tempo reale.
Ecco una cosa complicata. Dopo aver eseguito il codice, sul display LCD sono stati visualizzati dei simboli. Quindi ho regolato il contrasto dello schermo (dissolvenza dal nero al bianco) ruotando il potenziometro in senso orario o antiorario finché lo schermo non mostrava chiaramente i caratteri.
Prendere due batterie per misurarne le tensioni: 1,5 V e 3,7 V. Scollegare la connessione del secondo potenziometro con 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, altrimenti si otterrà un cortocircuito sulla batteria. Il valore 0V è la connessione inversa.
Quindi la tensione della batteria viene visualizzata sul display LCD. Potrebbe esserci qualche errore tra il valore e il valore nominale poiché la batteria non è completamente carica. Ed è per questo che ho bisogno di misurare la tensione per capire se posso usare la batteria o meno.
PS: Se hai problemi di visualizzazione, consulta questa FAQ per gli LCD: http://wiki.sunfounder.cc/index.php?title=LCD1602/I2C_LCD1602_FAQ.
Questo articolo mostra come collegare Arduino e PC e trasferire dati da ADC a PC. Il programma Windows è scritto utilizzando Visual C++ 2008 Express. Il programma del voltmetro è molto semplice e ha molti margini di miglioramento. Il suo scopo principale era mostrare come lavorare con una porta COM e scambiare dati tra un computer e un Arduino.
Comunicazione tra Arduino e PC:
- La lettura dall'ADC inizia quando il computer invia i comandi Arduino 0xAC e 0x1y. a- Numero canale ADC (0-2);
- La lettura si interrompe dopo che Arduino riceve i comandi 0xAC e 0x00;
- Durante le letture, Arduino invia i comandi 0xAB 0xaa 0xbb al computer ogni 50 ms, dove aa e bb sono i risultati di misurazione massimo e minimo.
Programma Arduino
Puoi leggere di più sulla comunicazione seriale su arduino.cc. Il programma è abbastanza semplice, la maggior parte è occupata lavorando con una porta parallela. Dopo la fine della lettura dei dati dall'ADC, otteniamo un valore di tensione a 10 bit (0 × 0000 - 0 × 0400) sotto forma di variabili a 16 bit (INT). La porta seriale (RS-232) consente la trasmissione dei dati in pacchetti da 8 bit. È necessario dividere le variabili a 16 bit in 2 parti di 8 bit.
Stampa.seriale (tensione >> 8, BYTE);
Serial.print (tensione% 256, BYTE);
Spostiamo a destra i byte della variabile di 8 bit e poi dividiamo per 256 e inviamo il risultato al computer.
Codice sorgente completo per il software Arduino che puoi scaricare
Visual c++
Presumo che tu abbia già una conoscenza di base della programmazione C++ per Windows, in caso contrario, cercalo su Google. Internet è pieno di lezioni per principianti.
La prima cosa da fare è aggiungere la porta seriale dalla barra degli strumenti al form in basso. Ciò consentirà di modificare alcuni parametri importanti della porta seriale: nome della porta, baud rate, bit rate. Questo è utile per aggiungere controlli alla finestra dell'applicazione, per modificare queste impostazioni in qualsiasi momento, senza ricompilare il programma. Ho usato solo l'opzione di selezione della porta.
Dopo aver cercato le porte seriali disponibili, per impostazione predefinita viene selezionata la prima porta. Come è fatto:
Vettore< String ^>^ serialPorts = nullptr;
serialPorts = serialPort1-> GetPortNames ();
this-> comboBox1-> Items-> AddRange (serialPorts);
this-> comboBox1-> SelectedIndex = 0;
La porta seriale su un PC può essere utilizzata solo da un'applicazione alla volta, quindi la porta deve essere aperta prima dell'uso e non chiusa. Semplici comandi per questo:
porta seriale1-> Apri ();
porta seriale1-> Chiudi ();
Per leggere correttamente i dati dalla porta seriale, è necessario utilizzare gli eventi (nel nostro caso un interrupt). Seleziona il tipo di evento:
Elenco a discesa quando si fa doppio clic su "Dati ricevuti".
Il codice evento viene generato automaticamente:
Se il primo byte che arriva sulla porta seriale è 0xAB, significa che i restanti byte portano i dati di tensione.
private: System :: Void serialPort1_DataReceived (System :: Object ^ sender, System :: IO :: Ports :: SerialDataReceivedEventArgs ^ e) (
unsigned char data0, data1;
if (porta seriale1-> ReadByte () == 0xAB) (
data0 = porta seriale1-> ReadByte ();
data1 = porta seriale1-> ReadByte ();
tensione = Math :: Round ((float (data0 * 256 + data1) /1024*5.00), 2);
data_count ++;
serialPort1-> ReadByte ();
Scrittura e lettura dei dati della porta seriale
Un piccolo problema per me è stato inviare dati HEX RAW tramite la porta seriale. È stato utilizzato il comando Write(); ma con tre argomenti: array, numero di byte iniziali, numero di byte da scrivere.
private: System :: Void button2_Click_1 (System :: Object ^ sender, System :: EventArgs ^ e) (
canale char senza segno = 0;
canale = questo-> listBox1-> SelectedIndex;
array ^ start = (0xAC, (0x10 + canale));
array ^ stop = (0xAC, 0x00);
serialPort1-> Scrivi (inizio, 0,2);
this-> button2-> Text = "Stop";
) altro (
serialPort1-> Scrivi (stop, 0.2);
this-> button2-> Text = "Avvia";
È tutto!
Articolo originale in inglese (traduzione: Alexander Kasyanov per il sito cxem.net)
Descritto come assemblare un doppio voltmetro fatto in casa basato sulla piattaforma Arduino UNO utilizzando un LCD 1602A. In alcuni casi, è necessario misurare due tensioni CC contemporaneamente e confrontarle. Ciò può essere necessario, ad esempio, durante la riparazione o la regolazione di un regolatore di tensione costante per misurare la tensione all'ingresso e all'uscita o in altri casi.
Diagramma schematico
Utilizzando un modulo microcontrollore universale ARDUINO UNO e un display LCD a due righe tipo 1602A (basato sul controller HD44780), tale dispositivo può essere facilmente realizzato. Su una riga, mostrerà la tensione U1, sull'altra - la tensione U2.
Riso. 1. Schema schematico di un doppio voltmetro con display 1602A su Arduino UNO.
Ma prima di tutto, vorrei ricordarti che ARDUINO UNO è un modulo già pronto relativamente economico: un piccolo circuito stampato su cui si trova il microcontrollore ATMEGA328, nonché tutte le sue "reggette" necessarie per il suo funzionamento, incluso un programmatore USB e un alimentatore.
Per chi non conosce ARDUINO UNO, consiglio di leggere prima gli articoli L.1 e L.2. Il circuito a doppio voltmetro è mostrato in Fig. 1. È progettato per misurare due tensioni da 0 a 100V (in pratica, fino a 90V).
Come si vede dallo schema, alle porte digitali D2-D7 della scheda ARDUINO UNO è collegato un modulo indicatore a cristalli liquidi 1602A tipo H1. L'indicatore LCD è alimentato da un regolatore di tensione 5V sulla scheda del regolatore di tensione 5V.
Le tensioni misurate vengono inviate a due ingressi analogici A1 e A2. Ci sono sei ingressi analogici in totale, - A0-A5, puoi sceglierne due qualsiasi. In questo caso vengono selezionati A1 e A2. La tensione alle porte analogiche può essere solo positiva e solo nell'intervallo da zero alla tensione di alimentazione del microcontrollore, cioè nominalmente fino a 5V.
L'uscita della porta analogica viene convertita in formato digitale dall'ADC del microcontrollore. Per ottenere il risultato in unità di volt, è necessario moltiplicarlo per 5 (per la tensione di riferimento, cioè per la tensione di alimentazione del microcontrollore) e dividere per 1024.
Per poter misurare una tensione superiore a 5V, o meglio, superiore alla tensione di alimentazione del microcontrollore, perché la tensione reale all'uscita dello stabilizzatore a 5 volt sulla scheda ARDUINO UNO può differire da 5V, e di solito un po 'più in basso, è necessario utilizzare i normali divisori resistivi all'ingresso. Questi sono i divisori di tensione sui resistori R1, R3 e R2, R4.
Allo stesso tempo, per portare le letture del dispositivo al valore reale della tensione di ingresso, è necessario impostare nel programma la divisione del risultato della misurazione per il fattore di divisione del partitore resistivo. E il fattore di divisione, designiamolo "K", può essere calcolato con la seguente formula:
K = R3 / (R1 + R3) o K = R4 / (R2 + R4),
rispettivamente per i diversi ingressi del doppio voltmetro.
È interessante notare che i resistori nei divisori non devono essere di alta precisione. Puoi prendere resistori ordinari, quindi misurare la loro resistenza effettiva con un ohmmetro accurato e sostituire questi valori misurati nella formula. Ottieni il valore "K" per un divisore specifico, che dovrà essere sostituito nella formula.
Programma voltmetro
Il programma C++ è mostrato in Figura 2.
Riso. 2. Il codice sorgente del programma.
Per controllare l'indicatore LCD si è deciso di utilizzare le porte da D2 a D7 della scheda ARDUINO UNO. In linea di principio sono possibili altre porte, ma così ho deciso di utilizzare queste.
Affinché l'indicatore interagisca con ARDUINO UNO, è necessario caricare una subroutine nel programma per controllarlo. Queste routine sono chiamate "librerie" e ci sono molte diverse "librerie" nella suite software ARDUINO UNO. La libreria LiquidCrystal è necessaria per funzionare con l'LCD basato su HD44780. Pertanto, il programma (tabella 1) inizia caricando questa libreria:
Questa riga fornisce il comando per caricare questa libreria in ARDUINO UNO. Quindi, è necessario assegnare le porte ARDUINO UNO che funzioneranno con l'indicatore LCD. Ho selezionato le porte da D2 a D7. Altri possono essere selezionati. Queste porte sono assegnate dalla linea:
led LiquidCrystal (2, 3, 4, 5, 6, 7);
Successivamente, il programma procede al funzionamento effettivo del voltmetro. Per misurare la tensione, si è deciso di utilizzare gli ingressi analogici A1 e A2. Questi input sono dati su righe:
int ingresso analogico = 1;
int ingresso analogico1 = 2;
La funzione analogRead viene utilizzata per leggere i dati dalle porte analogiche. La lettura dei dati dalle porte analogiche avviene nelle righe:
vout = analogRead (analogInput);
voutl = analogRead (analoglnput1);
Quindi, la tensione effettiva viene calcolata tenendo conto del rapporto di divisione del partitore di tensione in ingresso:
volt = vout * 5,0 / 1024,0 / 0,048;
volt1 = vout1 * 5,0 / 1024,0 / 0,048;
In queste righe il numero 5.0 è la tensione all'uscita dello stabilizzatore della scheda ARDUINO UNO. Idealmente, dovrebbe essere 5V, ma per un funzionamento accurato del voltmetro, questa tensione deve essere prima misurata. Collegare l'alimentatore e misurare la tensione +5V al connettore POWER della scheda con un voltmetro sufficientemente preciso. Cosa accadrà, quindi inserisci queste righe invece di 5.0, ad esempio, se è 4,85 V, le righe appariranno così:
volt = vout * 4,85 / 1024,0 / 0,048;
volt1 = vout1 * 4,85 / 1024,0 / 0,048;
Nella fase successiva, dovrai misurare le resistenze effettive dei resistori R1-R4 e determinare i coefficienti K (sono indicati 0,048) per queste linee utilizzando le formule:
K1 = R3 / (R1 + R3) e K2 = R4 / (R2 + R4)
Diciamo K1 = 0,046 e K2 = 0,051, quindi scriviamo:
volt = vout * 4,85 / 1024,0 / 0,046;
volt1 = vout1 * 4,85 / 1024,0 / 0,051;
Pertanto, il testo del programma deve essere modificato in base alla tensione effettiva all'uscita dello stabilizzatore a 5 volt della scheda ARDUINO UNO e in base ai fattori di divisione effettivi dei divisori resistivi. Successivamente, il dispositivo funzionerà in modo accurato e non richiederà alcuna regolazione o calibrazione.
Modificando i fattori di divisione dei divisori resistivi (e, di conseguenza, i fattori "K"), è possibile stabilire altri limiti di misura, e non necessariamente uguali per entrambi gli ingressi.
Karavkin V. RK-2017-01.
Letteratura:
- Karavkin V. - Lampeggiatore dell'albero di Natale su ARDUINO come rimedio per la paura dei microcontrollori. RK-11-2016.
- Karavkin V. - Frequenzimetro su ARDUINO. RK-12-2016.
Dati iniziali e revisione
Quindi a questo punto abbiamo un voltmetro DC con limite 0..20V (vedi parte precedente). Ora aggiungiamo un amperometro 0..5a ad esso. Per fare ciò, modifichiamo leggermente il circuito: diventerà un pass-through, cioè avrà sia un ingresso che un'uscita.
Ho rimosso la parte relativa al display sul LCD - non cambierà. In linea di principio, il principale nuovo elemento è lo shunt Rx da 0,1 ohm. La catena R1-C1-VD1 viene utilizzata per proteggere l'ingresso analogico. Ha senso mettere lo stesso all'ingresso A0. Poiché assumiamo correnti abbastanza grandi, ci sono requisiti di installazione: le linee elettriche devono essere realizzate con un filo sufficientemente spesso e collegate direttamente ai terminali dello shunt (in altre parole, sono saldati), altrimenti le letture saranno lontane dalla realtà. C'è anche una nota sulla corrente: in linea di principio, la tensione di riferimento di 1,1 v consente di registrarsi sullo shunt Corrente da 0,1 ohm fino a 11 ampere con una precisione leggermente inferiore a 0,01 a, ma quando tale tensione scende su Rx, la potenza rilasciata supererà i 10 watt, il che non è affatto divertente. Per risolvere il problema, è possibile utilizzare un amplificatore con un guadagno di 11 su un amplificatore operazionale di alta qualità e uno shunt da 10 mΩ (0,01 ). Ma per ora non ci complicheremo la vita e ci limiteremo semplicemente a una corrente fino a 5A (mentre la potenza Rx può essere selezionata nell'ordine di 3-5 W).
A questo punto, mi aspettava una sorpresa: si è scoperto che l'ADC del controller ha un missaggio dello zero abbastanza grande - circa -3 mV. Cioè, l'ADC semplicemente non vede segnali inferiori a 3 mV e segnali di livello leggermente superiore sono visibili con un'imprecisione caratteristica di -3 mV, che rovina la linearità all'inizio della gamma. Una rapida ricerca non ha fornito riferimenti espliciti a tale problema (l'offset zero è normale, ma dovrebbe essere significativamente più piccolo), quindi è del tutto possibile che si tratti di un problema di una particolare istanza di Atmega 328. 0,06 volt), per la corrente - una resistenza di pull-up sul bus 5V. Il resistore è indicato da una linea tratteggiata.
Fonte
La versione completa di questo voltmetro (nella versione I2C) può essere scaricata dal link alla fine dell'articolo. Successivamente, ti mostrerò le modifiche nel codice sorgente. Aggiunta la lettura dell'ingresso analogico A1 con la stessa media del voltmetro. In effetti, questo è lo stesso voltmetro, solo senza un divisore, e otteniamo ampere secondo la formula di Ohm: I = U / Rx (ad esempio, se la caduta di tensione su Rx = 0,01 V, la corrente è 0,1 A). Ho anche introdotto l'attuale costante di guadagno AmpMult - per il futuro. Potrebbe essere necessario regolare la costante AmpRx con la resistenza di shunt per tenere conto dell'imprecisione della resistenza di shunt. Bene, poiché questo è già un voltmetro e c'è ancora spazio sul display 1602, resta da visualizzare l'attuale consumo di energia in watt, avendo ricevuto funzionalità aggiuntive non complicate.
.... // Ingresso analogico #define PIN_VOLT A0 #define PIN_AMP A1 // Tensione di riferimento interna (pick up) const float VRef = 1.10; // Rapporto del partitore resistivo di ingresso (Rh + Rl) / Rl. IN 0.2) InVolt + = 3; // Conversione in Volt (In: 0..1023 -> (0..VRef) scalato da Mult) float Volt = InVolt * VoltMult * VRef / 1023; float Amp = InAmp * VRef / AmpMult / AmpRx / 1023; // Per tenere conto della caduta sullo shunt, decommentare 2 righe // float RxVolt = InAmp * VRef / 1023 / AmpMult; // Volt - = RxVolt; galleggiante Watt = Volt * Amp; // Dati in uscita lcd.setCursor (8, 0); lcd.print (Watt); lcd.print ("W"); lcd.setCursor (0, 1); lcd.print (Volt); lcd.print ("V"); lcd.setCursore (8, 1); lcd.print (Amp); lcd.print ("A"); )
Link
- Libreria LiquidCrystal_I2C per l'impostazione del pinout
Ciao, Habr! Oggi voglio continuare l'argomento di "attraversare" arduino e Android. In una precedente pubblicazione ne ho parlato, e oggi parleremo di un voltmetro bluetooth fai da te. Un altro dispositivo di questo tipo 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 suggerisco di iniziare con una dimostrazione del funzionamento del dispositivo per capire di cosa parlerà l'articolo.
Disclaimer: l'articolo è destinato all'hobbista medio di arduino che di solito non ha familiarità con la programmazione per Android, quindi, come nell'articolo precedente, creeremo un'applicazione per smartphone utilizzando l'ambiente di sviluppo visivo App Inventor 2 per applicazioni Android.
Per realizzare un voltmetro bluetooth fai da te, abbiamo bisogno di scrivere due programmi relativamente indipendenti: uno schizzo per arduino e un'applicazione per Android Iniziamo con uno schizzo.
Per cominciare, dovresti sapere che ci sono tre opzioni principali per misurare la tensione usando un arduino, indipendentemente da dove devi visualizzare le informazioni: alla porta com, allo schermo collegato ad arduino o a uno smartphone.
Primo caso: misure di tensione fino a 5 volt. Qui bastano 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: viene utilizzato un partitore di tensione per misurare tensioni superiori a 5 volt. Lo schema è molto semplice, anche il codice.
Schizzo
int ingresso analogico = A0;
valore float = 0.0;
tensione di galleggiamento = 0,0;
galleggiante R1 = 100000.0; // Batteria Vin-> 100K -> A0
galleggiante R2 = 10000.0; // Battery Gnd -> Arduino Gnd e Arduino Gnd -> 10K -> A0
int valore = 0;
Configurazione nulla () (
Inizio seriale (9600);
pinMode (ingresso analogico, INGRESSO);
}
Ciclo vuoto () (
valore = analogRead (analogInput);
val = (valore * 4,7) / 1024,0;
tensione = val / (R2 / (R1 + R2));
Serial.println (tensione);
ritardo (500);
}
Arduino Uno
Modulo Bluetooth
Terzo caso. Quando è necessario ottenere informazioni più accurate sulla tensione come tensione di riferimento, è necessario utilizzare non la tensione di alimentazione, che può cambiare leggermente se alimentata da una batteria, ad esempio, ma la tensione dello stabilizzatore interno di Arduino di 1,1 volt. Qui il circuito è lo stesso, ma il codice è leggermente più lungo. Non analizzerò in dettaglio questa opzione, poiché è già ben descritta negli articoli tematici e il secondo metodo è abbastanza per me, poiché ho un alimentatore stabile dalla porta USB del laptop.
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 App Inventor 2. Vai al sito web appinventor.mit.edu/explore, accedi con il tuo account Google, fai clic sul pulsante crea, nuovo progetto e semplicemente trascinando e rilasciando elementi crea qualcosa come questo design:
Ho reso la grafica molto semplice, se qualcuno vuole una grafica più interessante, ti ricordo che per questo devi usare file .png con sfondo trasparente invece di file .jpeg.
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ù comodo per chiunque. Di conseguenza, ho ricevuto la seguente applicazione:
Capisco che pochissime persone utilizzano l'ambiente di sviluppo visivo di App Inventor 2 per le applicazioni Android nei loro progetti, quindi potrebbero esserci molte domande su come lavorarci. Per rimuovere alcune di queste domande, ho realizzato un video dettagliato su come creare un'applicazione del genere "da zero" (devi andare su YouTube per visualizzarla):
P.S. Una raccolta di oltre 100 tutorial Arduino per principianti e professionisti
