ვოლტმეტრი Arduino-ზე ძაბვის ზუსტი გაზომვისთვის. ციფრული ვოლტმეტრი Arduino-ზე კომპიუტერთან დაკავშირებით სერიული პორტით

12.04.2019

სასარგებლო დიაგრამა წარმოდგენილია მათთვის, ვისაც უყვარს Arduino-ს ექსპერიმენტები. ეს არის მარტივი ციფრული ვოლტმეტრი, რომელსაც შეუძლია საიმედოდ გაზომოს DC ძაბვა 0 - 30 ვ დიაპაზონში. Arduino-ს დაფა, როგორც ყოველთვის, შეიძლება იკვებებოდეს 9 ვ ბატარეით.

როგორც მოგეხსენებათ, Arduino-ს ანალოგური შეყვანები შეიძლება გამოყენებულ იქნას DC ძაბვის გასაზომად 0 - 5 ვ დიაპაზონში და ეს დიაპაზონი შეიძლება გაიზარდოს.
ორი რეზისტორების გამოყენებით ძაბვის გამყოფად. გამყოფი შეამცირებს გაზომილ ძაბვას Arduino-ს ანალოგური შეყვანების დონემდე. და შემდეგ პროგრამა გამოთვლის ძაბვის რეალურ მნიშვნელობას.

Arduino-ს დაფაზე ანალოგური სენსორი აღმოაჩენს ძაბვის არსებობას ანალოგურ შესასვლელში და გარდაქმნის მას ციფრულ ფორმაში მიკროკონტროლერის მიერ შემდგომი დამუშავებისთვის. ფიგურაში ძაბვა მიეწოდება ანალოგურ შეყვანას (A0) ძაბვის მარტივი გამყოფის მეშვეობით, რომელიც შედგება რეზისტორებისგან R1 (100 kOhm) და R2 (10 kOhm).

ამ გამყოფი მნიშვნელობებით, Arduino დაფას შეიძლება მიეწოდოს ძაბვა 0-დან
55 ვ. A0 შესასვლელში გვაქვს გაზომილი ძაბვა გაყოფილი 11-ზე, ანუ 55V / 11=5V. სხვა სიტყვებით რომ ვთქვათ, Arduino-ს შეყვანაზე 55 ვ-ის გაზომვისას გვაქვს მაქსიმალური დასაშვები მნიშვნელობა 5 ვ. პრაქტიკაში, უმჯობესია ამ ვოლტმეტრზე დაწეროთ დიაპაზონი "0 - 30V" ისე, რომ ის დარჩეს
უსაფრთხოების ზღვარი!

შენიშვნები

თუ ჩვენების ჩვენებები არ ემთხვევა სამრეწველო (ლაბორატორიული) ვოლტმეტრის ჩვენებებს, მაშინ საჭიროა ზუსტი ხელსაწყოთი გავზომოთ R1 და R2 წინააღმდეგობების მნიშვნელობა და ჩასვათ ეს მნიშვნელობები R1=100000.0 და R2=10000.0 ნაცვლად. პროგრამის კოდში. შემდეგ თქვენ უნდა გაზომოთ რეალური ძაბვა არდუინოს დაფის 5V და „Ground“ ქინძისთავებს შორის ლაბორატორიული ვოლტმეტრით. შედეგი იქნება 5 ვ-ზე ნაკლები მნიშვნელობა, მაგალითად, ეს იქნება 4.95 ვ. ეს რეალური მნიშვნელობა უნდა იყოს ჩასმული კოდის ხაზში
Vout = (მნიშვნელობა * 5.0) / 1024.0 5.0-ის ნაცვლად.
ასევე, შეეცადეთ გამოიყენოთ ზუსტი რეზისტორები 1% ტოლერანტობით.

რეზისტორები R1 და R2 უზრუნველყოფენ გაზრდილი შეყვანის ძაბვისგან გარკვეულ დაცვას, თუმცა გახსოვდეთ, რომ ნებისმიერმა ძაბვამ შეიძლება დააზიანოს Arduino დაფა. გარდა ამისა, ეს დიზაინი არ უზრუნველყოფს სხვა სახის დაცვას (ძაბვის ტალღების, პოლარობის შებრუნების ან გადაჭარბებული ძაბვისგან).

ციფრული ვოლტმეტრის პროგრამა

/*
DC ვოლტმეტრი
Arduino DVM, რომელიც დაფუძნებულია ძაბვის გამყოფის კონცეფციაზე
T.K.Hareendran
*/
#შეიცავს
LiquidCrystal LCD (7, 8, 9, 10, 11, 12);
int analogInput = 0;
float vout = 0.0;
float vin = 0.0;
ათწილადი R1 = 100000.0; // R1-ის წინააღმდეგობა (100K) -იხილეთ ტექსტი!
ათწილადი R2 = 10000.0; // R2-ის წინააღმდეგობა (10K) – იხილეთ ტექსტი!
int მნიშვნელობა = 0;
void setup())(
pinMode(analogInput, INPUT);
lcd.begin(16, 2);
lcd.print ("DC VOLTMETER");
}
void loop ()
// წაიკითხეთ მნიშვნელობა ანალოგური შეყვანისას
მნიშვნელობა = analogRead(analogInput);
vout = (მნიშვნელობა * 5.0) / 1024.0; // იხილეთ ტექსტი
vin = vout / (R2/(R1+R2));
თუ (ვინ<0.09) {
vin=0.0;//განცხადება არასასურველი წაკითხვის გასაუქმებლად!
}
lcd.setCursor(0, 1);
lcd.print(“INPUT V=“);
lcd.print(vin);
დაგვიანებით (500);
}

