Voltmeter berbilang saluran pada arduino uno dengan PC. Voltmeter digital pada Arduino dengan sambungan ke PC melalui port bersiri

Hello, Habr! Hari ini saya ingin meneruskan topik "menyilang" arduino dan android. DALAM penerbitan sebelumnya Saya bercakap tentang mesin bluetooth, dan hari ini kita akan bercakap tentang DIY voltmeter bluetooth. Satu lagi peranti sedemikian boleh dipanggil voltmeter pintar, voltmeter "pintar", atau hanya voltmeter pintar, tanpa petikan. Nama akhir tidak betul dari sudut tatabahasa Rusia, bagaimanapun, ia sering dijumpai di media. Akan ada undian mengenai topik ini pada penghujung artikel, tetapi saya cadangkan bermula dengan demonstrasi operasi peranti untuk memahami tentang artikel itu.

Penafian: artikel itu ditujukan untuk peminat arduino biasa yang biasanya tidak biasa dengan pengaturcaraan untuk Android, oleh itu, seperti dalam artikel sebelumnya, kami akan membuat aplikasi untuk telefon pintar menggunakan persekitaran pembangunan visual aplikasi android App Pencipta 2.
Untuk membuat voltmeter bluetooth DIY, kita perlu menulis dua atur cara yang agak bebas: lakaran untuk Arduino dan aplikasi untuk Android. Mari kita mulakan dengan lakaran.
Pertama, anda harus tahu bahawa terdapat tiga pilihan utama untuk mengukur voltan menggunakan Arduino, tidak kira di mana anda perlu mengeluarkan maklumat: ke port com, ke skrin yang disambungkan ke Arduino, atau ke telefon pintar.
Kes pertama: pengukuran voltan sehingga 5 volt. Di sini, satu atau dua baris kod sudah mencukupi, dan voltan dibekalkan terus ke pin A0:
nilai int = analogRead(0); // baca bacaan dari A0
voltan = (nilai / 1023.0) * 5; // benar hanya jika Vcc = 5.0 volt
Kes kedua: untuk mengukur voltan lebih daripada 5 volt, pembahagi voltan digunakan. Litar ini sangat mudah, dan begitu juga kodnya.

Lakaran

int analogInput = A0;
float val = 0.0;
voltan apungan = 0.0;
terapung R1 = 100000.0; //Bateri Vin-> 100K -> A0
terapung R2 = 10000.0; //Bateri Gnd -> Arduino Gnd dan Arduino Gnd -> 10K -> A0
nilai int = 0;

Persediaan batal() (
Serial.begin(9600);
pinMode(analogInput, INPUT);
}

Gelung tidak sah() (
nilai = analogRead(analogInput);
val = (nilai * 4.7) / 1024.0;
voltan = val / (R2/(R1+R2));
Serial.println(voltan);
kelewatan(500);
}

Arduino Uno
modul Bluetooth
Kes ketiga. Apabila anda perlu mendapatkan maklumat yang lebih tepat tentang voltan, anda harus menggunakan sebagai voltan rujukan bukan voltan bekalan, yang boleh berubah sedikit apabila dikuasakan oleh bateri, contohnya, tetapi voltan penstabil Arduino dalaman sebanyak 1.1 volt. litar adalah sama di sini, tetapi kodnya lebih panjang sedikit. Saya tidak akan menganalisis pilihan ini secara terperinci, kerana ia sudah diterangkan dengan baik dalam artikel tematik, tetapi kaedah kedua cukup untuk saya, kerana bekalan kuasa saya stabil, dari port USB komputer riba.
Oleh itu, kami telah menyusun ukuran voltan, sekarang mari kita beralih ke separuh kedua projek: mencipta aplikasi Android. Kami akan mencipta aplikasi terus daripada penyemak imbas dalam persekitaran pembangunan visual untuk aplikasi Android App Inventor 2. Pergi ke tapak web appinventor.mit.edu/explore, log masuk menggunakan akaun Google anda, klik butang cipta, projek baharu dan dengan seret dan lepas mudah elemen yang kami buat seperti reka bentuk ini:

Saya membuat grafik dengan sangat mudah, jika sesiapa mahukan grafik yang lebih menarik, izinkan saya mengingatkan anda bahawa untuk ini anda perlu menggunakan fail .png dengan latar belakang lutsinar dan bukannya fail .jpeg.
Sekarang pergi ke tab Blok dan buat logik aplikasi di sana seperti ini:

