Sa ilang mga karagdagan.
Ang isang maliit na kilalang tampok ng Arduino at marami pang ibang AVR chips ay ang kakayahang sukatin ang panloob na 1.1 V reference na boltahe. Ang tampok na ito ay maaaring gamitin para sa pagtaas ng katumpakan Mga function ng Arduino - analogRead kapag gumagamit karaniwang boltahe ng sanggunian na 5 V (sa mga platform na may boltahe ng supply na 5 V) o 3.3 V (sa mga platform na may boltahe ng supply na 3.3 V).Maaaring siya rin ginagamit sa pagsukat Inilapat ang Vcc sa chip, na nagbibigay paraan ng kontrol boltahe ng baterya nang hindi gumagamit mahalagang mga analog na pin.
Pagganyak
At least meron hindi bababa sa dalawang dahilan para sa pagsukat supply ng boltahe aming Arduino (Vcc). Isa na rito ang ating battery powered project kung gusto nating subaybayan ang level ng boltahe ng baterya. Bilang karagdagan, kapag ang lakas ng baterya (Vcc) ay hindi maaaring maging 5.0 volts (halimbawa, ang kapangyarihan mula sa 3 mga cell ay 1.5 V), at gusto naming gawin mga sukat ng analog mas tumpak - dapat nating gamitin ang alinman sa panloob na 1.1 V na sanggunian o panlabas na pinagmulan reference na boltahe. Bakit?
Karaniwang ipagpalagay kapag gumagamit ng analogRead() na ang analog supply ng boltahe ng controller ay 5.0 volts, kapag sa katotohanan ay maaaring hindi ito ang kaso sa lahat (halimbawa, isang power supply mula sa 3 elemento ay 1.5 V). Ang opisyal na dokumentasyon ng Arduino ay maaaring humantong sa amin sa maling palagay na ito. Ang punto ay ang kapangyarihan ay hindi kinakailangang 5.0 volts, anuman ang kasalukuyang antas ang kapangyarihang ito ay inilalapat sa Vcc ng chip. Kung ang aming power supply ay hindi na-stabilize o kung kami ay tumatakbo sa lakas ng baterya, ang boltahe na ito ay maaaring mag-iba nang kaunti. Narito ang isang halimbawa ng code na naglalarawan ng problemang ito:
Dobleng Vcc = 5.0; // not necessarily true int value = analogRead(0); / basahin ang mga pagbabasa mula sa A0 double volt = (value / 1023.0) * Vcc; // true lang kung Vcc = 5.0 volts Upang tumpak na masukat ang boltahe, kailangan ng tumpak na reference na boltahe. Karamihan sa mga AVR chip ay nagbibigay ng tatlong sanggunian ng boltahe:
- 1.1 in mula sa panloob na pinagmulan, sa dokumentasyon ito ay pumasa bilang isang bandgap reference (ang ilan sa mga ito ay 2.56 V, halimbawa ATMega 2560). Ang pagpili ay ginawa ng analogReference() function na may INTERNAL parameter: analogReference(INTERNAL) ;
- panlabas na pinagmumulan ng reference na boltahe, na may label na AREF sa arduino. Piliin ang: analogReference(EXTERNAL);
- Ang Vcc ay ang power supply ng controller mismo. Piliin ang: analogReference(DEFAULT).
Sa Arduino hindi mo lang maikonekta ang Vcc sa analog pin nang direkta - bilang default, ang AREF ay konektado sa Vcc at palagi kang makakakuha pinakamataas na halaga 1023, kahit anong boltahe ang ginagamit mo. Ang pagkonekta sa AREF sa isang mapagkukunan ng boltahe na may dating kilala, matatag na boltahe ay nakakatulong, ngunit ito ay dagdag na elemento sa diagram.
Maaari mo ring ikonekta ang Vcc sa AREF sa pamamagitan ng diode: Ang pagbaba ng boltahe sa diode ay alam nang maaga, kaya ang pagkalkula ng Vcc ay hindi mahirap. Gayunpaman, na may tulad na isang circuit sa pamamagitan ng isang diode patuloy na dumadaloy ang kasalukuyang, nagpapaikli sa buhay ng baterya, na hindi rin masyadong maganda.
Ang isang panlabas na sanggunian ng boltahe ay ang pinakatumpak, ngunit nangangailangan ng karagdagang hardware. Ang panloob na ION ay stable ngunit hindi tumpak +/- 10% deviation. Ang Vcc ay ganap na hindi maaasahan sa karamihan ng mga kaso. Ang pagpili ng panloob na sanggunian ng boltahe ay mura at matatag, ngunit kadalasan, gusto naming sukatin ang higit pang boltahe kaysa 1.1V, kaya ang paggamit ng Vcc ay ang pinakapraktikal, ngunit posibleng hindi gaanong tumpak. Sa ilang mga kaso maaari itong maging lubhang hindi mapagkakatiwalaan!
Paano ito gagawin
Maraming AVR chips kabilang ang ATmega at ATtiny series ang nagbibigay ng paraan ng pagsukat ng internal reference voltage. Bakit kailangan ito? Ang dahilan ay simple - sa pamamagitan ng pagsukat ng panloob na boltahe, matutukoy natin ang halaga ng Vcc. Ganito:
- Itakda ang default na sanggunian ng boltahe: analogReference(DEFAULT); . Ginagamit namin ang Vcc bilang mapagkukunan.
- Kumuha ng mga pagbabasa ng ADC para sa panloob na 1.1 V na pinagmulan.
- Kalkulahin ang halaga ng Vcc batay sa 1.1 V na pagsukat gamit ang formula:
Vcc * (pagbabasa ng ADC) / 1023 = 1.1 V
Ano ang sumusunod:
Vcc = 1.1 V * 1023 / (pagbabasa ng ADC)
Pagsasama-sama ng lahat at makuha namin ang code:
mahabang readVcc() ( // Basahin ang 1.1V reference laban sa AVcc // itakda ang reference sa Vcc at ang pagsukat sa panloob na 1.1V reference #if tinukoy(__AVR_ATmega32U4__) || tinukoy(__AVR_ATmega1280__) || tinukoy(__AVR_ATmega2560__) ADMUX = . (REFS0) |. _BV(MUX3) |. _BV(MUX1); else ADMUX = _BV(MUX3) |. _BV(MUX1); #endif delay(75); ); ADCL; // dapat basahin muna ang ADCL - pagkatapos ay i-lock ang ADCH uint8_t high = ADCH;<<8) | low; result = 1125300L / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000 return result; // Vcc in millivolts }Paggamit
Sinusuri ang Vcc o Boltahe ng Baterya
Maaari mong tawagan ang function na ito readVcc() kung gusto mong subaybayan ang Vcc. Ang isang halimbawa ay ang pagsuri sa antas ng singil ng baterya. Magagamit mo rin ito upang matukoy kung nakakonekta ka sa pinagmumulan ng kuryente o tumatakbo sa lakas ng baterya.
Pagsukat ng Vcc para sa reference na boltahe
Maaari mo ring gamitin ito upang makuha ang tamang halaga ng Vcc para magamit sa analogRead() kapag ginagamit mo ang reference na boltahe (Vcc). Maliban kung gagamit ka ng regulated power supply, hindi ka makatitiyak na Vcc = 5.0 volts. Binibigyang-daan ka ng function na ito na makuha ang tamang halaga. May isang caveat bagaman...
Sa isa sa mga artikulo gumawa ako ng isang pahayag na ang function na ito ay maaaring gamitin upang mapabuti ang katumpakan ng mga analog na sukat sa mga kaso kung saan ang Vcc ay hindi masyadong 5.0 volts. Sa kasamaang palad, ang pamamaraang ito ay hindi magbibigay ng tumpak na resulta. Bakit? Depende ito sa katumpakan ng sanggunian ng panloob na boltahe. Ang pagtutukoy ay nagbibigay ng nominal na boltahe na 1.1 volts, ngunit nagsasabing maaari itong mag-iba ng hanggang 10%. Ang ganitong mga sukat ay maaaring hindi gaanong tumpak kaysa sa aming Arduino power supply!
Ang pagtaas ng katumpakan
Habang ang malalaking tolerance ng panloob na 1.1V power supply ay makabuluhang nililimitahan ang katumpakan ng pagsukat kapag ginamit sa mass production, makakamit natin ang higit na katumpakan para sa mga custom na proyekto. Ito ay madaling gawin sa pamamagitan lamang ng pagsukat ng Vcc gamit ang isang voltmeter at ang aming readVcc() function. Susunod, palitan ang constant 1125300L ng bagong variable:
scale_constant = panloob1.1Ref * 1023 * 1000
panloob1.1Ref = 1.1 * Vcc1 (voltmeter_readings) / Vcc2 (readVcc_function_readings)
Ang naka-calibrate na value na ito ay magiging isang magandang indicator para sa mga sukat ng AVR chip, ngunit maaaring maapektuhan ng mga pagbabago sa temperatura. Huwag mag-atubiling mag-eksperimento sa iyong sariling mga sukat.
Konklusyon
Marami kang magagawa sa maliit na feature na ito. Maaari kang gumamit ng stable na reference na boltahe na malapit sa 5.0V nang hindi aktwal na mayroong 5.0V sa Vcc. Maaari mong sukatin ang boltahe ng iyong baterya o kahit na makita kung tumatakbo ka sa lakas ng baterya o nakatigil na kapangyarihan.
Sa wakas, susuportahan ng code ang lahat ng Arduinos, kabilang ang bagong Leonardo, pati na rin ang ATtinyX4 at ATtinyX5 series chips.
Ang isang kapaki-pakinabang na diagram ay ipinakita para sa mga gustong mag-eksperimento sa Arduino. Ito ay isang simpleng digital voltmeter na mapagkakatiwalaang sukatin ang boltahe ng DC sa hanay na 0 - 30V. Ang Arduino board, gaya ng dati, ay maaaring paandarin ng 9V na baterya.
Tulad ng malamang na alam mo, ang mga analog input ng Arduino ay maaaring gamitin upang sukatin ang boltahe ng DC sa hanay ng 0 - 5V at ang saklaw na ito ay maaaring tumaas,
gamit ang dalawang resistors bilang boltahe divider. Babawasan ng divider ang sinusukat na boltahe sa antas ng mga Arduino analog input. At pagkatapos ay kalkulahin ng programa ang tunay na halaga ng boltahe.
Nakikita ng analog sensor sa Arduino board ang pagkakaroon ng boltahe sa analog input at kino-convert ito sa digital form para sa karagdagang pagproseso ng microcontroller. Sa figure, ang boltahe ay ibinibigay sa analog input (A0) sa pamamagitan ng isang simpleng boltahe divider na binubuo ng mga resistors R1 (100 kOhm) at R2 (10 kOhm).
Sa mga halaga ng divider na ito, ang Arduino board ay maaaring bigyan ng boltahe mula 0 hanggang
55V. Sa input A0 mayroon kaming sinusukat na boltahe na hinati sa 11, ibig sabihin, 55V / 11=5V. Sa madaling salita, kapag nagsusukat ng 55V sa Arduino input, mayroon kaming maximum na pinahihintulutang halaga na 5V. Sa pagsasagawa, mas mainam na isulat ang saklaw na "0 - 30V" sa voltmeter na ito upang manatili ito
Safety margin!
Mga Tala
Kung ang mga pagbabasa ng display ay hindi tumutugma sa mga pagbabasa ng isang pang-industriya (laboratoryo) voltmeter, kung gayon kinakailangan upang sukatin ang mga halaga ng paglaban R1 at R2 gamit ang isang tumpak na instrumento at ipasok ang mga halagang ito sa halip na R1=100000.0 at R2= 10000.0 sa program code. Pagkatapos ay dapat mong sukatin ang tunay na boltahe sa pagitan ng 5V at "Ground" na mga pin ng Arduino board gamit ang isang laboratory voltmeter. Ang resulta ay magiging isang halaga na mas mababa sa 5V, halimbawa, ito ay magiging 4.95V. Ang tunay na halaga na ito ay dapat na ipasok sa linya ng code
vout = (value * 5.0) / 1024.0 sa halip na 5.0.
Gayundin, subukang gumamit ng precision resistors na may 1% tolerance.
Ang mga resistors R1 at R2 ay nagbibigay ng ilang proteksyon laban sa tumaas na mga boltahe ng input, gayunpaman, tandaan na ang anumang mga boltahe sa itaas ng 55V ay maaaring makapinsala sa Arduino board. Bilang karagdagan, ang disenyo na ito ay hindi nagbibigay ng iba pang mga uri ng proteksyon (mula sa power surges, mula sa polarity reversal o overvoltage).
Programa ng digital voltmeter
/*
DC Voltmeter
Isang Arduino DVM batay sa konsepto ng divider ng boltahe
T.K.Hareendran
*/
#isama
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
int analogInput = 0;
float vout = 0.0;
float vin = 0.0;
lumutang R1 = 100000.0; // paglaban ng R1 (100K) -tingnan ang teksto!
lumutang R2 = 10000.0; // paglaban ng R2 (10K) - tingnan ang teksto!
int value = 0;
void setup())(
pinMode(analogInput, INPUT);
lcd.begin(16, 2);
lcd.print("DC VOLTMETER");
}
void loop()
// basahin ang halaga sa analog input
halaga = analogRead(analogInput);
vout = (value * 5.0) / 1024.0; // tingnan ang teksto
vin = vout / (R2/(R1+R2));
kung (vin<0.09) {
vin=0.0;//statement para iwaksi ang hindi gustong pagbabasa !
}
lcd.setCursor(0, 1);
lcd.print(“INPUT V= “);
lcd.print(vin);
pagkaantala(500);
}
Schematic diagram ng Arduino-voltmeter
Listahan ng mga sangkap
Arduino Uno board
100 kOhm risistor
10 kOhm risistor
100 ohm risistor
10kOhm Trimmer Resistor
LCD display 16?2 (Hitachi HD44780)
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++
Ipinapalagay ko na mayroon ka nang pangunahing kaalaman sa C++ programming para sa Windows, kung hindi, pagkatapos 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. Papayagan ka nitong baguhin ang ilang mahahalagang parameter ng 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)
May mga pagkakataon na gusto mong suriin ang boltahe o ilang punto sa isang circuit, ngunit wala kang voltmeter o multimeter sa kamay? Tumakbo para bumili? Ito ay mahaba at mahal. Bago mo gawin iyon, paano ang paggawa ng isang voltmeter sa iyong sarili? Sa katunayan, sa mga simpleng sangkap ay maaari mong gawin ito sa iyong sarili.
- Sa aralin gumamit kami ng board na katugma sa Arduino - SunFounder Uno / Mars (http://bit.ly/2tkaMba)
- USB data cable
- 2 potentiometers (50k)
- LCD1602 - http://bit.ly/2ubNEfi
- Development board - http://bit.ly/2slvfrB
- Maramihang mga jumper
Bago kumonekta, unawain muna natin kung paano ito gumagana.
Gamitin ang SunFounder Uno board para sa pangunahing bahagi ng pagpoproseso ng data ng voltmeter, LCD1602 bilang screen, isang potentiometer upang ayusin ang contrast ng LCD, at isa pa para hatiin ang boltahe.
Kapag inikot mo ang potentiometer na konektado sa Uno board, nagbabago ang potentiometer resistor, at sa gayon ay binabago ang boltahe sa kabuuan nito. Ang signal ng boltahe ay ipapadala sa Uno board sa pamamagitan ng pin A0, at kino-convert ni Uno ang natanggap analog signal sa digital form at mga tala sa LCD display. Sa ganitong paraan makikita mo ang halaga ng boltahe sa kasalukuyang capacitance resistance.
Ang LCD1602 ay may dalawang operating mode: 4-bit at 8-bit. Kapag hindi sapat ang MCU IO, maaari kang pumili ng 4-bit mode, na gumagamit lamang ng mga pin D4~D7.
Sundin ang talahanayan upang ikonekta ang mga ito.
Hakbang 4: Ikonekta ang potentiometer sa LCD1602
Ikonekta ang gitnang pin ng potentiometer sa Vo pin sa LCD1602 at alinman sa iba pang mga pin sa GND.
Ikonekta ang gitnang pin ng potentiometer sa pin A0 mula sa SunFounder Uno, at isa sa iba pa sa 5V habang ang isa sa GND.
Hakbang 6: I-upload ang code
Ang code na ito:
#include /************************************************** ********** *****/ const int analogIn = A0;//potentiometer na nakakabit sa A0 LiquidCrystal lcd(4, 6, 10, 11, 12, 13);//lcd(RS, E,D4,D5,D6.D7) float val = 0;// tukuyin ang variable bilang value=0 /************************ ********** *****************/ void setup() ( Serial.begin(9600);//Initialize ang serial lcd.begin(16 , 2);//itakda ang posisyon ng mga character sa LCD bilang Line 2, Column 16 lcd.print("Voltage Value:");//print "Voltage Value:" ) /******** ********** **********************************/ void loop() ( val = analogRead(A0);//Basahin ang halaga ng potentiometer sa val val = val/1024*5.0;// I-convert ang data sa katumbas na halaga ng boltahe sa paraang matematika Serial.print(val);//I-print ang bilang ng val sa serial monitor Serial.print ("V"); // i-print ang unit bilang V, maikli para sa boltahe sa serial monitor lcd.setCursor(6,1);//Ilagay ang cursor sa Linya 1, Column 6. Mula dito ang mga character ay ipapakita lcd.print(val);//I-print ang bilang ng val sa LCD lcd.print("V");//Pagkatapos ay i-print ang unit bilang V, maikli para sa boltahe sa Pagkaantala ng LCD(200); //Maghintay ng 200ms )I-rotate ang potentiometer upang suriin ang boltahe sa LCD1602 sa real time.
Narito ang isang nakakalito na bagay. Pagkatapos kong patakbuhin ang code, ang LCD ay nagpakita ng mga character. Pagkatapos ay inayos ko ang contrast ng screen (unti-unting pagbabago mula sa itim patungo sa puti) sa pamamagitan ng pag-ikot ng potentiometer sa clockwise o counterclockwise hanggang sa malinaw na ipinakita ng screen ang mga character.
Kumuha ng dalawang baterya upang sukatin ang kanilang boltahe: 1.5 V at 3.7 V. Alisin ang pagkakabit ng pangalawang potentiometer sa A0 at GND pin, na nangangahulugang alisin ang potentiometer mula sa circuit. I-clamp ang dulo ng wire A0 sa anode ng baterya at ang circuit ng GND sa cathode. HUWAG isaksak muli ang mga ito o makakakuha ka maikling circuit sa baterya. Ang halaga ng 0V ay isang baligtad na koneksyon.
Kaya, ang boltahe ng baterya ay ipinapakita sa LCD display. Maaaring may ilang error sa pagitan ng halaga at ng nominal na halaga dahil hindi pa ganap na naka-charge ang baterya. At iyon ang dahilan kung bakit kailangan kong sukatin ang boltahe upang maunawaan kung magagamit ko ang baterya o hindi.
PS: Kung mayroon kang mga problema sa display sa iyong display - tingnan ang FAQ na ito para sa mga LCD display - http://wiki.sunfounder.cc/index.php?title=LCD1602/I2C_LCD1602_FAQ.