არდუინო-ვოლტმეტრის სქემატური დიაგრამა

კომპონენტების სია

Arduino Uno დაფა
100 kOhm რეზისტორი
10 kOhm რეზისტორი
100 ომიანი რეზისტორი
10 kOhm ტრიმერის რეზისტორი
LCD დისპლეი 16?2 (Hitachi HD44780)

იდეა

იდეა ძაბვის, დენის, სიმძლავრის, გამონადენის და შესაძლოა დამუხტვის საზომი მოწყობილობები დიდი ხნის წინ გაჩნდა და არა მარტო ჩემთვის. თქვენ შეგიძლიათ იპოვოთ მრავალი სათამაშო, სახელწოდებით USB Tester (ექიმი) სხვადასხვა USB მოწყობილობების შესამოწმებლად. მე მაინტერესებს გარკვეულწილად უნივერსალური მოწყობილობა, ინტერფეისისგან დამოუკიდებელი, მაგრამ უბრალოდ შექმნილია გარკვეული ძაბვისა და დენისთვის. მაგალითად, 0 - 20.00v, 0 - 5.00a, 0 - 99.99Ah. რაც შეეხება ფუნქციებს, მე ასე ვხედავ

აჩვენებს მიმდინარე ძაბვას და დენს, ანუ ვოლტ-ამპერ მეტრს. პრინციპში, თქვენ შეგიძლიათ დაუყოვნებლივ ასახოთ ძალა.
დათვლა და დაგროვილი სიმძლავრის ჩვენება. ამპერ საათებში და დიდი ალბათობით ვატ საათებში.
პროცესის დროის ჩვენება
და, სავარაუდოდ, რეგულირებადი ქვედა და ზედა ძაბვის გამორთვის ზღურბლები (გამონადენი და დატენვის ლიმიტები)

განვითარება

გამოთვლებისა და გაზომვების განსახორციელებლად ჩვენ გვჭირდება კონტროლერი. ეს იდეა გამახსენდა, როგორც Arduino-სთან გაცნობის ნაწილი, ამიტომ კონტროლერი იქნება მარტივი პოპულარული Atmega328 და ის დაპროგრამდება გარემოში. არდუინო. საინჟინრო თვალსაზრისით არჩევანი ალბათ საუკეთესო არ არის - კონტროლერი ცოტა მსუქანია ამოცანისთვის და მის ADC-ს საზომი არ შეიძლება ეწოდოს, მაგრამ... შევეცდებით.

ამ პროექტში ბევრს არ დავდებთ. საფუძვლად, ჩვენ ავიღებთ მზა Arduino Pro Mini მოდულს, რადგან ჩინელები მზად არიან მიაწოდონ ისინი $1,5 საცალო ფასად.
დისპლეი იქნება 1602 დისპლეი - კიდევ $1.5. მე მაქვს ვარიანტი I2C ინტერფეისის მოდულით, მაგრამ ამ პროექტში ის ნამდვილად არ არის საჭირო ($0,7).
განვითარებისთვის გვჭირდება პურის დაფა. ჩემს შემთხვევაში, ეს არის პატარა BreadBoard 1 დოლარად.
რა თქმა უნდა, დაგჭირდებათ მავთულები და სხვადასხვა მნიშვნელობის რეზისტორების რაოდენობა. 1602 დისპლეისთვის I2C გარეშე, თქვენ ასევე უნდა აირჩიოთ კონტრასტი - ეს კეთდება ცვლადი რეზისტორით 2 - 20 kOhm.
ამპერმეტრის განსახორციელებლად დაგჭირდებათ შუნტი. პირველი მიახლოებით, ეს შეიძლება იყოს 0.1 Ohm, 5 W რეზისტორი.
ავტომატური გამორთვის განსახორციელებლად, დაგჭირდებათ რელე კონტაქტებით, რომლებიც განკუთვნილია მოწყობილობის მაქსიმალური დენისთვის და მიწოდების ძაბვის ტოლი ძაბვით. რელეს გასაკონტროლებლად გჭირდებათ NPN ტრანზისტორი და დამცავი დიოდი.
მოწყობილობა იკვებება გარე კვების წყაროდან, ცხადია, მინიმუმ 5 ვ. თუ ელექტრომომარაგება მნიშვნელოვნად განსხვავდება, მაშინ ასევე საჭირო იქნება 7805 ტიპის ინტეგრირებული სტაბილიზატორი - ის განსაზღვრავს სარელეო ძაბვას.
Როდესაც Arduino Pro Mini საჭიროებს USB-TTL კონვერტერს პროგრამული უზრუნველყოფის ასატვირთად.
დაყენებისთვის დაგჭირდებათ მულტიმეტრი.

ვოლტმეტრი