Jika semuanya berjaya, anda boleh mengklik butang Bina dan simpan .apk ke komputer saya, dan kemudian muat turun dan pasang aplikasi pada telefon pintar anda, walaupun terdapat cara lain untuk memuat naik aplikasi. di sini ia lebih mudah untuk sesiapa sahaja. Akibatnya, saya berakhir dengan aplikasi ini:

Saya faham bahawa beberapa orang menggunakan persekitaran pembangunan visual App Inventor 2 untuk aplikasi Android dalam projek mereka, begitu banyak soalan mungkin timbul tentang bekerja di dalamnya. Untuk mengalih keluar beberapa soalan ini, saya lakukan video terperinci, tentang cara membuat aplikasi sedemikian "dari awal" (untuk melihatnya anda perlu pergi ke YouTube):

P.S. Koleksi lebih daripada 100 bahan pendidikan pada Arduino untuk pemula dan profesional

Diterangkan cara memasang voltmeter berganda buatan sendiri berdasarkan platform Arduino UNO menggunakan paparan LCD 1602A. Dalam sesetengah kes, adalah perlu untuk mengukur dua voltan malar secara serentak dan membandingkannya. Ini mungkin diperlukan, sebagai contoh, semasa membaiki atau melaraskan penstabil voltan DC untuk mengukur voltan pada input dan outputnya, atau dalam kes lain.

Gambarajah skematik

Menggunakan modul pengawal mikro universal ARDUINO UNO dan jenis paparan LCD dua baris 1602A (berdasarkan pengawal HD44780), anda boleh membuat peranti sedemikian dengan mudah. Dalam satu baris ia akan menunjukkan voltan U1, di yang lain - voltan U2.

nasi. 1. Gambarajah skematik voltmeter berganda dengan paparan 1602A pada Arduino UNO.

Tetapi, pertama sekali, saya ingin mengingatkan anda bahawa ARDUINO UNO ialah modul siap sedia yang agak murah - modul kecil papan litar bercetak, di mana mikropengawal ATMEGA328 terletak, serta semua "abah-abah" yang diperlukan untuk operasinya, termasuk pengaturcara USB dan bekalan kuasa.

Bagi mereka yang tidak mengenali ARDUINO UNO, saya nasihatkan anda membaca dahulu artikel L.1 dan L.2. Litar voltmeter berganda ditunjukkan dalam Rajah. 1. Ia direka untuk mengukur dua voltan dari 0 hingga 100V (secara praktikal sehingga 90V).

Seperti yang dapat dilihat dari rajah, ke port digital D2-D7 papan ARDUINO UNO disambungkan kepada modul paparan kristal cecair H1 jenis 1602A. Penunjuk LCD dikuasakan oleh penstabil voltan 5V yang terletak pada papan penstabil voltan 5V.

Voltan yang diukur dibekalkan kepada dua input analog A1 dan A2. Terdapat enam input analog secara keseluruhan, A0-A5, anda boleh memilih mana-mana dua daripadanya. DALAM dalam kes ini, A1 dan A2 dipilih. Voltan pada port analog hanya boleh positif dan hanya dalam julat dari sifar hingga voltan bekalan mikropengawal, iaitu, secara nominal, sehingga 5V.

Output port analog ditukar kepada bentuk digital oleh ADC mikropengawal. Untuk mendapatkan hasil dalam unit volt, anda perlu mendarabkannya dengan 5 (dengan voltan rujukan, iaitu dengan voltan bekalan mikropengawal) dan bahagikan dengan 1024.

Untuk dapat mengukur voltan lebih besar daripada 5V, atau lebih tepat, lebih besar daripada voltan bekalan mikropengawal, kerana voltan sebenar pada output penstabil 5 volt pada papan ARDUINO UNO mungkin berbeza daripada 5V, dan biasanya a sedikit lebih rendah, anda perlu menggunakan pembahagi rintangan konvensional pada input. Ini adalah pembahagi voltan merentasi perintang R1, R3 dan R2, R4.

Dalam kes ini, untuk membawa bacaan peranti kepada nilai sebenar voltan input, anda perlu menetapkan dalam program pembahagian hasil pengukuran dengan pekali pembahagian pembahagi rintangan. Dan pekali pembahagian, mari kita nyatakan "K," boleh dikira menggunakan formula berikut:

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

masing-masing untuk pintu masuk yang berbeza voltmeter berganda.

