Există momente în care doriți să verificați tensiunea sau un anumit punct dintr-un circuit, dar nu aveți un voltmetru sau un multimetru la îndemână? Fugi să cumperi? Este lung și scump. Înainte să faci asta, ce zici de a construi singur un voltmetru? De fapt, cu ingrediente simple o poți face singur.
Pasul 1: Pregătiți componentele
- În lecție am folosit o placă compatibilă cu Arduino - SunFounder Uno/Mars (http://bit.ly/2tkaMba)
- cablu de date USB
- 2 potențiometre (50k)
- LCD1602 - http://bit.ly/2ubNEfi
- Placă de dezvoltare - http://bit.ly/2slvfrB
- Mai multe săritori
Înainte de a vă conecta, să vedem mai întâi cum funcționează.
Utilizați placa SunFounder Uno pentru partea principală a procesării datelor voltmetrului, LCD1602 ca ecran, un potențiometru pentru a regla contrastul LCD și altul pentru a împărți tensiunea.
Când rotiți potențiometrul conectat la placa Uno, rezistența potențiometrului se schimbă, modificând astfel tensiunea pe el. Semnalul de tensiune va fi trimis la placa Uno prin pinul A0, iar Uno va converti semnalul analog primit în formă digitală și va înregistra pe LCD. În acest fel, puteți vedea valoarea tensiunii la rezistența capacității curente.
LCD1602 are două moduri de operare: 4 biți și 8 biți. Când MCU IO este insuficient, puteți alege modul pe 4 biți, care utilizează doar pinii D4 ~ D7.
Urmați tabelul pentru a le conecta.
Pasul 4: Conectați potențiometrul la LCD1602
Conectați pinul din mijloc al potențiometrului la pinul Vo de pe LCD1602 și oricare dintre ceilalți pini la GND.
Conectați pinul din mijloc al potențiometrului la pinul A0 de la SunFounder Uno și unul dintre ceilalți la 5V, în timp ce celălalt la GND.
Pasul 6: Încărcați codul
Acest cod:
#include /*********************************************** ******* *****/ const int analogIn = A0;//potențiometrul atașat la A0 LiquidCrystal lcd(4, 6, 10, 11, 12, 13);//lcd(RS,E,D4) ,D5,D6.D7) float val = 0;// definiți variabila ca valoare=0 /**************************** ******* *****************/ void setup() ( Serial.begin(9600);//Inițializați seria lcd.begin(16, 2) ;//setează poziția caracterelor de pe LCD ca linia 2, coloana 16 lcd.print("Valoarea tensiunii:");//printează "Valoarea tensiunii:" ) /*********** ******* **********************************/ bucla void() ( val = analogRead (A0);//Citiți valoarea potențiometrului la val val = val/1024*5.0;// Convertiți datele la valoarea tensiunii corespunzătoare într-un mod matematic Serial.print(val);//Imprimați numărul de val pe monitorul serial Serial.print ("V"); // tipăriți unitatea ca V, prescurtare pentru tensiune pe monitorul serial lcd.setCursor(6,1);//Plasați cursorul la linia 1, coloana 6. Din aici caracterele vor fi afișate lcd.print(val);//Tipărește numărul de val pe LCD lcd.print("V");//Apoi imprimă unitatea ca V, scurt pentru tensiune pe LCD delay( 200); //Așteptați 200 ms)
Rotiți potențiometrul pentru a verifica tensiunea de pe LCD1602 în timp real.
Iată un lucru complicat. După ce am rulat codul, ecranul LCD arăta caractere. Am ajustat apoi contrastul ecranului (modificare treptată de la negru la alb) rotind potențiometrul în sensul acelor de ceasornic sau în sens invers acelor de ceasornic până când ecranul a afișat clar caracterele.
Luați două baterii pentru a le măsura tensiunea: 1,5 V și 3,7 V. Decuplați conexiunea celui de-al doilea potențiometru la pinul A0 și GND, ceea ce înseamnă scoaterea potențiometrului din circuit. Fixați capătul firului A0 la anodul bateriei și circuitul GND la catod. NU le reconectați sau veți scurtcircuita bateria. O valoare de 0V este o conexiune inversă.
Deci, tensiunea bateriei este afișată pe afișajul LCD. Este posibil să existe o eroare între valoare și valoarea nominală, deoarece bateria nu este încărcată complet. Și de aceea trebuie să măsoare tensiunea pentru a înțelege dacă pot folosi bateria sau nu.
PS: Dacă aveți probleme cu afișarea pe afișaj - consultați această Întrebări frecvente pentru afișajele LCD - http://wiki.sunfounder.cc/index.php?title=LCD1602/I2C_LCD1602_FAQ.
Intrări analogice ale plăcii Arduino.
Placa Arduino UNO conține 6 intrări analogice concepute pentru a măsura semnalele de tensiune. Ar fi mai corect să spunem că cei 6 pini ai plăcii pot funcționa atât în moduri de ieșire discretă, cât și de intrare analogică.
Acești pini sunt numerotați de la 14 la 19. Sunt configurați inițial ca intrări analogice și pot fi accesați folosind numele A0-A5. Ele pot fi configurate în modul de ieșire discretă în orice moment.
pinMode(A3, IEȘIRE); // setarea modului de ieșire discretă pentru A3
digitalWrite(A3, LOW); // setarea ieșirii A3 la un nivel scăzut
Pentru a reveni la modul de intrare analogică:
pinMode(A3, INPUT); // setarea modului de intrare analogic pentru A3
Intrări analogice și rezistențe pull-up.
Rezistoarele de tragere sunt conectate la pinii de intrare analogici, precum și la pinii discreti. Aceste rezistențe sunt pornite folosind comanda
digitalWrite(A3, HIGH); // porniți rezistența de tragere la intrarea A3
Comanda trebuie aplicată unui pin configurat în modul de intrare.
Trebuie reținut că rezistorul poate afecta nivelul semnalului analogic de intrare. Curentul de la sursa de alimentare de 5V, prin rezistorul de tragere, va provoca o scădere de tensiune pe rezistența internă a sursei de semnal. Deci este mai bine să deconectați rezistența.
Convertor analog-digital al plăcii Arduino.
Măsurarea tensiunii reale la intrări este efectuată de un convertor analog-digital (ADC) cu un comutator pentru 6 canale. ADC-ul are o rezoluție de 10 biți, care corespunde codului de la ieșirea convertorului 0...1023. Eroarea de măsurare nu este mai mare de 2 unități din cifra cea mai puțin semnificativă.
Pentru a menține acuratețea maximă (10 biți), este necesar ca rezistența internă a sursei de semnal să nu depășească 10 kOhm. Această cerință este deosebit de importantă atunci când se utilizează divizoare de rezistență conectate la intrările analogice ale plăcii. Rezistența rezistențelor divizor nu poate fi prea mare.
Funcții software de intrare analogică.
int analogRead(port)
Citește valoarea tensiunii la intrarea analogică specificată. Tensiunea de intrare variază de la 0 la nivelul tensiunii de referință (adesea 5 V) care se transformă într-un cod de la 0 la 1023.
Cu o tensiune de referință de 5 V, rezoluția este de 5 V / 1024 = 4,88 mV.
Conversia durează aproximativ 100 μs.
int inputCod; // codul tensiunii de intrare
Tensiune de intrare float; // tensiune de intrare în V
inputCod= analogRead(A3); // citirea tensiunii la intrarea A3
inputVoltage= ((float)inputCod * 5. / 1024.); // conversia codului în tensiune (V)
void analogReference(tip)
Setează tensiunea de referință pentru ADC. Acesta definește tensiunea maximă de intrare analogică pe care ADC-ul o poate converti corect. Valoarea tensiunii de referință determină, de asemenea, factorul de conversie cod-la-tensiune:
Tensiune de intrare = cod ADC * tensiune de referință / 1024.
Argumentul tip poate lua următoarele valori:
- IMPLICIT – tensiunea de referință este egală cu tensiunea de alimentare a controlerului (5 V sau 3,3 V). Pentru Arduino UNO R3 – 5 V.
- INTERN – tensiune de referință internă 1,1 V pentru plăci cu controlere ATmega168 și ATmega328, pentru ATmega8 – 2,56 V.
- INTERNAL1V1 – tensiune de referință internă de 1,1 V pentru controlerele Arduino Mega.
- INTERNAL2V56 – tensiune de referință internă de 2,56 V pentru controlerele Arduino Mega.
- EXTERN – sursă externă de tensiune de referință, conectată la intrarea AREF.
analogReference(INTERN); // tensiunea de referință este de 1,1 V
Voltmetru cu două canale pe Arduino.
Ca exemplu de utilizare a funcțiilor de intrare analogică, să creăm un proiect pentru un voltmetru digital simplu pe Arduino. Dispozitivul trebuie să măsoare tensiunile la două intrări analogice ale plăcii și să transmită valorile măsurate către computer printr-un port serial. Folosind acest proiect ca exemplu, voi arăta principiile creării sistemelor simple de măsurare și colectare a informațiilor.
Să decidem că voltmetrul ar trebui să măsoare tensiunea în intervalul de cel puțin 0...20 V și să dezvoltăm un circuit pentru conectarea intrărilor voltmetrului la placa Arduino UNO.
Dacă setăm tensiunea de referință la 5 V, atunci intrările analogice ale plăcii vor măsura tensiunea în intervalul 0...5 V. Și avem nevoie de cel puțin 0...20 V. Aceasta înseamnă că trebuie să folosim un divizor de tensiune.
Tensiunea la intrarea și ieșirea divizorului este legată de relația:
Uieșire = (Uinput / (R1 + R2)) * R2
Raport de transmisie:
K = Uieșire / Uintrare = R2 / (R1 + R2)
Avem nevoie de un raport de transfer de 1/4 (20 V * 1/4 = 5 V).
Pentru a menține acuratețea maximă (10 biți), este necesar ca rezistența internă a sursei de semnal să nu depășească 10 kOhm. Prin urmare, alegem rezistorul R2 egal cu 4,22 kOhm. Se calculează rezistența rezistenței R1.
0,25 = 4,22 / (R1 + 4,22)
R1 = 4,22 / 0,25 – 4,22 = 12,66 kOhm
Am găsit rezistențe cu o rezistență de 15 kOhm cu cea mai apropiată valoare. Cu rezistențe R1 = 15 kOhm și R2 = 4,22:
5 / (4,22 / (15 + 4,22)) = 22,77 V.
Circuitul voltmetrului bazat pe Arduino va arăta astfel. 
Două divizoare de tensiune sunt conectate la intrările analogice A0 și A1. Condensatorii C1 și C2, împreună cu rezistențele de divizare, formează filtre trece-jos care elimină zgomotul de înaltă frecvență din semnale.
Am asamblat acest circuit pe o placă.
Am conectat prima intrare a voltmetrului la o sursă de alimentare reglată, iar a doua la sursa de alimentare de 3,3 V a plăcii Arduino. Pentru a monitoriza tensiunea, am conectat un voltmetru la prima intrare. Rămâne doar să scrieți programul.
Un program pentru măsurarea tensiunii folosind o placă Arduino.
Algoritmul este simplu. Necesar:
- citiți codul ADC de două ori pe secundă;
- convertiți-l în tensiune;
- trimiteți valorile măsurate prin portul serial către un computer;
- Programul de monitorizare a portului Arduino IDE afișează valorile de tensiune obținute pe ecranul computerului.
Vă voi oferi imediat o schiță completă a programului.
// program de măsurare a tensiunii
// pe intrările analogice A0 și A1
#include
timpul perioadei de măsurare
#define R1 15. // rezistența rezistenței R1
#define R2 4.22 // rezistența rezistenței R2
plutitor u1, u2; // tensiuni măsurate
void setup() (
Serial.begin(9600); //
MsTimer2::start(); // activare întrerupere
}
void loop() (
// perioada 500 ms
dacă (timeCount >= MEASURE_PERIOD) (
timeCount= 0;
//
// citirea codului canalului 2 și conversia la tensiune
u2= ((float)analogRead(A1)) * 5. / 1024. / R2 * (R1 + R2);
// transfer de date prin portul serial
Serial.print("U1 = "); Serial.print(u1, 2);
Serial.print(" U2 = "); Serial.println(u2, 2);
}
}
// întrerupe procesarea 1 ms
void timerInterrupt() (
timeCount++;
}
Permiteți-mi să explic linia în care codul ADC este convertit în tensiune:
// citirea codului canalului 1 și conversia la tensiune
u1= ((float)analogRead(A0)) * 5. / 1024. / R2 * (R1 + R2);
- Codul ADC este citit: analogRead(A0) .
- Convertit explicit în format virgulă mobilă: (float) .
- Convertit la tensiune la intrarea analogică: * 5. / 1024. Punctul de la sfârșitul numerelor indică faptul că acesta este un număr în virgulă mobilă.
- Se ia în considerare coeficientul de transmisie divizor: / R2 * (R1 + R2).
Să încărcăm programul pe placă și să lansăm monitorul portului serial.
Două bare de rulare arată valorile tensiunilor măsurate. Totul merge.
Măsurarea valorii medii a semnalului.
Să conectăm primul canal al voltmetrului nostru la o sursă de tensiune cu un nivel ridicat de ondulare. Vom vedea această poză pe monitor.
Valorile tensiunii primului canal de pe ecranul monitorului trec și sar în mod constant. Și citirile voltmetrului de control sunt destul de stabile. Acest lucru se datorează faptului că voltmetrul de referință măsoară valoarea medie a semnalului, în timp ce placa Arduino citește mostre individuale la fiecare 500 ms. Desigur, momentul citirii ADC scade în diferite puncte ale semnalului. Și la un nivel ridicat de pulsații, amplitudinea în aceste puncte este diferită.
În plus, dacă semnalul este citit în eșantioane rare și separate, atunci orice zgomot de impuls poate introduce o eroare semnificativă în măsurare.
Soluția este să luați mai multe probe frecvente și să faceți o medie a valorii măsurate. Pentru aceasta:
- în manipulatorul de întreruperi citim codul ADC și îl însumăm cu mostrele anterioare;
- numărați timpul de mediere (numărul de probe de mediere);
- când se atinge numărul specificat de mostre, salvăm valoarea totală a codurilor ADC;
- Pentru a obține valoarea medie, împărțiți suma codurilor ADC la numărul de eșantioane de mediere.
Problemă dintr-un manual de matematică de clasa a VIII-a. Iată o schiță a programului, un voltmetru de valoare medie cu două canale.
// program de măsurare a mediei tensiuni
// pe intrările analogice A0 și A1
#include
#define MEASURE_PERIOD 500 // timpul perioadei de măsurare
#define R1 15. // rezistența rezistenței R1
#define R2 4.22 // rezistența rezistenței R2
int timeCount; // contor de timp
lung sumU1, sumU2; // variabile pentru însumarea codurilor ADC
medie lungăU1, medieU2; // suma codurilor ADC (valoare medie * 500)
steag boolean Gata; // indicator al gradului de pregătire al datelor de măsurare
void setup() (
Serial.begin(9600); // inițializați portul, viteza 9600
MsTimer2::set(1, timerInterupt); // cronometrul întrerupe, perioadă 1 ms
MsTimer2::start(); // activare întrerupere
}
void loop() (
dacă (flagReady == adevărat) (
flagReady= fals;
// conversie la tensiune și transfer pe computer
Serial.print("U1 = ");
Serial.print((float)avarageU1 / 500. * 5. / 1024. / R2 * (R1 + R2), 2);
Serial.print(" U2 = ");
Serial.println((float)avarageU2 / 500. * 5. / 1024. / R2 * (R1 + R2), 2);
}
}
// întrerupe procesarea 1 ms
void timerInterrupt() (
timeCount++; // +1 contor de probă medie
sumU1+= analogRead(A0); // însumând codurile ADC
sumU2+= analogRead(A1); // însumând codurile ADC
// verificarea numărului de probe de mediere
dacă (timeCount >= MEASURE_PERIOD) (
timeCount= 0;
medieU1= sumaU1; // suprasarcină de valoare medie
medieU2= sumaU2; // suprasarcină de valoare medie
sumU1= 0;
sumaU2= 0;
flagReady= adevărat; // rezultatul măsurării semnului este gata
}
}
În formula de conversie a codului ADC în tensiune, a fost adăugat /500 - numărul de mostre. Încărcați, lansați monitorul portului (Cntr+Shift+M).
Acum, chiar și cu un nivel semnificativ de pulsație, citirile se modifică cu sutimi. Acest lucru se datorează faptului că tensiunea nu este stabilizată.
Numărul de probe trebuie ales luând în considerare:
- numărul de probe determină timpul de măsurare;
- Cu cât numărul de mostre este mai mare, cu atât interferența va fi mai mică.
Principala sursă de interferență în semnalele analogice este rețeaua de 50 Hz. Prin urmare, este recomandabil să alegeți un timp de mediere care este un multiplu de 10 ms – timpul de jumătate de ciclu al unei rețele de 50 Hz.
Optimizarea calculelor.
Calculele cu virgulă mobilă pur și simplu consumă resursele unui microcontroler pe 8 biți. Orice operațiune în virgulă mobilă necesită denormalizarea mantisei, operarea în virgulă fixă, normalizarea mantisei, corectarea comenzii... Și toate operațiunile cu numere pe 32 de biți. Prin urmare, este necesar să se minimizeze utilizarea calculelor în virgulă mobilă. Vă voi spune cum să faceți acest lucru în lecțiile următoare, dar să ne optimizăm cel puțin calculele. Efectul va fi semnificativ.
În programul nostru, conversia codului ADC în tensiune este scrisă după cum urmează:
(float)medieU1 / 500. * 5. / 1024. / R2 * (R1 + R2)
Sunt atât de multe calcule aici, toate cu virgulă mobilă. Dar majoritatea calculelor sunt operații cu constante. O parte a liniei:
/ 500. * 5. / 1024. / R2 * (R1 + R2)
(float)avarageU1 * 0,00004447756
Compilatoarele inteligente recunosc calculele cu constante și le calculează în etapa de compilare. Am o întrebare despre cât de inteligent este compilatorul lui Andruino. Am decis să verific.
Am scris un scurt program. Efectuează un ciclu de 10.000 de treceri și apoi transmite timpul de execuție a acelor 10.000 de cicluri către computer. Acestea. vă permite să vedeți timpul de execuție al operațiilor plasate în corpul buclei.
// verificarea optimizării calculelor
int x= 876;
float y;
unsigned int număr;
nesemnat lung timeCurrent, timePrev;
void setup() (
Serial.begin(9600);
}
void loop() (
numără++;
// y= (float)x / 500. * 5. / 1024. / 4.22 * (15. + 4.22);
// y= (float)x * 0,00004447756 ;
dacă (număr >= 10000) (
număr = 0;
timeCurrent= milis();
Serial.println(timeCurrent - timePrev);
timePrev= timeCurrent;
}
}
În prima opțiune, când operațiunile în virgulă mobilă din buclă sunt comentate și nu sunt executate, programul a produs un rezultat de 34 ms.
Acestea. 10.000 de bucle goale sunt finalizate în 34 ms.
Apoi am deschis linia:
y= (float)x / 500. * 5. / 1024. / 4.22 * (15. + 4.22);
repetă calculele noastre. Rezultat de 10.000 de treceri în 922 ms sau
(922 – 34) / 10.000 = 88,8 µs.
Acestea. această linie de calcule cu virgulă mobilă durează 89 µs pentru a fi finalizată. Am crezut că vor fi mai multe.
Acum am închis această linie cu un comentariu și am deschis-o pe următoarea, înmulțind cu o constantă precalculată:
y= (float)x * 0,00004447756;
Rezultat de 10.000 de treceri în 166 ms sau
(166 – 34) / 10.000 = 13,2 µs.
Rezultat uimitor. Am economisit 75,6 μs pe linie. L-am finalizat de aproape 7 ori mai repede. Avem 2 astfel de linii, dar pot fi mult mai multe în program.
Concluzie - calculele cu constante trebuie făcute singur pe un calculator și utilizate în programe ca coeficienți gata pregătiți. Compilatorul Arduino nu le va calcula în etapa de compilare. În cazul nostru ar trebui să facem asta:
#define ADC_U_COEFF 0,00004447756 // factor de conversie a codului ADC la tensiune
Serial.print((float)avarageU1 * ADC_U_COEFF, 2);
Opțiunea optimă pentru performanță este transferul codului ADC pe computer și, împreună cu acesta, toate calculele în virgulă mobilă. În acest caz, un program specializat de pe computer trebuie să primească datele. Monitorul portului de la Arduino IDE nu va funcționa.
Voi vorbi despre alte modalități de optimizare a programelor Arduino în lecțiile viitoare, după cum este necesar. Dar fără a rezolva această problemă, este imposibil să se dezvolte programe complexe pe un microcontroler pe 8 biți.
Pe site a apărut o altă lecție () dedicată măsurării semnalelor analogice. Acesta examinează funcționarea unui ADC în fundal.
În lecția următoare vom învăța cum să lucrăm cu EEPROM internă și vom vorbi despre monitorizarea integrității datelor.
Categorie: . Puteți să-l marcați.Acest articol arată cum să interfațați Arduino cu PC-ul și să transferați date de la ADC la PC. Programul pentru Windows este scris folosind Visual C++ 2008 Express. Programul voltmetrului este foarte simplu și are mult loc de îmbunătățire. Scopul său principal a fost să arate cum să lucrezi cu un port COM și să schimbi date între un computer și Arduino.
Comunicarea dintre Arduino și PC:
- Preluarea citirilor de la ADC începe atunci când computerul trimite comenzile Arduino 0xAC și 0x1y. la– numărul canalului ADC (0-2);
- Citirea se oprește după ce Arduino primește comenzile 0xAC și 0x00;
- La efectuarea citirilor, Arduino trimite la computer comenzile 0xAB 0xaa 0xbb la fiecare 50 ms, unde aa și bb sunt rezultatele maxime și minime ale măsurătorilor.
Program pentru Arduino
Puteți citi mai multe despre comunicarea serială la arduino.cc. Programul este destul de simplu, cea mai mare parte este cheltuită lucrând cu portul paralel. După ce am terminat de citit datele de la ADC, primim o valoare a tensiunii de 10 biți (0x0000 – 0x0400) sub formă de variabile de 16 biți (INT). Portul serial (RS-232) permite transmiterea datelor în pachete de 8 biți. Este necesar să se împartă variabilele de 16 biți în 2 părți de 8 biți.
Serial.print(tensiune>>8,BYTE);
Serial.print(tensiune%256,BYTE);
Deplasăm octeții variabilei 8 biți la dreapta și apoi împărțim la 256 și trimitem rezultatul la computer.
Puteți descărca codul sursă complet pentru software-ul Arduino
Visual C++
Presupun că aveți deja cunoștințe de bază despre programarea C++ pentru Windows, dacă nu, atunci utilizați Google. Internetul este plin de tutoriale pentru începători.
Primul lucru de făcut este să adăugați portul serial din bara de instrumente în formularul de jos. Acest lucru vă va permite să modificați câțiva parametri importanți ai portului serial: numele portului, rata de transmisie, adâncimea de biți. Acest lucru este util pentru adăugarea de controale la o fereastră de aplicație, modificând aceste setări în orice moment, fără a recompila programul. Am folosit doar opțiunea de selecție a portului.
După căutarea porturilor seriale disponibile, primul port este selectat implicit. Cum se face:
matrice< String ^>^ serialPorts = nullptr;
serialPorts = serialPort1->GetPortNames();
this->comboBox1->Items->AddRange(serialPorts);
this->comboBox1->SelectedIndex=0;
Portul serial de pe un PC poate fi folosit doar de o aplicație la un moment dat, așa că portul trebuie să fie deschis înainte de utilizare și nu închis. Comenzi simple pentru asta:
serialPort1->Open();
serialPort1->Close();
Pentru a citi corect datele de pe un port serial, trebuie să utilizați evenimente (în cazul nostru, o întrerupere). Selectați tipul de eveniment:
Listă drop-down când faceți dublu clic pe „DateReceived”.
Codul evenimentului este generat automat:
Dacă primul octet sosit pe portul serial este 0xAB, dacă asta înseamnă că octeții rămași poartă date de tensiune.
privat: System::Void serialPort1_DataReceived(System::Object^ expeditor, System::IO::Ports::SerialDataReceivedEventArgs^ e) (
unsigned char data0, data1;
dacă (serialPort1->ReadByte()==0xAB) (
data0=serialPort1->ReadByte();
data1=serialPort1->ReadByte();
voltage=Math::Round((float(data0*256+data1)/1024*5.00),2);
data_count++;
serialPort1->ReadByte();
Scrieți și citiți datele portului serial
O mică problemă pentru mine a fost trimiterea de date RAW hexadecimale prin portul serial. S-a folosit comanda Write(); dar cu trei argumente: matrice, număr de octeți de pornire, număr de octeți de scris.
privat: System::Void button2_Click_1(System::Object^ expeditor, System::EventArgs^ e) (
canal de caracter nesemnat=0;
channel=this->listBox1->SelectedIndex;
matrice^start =(0xAC,(0x10+canal));
matrice^stop =(0xAC,0x00);
serialPort1->Write(start,0,2);
this->button2->Text="Stop";
) altfel (
serialPort1->Write(stop,0,2);
this->button2->Text="Start";
Asta e tot!
Articolul original în engleză (traducere: Alexandru Kasyanov pentru site-ul cxem.net)
Ansamblurile multifuncționale Arduino sunt de mare interes pentru fanii dispozitivelor de casă programabile electronic, permițându-le să dea viață ideilor interesante.
Principalul avantaj al circuitelor Arduino gata făcute este principiul unic bloc-modular: fiecare placă poate fi adăugată cu interfețe suplimentare, extinzând la nesfârșit posibilitățile de creare a diferitelor proiecte.
module Arduino sunt construite pe un microcontroler universal cu propriul bootloader, ceea ce face ușor să-l flash cu codul de program necesar, fără a utiliza dispozitive suplimentare. Programarea se realizează în limbajul standard C++.
Unul dintre cele mai simple exemple de utilizare a Arduino poate fi implementarea, pe baza acestui ansamblu, a unui voltmetru DC de înaltă precizie cu un interval de măsurare de la 0 la 30 V.
Intrările analogice Arduino sunt proiectate pentru o tensiune constantă de cel mult cinci volți, prin urmare, utilizarea lor la tensiuni care depășesc această valoare este posibilă cu un divizor de tensiune.
Schema de conectare a lui Areduino prin divizor de tensiune Un divizor de tensiune este format din două rezistențe conectate în serie. Se calculează folosind formula:
Conector USB extern în radioul auto 
Bună, Habr! Astăzi vreau să continui subiectul „încrucișării” arduino și android. În publicația anterioară am vorbit, iar astăzi vom vorbi despre un voltmetru bluetooth DIY. Un alt astfel de dispozitiv poate fi numit un voltmetru inteligent, un voltmetru „inteligent” sau doar un voltmetru inteligent, fără ghilimele. Numele de familie este incorect din punctul de vedere al gramaticii ruse, cu toate acestea, este adesea găsit în mass-media. Va fi un vot pe acest subiect la sfârșitul articolului, dar vă sugerez să începeți cu o demonstrație a funcționării dispozitivului pentru a înțelege despre ce va fi articolul.
Disclaimer: articolul este destinat pasionatului mediu de arduino care de obicei nu este familiarizat cu programarea Android, prin urmare, ca și în articolul precedent, vom crea o aplicație pentru un smartphone folosind mediul de dezvoltare vizuală App Inventor 2 pentru aplicațiile Android.
Pentru a face un voltmetru bluetooth DIY, trebuie să scriem două programe relativ independente: o schiță pentru Arduino și o aplicație pentru Android. Să începem cu o schiță.
În primul rând, ar trebui să știți că există trei opțiuni principale pentru măsurarea tensiunii folosind Arduino, indiferent de locul în care trebuie să scoateți informațiile: către portul com, pe un ecran conectat la Arduino sau la un smartphone.
Primul caz: măsurători de tensiune până la 5 volți. Aici, una sau două linii de cod sunt suficiente, iar tensiunea este furnizată direct pinului A0:
int valoare = analogRead(0); // citește citirile de la A0
tensiune = (valoare / 1023,0) * 5; // adevărat numai dacă Vcc = 5,0 volți
Al doilea caz: pentru a măsura tensiuni mai mari de 5 volți, se folosește un divizor de tensiune. Circuitul este foarte simplu, la fel și codul.
Schiță
int analogInput = A0;
val float = 0,0;
tensiune float = 0,0;
float R1 = 100000,0; //Bateria Vin-> 100K -> A0
float R2 = 10000,0; //Battery Gnd -> Arduino Gnd și Arduino Gnd -> 10K -> A0
valoare int = 0;
Void setup() (
Serial.begin(9600);
pinMode(analogInput, INPUT);
}
Void loop() (
valoare = analogRead(analogInput);
val = (valoare * 4,7) / 1024,0;
tensiune = val / (R2/(R1+R2));
Serial.println(tensiune);
întârziere (500);
}
Arduino Uno
modul Bluetooth
Al treilea caz. Când trebuie să obțineți informații mai precise despre tensiune, ar trebui să utilizați ca tensiune de referință nu tensiunea de alimentare, care poate varia ușor atunci când este alimentată de o baterie, de exemplu, ci tensiunea stabilizatorului intern Arduino de 1,1 volți. circuitul este același aici, dar codul este puțin mai lung. Nu voi analiza în detaliu această opțiune, deoarece este deja bine descrisă în articolele tematice, dar a doua metodă îmi este destul de suficientă, deoarece sursa mea de alimentare este stabilă, de la portul USB al laptopului.
Deci am rezolvat măsurarea tensiunii, acum să trecem la a doua jumătate a proiectului: crearea unei aplicații Android. Vom crea aplicația direct din browser în mediul de dezvoltare vizuală pentru aplicațiile Android App Inventor 2. Accesați site-ul web appinventor.mit.edu/explore, conectați-vă folosind contul dvs. Google, faceți clic pe butonul creați, proiect nou și prin pur și simplu trăgând și plasând elemente, vom crea ceva de genul acesta:
Am făcut grafica foarte simplă, dacă cineva dorește o grafică mai interesantă, permiteți-mi să vă reamintesc că pentru aceasta trebuie să folosiți fișiere .png cu fundal transparent în loc de fișiere .jpeg.
Acum accesați fila Blocuri și creați logica aplicației acolo ceva de genul acesta:
Dacă totul merge bine, puteți să faceți clic pe butonul Build și să salvați .apk pe computerul meu, apoi să descărcați și să instalați aplicația pe smartphone, deși există și alte modalități de a încărca aplicația. aici este mai convenabil pentru oricine. Ca rezultat, am ajuns cu această aplicație:
Înțeleg că puțini oameni folosesc mediul de dezvoltare vizuală App Inventor 2 pentru aplicațiile Android în proiectele lor, așa că pot apărea multe întrebări despre lucrul în el. Pentru a răspunde unora dintre aceste întrebări, am realizat un videoclip detaliat despre cum să faci o astfel de aplicație „de la zero” (pentru a o vizualiza trebuie să mergi pe YouTube):
P.S. O colecție de peste 100 de materiale educaționale despre Arduino pentru începători și profesioniști