მე ვახორციელებ მარტივ ვოლტმეტრს ერთი დიაპაზონით დაახლოებით 0 - 20 ვ. ეს შენიშვნა მნიშვნელოვანია, რადგან ჩვენი კონტროლერის ADC-ს აქვს 10-ბიტიანი სიმძლავრე (1024 დისკრეტული მნიშვნელობა), ამიტომ შეცდომა იქნება მინიმუმ 0.02 ვ (20/1024). ტექნიკის განსახორციელებლად, ჩვენ გვჭირდება კონტროლერის ანალოგური შეყვანა, წყვილი რეზისტორებისგან დამზადებული გამყოფი და რაიმე სახის გამომავალი (ჩვენება მზა ვერსიაში, სერიული პორტი შეიძლება გამოყენებულ იქნას გამართვისთვის).

ADC გაზომვის პრინციპია ანალოგური შეყვანის ძაბვის შედარება VRef მითითებით. ADC გამომავალი ყოველთვის მთელი რიცხვია - 0 შეესაბამება 0V, 1023 შეესაბამება ძაბვას VRef. გაზომვა ხორციელდება ძაბვის თანმიმდევრული ჩვენებების სერიით და საშუალოდ ეკრანზე მნიშვნელობის განახლებებს შორის პერიოდის განმავლობაში. საორიენტაციო ძაბვის არჩევა მნიშვნელოვანია, რადგან ის ნაგულისხმევია მიწოდების ძაბვაზე, რომელიც შეიძლება არ იყოს სტაბილური. ეს ჩვენ საერთოდ არ ჯდება - ჩვენ საფუძვლად ავიღებთ სტაბილურ შიდა საცნობარო წყაროს 1.1 ვ ძაბვით, ინიციალიზებით მას analogReference (INTERNAL) გამოძახებით. შემდეგ ჩვენ დავაკალიბრებთ მის მნიშვნელობას მულტიმეტრის ჩვენებების გამოყენებით.

მარცხნივ დიაგრამა აჩვენებს ვარიანტს ეკრანის პირდაპირი კონტროლით (ის უბრალოდ კონტროლდება - იხილეთ სტანდარტული LiquidCrystal\HelloWorld ესკიზი). მარჯვნივ არის I2C ვარიანტი, რომელსაც შემდგომში გამოვიყენებ. I2C საშუალებას გაძლევთ დაზოგოთ მავთულები (მათგან 10 არის ჩვეულ ვერსიაში, განათების გარეშე). მაგრამ ეს მოითხოვს დამატებით მოდულს და უფრო რთულ ინიციალიზაციას. ნებისმიერ შემთხვევაში, ჯერ უნდა შემოწმდეს მოდულზე სიმბოლოების ჩვენება და დაარეგულიროთ კონტრასტი - ამისათვის თქვენ უბრალოდ უნდა აჩვენოთ ნებისმიერი ტექსტი ინიციალიზაციის შემდეგ. კონტრასტი რეგულირდება რეზისტორით R1, ან I2C მოდულის მსგავსი რეზისტორით.

შეყვანა არის 1:19 გამყოფი, რომელიც საშუალებას გაძლევთ მიიღოთ მაქსიმალური ძაბვა დაახლოებით 20 ვ Vref = 1.1 (როგორც წესი, კონდენსატორი + ზენერის დიოდი მოთავსებულია შეყვანის პარალელურად დაცვის მიზნით, მაგრამ ეს ჩვენთვის ჯერ არ არის მნიშვნელოვანი. ). რეზისტორებს აქვთ გავრცელება და ასევე აქვს კონტროლერის მითითება Vref, ამიტომ აწყობის შემდეგ უნდა გავზომოთ ძაბვა (მინიმუმ მიწოდება) ჩვენი მოწყობილობისა და საცნობარო მულტიმეტრის პარალელურად და კოდში ავირჩიოთ Vref, სანამ წაკითხვები არ ემთხვევა. აღსანიშნავია ისიც, რომ ნებისმიერ ADC-ს აქვს ნულოვანი ოფსეტური ძაბვა (რაც აფუჭებს კითხვებს დიაპაზონის დასაწყისში), მაგრამ ჩვენ ამას ჯერ არ შევეხებით.

ასევე მნიშვნელოვანი იქნება მიწოდებისა და საზომი ადგილის გამიჯვნა. ჩვენს ADC-ს აქვს 1 მვ-ზე ოდნავ უარესი გარჩევადობა, რამაც შეიძლება გამოიწვიოს პრობლემები, თუ გაყვანილობა არასწორია, განსაკუთრებით პურის დაფაზე. ვინაიდან მოდულის დაფის განლაგება უკვე შესრულებულია და ჩვენ მხოლოდ ქინძისთავები უნდა ავირჩიოთ. მოდულს აქვს რამდენიმე „დამიწის“ ქინძისთავები, ამიტომ უნდა დავრწმუნდეთ, რომ დენი შედის მოდულში ერთი „მიწის“ მეშვეობით, ხოლო გაზომვები მეორის მეშვეობით. ფაქტობრივად, ცვლილებების შესატანად, მე ყოველთვის ვიყენებ დამიწების პინს, რომელიც ყველაზე ახლოსაა ანალოგურ შეყვანებთან.

I2C-ის გასაკონტროლებლად გამოიყენება LiquidCrystal_I2C ბიბლიოთეკის ვერსია - ჩემს შემთხვევაში მითითებულია I2C მოდულის კონკრეტული პინი (ჩინელები აწარმოებენ მოდულებს სხვადასხვა კონტროლით). მე ასევე აღვნიშნავ, რომ Arduino-ში I2C მოითხოვს A4 და A5 ქინძისთავების გამოყენებას - Pro Mini დაფაზე ისინი არ არიან განლაგებული ზღვარზე, რაც მოუხერხებელია BreadBoard-ზე პროტოტიპისთვის.