Sangat menarik bahawa perintang dalam pembahagi tidak semestinya mempunyai ketepatan tinggi. Anda boleh mengambil perintang biasa, kemudian mengukur rintangan sebenar mereka dengan ohmmeter yang tepat, dan menggantikan nilai yang diukur ini ke dalam formula. Anda akan mendapat nilai "K" untuk pembahagi tertentu, yang perlu digantikan ke dalam formula.

Program voltmeter

Program C++ ditunjukkan dalam Rajah 2.

nasi. 2. Sumber program.

Untuk mengawal penunjuk LCD, telah diputuskan untuk menggunakan port D2 hingga D7 papan ARDUINO UNO. Pada dasarnya, port lain mungkin, tetapi inilah cara saya memutuskan untuk menggunakannya.

Agar penunjuk berinteraksi dengan ARDUINO UNO, anda perlu memuatkan subrutin ke dalam program untuk mengawalnya. Rutin sedemikian dipanggil "perpustakaan", dan terdapat banyak "perpustakaan" yang berbeza dalam pakej perisian ARDUINO UNO. Untuk bekerja dengan penunjuk LCD berdasarkan HD44780, anda memerlukan perpustakaan LiquidCrystal. Oleh itu, atur cara (Jadual 1) bermula dengan memuatkan perpustakaan ini:

Baris ini memberikan arahan untuk memuatkan ke dalam ARDUINO UNO perpustakaan ini. Seterusnya, anda perlu menetapkan port ARDUINO UNO yang akan berfungsi dengan penunjuk LCD. Saya memilih port D2 hingga D7. Anda boleh memilih yang lain. Port ini diberikan oleh baris:

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

Selepas itu, program meneruskan operasi sebenar voltmeter. Untuk mengukur voltan, ia telah memutuskan untuk menggunakan input analog A1 dan A2. Input ini dinyatakan dalam baris:

int analogInput=1;

int analogInput1=2;

Untuk membaca data dari port analog, gunakan fungsi analogRead. Membaca data dari port analog berlaku dalam baris:

vout=analogRead(analogInput);

voutl=analogRead(analoglnput1);

Kemudian, voltan sebenar dikira dengan mengambil kira nisbah pembahagian pembahagi voltan masukan:

volt=vout*5.0/1024.0/0.048 ;

volt1=vout1*5.0/1024.0/0.048;

Dalam talian ini, nombor 5.0 ialah voltan pada output penstabil papan ARDUINO UNO. Sebaik-baiknya, ia mestilah 5V, tetapi untuk voltmeter berfungsi dengan tepat, voltan ini mesti diukur terlebih dahulu. Sambungkan punca kuasa dan ukur voltan +5V pada penyambung POWER papan dengan voltmeter yang agak tepat. Apa yang berlaku, kemudian masukkan dalam baris ini dan bukannya 5.0, sebagai contoh, jika terdapat 4.85V, garisan akan kelihatan seperti ini:

volt=vout*4.85/1024.0/0.048;

volt1=vout1*4.85/1024.0/0.048;

Pada peringkat seterusnya, anda perlu mengukur rintangan sebenar perintang R1-R4 dan menentukan pekali K (ditunjukkan sebagai 0.048) untuk garisan ini menggunakan formula:

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

Katakan K1 = 0.046, dan K2 = 0.051, jadi kita tulis:

volt=vout*4.85/1024.0/0.046 ;

volt1=vout1*4.85/1024.0/0.051;

Oleh itu, perubahan mesti dibuat pada teks program mengikut voltan sebenar pada output penstabil 5-volt papan ARDUINO UNO dan mengikut pekali pembahagian sebenar pembahagi rintangan. Selepas ini, peranti akan berfungsi dengan tepat dan tidak memerlukan sebarang pelarasan atau penentukuran.

Dengan menukar pekali pembahagian pembahagi rintangan (dan, dengan itu, pekali "K"), anda boleh membuat had pengukuran lain, dan tidak semestinya sama untuk kedua-dua input.

Karavkin V. RK-2017-01.

kesusasteraan:

Karavkin V. - Penyiar pokok Krismas pada ARDUINO sebagai ubat untuk ketakutan mikropengawal. RK-11-2016.
Karavkin V. - Meter kekerapan pada ARDUINO. RK-12-2016.

Idea

Idea peranti untuk mengukur voltan, arus, kapasiti, nyahcas, dan mungkin caj timbul sejak lama dahulu dan bukan hanya untuk saya. Anda boleh menemui banyak mainan yang dipanggil Penguji USB (Doktor) untuk ujian pelbagai peranti daripada USB. Saya lebih berminat sedikit peranti universal, bebas daripada antara muka, tetapi hanya direka untuk voltan dan arus tertentu. Contohnya, 0 - 20.00v, 0 - 5.00a, 0 - 99.99Ah. Mengenai fungsi, saya melihatnya seperti ini

