Ciao, Habr! Oggi voglio continuare l'argomento di "attraversare" arduino e Android. Nella pubblicazione precedente, ho parlato di una macchina bluetooth 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, è necessario utilizzare non la tensione di alimentazione come tensione di riferimento, 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
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 in arrivo 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)
Questo articolo fornisce un diagramma interessante per coloro che amano sperimentare e Arduino... Introduce un semplice voltmetro digitale in grado di misurare in sicurezza tensioni CC da 0 a 30 V. La stessa scheda Arduino può essere alimentata da uno standard da 9 V.
Come sapete, l'ingresso analogico di Arduino può misurare tensioni da 0 a 5V (con un riferimento standard a 5V). Ma questa gamma può essere ampliata utilizzando un partitore di tensione.
Il divisore riduce la tensione misurata a un livello accettabile per l'ingresso analogico. Il codice appositamente scritto calcola quindi la tensione effettiva.
Un sensore analogico nell'Arduino rileva la tensione all'ingresso analogico e la converte in un formato digitale leggibile dal microcontrollore. All'ingresso analogico A0 colleghiamo un partitore di tensione formato dalle resistenze R1 (100K) e R2 (10K). Con tali valori di resistenza, è possibile fornire all'Arduino fino a 55 V, poiché il rapporto di divisione in questo caso è 11, quindi 55 V / 11 = 5 V. Per essere sicuri che le misurazioni siano sicure per la scheda, è meglio misurare la tensione nell'intervallo da 0 a 30 V.
Se il display non corrisponde a quello di un voltmetro verificato, è necessario utilizzare un multimetro digitale di precisione per trovare i valori esatti per R1 e R2. In questo caso, nel codice dovrai sostituire R1 = 100000.0 e R2 = 10000.0 con i tuoi valori. Quindi vale la pena controllare la potenza misurando la tensione sulla scheda tra 5V e GND. La tensione può essere 4,95 V. Quindi nel codice vout = (valore * 5,0) / 1024,0 è necessario sostituire 5,0 con 4,95. Si consiglia di utilizzare resistori di precisione con un errore non superiore all'1%. Ricorda che tensioni superiori a 55V possono danneggiare la scheda Arduino!
#includere
Elementi utilizzati:
Scheda Arduino Uno
Resistenza da 100K ohm
Resistenza da 10K
Resistenza da 100 ohm
Potenziometro 10Kohm
Display LCD 16 × 2
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 il 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 in quanto 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 LCD - http://wiki.sunfounder.cc/index.php?title=LCD1602/I2C_LCD1602_FAQ.
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 per me. Puoi trovare alcuni giocattoli chiamati USB Tester (Dottore) per testare vari dispositivi USB. Sono interessato a un dispositivo un po' più universale, 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, io la vedo così
- Visualizzazione della tensione e della corrente attuali, ad es. volt-amperemetro. In linea di principio, puoi immediatamente riflettere il potere.
- Conteggio e visualizzazione della capacità accumulata. Ampere-ora e molto probabilmente wattora.
- Visualizzazione del tempo di processo
- E, molto probabilmente, soglie di interruzione della tensione inferiore e superiore personalizzabili (limiti di scarica e di carica)
Sviluppo di
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 'grasso per il compito e il suo ADC non può essere chiamato misura, ma ... ci proveremo.
- Non venderemo molto in questo progetto. Come base, prenderemo un modulo Arduino Pro Mini già pronto, poiché i cinesi sono pronti a fornirli a $ 1,5 al dettaglio.
- Il display 1602 fungerà da dispositivo di visualizzazione: altri $ 1,5. Ho una variante 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, questo è un piccolo breadboard da $ 1.
- Naturalmente, avrai bisogno di cavi e un numero di resistori di diversa potenza. Per un display 1602 senza I2C, è necessaria anche una selezione di contrasto, eseguita con un resistore variabile di 2 - 20 kOhm.
- Per implementare un amperometro, hai bisogno di uno shunt. In prima approssimazione, potrebbe essere un resistore da 0,1 ohm, 5 W.
- Per implementare lo spegnimento automatico, è necessario un relè con contatti progettati per la corrente e la tensione massime del dispositivo pari alla tensione di alimentazione. Per controllare il relè sono necessari un transistor NPN e un diodo di protezione.
- Il dispositivo sarà alimentato da un alimentatore esterno, ovviamente almeno 5V. Se l'alimentazione varia notevolmente, è necessario anche uno stabilizzatore integrale del tipo 7805: determinerà la tensione del relè.
- quando Arduino Pro Mini richiede un convertitore USB-TTL per caricare il firmware.
- Avrai bisogno di un multimetro per la configurazione.
Voltmetro
Sto implementando un semplice voltmetro con un singolo 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 implementarlo, abbiamo bisogno di un ingresso analogico del controller, un divisore da una coppia di resistori e una sorta di uscita (il display è finito, per il debug è possibile utilizzare una porta seriale).
Il principio di misura dell'ADC consiste nel confrontare la tensione all'ingresso analogico con il riferimento VRef. L'uscita ADC è sempre intera - 0 corrisponde a 0V, 1023 corrisponde alla tensione VRef. La misurazione è realizzata da una serie di letture sequenziali di tensione e media nel periodo tra gli aggiornamenti del valore sullo schermo. La scelta della tensione di riferimento è importante perché di default è 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 a analogReference (INTERNAL). Quindi calibreremo il suo valore in base alle letture del multimetro.
Nel diagramma a sinistra - una variante con controllo del display diretto (è semplicemente controllato - vedi lo schizzo LiquidCrystal \ HelloWorld standard). Sulla destra c'è la variante I2C, che userò ulteriormente. I2C ti consente di risparmiare sui fili (di cui nella 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 simboli sul modulo e regolare il contrasto: per questo, è sufficiente visualizzare qualsiasi testo dopo l'inizializzazione. Il contrasto viene regolato dal resistore R1 o da un resistore simile nel modulo I2C.
L'ingresso è un divisore 1:19, che permette a Vref=1,1 di ottenere una tensione massima di circa 20V (di solito un condensatore + diodo zener è posto in parallelo all'ingresso per protezione, ma questo per noi non è ancora importante). I resistori 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 il multimetro di riferimento e selezionare Vref nel codice fino a quando le letture coincidono . Vale anche la pena notare che qualsiasi ADC ha una tensione di offset zero (che rovina le letture all'inizio dell'intervallo), ma per ora non ne parleremo.
Sarà inoltre importante separare il “massa” di alimentazione e misura. Il nostro ADC ha una risoluzione leggermente peggiore di 1mV, che può creare problemi con un cablaggio errato, soprattutto su una breadboard. Poiché il layout della scheda del modulo è già stato realizzato e non ci resta che scegliere i pin. Il modulo ha diversi pin di "massa", quindi dobbiamo assicurarci che l'alimentazione al modulo arrivi su una "massa" e le misurazioni sull'altra. In effetti, uso sempre il pin di massa più vicino agli ingressi analogici per le modifiche.
Per controllare I2C, viene utilizzata una versione della libreria LiquidCrystal_I2C - nel mio caso è indicato il pinout specifico del modulo I2C (i cinesi producono moduli con controllo diverso). Noto anche che I2C in Arduino presuppone l'uso dei pin A4, A5 - sulla scheda Pro Mini non sono sul bordo, il che è scomodo per la prototipazione sul BreadBoard.