წყარო

#შეიცავს #შეიცავს // მარტივი ვოლტმეტრი i2c დისპლეით 1602. V 16.11 // პარამეტრები i2c დისპლეისთვის 1602 არასტანდარტული პინუტით #განსაზღვე LCD_I2C_ADDR 0x27 #განისაზღვროს BACKLIGHT 3 #განსაზღვროს LCD_EN 2 #განსაზღვროს LCD_EN 2 #განსაზღვროს LCD_RW5 #define LCD_RW5 #define LCD_RW5 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); // წაკითხვის განახლების დრო, ms (200-2000) #define REFRESH_TIME 330 // ანალოგური შეყვანა #define PIN_VOLT A0 // შიდა საცნობარო ძაბვა (არჩევა) const float VRef = 1.10; // შეყვანის წინააღმდეგობის გამყოფი კოეფიციენტი (Rh + Rl) / Rl. IN<-[ 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) ინვოლტი += 3; // კონვერტაცია ვოლტებად (მნიშვნელობა: 0..1023 -> (0..VRef) მასშტაბირებული Mult-ით) ვოლტი = InVolt * VoltMult * VRef / 1023; // გამომავალი მონაცემები lcd.setCursor (0, 1); lcd.print(Volt); lcd.print("V"); )

გამარჯობა, ჰაბრ! დღეს მინდა გავაგრძელო არდუინოს და ანდროიდის „გადაკვეთის“ თემა. წინა პუბლიკაციაში მე ვისაუბრე, დღეს კი ვისაუბრებთ წვრილმანი ბლუთუს ვოლტმეტრზე. სხვა ასეთ მოწყობილობას შეიძლება ეწოდოს ჭკვიანი ვოლტმეტრი, "ჭკვიანი" ვოლტმეტრი ან უბრალოდ ჭკვიანი ვოლტმეტრი, ბრჭყალების გარეშე. გვარი რუსული გრამატიკის თვალსაზრისით არასწორია, თუმცა მედიაში ხშირად გვხვდება. სტატიის ბოლოს იქნება კენჭისყრა ამ თემაზე, მაგრამ მე გთავაზობთ დაწყებას მოწყობილობის მუშაობის დემონსტრირებით, რათა გავიგოთ რაზე იქნება სტატია.

უარი პასუხისმგებლობაზე: სტატია განკუთვნილია არდუინოს საშუალო მოყვარულისთვის, რომელიც ჩვეულებრივ არ იცნობს Android პროგრამირებას, ამიტომ, როგორც წინა სტატიაში, ჩვენ შევქმნით აპლიკაციას სმარტფონისთვის App Inventor 2 ვიზუალური განვითარების გარემოს გამოყენებით Android აპლიკაციებისთვის.
წვრილმანი ბლუთუს ვოლტმეტრის გასაკეთებლად ორი შედარებით დამოუკიდებელი პროგრამა უნდა დავწეროთ: ესკიზი Arduino-სთვის და აპლიკაცია Android-ისთვის დავიწყოთ ესკიზით.
პირველ რიგში, უნდა იცოდეთ, რომ Arduino-ს გამოყენებით ძაბვის გაზომვის სამი ძირითადი ვარიანტია, მიუხედავად იმისა, თუ სად გჭირდებათ ინფორმაციის გამოტანა: com პორტში, Arduino-სთან დაკავშირებულ ეკრანზე ან სმარტფონზე.
პირველი შემთხვევა: ძაბვის გაზომვები 5 ვოლტამდე. აქ საკმარისია კოდის ერთი ან ორი ხაზი და ძაბვა გამოიყენება პირდაპირ A0-ზე:
int value = analogRead(0) // წაკითხული A0-დან
ძაბვა = (მნიშვნელობა / 1023.0) * 5; // მართალია მხოლოდ იმ შემთხვევაში, თუ Vcc = 5.0 ვოლტი
მეორე შემთხვევა: 5 ვოლტზე მეტი ძაბვის გასაზომად გამოიყენება ძაბვის გამყოფი. წრე ძალიან მარტივია და კოდიც.

ესკიზი

int analogInput = A0;
float val = 0.0;
float ძაბვა = 0.0;
ათწილადი R1 = 100000.0; //Battery Vin-> 100K -> A0
float R2 = 10000.0; //ბატარეა Gnd -> Arduino Gnd და Arduino Gnd -> 10K -> A0
int მნიშვნელობა = 0;

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

Void loop() (
მნიშვნელობა = analogRead(analogInput);
val = (მნიშვნელობა * 4.7) / 1024.0;
ძაბვა = val / (R2/(R1+R2));
Serial.println(ძაბვა);
დაგვიანებით (500);
}