Memaparkan voltan dan arus semasa, iaitu meter volt-ampere. Pada dasarnya, anda boleh segera mencerminkan kuasa.
Mengira dan memaparkan kapasiti terkumpul. Dalam jam ampere dan kemungkinan besar dalam jam watt.
Paparan masa proses
Dan, kemungkinan besar, ambang potong voltan bawah dan atas boleh laras (had nyahcas dan cas)

Pembangunan

Untuk melaksanakan pengiraan dan pengukuran kita memerlukan pengawal. Saya teringat idea ini sebagai sebahagian daripada kenalan saya dengan Arduino, jadi pengawal akan menjadi Atmega328 popular yang mudah dan ia akan diprogramkan dalam persekitaran Arduino. Dari sudut pandangan kejuruteraan, pilihannya mungkin bukan yang terbaik - pengawal agak gemuk untuk tugas itu, dan ADCnya tidak boleh dipanggil mengukur, tetapi... kami akan cuba.

Kami tidak akan memateri banyak dalam projek ini. Sebagai asas, kami akan mengambil yang sudah siap Modul Arduino Pro Mini, nasib baik orang Cina sedia membekalkannya pada harga runcit $1.5.
Peranti paparan akan menjadi paparan 1602 - $1.5 lagi. Saya mempunyai pilihan dengan modul antara muka I2C, tetapi dalam projek ini ia tidak benar-benar diperlukan ($0.7).
Untuk pembangunan kita perlukan papan roti. Dalam kes saya, ini adalah BreadBoard kecil untuk $1.
Sudah tentu, anda memerlukan wayar dan beberapa perintang dengan nilai yang berbeza. Untuk paparan 1602 tanpa I2C, anda juga perlu memilih kontras - ini dilakukan dengan perintang pembolehubah 2 - 20 kOhm.
Untuk melaksanakan ammeter anda memerlukan shunt. Untuk anggaran pertama, ia boleh menjadi perintang 0.1 Ohm, 5 W.
Untuk melaksanakan penutupan automatik, anda memerlukan geganti dengan kenalan yang direka untuknya arus maksimum peranti dan voltan sama dengan voltan bekalan. Untuk mengawal geganti anda memerlukan transistor NPN dan diod pelindung.
Peranti akan dikuasakan daripada sumber kuasa luaran, jelas sekurang-kurangnya 5 V. Sekiranya bekalan kuasa sangat berbeza, maka penstabil bersepadu jenis 7805 juga akan diperlukan - ia akan menentukan voltan geganti.
Bila Arduino Pro Mini memerlukan penukar USB-TTL untuk memuat naik perisian tegar.
Untuk persediaan anda memerlukan multimeter.

Voltmeter

Saya sedang melaksanakan voltmeter mudah dengan satu julat kira-kira 0 - 20V. Nota ini penting kerana ADC pengawal kami mempunyai kapasiti 10-bit (1024 nilai diskret), jadi ralat akan sekurang-kurangnya 0.02 V (20 / 1024). Untuk melaksanakan perkakasan, kami memerlukan input analog pengawal, pembahagi yang diperbuat daripada sepasang perintang dan beberapa jenis output (paparan dalam versi siap, port bersiri boleh digunakan untuk debugging).

Prinsip pengukuran ADC adalah untuk membandingkan voltan pada input analog dengan rujukan VRef. Output ADC sentiasa integer - 0 sepadan dengan 0V, 1023 sepadan dengan voltan VRef. Pengukuran dilaksanakan oleh satu siri bacaan voltan berjujukan dan purata sepanjang tempoh antara kemas kini nilai pada skrin. Pilihan voltan rujukan adalah penting kerana ia lalai kepada voltan bekalan, yang mungkin tidak stabil. Ini tidak sesuai dengan kami sama sekali - kami akan mengambil sebagai asas sumber rujukan dalaman yang stabil dengan voltan 1.1V, memulakannya dengan memanggil analogReference(INTERNAL). Kami kemudian akan menentukur nilainya menggunakan bacaan multimeter.

