Mga elementong ginamit:

Ipinapakita ng artikulong ito kung paano i-interface ang Arduino at PC at maglipat ng data mula sa ADC patungo sa PC. Ang programa para sa Windows ay isinulat gamit ang Visual C++ 2008 Express. Ang programa ng voltmeter ay napaka-simple at may maraming puwang para sa pagpapabuti. Ang pangunahing layunin nito ay upang ipakita kung paano magtrabaho sa isang COM port at makipagpalitan ng data sa pagitan ng isang computer at Arduino.

Komunikasyon sa pagitan ng Arduino at PC:

• Ang pagkuha ng mga pagbabasa mula sa ADC ay nagsisimula kapag ipinadala ng computer ang Arduino na mga utos ng 0xAC at 0x1y. sa– Numero ng channel ng ADC (0-2);
• Humihinto ang pagbabasa pagkatapos makatanggap ang Arduino ng mga utos na 0xAC at 0x00;
• Habang kumukuha ng mga pagbabasa, ipinapadala ng Arduino ang mga command na 0xAB 0xaa 0xbb sa computer tuwing 50 ms, kung saan ang aa at bb ang pinakamataas at pinakamababang resulta ng pagsukat.

Programa para sa Arduino

Maaari kang magbasa nang higit pa tungkol sa serial communication sa arduino.cc. Ang programa ay medyo simple, karamihan sa mga ito ay ginugol sa pagtatrabaho sa parallel port. Matapos tapusin ang pagbabasa ng data mula sa ADC, nakatanggap kami ng 10-bit na halaga ng boltahe (0x0000 - 0x0400) sa anyo ng mga 16-bit na variable (INT). Ang serial port (RS-232) ay nagpapahintulot sa data na maipadala sa 8-bit na mga packet. Kinakailangang hatiin ang 16-bit na mga variable sa 2 bahagi ng 8 bits.

Serial.print(boltahe>>8,BYTE);

Serial.print(boltahe%256,BYTE);

Inilipat namin ang mga byte ng variable na 8 bits sa kanan at pagkatapos ay hatiin sa 256 at ipadala ang resulta sa computer.

Maaari mong i-download ang buong source code para sa Arduino software

Visual C++

I assume na meron ka na pangunahing kaalaman sa C++ programming para sa Windows, kung hindi ay gamitin ang Google. Ang Internet ay puno ng mga tutorial para sa mga nagsisimula.

Ang unang bagay na dapat gawin ay magdagdag serial port mula sa toolbar hanggang sa mas mababang anyo. Magbabago ito ng ilan mahalagang mga parameter serial port: pangalan ng port, baud rate, bit depth. Ito ay kapaki-pakinabang para sa pagdaragdag ng mga kontrol sa isang window ng application, pagbabago ng mga setting na ito anumang oras, nang hindi muling kino-compile ang program. Ginamit ko lang ang opsyon sa pagpili ng port.

Pagkatapos maghanap ng mga available na serial port, ang unang port ay pinili bilang default. Paano ito ginagawa:

array< String ^>^ serialPorts = nullptr;

serialPorts = serialPort1->GetPortNames();

ito->comboBox1->Mga Item->AddRange(serialPorts);

ito->comboBox1->SelectedIndex=0;

Ang serial port sa isang PC ay maaari lamang gamitin ng isang application sa isang pagkakataon, kaya ang port ay dapat na bukas bago gamitin at hindi sarado. Mga simpleng utos para dito:

serialPort1->Buksan();

serialPort1->Close();

Upang basahin nang tama ang data mula sa isang serial port, dapat mong gamitin ang mga kaganapan (sa aming kaso, isang interrupt). Pumili ng uri ng kaganapan:

Drop-down list kung kailan i-double click"DataReceived".

Awtomatikong nabuo ang code ng kaganapan:

Kung dumating ang unang byte sa serial port 0xAB kung nangangahulugan ito na ang natitirang mga byte ay nagdadala ng data ng boltahe.

pribado: System::Void serialPort1_DataReceived(System::Object^ sender, System::IO::Ports::SerialDataReceivedEventArgs^ e) (

unsigned char data0, data1;

kung (serialPort1->ReadByte()==0xAB) (

data0=serialPort1->ReadByte();

data1=serialPort1->ReadByte();

boltahe=Math::Round((float(data0*256+data1)/1024*5.00),2);

data_count++;

serialPort1->ReadByte();

Sumulat at magbasa ng serial port data

Ang isang maliit na problema para sa akin ay ang pagpapadala ng hex RAW data sa pamamagitan ng serial port. Ang Write() command ay ginamit; ngunit may tatlong argumento: array, start byte number, bilang ng byte na isusulat.

pribado: System::Void button2_Click_1(System::Object^ sender, System::EventArgs^ e) (

unsigned char channel=0;

channel=this->listBox1->SelectedIndex;

array^start =(0xAC,(0x10+channel));

array^stop =(0xAC,0x00);

serialPort1->Write(start,0,2);

ito->button2->Text="Stop";

) iba (

serialPort1->Write(stop,0,2);

ito->button2->Text="Start";

Iyon lang!

Orihinal na artikulo sa Ingles(pagsasalin: Alexander Kasyanov para sa site na cxem.net)

Inilarawan kung paano mag-assemble ng isang homemade double voltmeter batay sa platform Arduino UNO gamit ang 1602A LCD display. Sa ilang mga kaso, kinakailangan upang sukatin ang dalawang pare-parehong boltahe nang sabay-sabay at ihambing ang mga ito. Maaaring kailanganin ito, halimbawa, kapag nag-aayos o nag-aayos ng stabilizer DC boltahe upang sukatin ang boltahe sa input at output nito, o sa iba pang mga kaso.

Diagram ng eskematiko

Gamit ang isang unibersal na microcontroller ARDUINO module Ang UNO at isang two-line na LCD display type 1602A (batay sa HD44780 controller) ay madaling makagawa ng ganoong device. Sa isang linya ipapakita nito ang boltahe U1, sa kabilang linya - ang boltahe U2.

kanin. 1. Diagram ng eskematiko dobleng voltmeter na may 1602A display sa Arduino UNO.

Ngunit, una sa lahat, gusto kong ipaalala sa iyo na ang ARDUINO UNO ay isang medyo murang handa na module - isang maliit na PCB, kung saan matatagpuan ang ATMEGA328 microcontroller, pati na rin ang lahat ng "harness" nito na kinakailangan para sa operasyon nito, kabilang ang isang USB programmer at power supply.

Para sa mga hindi pamilyar sa ARDUINO UNO, ipinapayo ko sa inyo na basahin muna ang mga artikulong L.1 at L.2. Ang circuit ng isang double voltmeter ay ipinapakita sa Fig. 1. Ito ay dinisenyo upang sukatin ang dalawang boltahe mula 0 hanggang 100V (halos hanggang 90V).

Tulad ng makikita mula sa diagram, hanggang sa mga digital port na D2-D7 ARDUINO boards Ang UNO ay konektado sa liquid crystal display module H1 type 1602A. Ang LCD indicator ay pinapagana ng 5V voltage stabilizer na matatagpuan sa 5V voltage stabilizer board.

Ang mga sinusukat na boltahe ay ibinibigay sa dalawang analog input na A1 at A2. Mayroong anim na analog input sa kabuuan, A0-A5, maaari kang pumili ng alinman sa dalawa sa kanila. Sa kasong ito, napili ang A1 at A2. Ang boltahe sa mga analog port ay maaari lamang maging positibo at nasa hanay lamang mula sa zero hanggang sa boltahe ng supply ng microcontroller, iyon ay, sa nominal, hanggang sa 5V.

Ang output ng analog port ay na-convert sa digital form ng ADC ng microcontroller. Upang makuha ang resulta sa mga yunit ng volts, kailangan mong i-multiply ito ng 5 (sa pamamagitan ng reference na boltahe, iyon ay, sa pamamagitan ng supply boltahe ng microcontroller) at hatiin ng 1024.

Upang masukat ang mga boltahe na mas malaki kaysa sa 5V, o sa halip, mas malaki kaysa sa supply ng boltahe ng microcontroller, dahil ang aktwal na boltahe sa output ng 5-volt stabilizer sa ARDUINO UNO board ay maaaring mag-iba sa 5V, at karaniwan ay isang maliit na mas mababa, kailangan mong gumamit ng maginoo resistive divider sa input. Narito ang mga ito ay boltahe dividers sa mga resistors R1, R3 at R2, R4.

Sa kasong ito, upang dalhin ang mga pagbabasa ng aparato sa tunay na halaga ng boltahe ng input, kailangan mong itakda sa programa ang paghahati ng resulta ng pagsukat sa pamamagitan ng division coefficient ng resistive divider. At ang division coefficient, sabihin nating "K," ay maaaring kalkulahin gamit ang sumusunod na formula:

K = R3 / (R1+R3) o K = R4 / (R2+R4),

ayon sa pagkakabanggit para sa iba't ibang pasukan dobleng voltmeter.

Napaka-interesante na ang mga resistors sa mga divider ay hindi kinakailangang maging mataas ang katumpakan. Maaari kang kumuha ng mga ordinaryong resistor, pagkatapos ay sukatin ang kanilang aktwal na paglaban sa isang tumpak na ohmmeter, at palitan ang mga sinusukat na halaga sa formula. Makukuha mo ang value na "K" para sa isang partikular na divisor, na kakailanganing i-substitute sa formula.

Programa ng Voltmeter

Ang C++ program ay ipinapakita sa Figure 2.

kanin. 2. Source code mga programa.

Para makontrol ang LCD indicator, napagpasyahan na gumamit ng mga port D2 hanggang D7 ng ARDUINO UNO board. Sa prinsipyo, ang iba pang mga port ay posible, ngunit ito ay kung paano ako nagpasya na gamitin ang mga ito.

Para makipag-ugnayan ang indicator sa ARDUINO UNO, kailangan mong mag-load ng subroutine sa program para makontrol ito. Ang ganitong mga gawain ay tinatawag na "mga aklatan", at mayroong maraming iba't ibang "mga aklatan" sa ARDUINO UNO software suite. Upang gumana sa isang LCD indicator batay sa HD44780, kailangan mo ang LiquidCrystal library. Samakatuwid, ang programa (Talahanayan 1) ay nagsisimula sa pamamagitan ng pag-load sa library na ito:

Ang linyang ito ay nagbibigay ng utos na mag-load sa ARDUINO UNO aklatang ito. Susunod, kailangan mong magtalaga ng mga port ng ARDUINO UNO na gagana sa indicator ng LCD. Pinili ko ang mga port D2 hanggang D7. Maaari kang pumili ng iba. Ang mga port na ito ay itinalaga ng linya:

LiquidCrystal led(2, 3, 4, 5, 6, 7);

Pagkatapos nito, ang programa ay nagpapatuloy sa aktwal na operasyon ng voltmeter. Upang sukatin ang boltahe, napagpasyahan na gumamit ng mga analog input na A1 at A2. Ang mga input na ito ay tinukoy sa mga linya:

int analogInput=1;

int analogInput1=2;

Upang basahin ang data mula sa mga analog port, gamitin ang analogRead function. Ang pagbabasa ng data mula sa mga analog port ay nangyayari sa mga linya:

vout=analogRead(analogInput);

voutl=analogRead(analoglnput1);

Pagkatapos, ang aktwal na boltahe ay kinakalkula na isinasaalang-alang ang dibisyon ratio ng input boltahe divider:

volt=vout*5.0/1024.0/0.048 ;

volt1=vout1*5.0/1024.0/0.048;

Sa mga linyang ito, ang bilang na 5.0 ay ang boltahe sa output ng stabilizer ng ARDUINO UNO board. Sa isip, ito ay dapat na 5V, ngunit para sa voltmeter upang gumana nang tumpak, ang boltahe na ito ay dapat munang masukat. Ikonekta ang pinagmumulan ng kuryente at sukatin ang boltahe ng +5V sa POWER connector ng board gamit ang isang medyo tumpak na voltmeter. Ano ang mangyayari, pagkatapos ay ipasok ang mga linyang ito sa halip na 5.0, halimbawa, kung mayroong 4.85V, ang mga linya ay magiging ganito:

volt=vout*4.85/1024.0/0.048;

volt1=vout1*4.85/1024.0/0.048;

Sa susunod na yugto, kakailanganin mong sukatin ang aktwal na mga paglaban ng mga resistors R1-R4 at tukuyin ang K coefficients (ipinahiwatig bilang 0.048) para sa mga linyang ito gamit ang mga formula:

K1 = R3 / (R1+R3) at K2 = R4 / (R2+R4)

Sabihin nating K1 = 0.046, at K2 = 0.051, kaya isusulat namin:

volt=vout*4.85/1024.0/0.046 ;

volt1=vout1*4.85/1024.0/0.051;

Kaya, dapat gawin ang mga pagbabago sa teksto ng programa ayon sa aktwal na boltahe sa output ng 5-volt stabilizer ng ARDUINO UNO board at ayon sa aktwal na division coefficient ng resistive divider. Pagkatapos nito, gagana nang tumpak ang device at hindi mangangailangan ng anumang pagsasaayos o pagkakalibrate.

Sa pamamagitan ng pagbabago ng mga dibisyon coefficient ng resistive divider (at, nang naaayon, ang "K" coefficients), maaari kang gumawa ng iba pang mga limitasyon sa pagsukat, at hindi palaging pareho para sa parehong mga input.

Karavkin V. RK-2017-01.

Panitikan:

1. Karavkin V. - Flasher ng Christmas tree sa ARDUINO bilang isang lunas sa takot sa mga microcontroller. RK-11-2016.
2. Karavkin V. - Frequency meter sa ARDUINO. RK-12-2016.

Hello, Habr! Ngayon gusto kong ipagpatuloy ang paksa ng "pagtawid" sa arduino at android. SA nakaraang publikasyon Napag-usapan ko, at ngayon ay pag-uusapan natin ang tungkol sa isang DIY bluetooth voltmeter. Ang isa pang ganoong aparato ay maaaring tawaging isang matalinong voltmeter, isang "matalinong" voltmeter, o isang matalinong voltmeter lamang, nang walang mga panipi. Ang apelyido ay hindi tama mula sa punto ng view ng Russian grammar, gayunpaman, ito ay madalas na matatagpuan sa media. Magkakaroon ng boto sa paksang ito sa dulo ng artikulo, ngunit iminumungkahi kong magsimula sa isang pagpapakita ng pagpapatakbo ng device upang maunawaan kung tungkol saan ang artikulo.

Sketch

int analogInput = A0;
float val = 0.0;
float boltahe = 0.0;
lumutang R1 = 100000.0; //Baterya Vin-> 100K -> A0
lumutang R2 = 10000.0; //Baterya Gnd -> Arduino Gnd at Arduino Gnd -> 10K -> A0
int value = 0;

Void setup() (
Serial.begin(9600);
pinMode(analogInput, INPUT);
}

Void loop() (
halaga = analogRead(analogInput);
val = (value * 4.7) / 1024.0;
boltahe = val / (R2/(R1+R2));
Serial.println(boltahe);
pagkaantala(500);
}