არდუინო უნო
Bluetooth მოდული
მესამე შემთხვევა. როდესაც თქვენ გჭირდებათ უფრო ზუსტი ინფორმაციის მიღება ძაბვის შესახებ, თქვენ უნდა გამოიყენოთ როგორც საცნობარო ძაბვა არა მიწოდების ძაბვა, რომელიც შეიძლება ოდნავ განსხვავდებოდეს, როდესაც იკვებება ბატარეით, არამედ შიდა Arduino სტაბილიზატორის ძაბვა 1.1 ვოლტი წრე აქაც იგივეა, მაგრამ კოდი ცოტა გრძელია. მე არ გავაანალიზებ ამ ვარიანტს დეტალურად, რადგან ის უკვე კარგად არის აღწერილი თემატურ სტატიებში, მაგრამ მეორე მეთოდი ჩემთვის სავსებით საკმარისია, რადგან ჩემი ელექტრომომარაგება სტაბილურია, ლეპტოპის USB პორტიდან.
ასე რომ, ჩვენ დავახარისხეთ ძაბვის გაზომვა, ახლა მოდით გადავიდეთ პროექტის მეორე ნახევარზე: Android აპლიკაციის შექმნაზე. ჩვენ შევქმნით აპლიკაციას პირდაპირ ბრაუზერიდან Android აპლიკაციების ვიზუალური განვითარების გარემოში App Inventor 2. გადადით ვებსაიტზე appinventor.mit.edu/explore, შედით თქვენი Google ანგარიშის გამოყენებით, დააწკაპუნეთ ღილაკზე შექმნა, ახალი პროექტი და შემდეგ უბრალოდ ელემენტების გადათრევით და ჩამოშვებით ჩვენ შევქმნით ამ დიზაინს:

გრაფიკა ძალიან გამარტივდა, თუ ვინმეს უფრო საინტერესო გრაფიკა უნდა, შეგახსენებთ, რომ ამისთვის საჭიროა .jpeg ფაილების ნაცვლად გამჭვირვალე ფონის მქონე .png ფაილების გამოყენება.
ახლა გადადით ბლოკების ჩანართზე და შექმენით აპლიკაციის ლოგიკა მსგავსი რამ:

თუ ყველაფერი გამოსწორდა, შეგიძლიათ დააჭიროთ Build ღილაკს და შეინახოთ .apk ჩემს კომპიუტერში, შემდეგ ჩამოტვირთოთ და დააინსტალიროთ აპლიკაცია თქვენს სმარტფონზე, თუმცა აპლიკაციის ატვირთვის სხვა გზებიც არსებობს. აქ ვინმესთვის უფრო მოსახერხებელია. შედეგად, მე დავასრულე ეს აპლიკაცია:

მე მესმის, რომ რამდენიმე ადამიანი იყენებს App Inventor 2 ვიზუალური განვითარების გარემოს Android აპლიკაციებისთვის თავიანთ პროექტებში, ამიტომ ბევრი კითხვა შეიძლება გაჩნდეს მასში მუშაობის შესახებ. ზოგიერთი ამ კითხვის გადასაჭრელად, მე გავაკეთე დეტალური ვიდეო, თუ როგორ უნდა გააკეთოთ ასეთი აპლიკაცია "ნულიდან" (მის სანახავად უნდა გადახვიდეთ YouTube-ზე):

P.S. 100-ზე მეტი საგანმანათლებლო მასალის კოლექცია Arduino-ზე დამწყებთათვის და პროფესიონალებისთვის

გარკვეული დამატებებით.

Arduino-ს და მრავალი სხვა AVR ჩიპის ნაკლებად ცნობილი თვისებაა შიდა 1.1 V საცნობარო ძაბვის გაზომვის შესაძლებლობა. ამ ფუნქციას შეუძლია გამოიყენება მზარდი სიზუსტე Arduino ფუნქციები - analogRead გამოყენებითსტანდარტული საცნობარო ძაბვა 5 ვ (პლატფორმებზე, მიწოდების ძაბვით 5 ვ) ან 3.3 ვ (პლატფორმებზე მიწოდების ძაბვით 3.3 ვ).ის ასევე შეიძლება იყოს გამოიყენება გასაზომად Vcc მიმართა ჩიპს, რომელიც უზრუნველყოფს კონტროლის საშუალება ბატარეის ძაბვა გამოყენების გარეშეძვირფასი ანალოგური ქინძისთავები.

Მოტივაცია

მაინც არსებობს მინიმუმ ორი მიზეზიგასაზომად მიწოდების ძაბვაჩვენი Arduino (Vcc). ერთ-ერთი მათგანია ჩვენი ბატარეით მომუშავე პროექტი, თუ გვინდა თვალი ვადევნოთ ბატარეის ძაბვის დონეს. ასევე, როდესაც ბატარეის სიმძლავრე (Vcc) არ შეიძლება იყოს 5.0 ვოლტი (მაგ. 3 უჯრედიანი 1.5 ვ დენის წყარო) და გვსურს ანალოგური გაზომვები უფრო ზუსტი გავხადოთ - უნდა გამოვიყენოთ ან შიდა 1.1 ვ მითითება ან გარე საცნობარო ძაბვის წყარო. რატომ?