Gambar rajah di sebelah kiri menunjukkan varian dengan kawalan langsung paparan (ia hanya dikawal - lihat lakaran LiquidCrystal\HelloWorld standard). Di sebelah kanan ialah pilihan I2C, yang akan saya gunakan selanjutnya. I2C membolehkan anda menjimatkan wayar (di mana terdapat 10 dalam versi biasa, tidak mengira lampu latar). Tetapi ini memerlukan modul tambahan dan permulaan yang lebih kompleks. Walau apa pun, paparan aksara pada modul mesti disemak terlebih dahulu dan kontras diselaraskan - untuk melakukan ini, anda hanya perlu memaparkan sebarang teks selepas permulaan. Kontras dilaraskan oleh perintang R1, atau perintang serupa modul I2C.

Input ialah pembahagi 1:19, yang membolehkan anda mendapatkan voltan maksimum kira-kira 20V (biasanya kapasitor + diod zener diletakkan selari dengan input untuk perlindungan, tetapi ini tidak penting kepada kami buat masa ini). Perintang mempunyai hamparan, dan begitu juga dengan rujukan Vref pengawal, jadi selepas pemasangan kita perlu mengukur voltan (sekurang-kurangnya bekalan) selari dengan peranti kami dan multimeter rujukan dan pilih Vref dalam kod sehingga bacaan sepadan. Perlu juga diperhatikan bahawa mana-mana ADC mempunyai voltan mengimbangi sifar (yang merosakkan bacaan pada permulaan julat), tetapi kami tidak akan membincangkannya buat masa ini.

Ia juga penting untuk memisahkan bekalan dan tanah pengukur. ADC kami mempunyai resolusi lebih buruk sedikit daripada 1mV, yang boleh menimbulkan masalah jika pendawaian tidak betul, terutamanya pada papan roti. Memandangkan susun atur papan modul telah pun dilakukan dan kita hanya perlu memilih pin. Modul ini mempunyai beberapa pin "tanah", jadi kita mesti memastikan bahawa kuasa memasuki modul melalui satu "tanah", dan pengukuran melalui yang lain. Malah, untuk membuat perubahan, saya sentiasa menggunakan pin tanah yang paling hampir dengan input analog.

Untuk mengawal I2C, versi perpustakaan LiquidCrystal_I2C digunakan - dalam kes saya, pinout khusus modul I2C ditunjukkan (modul Cina menghasilkan dengan kawalan berbeza). Saya juga ambil perhatian bahawa I2C dalam Arduino melibatkan penggunaan pin A4, A5 - on Papan pro Mini, mereka tidak terletak di tepi, yang menyusahkan untuk membuat prototaip pada BreadBoard.

Sumber

#termasuk #termasuk // Voltmeter ringkas dengan paparan i2c 1602. V 16.11 // Tetapan untuk paparan i2c 1602 dengan pinout bukan standard #define LCD_I2C_ADDR 0x27 #define BACKLIGHT 3 #define LCD_EN 2 #define LCD_RW 1 #define LCD_RS 0 #define LCD_RS 0 #define LCD_RS 0 #define LCD 5 #define LCD_D6 6 #define LCD_D7 7 LiquidCrystal_I2C lcd(LCD_I2C_ADDR,LCD_EN,LCD_RW,LCD_RS,LCD_D4,LCD_D5,LCD_D6,LCD_D7); // Membaca masa kemas kini, ms (200-2000) #define REFRESH_TIME 330 // Input analog #define PIN_VOLT A0 // Voltan rujukan dalaman (pilih) const float VRef = 1.10; // Input pekali pembahagi rintangan (Rh + Rl) / Rl. DALAM<-[ Rh ]--(analogInPin)--[ Rl ]--|GND const float VoltMult = (180.0 + 10.0) / 10.0; float InVolt, Volt; void setup() { analogReference(INTERNAL); // Инициализация дисплея lcd.begin (16, 2); lcd.setBacklightPin(BACKLIGHT, POSITIVE); lcd.setBacklight(HIGH); // включить подсветку lcd.clear(); // очистить дисплей lcd.print("Voltage"); } void loop() { unsigned long CalcStart = millis(); int ReadCnt = 0; InVolt = 0; // Чтение из порта с усреднением while ((millis() - CalcStart) < REFRESH_TIME) { InVolt += analogRead(PIN_VOLT); ReadCnt++; } InVolt = InVolt / ReadCnt; // Смещение 0 для конкретного ADC (подобрать или отключить) if (InVolt >0.2) InVolt += 3; // Tukar kepada volt (Nilai: 0..1023 -> (0..VRef) berskala dengan Mult) Volt = InVolt * VoltMult * VRef / 1023; // Output data lcd.setCursor (0, 1); lcd.print(Volt); lcd.print("V "); )

Dengan beberapa tambahan.

Ciri Arduino yang kurang dikenali dan banyak cip AVR lain ialah keupayaan untuk mengukur voltan rujukan 1.1 V dalaman. Fungsi ini boleh digunakan untuk meningkatkan ketepatan Fungsi Arduino - analogRead menggunakan voltan rujukan standard 5 V (pada platform dengan voltan bekalan 5 V) atau 3.3 V (pada platform dengan voltan bekalan 3.3 V).Dia juga mungkin digunakan untuk mengukur Vcc digunakan pada cip, menyediakan cara kawalan voltan bateri tanpa guna pin analog berharga.

Motivasi

Sekurang-kurangnya ada sekurang-kurangnya dua sebab untuk mengukur voltan bekalan Arduino (Vcc) kami. Salah satunya ialah projek berkuasa bateri kami jika kami ingin memerhatikan tahap voltan bateri. Di samping itu, apabila kuasa bateri (Vcc) tidak boleh menjadi 5.0 volt (contohnya, kuasa daripada 3 sel ialah 1.5 V), dan kami mahu lakukan ukuran analog lebih tepat - kita mesti menggunakan sama ada rujukan 1.1 V dalaman atau sumber luar voltan rujukan. kenapa?

Adalah biasa untuk mengandaikan apabila menggunakan analogRead() bahawa voltan bekalan analog pengawal ialah 5.0 volt, sedangkan pada hakikatnya ini mungkin tidak berlaku sama sekali (contohnya, bekalan kuasa daripada 3 elemen ialah 1.5 V). Dokumentasi rasmi Arduino mungkin membawa kita kepada andaian yang salah ini. Maksudnya ialah kuasa tidak semestinya 5.0 volt, tidak kira tahap semasa kuasa ini digunakan pada Vcc cip. Jika bekalan kuasa kami tidak stabil atau jika kami menggunakan kuasa bateri, voltan ini mungkin berbeza sedikit. Berikut ialah contoh kod yang menggambarkan masalah ini:

Vcc Berganda = 5.0; // tidak semestinya nilai int benar = analogRead(0); / baca bacaan dari A0 double volt = (nilai / 1023.0) * Vcc; // hanya benar jika Vcc = 5.0 volt Untuk mengukur voltan dengan tepat, voltan rujukan yang tepat diperlukan. Kebanyakan cip AVR menyediakan tiga rujukan voltan:

1.1 dalam daripada sumber dalaman, dalam dokumentasi ia lulus sebagai rujukan celah jalur (sesetengahnya ialah 2.56 V, contohnya ATMega 2560). Pemilihan dibuat oleh fungsi analogReference() dengan parameter INTERNAL: analogReference(INTERNAL) ;

sumber voltan rujukan luaran, berlabel AREF pada arduino. Pilih: analogReference(LUARAN);

Vcc ialah bekalan kuasa pengawal itu sendiri. Pilih: analogReference(DEFAULT).

Dalam Arduino anda tidak boleh hanya menyambungkan Vcc ke pin analog secara terus - secara lalai AREF disambungkan ke Vcc dan anda akan sentiasa mendapat nilai maksimum 1023, tidak kira dari mana voltan anda dikuasakan. Menyambung kepada AREF sumber voltan dengan voltan stabil yang diketahui sebelum ini membantu, tetapi ini adalah unsur tambahan dalam rajah.

Anda juga boleh menyambungkan Vcc ke AREF melalui diod: Penurunan voltan merentasi diod diketahui lebih awal, jadi pengiraan Vcc tidak sukar. Walau bagaimanapun, dengan litar sedemikian melalui diod arus mengalir secara berterusan, memendekkan hayat bateri, yang juga tidak begitu baik.

Rujukan voltan luaran adalah yang paling tepat, tetapi memerlukan perkakasan tambahan. ION dalaman adalah stabil tetapi tidak tepat +/- sisihan 10%. Vcc benar-benar tidak boleh dipercayai dalam kebanyakan kes. Memilih rujukan voltan dalaman adalah murah dan stabil, tetapi kebanyakan masa, kami ingin mengukur lebih banyak voltan daripada 1.1V, jadi menggunakan Vcc adalah yang paling praktikal, tetapi berpotensi paling kurang tepat. Dalam sesetengah kes, ia boleh menjadi sangat tidak boleh dipercayai!

Bagaimana hendak melakukannya