ჩვეულებრივ, analogRead()-ის გამოყენებისას ვივარაუდოთ, რომ კონტროლერის ანალოგური მიწოდების ძაბვა არის 5.0 ვოლტი, მაშინ როცა სინამდვილეში ეს შეიძლება საერთოდ არ იყოს (მაგალითად, 3 ელემენტიდან კვების წყარო არის 1.5 ვ). Arduino-ს ოფიციალურმა დოკუმენტაციამ შეიძლება მიგვიყვანოს ამ არასწორ ვარაუდამდე. ფაქტია, რომ სიმძლავრე სულაც არ არის 5.0 ვოლტი, მიუხედავად მიმდინარე დონისა, ეს სიმძლავრე მიეწოდება ჩიპის Vcc-ს. თუ ჩვენი ელექტრომომარაგება არ არის სტაბილიზირებული ან თუ ჩვენ ვმუშაობთ ბატარეაზე, ეს ძაბვა შეიძლება საკმაოდ განსხვავდებოდეს. აქ არის კოდის მაგალითი, რომელიც ასახავს ამ პრობლემას:

ორმაგი Vcc = 5.0; // არ არის აუცილებლად ჭეშმარიტი int მნიშვნელობა = analogRead(0); / წაიკითხეთ წაკითხვები A0-დან ორმაგი ვოლტი = (მნიშვნელობა / 1023.0) * Vcc; // მართალია მხოლოდ იმ შემთხვევაში, თუ Vcc = 5.0 ვოლტი ძაბვის ზუსტად გასაზომად საჭიროა ზუსტი საცნობარო ძაბვა. AVR ჩიპების უმეტესობა უზრუნველყოფს სამი ძაბვის მითითებას:

1.1 V შიდა წყაროდან, დოკუმენტაციაში ის გადის როგორც bandgap მითითება (ზოგიერთი მათგანია 2.56 V, მაგალითად ATMega 2560). შერჩევა ხდება analogReference() ფუნქციით INTERNAL პარამეტრით: analogReference(INTERNAL) ;

საცნობარო ძაბვის გარე წყარო, ეტიკეტირებული AREF არდუინოზე. აირჩიეთ: analogreference(EXTERNAL);

Vcc არის თავად კონტროლერის კვების წყარო. აირჩიეთ: analogreference(DEFAULT).

Arduino-ში თქვენ არ შეგიძლიათ უბრალოდ დააკავშიროთ Vcc ანალოგურ პინთან - ნაგულისხმევად AREF უკავშირდება Vcc-ს და თქვენ ყოველთვის მიიღებთ მაქსიმალურ მნიშვნელობას 1023, არ აქვს მნიშვნელობა რა ძაბვისგან იკვებება. AREF-თან დაკავშირება ძაბვის წყაროს ადრე ცნობილი, სტაბილური ძაბვით ეხმარება, მაგრამ ეს არის დამატებითი ელემენტი წრეში.

თქვენ ასევე შეგიძლიათ დაუკავშიროთ Vcc AREF-ს მეშვეობით დიოდი: დიოდზე ძაბვის ვარდნა წინასწარ არის ცნობილი, ამიტომ Vcc-ის გამოთვლა რთული არ არის. თუმცა, ასეთი სქემით დიოდის საშუალებით დენი მუდმივად მიედინება, ამცირებს ბატარეის ხანგრძლივობას, რაც ასევე არ არის ძალიან კარგი.

გარე ძაბვის მითითება ყველაზე ზუსტია, მაგრამ საჭიროებს დამატებით აპარატურას. შიდა ION არის სტაბილური, მაგრამ არა ზუსტი +/- 10% გადახრა. Vcc უმეტეს შემთხვევაში სრულიად არასანდოა. შიდა ძაბვის მითითების არჩევა იაფი და სტაბილურია, მაგრამ უმეტეს შემთხვევაში, ჩვენ გვსურს გავზომოთ მეტი ძაბვა ვიდრე 1.1V, ამიტომ Vcc გამოყენება ყველაზე პრაქტიკულია, მაგრამ პოტენციურად ყველაზე ნაკლებად ზუსტი. ზოგიერთ შემთხვევაში ეს შეიძლება იყოს ძალიან არასანდო!

Როგორ გავაკეთო ეს

ბევრი AVR ჩიპი, მათ შორის ATmega და ATtiny სერიები, უზრუნველყოფს შიდა საცნობარო ძაბვის გაზომვის საშუალებას. რატომ არის ეს საჭირო? მიზეზი მარტივია - შიდა ძაბვის გაზომვით შეგვიძლია დავადგინოთ Vcc-ის მნიშვნელობა. Აი როგორ:

ნაგულისხმევი ძაბვის მითითების დაყენება: analogReference(DEFAULT); . ჩვენ ვიყენებთ Vcc როგორც წყარო.
მიიღეთ ADC წაკითხვები შიდა 1.1 ვ წყაროსთვის.
გამოთვალეთ Vcc მნიშვნელობა 1.1 ვ გაზომვის საფუძველზე ფორმულის გამოყენებით:

Vcc * (ADC კითხვა) / 1023 = 1.1 ვ

რა მოჰყვება:

Vcc = 1.1 V * 1023 / (ADC კითხვა)

ყველაფერს ერთად ვაწყობთ და ვიღებთ კოდს:

long readVcc() (// წაკითხვა 1.1V მიმართვის წინააღმდეგ AVcc // დააყენეთ მითითება Vcc-ზე და გაზომვა შიდა 1.1V მითითებაზე #if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR__ATmega25) (REFS0) _BV(MUX3) | 2); else ADMUX = _BV(MUX2) |._BV(MUX1) ADCL // უნდა წაიკითხოს ADCL - შემდეგ იბლოკება ADCH uint8_t = ADCH;<<8) | low; result = 1125300L / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000 return result; // Vcc in millivolts }

გამოყენება

Vcc ან ბატარეის ძაბვის შემოწმება

თქვენ შეგიძლიათ დარეკოთ ეს ფუნქცია readVcc(), თუ გსურთ Vcc-ის მონიტორინგი. მაგალითი იქნება ბატარეის დატენვის დონის შემოწმება. თქვენ ასევე შეგიძლიათ გამოიყენოთ იგი იმის დასადგენად, ხართ თუ არა დაკავშირებული კვების წყაროსთან თუ მუშაობთ ბატარეაზე.

Vcc გაზომვა საცნობარო ძაბვისთვის

თქვენ ასევე შეგიძლიათ გამოიყენოთ ის, რომ მიიღოთ სწორი Vcc მნიშვნელობა analogRead()-ით გამოსაყენებლად, როდესაც იყენებთ საცნობარო ძაბვას (Vcc). თუ არ იყენებთ რეგულირებულ ელექტრომომარაგებას, ვერ იქნებით დარწმუნებული, რომ Vcc = 5.0 ვოლტი. ეს ფუნქცია საშუალებას გაძლევთ მიიღოთ სწორი მნიშვნელობა. თუმცა არის ერთი გაფრთხილება...

ერთ-ერთ სტატიაში მე გავაკეთე განცხადება, რომ ეს ფუნქცია შეიძლება გამოყენებულ იქნას ანალოგური გაზომვების სიზუსტის გასაუმჯობესებლად იმ შემთხვევებში, როდესაც Vcc არ იყო საკმაოდ 5.0 ვოლტი. სამწუხაროდ, ეს პროცედურა არ იძლევა ზუსტ შედეგს. რატომ? ეს დამოკიდებულია შიდა ძაბვის მითითების სიზუსტეზე. სპეციფიკაცია იძლევა ნომინალურ ძაბვას 1.1 ვოლტს, მაგრამ ამბობს, რომ ის შეიძლება განსხვავდებოდეს 10% -მდე. ასეთი გაზომვები შეიძლება იყოს ნაკლებად ზუსტი ვიდრე ჩვენი Arduino კვების წყარო!

სიზუსტის გაზრდა

მიუხედავად იმისა, რომ შიდა 1.1 ვ ელექტრომომარაგების დიდი ტოლერანტობა მნიშვნელოვნად ზღუდავს გაზომვის სიზუსტეს მასობრივ წარმოებაში გამოყენებისას, ჩვენ შეგვიძლია მივაღწიოთ უფრო მეტ სიზუსტეს საბაჟო პროექტებისთვის. ამის გაკეთება მარტივია უბრალოდ ვოლტმეტრის და ჩვენი readVcc() ფუნქციის გამოყენებით Vcc-ის გაზომვით. შემდეგი, შეცვალეთ მუდმივი 1125300L ახალი ცვლადით:

scale_constant = შიდა1.1Ref * 1023 * 1000

შიდა1.1Ref = 1.1 * Vcc1 (ვოლტმეტრის_კითხვები) / Vcc2 (წაკითხვა Vcc_ფუნქციის_კითხვები)

ეს დაკალიბრებული მნიშვნელობა იქნება კარგი მაჩვენებელი AVR ჩიპის გაზომვებისთვის, მაგრამ შეიძლება გავლენა იქონიოს ტემპერატურის ცვლილებებმა. მოგერიდებათ ექსპერიმენტი საკუთარი გაზომვებით.

დასკვნა

ამ პატარა ფუნქციით ბევრი რამის გაკეთება შეგიძლიათ. თქვენ შეგიძლიათ გამოიყენოთ სტაბილური საცნობარო ძაბვა 5.0 ვ-სთან ახლოს, რეალურად რომ არ გქონდეთ 5.0 ვ Vcc-ზე. თქვენ შეგიძლიათ გაზომოთ თქვენი ბატარეის ძაბვა ან თუნდაც ნახოთ, მუშაობთ თუ არა ბატარეის ენერგიაზე ან სტაციონარული დენით.

დაბოლოს, კოდი მხარს დაუჭერს ყველა Arduinos-ს, მათ შორის ახალ Leonardo-ს, ასევე ATtinyX4 და ATtinyX5 სერიის ჩიპებს.

ეს სტატია გვიჩვენებს, თუ როგორ დააკავშიროთ Arduino და PC და გადაიტანოთ მონაცემები ADC-დან კომპიუტერზე. პროგრამა Windows-ისთვის დაწერილია Visual C++ 2008 Express-ის გამოყენებით. ვოლტმეტრის პროგრამა ძალიან მარტივია და გასაუმჯობესებლად ბევრი ადგილი აქვს. მისი მთავარი მიზანი იყო ეჩვენებინა, თუ როგორ უნდა იმუშაოს COM პორტთან და გაცვალოს მონაცემები კომპიუტერსა და Arduino-ს შორის.

კომუნიკაცია Arduino-სა და PC-ს შორის:

ADC-დან წაკითხვის აღება იწყება მაშინ, როდესაც კომპიუტერი აგზავნის Arduino ბრძანებებს 0xAC და 0x1y. ზე– ADC არხის ნომერი (0-2);
კითხვა ჩერდება მას შემდეგ, რაც Arduino მიიღებს ბრძანებებს 0xAC და 0x00;
წაკითხვისას, Arduino აგზავნის ბრძანებებს 0xAB 0xaa 0xbb კომპიუტერში ყოველ 50 ms, სადაც aa და bb არის გაზომვის მაქსიმალური და მინიმალური შედეგები.

პროგრამა Arduino-სთვის

შეგიძლიათ მეტი წაიკითხოთ სერიული კომუნიკაციის შესახებ arduino.cc-ზე. პროგრამა საკმაოდ მარტივია, მისი უმეტესი ნაწილი იხარჯება პარალელურ პორტთან მუშაობაში. ADC-დან მონაცემების წაკითხვის დასრულების შემდეგ ვიღებთ 10-ბიტიან ძაბვის მნიშვნელობას (0x0000 – 0x0400) 16-ბიტიანი ცვლადების (INT) სახით. სერიული პორტი (RS-232) საშუალებას აძლევს მონაცემთა გადაცემას 8-ბიტიან პაკეტებში. აუცილებელია 16-ბიტიანი ცვლადების დაყოფა 8 ბიტის 2 ნაწილად.

Serial.print(ძაბვა>>8,BYTE);

Serial.print(ძაბვა%256,BYTE);

ცვლადის ბაიტი 8 ბიტით გადავაადგილებთ მარჯვნივ და შემდეგ ვყოფთ 256-ზე და შედეგს ვუგზავნით კომპიუტერს.

შეგიძლიათ ჩამოტვირთოთ Arduino პროგრამული უზრუნველყოფის სრული წყარო კოდი

ვიზუალური C++

ვვარაუდობ, რომ თქვენ უკვე გაქვთ Windows-ისთვის C++ პროგრამირების საბაზისო ცოდნა, თუ არა, მაშინ გამოიყენეთ Google. ინტერნეტი სავსეა გაკვეთილებით დამწყებთათვის.

პირველი რაც უნდა გააკეთოთ არის სერიული პორტის დამატება ხელსაწყოთა ზოლიდან ქვედა ფორმაში. ეს საშუალებას მოგცემთ შეცვალოთ სერიული პორტის რამდენიმე მნიშვნელოვანი პარამეტრი: პორტის სახელი, ბაუდის სიჩქარე, ბიტის სიღრმე. ეს სასარგებლოა აპლიკაციის ფანჯარაში კონტროლის დასამატებლად, ამ პარამეტრების შესაცვლელად ნებისმიერ დროს, პროგრამის ხელახალი კომპილაციის გარეშე. მე მხოლოდ პორტის შერჩევის ვარიანტი გამოვიყენე.

ხელმისაწვდომი სერიული პორტების ძიების შემდეგ, ნაგულისხმევად არჩეულია პირველი პორტი. როგორ კეთდება:

მასივი< String ^>^ სერიული პორტები = nullptr;

serialPorts = serialPort1->GetPortNames();

this->comboBox1->Items->AddRange(serialPorts);

this->comboBox1->SelectedIndex=0;

კომპიუტერის სერიული პორტის გამოყენება შესაძლებელია მხოლოდ ერთი აპლიკაციის მიერ ერთდროულად, ამიტომ პორტი უნდა იყოს ღია გამოყენებამდე და არა დახურული. მარტივი ბრძანებები ამისათვის:

serialPort1->Open();

serialPort1->Close();

სერიული პორტიდან მონაცემების სწორად წასაკითხად, თქვენ უნდა გამოიყენოთ მოვლენები (ჩვენს შემთხვევაში, შეფერხება). აირჩიეთ მოვლენის ტიპი:

ჩამოსაშლელი სია "Data Received" ორჯერ დაწკაპუნებით.

ღონისძიების კოდი იქმნება ავტომატურად:

თუ სერიულ პორტზე ჩამოსული პირველი ბაიტი არის 0xAB, თუ ეს ნიშნავს, რომ დარჩენილი ბაიტი ატარებს ძაბვის მონაცემებს.

პირადი: სისტემა:: Void serialPort1_Data Received(System::Object^ გამგზავნი, System::IO::Ports::SerialDataReceivedEventArgs^ e) (

ხელმოუწერელი char data0, data1;

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

data0=serialPort1->ReadByte();

data1=serialPort1->ReadByte();

ძაბვა=მათემატიკა::მრგვალი((float(data0*256+data1)/1024*5.00),2);

data_count ++;

serialPort1->ReadByte();

სერიული პორტის მონაცემების ჩაწერა და წაკითხვა

ჩემთვის მცირე პრობლემა იყო თექვსმეტი RAW მონაცემების გაგზავნა სერიული პორტით. გამოყენებული იყო ბრძანება Write(); მაგრამ სამი არგუმენტით: მასივი, საწყისი ბაიტის ნომერი, ჩასაწერი ბაიტების რაოდენობა.

პირადი: System:: Void button2_Click_1(System::Object^ გამგზავნი, System::EventArgs^ e) (

ხელმოუწერელი char არხი=0;

channel=this->listBox1->SelectedIndex;

მასივი^დაწყება =(0xAC,(0x10+არხი));

მასივი ^ გაჩერება =(0xAC,0x00);

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

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

) სხვა (

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

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

Სულ ეს არის!

ორიგინალური სტატია ინგლისურად (თარგმანი: ალექსანდრე კასიანოვისაიტისთვის cxem.net)