Banyak cip AVR termasuk siri ATmega dan ATtiny menyediakan cara untuk mengukur voltan rujukan dalaman. Mengapa ini perlu? Sebabnya mudah - dengan mengukur voltan dalaman, kita boleh menentukan nilai Vcc. Ini caranya:

Tetapkan rujukan voltan lalai: analogReference(DEFAULT); . Kami menggunakan Vcc sebagai sumber.
Ambil bacaan ADC untuk sumber dalaman 1.1 V.
Kira nilai Vcc berdasarkan ukuran 1.1 V menggunakan formula:

Vcc * (bacaan ADC) / 1023 = 1.1 V

Apa yang berikut:

Vcc = 1.1 V * 1023 / (bacaan ADC)

Menyatukan semuanya dan kami mendapat kod:

long readVcc() ( // Baca rujukan 1.1V terhadap AVcc // tetapkan rujukan kepada Vcc dan ukuran kepada rujukan 1.1V dalaman #jika ditakrifkan(__AVR_ATmega32U4__) || ditakrifkan(__AVR_ATmega1280__) || ditakrifkan(__AVR_ATmega2560__) ADMUX = . (REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1); #elif ditakrifkan (__AVR_ATtiny24__) || ditakrifkan(__AVR_ATtiny44__) || ditakrifkan(__AVR_ATtiny84__) ADMX = _BV(_MUXV5) | (MUX0); #elif ditakrifkan (__AVR_ATtiny25__) || ditakrifkan(__AVR_ATtiny45__) || ditakrifkan(__AVR_ATtiny85__) ADMUX = _BV(MUX3) | _BV(MUX2); #else ADMUX = _BV(REFS0) | _BV(BV3) MUX2) | _BV(MUX1); #endif delay(75); // Tunggu Vref menyelesaikan ADCSRA |= _BV(ADSC); // Mulakan penukaran sambil (bit_is_set(ADCSRA,ADSC)); // mengukur uint8_t rendah = ADCL; // mesti membaca ADCL dahulu - ia kemudian mengunci ADCH uint8_t tinggi = ADCH; // membuka kunci kedua-dua keputusan panjang = (tinggi<<8) | low; result = 1125300L / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000 return result; // Vcc in millivolts }

Penggunaan

Memeriksa Vcc atau Voltan Bateri

Anda boleh memanggil fungsi ini readVcc() jika anda ingin memantau Vcc. Contohnya ialah memeriksa tahap cas bateri. Anda juga boleh menggunakannya untuk menentukan sama ada anda disambungkan kepada sumber kuasa atau menggunakan kuasa bateri.

Pengukuran Vcc untuk voltan rujukan

Anda juga boleh menggunakannya untuk mendapatkan nilai Vcc yang betul untuk digunakan dengan analogRead() apabila anda menggunakan voltan rujukan (Vcc). Melainkan anda menggunakan bekalan kuasa terkawal, anda tidak boleh pasti bahawa Vcc = 5.0 volt. Fungsi ini membolehkan anda mendapatkan nilai yang betul. Terdapat satu kaveat walaupun...

Dalam salah satu artikel saya membuat kenyataan bahawa fungsi ini boleh digunakan untuk meningkatkan ketepatan pengukuran analog dalam kes di mana Vcc tidak cukup 5.0 volt. Malangnya, prosedur ini tidak akan memberikan hasil yang tepat. kenapa? Ini bergantung kepada ketepatan rujukan voltan dalaman. Spesifikasi memberikan voltan nominal 1.1 volt, tetapi mengatakan ia boleh berubah sehingga 10%. Pengukuran sedemikian mungkin kurang tepat daripada bekalan kuasa Arduino kami!

Meningkatkan ketepatan

Walaupun toleransi besar bagi bekalan kuasa 1.1V dalaman mengehadkan ketepatan pengukuran dengan ketara apabila digunakan dalam pengeluaran besar-besaran, kami boleh mencapai ketepatan yang lebih tinggi untuk projek tersuai. Ini mudah dilakukan dengan hanya mengukur Vcc menggunakan voltmeter dan fungsi readVcc() kami. Seterusnya, gantikan pemalar 1125300L dengan pembolehubah baharu:

skala_malar = dalaman1.1Ruj * 1023 * 1000

internal1.1Ref = 1.1 * Vcc1 (voltmeter_readings) / Vcc2 (readVcc_function_readings)

Nilai yang ditentukur ini akan menjadi penunjuk yang baik untuk pengukuran cip AVR, tetapi mungkin dipengaruhi oleh perubahan suhu. Jangan ragu untuk bereksperimen dengan ukuran anda sendiri.

Kesimpulan

Banyak yang boleh anda lakukan dengan ciri kecil ini. Anda boleh menggunakan voltan rujukan yang stabil hampir kepada 5.0V tanpa sebenarnya mempunyai 5.0V pada Vcc. Anda boleh mengukur voltan bateri anda atau melihat sama ada anda menggunakan kuasa bateri atau kuasa pegun.

Akhirnya, kod tersebut akan menyokong semua Arduino, termasuk Leonardo baharu, serta cip siri ATtinyX4 dan ATtinyX5.

Gambar rajah berguna dibentangkan untuk mereka yang suka bereksperimen dengan Arduino. Ini ialah voltmeter digital ringkas yang boleh mengukur voltan DC dengan pasti dalam julat 0 - 30V. Papan Arduino, seperti biasa, boleh dikuasakan oleh bateri 9V.

Seperti yang anda ketahui, input analog Arduino boleh digunakan untuk mengukur voltan DC dalam julat 0 - 5V dan julat ini boleh ditingkatkan,
menggunakan dua perintang sebagai pembahagi voltan. Pembahagi akan mengurangkan voltan yang diukur ke tahap input analog Arduino. Dan kemudian program akan mengira nilai voltan sebenar.

Sensor analog pada papan Arduino mengesan kehadiran voltan pada input analog dan menukarnya ke dalam bentuk digital untuk diproses selanjutnya oleh mikropengawal. Dalam rajah, voltan dibekalkan kepada input analog (A0) melalui pembahagi voltan ringkas yang terdiri daripada perintang R1 (100 kOhm) dan R2 (10 kOhm).

Dengan nilai pembahagi ini, papan Arduino boleh dibekalkan dengan voltan dari 0 hingga
55V. Pada input A0 kita mempunyai voltan yang diukur dibahagikan dengan 11, iaitu 55V / 11=5V. Dalam erti kata lain, apabila mengukur 55V pada input Arduino, kami mempunyai nilai maksimum yang dibenarkan sebanyak 5V. Dalam amalan, adalah lebih baik untuk menulis julat "0 - 30V" pada voltmeter ini supaya ia kekal
Margin keselamatan!

Nota

Jika bacaan paparan tidak bertepatan dengan bacaan voltmeter industri (makmal), maka nilai rintangan R1 dan R2 perlu diukur dengan instrumen yang tepat dan masukkan nilai ini dan bukannya R1=100000.0 dan R2=10000.0 dalam kod program. Kemudian anda harus mengukur voltan sebenar antara pin 5V dan "Ground" papan Arduino dengan voltmeter makmal. Hasilnya ialah nilai kurang daripada 5V, contohnya, ia akan menjadi 4.95V. Nilai sebenar ini harus dimasukkan dalam baris kod
vout = (nilai * 5.0) / 1024.0 bukannya 5.0.
Juga, cuba gunakan perintang ketepatan dengan toleransi 1%.

Perintang R1 dan R2 memberikan sedikit perlindungan terhadap peningkatan voltan input. Walau bagaimanapun, ingat bahawa sebarang voltan melebihi 55V boleh merosakkan papan Arduino. Di samping itu, reka bentuk ini tidak menyediakan jenis perlindungan lain (terhadap lonjakan voltan, pembalikan polariti atau voltan lampau).

Program voltmeter digital

/*
Voltmeter DC
Arduino DVM berdasarkan konsep pembahagi voltan
T.K.Hareendran
*/
#termasuk
lcd LiquidCrystal(7, 8, 9, 10, 11, 12);
int analogInput = 0;
vout apungan = 0.0;
float vin = 0.0;
terapung R1 = 100000.0; // rintangan R1 (100K) -lihat teks!
terapung R2 = 10000.0; // rintangan R2 (10K) – lihat teks!
nilai int = 0;
persediaan batal())(
pinMode(analogInput, INPUT);
lcd.begin(16, 2);
lcd.print(“VOLTMETER DC”);
}
gelung kosong()
// baca nilai pada input analog
nilai = analogRead(analogInput);
vout = (nilai * 5.0) / 1024.0; // lihat teks
vin = vout / (R2/(R1+R2));
jika (vin<0.09) {
vin=0.0;//pernyataan untuk membatalkan bacaan yang tidak diingini !
}
lcd.setCursor(0, 1);
lcd.print(“INPUT V= “);
lcd.print(vin);
kelewatan(500);
}