Има моменти, когато искате да проверите напрежението или някаква точка във веригата, но нямате волтметър или мултицет под ръка? Бягам да купя? Това е дълго и скъпо. Преди да направите това, какво ще кажете сами да си направите волтметър? Всъщност с помощта прости компонентиможете да го направите сами.
Стъпка 1: Подгответе компонентите
- В урока използвахме платка, съвместима с Arduino - SunFounder Uno / Mars (http://bit.ly/2tkaMba)
- USB кабел за данни
- 2 потенциометъра (50k)
- LCD1602 - http://bit.ly/2ubNEfi
- Платка за разработка - http://bit.ly/2slvfrB
- Множество джъмпери
Преди да се свържете, нека първо да разгледаме как работи.
Използвайте платката SunFounder Uno за основната част от обработката на данни от волтметъра, LCD1602 като екран, потенциометър за регулиране на LCD контраста и друг за разделяне на напрежението.
Когато завъртите потенциометъра, свързан към платката Uno, резисторът на потенциометъра се променя, като по този начин се променя напрежението върху него. Сигналът за напрежение ще бъде изпратен до платката Uno през щифт A0 и Uno ще преобразува получения аналогов сигнал в цифрова форма и ще го запише на LCD. По този начин можете да видите стойността на напрежението при текущото съпротивление на капацитета.
LCD1602 има два режима на работа: 4-битов и 8-битов. Когато MCU IO е недостатъчен, можете да изберете 4-битов режим, който използва само щифтове D4~D7.
Следвайте таблицата, за да ги свържете.
Стъпка 4: Свържете потенциометъра към LCD1602
Свържете средния щифт на потенциометъра към щифта Vo на LCD1602 и всеки от другите щифтове към GND.
Свържете средния щифт на потенциометъра към щифт A0 от SunFounder Uno и един от другите към 5V, а другият към GND.
Стъпка 6: Качете кода
Този код:
#включи /**************************************************** ********** *****/ const int analogIn = A0;//потенциометър, прикрепен към A0 LiquidCrystal lcd(4, 6, 10, 11, 12, 13);//lcd(RS, E,D4,D5,D6.D7) float val = 0;// дефинирайте променливата като стойност=0 /**************************** ********** *****************/ void setup() ( Serial.begin(9600);//Инициализиране на серийния lcd.begin(16) , 2);//задайте позицията на знаците на LCD като ред 2, колона 16 lcd.print("Стойност на напрежението:");//отпечатайте "Стойност на напрежението:" ) /******** ********** *************************************/ void loop() ( val = analogRead(A0);//Прочетете стойността на потенциометъра на val val = val/1024*5.0;// Преобразувайте данните в съответната стойност на напрежението по математически начин Serial.print(val);//Отпечатайте номер на val на серийния монитор Serial.print ("V"); // отпечатайте единицата като V, съкратено от напрежение на серийния монитор lcd.setCursor(6,1);//Поставете курсора на ред 1, колона 6. От тук знаците трябва да бъдат показани lcd.print(val);//Отпечатайте броя на val на LCD дисплея lcd.print("V");//След това отпечатайте единицата като V, съкращение от напрежение на LCD забавяне (200); //Изчакайте 200ms )
Завъртете потенциометъра, за да проверите напрежението на LCD1602 в реално време.
Ето една сложна работа. След като стартирах кода, LCD показа знаци. След това регулирах контраста на екрана (постепенна промяна от черно към бяло) чрез завъртане на потенциометъра по или обратно на часовниковата стрелка, докато екранът покаже ясно символите.
Вземете две батерии, за да измерите напрежението им: 1,5 V и 3,7 V. Разкачете връзката на втория потенциометър към A0 и GND щифта, което означава премахване на потенциометъра от веригата. Затегнете края на проводник A0 към анода на батерията и веригата GND към катода. НЕ ги включвайте обратно или ще получите късо съединениена батерията. Стойност от 0 V е обратна връзка.
И така, напрежението на батерията се показва на LCD дисплея. Възможно е да има грешка между стойността и номиналната стойност, тъй като батерията не е напълно заредена. И затова трябва да измеря напрежението, за да разбера дали мога да използвам батерията или не.
ПС:Ако имате проблеми с дисплея на вашия дисплей - вижте този ЧЗВ за LCD дисплеи - http://wiki.sunfounder.cc/index.php?title=LCD1602/I2C_LCD1602_FAQ.
Аналогови входове на платката Arduino.
Платката Arduino UNO съдържа 6 аналогови входа, предназначени за измерване на сигнали за напрежение. Би било по-правилно да се каже, че 6-те пина на платката могат да работят както в режим на дискретен изход, така и в режим на аналогов вход.
Тези изводи са номерирани от 14 до 19. Те първоначално са конфигурирани като аналогови входове и могат да бъдат достъпни с имената A0-A5. Те могат да бъдат конфигурирани за режим на дискретно извеждане по всяко време.
pinMode(A3, ИЗХОД); // настройка на режима на дискретния изход за A3
digitalWrite(A3, LOW); // настройка на изход A3 ниско
За да се върнете към режим на аналогов вход:
pinMode(A3, INPUT); // настройване на режима на аналогов вход за A3
Аналогови входове и подтягащи резистори.
Изтеглящите резистори са свързани към аналоговите входни щифтове, както и към дискретните щифтове. Тези резистори се включват с помощта на командата
digitalWrite(A3, HIGH); // включете издърпващия резистор към вход A3
Командата трябва да се приложи към щифт, конфигуриран в режим на въвеждане.
Трябва да се помни, че резисторът може да повлияе на нивото на аналоговия входен сигнал. Токът от 5V захранване, през изтеглящия резистор, ще причини спад на напрежението във вътрешното съпротивление на източника на сигнал. Така че е по-добре да изключите резистора.
Аналогово-цифров преобразувател на платка Arduino.
Реалното измерване на напрежението на входовете се извършва от аналогово-цифров преобразувател (ADC) с ключ за 6 канала. АЦП има разделителна способност 10 бита, което съответства на кода на изхода на преобразувателя 0...1023. Грешката на измерване е не повече от 2 единици от най-малката цифра.
За да се поддържа максимална точност (10 цифри), е необходимо вътрешно съпротивлениеизточникът на сигнал не надвишава 10 kOhm. Това изискване е особено важно при използване на резисторни делители, свързани към аналоговите входове на платката. Съпротивлението на разделителните резистори не може да бъде твърде високо.
Функции на софтуерааналогов вход.
int analogRead(порт)
Чете стойността на напрежението на посочения аналогов вход. Входното напрежение варира от 0 до нивото на референтното напрежение (често 5 V), което се преобразува в код от 0 до 1023.
При референтно напрежение от 5 V разделителната способност е 5 V / 1024 = 4,88 mV.
Преобразуването отнема приблизително 100 μs.
int inputCod; // код на входното напрежение
плаващо входно напрежение; // входно напрежение във V
inputCod= analogRead(A3); // напрежение за отчитане на вход A3
inputVoltage= ((float)inputCod * 5. / 1024.); // преобразуване на кода в напрежение (V)
void analogReference(type)
Задава референтното напрежение за ADC. То определя максимална стойностнапрежение на аналоговия вход, което ADC може правилно да преобразува. Стойността на референтното напрежение също определя коефициента на преобразуване на код към напрежение:
Входно напрежение = ADC код * референтно напрежение / 1024.
Аргументът тип може да приема следните стойности:
- ПО ПОДРАЗБИРАНЕ – референтното напрежение е равно на захранващото напрежение на контролера (5 V или 3,3 V). За Arduino UNO R3 – 5 V.
- INTERNAL – вътрешно референтно напрежение 1.1 V за платки с контролери ATmega168 и ATmega328, за ATmega8 – 2.56 V.
- INTERNAL1V1 – вътрешно 1.1 V референтно напрежение за Arduino Mega контролери.
- INTERNAL2V56 – вътрешно референтно напрежение 2,56 V за Arduino Mega контролери.
- EXTERNAL – външен източник на референтно напрежение, свързан към входа AREF.
analogReference(INTERNAL); // референтното напрежение е 1,1 V
Двуканален волтметър на Arduino.
Като пример за използване на аналогови входни функции, нека създадем проект за обикновен цифров волтметър на Arduino. Устройството трябва да измерва напрежението на два аналогови входа на платката и да предава измерените стойности към компютъра чрез сериен порт. Използвайки този проект като пример, ще покажа принципите на създаване прости системиизмерване и събиране на информация.
Нека решим, че волтметърът трябва да измерва напрежение в диапазона от поне 0...20 V и да разработим схема за свързване на входовете на волтметъра към платката Arduino UNO.
Ако зададем референтното напрежение на 5 V, тогава аналоговите входове на платката ще измерват напрежение в рамките на 0...5 V. А имаме нужда от поне 0...20 V. Това означава, че трябва да използваме делител на напрежение.
Напрежението на входа и изхода на делителя са свързани по отношение:
Uизход = (Uвход / (R1 + R2)) * R2
Коефициент на предаване:
K = Uизход / Uвход = R2 / (R1 + R2)
Нуждаем се от предавателно съотношение 1/4 (20 V * 1/4 = 5 V).
За да се поддържа максимална точност (10 бита), е необходимо вътрешното съпротивление на източника на сигнал да не надвишава 10 kOhm. Затова избираме резистор R2 равен на 4,22 kOhm. Изчисляваме съпротивлението на резистора R1.
0,25 = 4,22 / (R1 + 4,22)
R1 = 4,22 / 0,25 – 4,22 = 12,66 kOhm
Намерих резистори със съпротивление 15 kOhm с най-близка стойност. С резистори R1 = 15 kOhm и R2 = 4,22:
5 / (4,22 / (15 + 4,22)) = 22,77 V.
Веригата на волтметър, базирана на Arduino, ще изглежда така. 
Два делителя на напрежение са свързани към аналогови входове A0 и A1. Кондензаторите C1 и C2, заедно с разделителните резистори, образуват нискочестотни филтри, които премахват високочестотния шум от сигналите.
Сглобих тази схема на макет.
Свързах първия вход на волтметъра към регулиран източник на захранване, а втория към захранването 3,3 V на платката Arduino. За да следя напрежението, свързах волтметър към първия вход. Остава само да напишем програмата.
Програма за измерване на напрежение с помощта на платка Arduino.
Алгоритъмът е прост. Необходимо е:
- прочетете ADC кода два пъти в секунда;
- преобразувайте го в напрежение;
- изпращане на измерени стойности през сериен порт към компютър;
- програма за наблюдение на портове Arduino IDEпокажете получените стойности на напрежението на екрана на компютъра.
Веднага ще ви дам пълна скица на програмата.
// програма за измерване на напрежение
// на аналогови входове А0 и А1
#включи
период на измерване време
#define R1 15. // съпротивление на резистор R1
#define R2 4.22 // съпротивление на резистор R2
float u1, u2; // измерени напрежения
void setup() (
Serial.begin(9600); //
MsTimer2::start(); // разрешаване на прекъсване
}
void loop() (
// период 500 ms
if (timeCount >= MEASURE_PERIOD) (
timeCount= 0;
//
// четене на код на канал 2 и преобразуване в напрежение
u2= ((float)analogRead(A1)) * 5. / 1024. / R2 * (R1 + R2);
// прехвърляне на данни чрез сериен порт
Serial.print("U1 = "); Serial.print(u1, 2);
Serial.print(" U2 = "); Serial.println(u2, 2);
}
}
// обработка на прекъсване 1 ms
void timerInterrupt() (
timeCount++;
}
Нека обясня реда, в който ADC кодът се преобразува в напрежение:
// четене на код на канал 1 и преобразуване в напрежение
u1= ((float)analogRead(A0)) * 5. / 1024. / R2 * (R1 + R2);
- ADC кодът се чете: analogRead(A0) .
- Изрично преобразувано във формат с плаваща запетая: (float) .
- Преобразувано в напрежение на аналоговия вход: * 5. / 1024. Точката в края на числата показва, че това е число с плаваща запетая.
- Коефициентът на предаване на делителя се взема предвид: / R2 * (R1 + R2).
Нека заредим програмата в платката и стартираме монитора на серийния порт.
Две движещи се ленти показват стойностите на измерените напрежения. всичко работи
Измерване на средната стойност на сигнала.
Нека свържем първия канал на нашия волтметър към източник на напрежение с високо ниво на пулсации. Ще видим тази картина на монитора.
Стойностите на напрежението на първия канал на екрана на монитора непрекъснато потрепват и скачат. И показанията на контролния волтметър са доста стабилни. Това е така, защото референтният волтметър измерва средната стойност на сигнала, докато платката Arduino чете отделни проби на всеки 500 ms. Естествено попада и момента на четене на ADC различни точкисигнал. И кога високо нивоАмплитудата на пулсациите в тези точки е различна.
В допълнение, ако сигналът се чете в отделни оскъдни проби, тогава всеки импулсен шум може да въведе значителна грешка в измерването.
Решението е да се вземат няколко чести проби и да се осредни измерената стойност. За да направите това:
- в манипулатора на прекъсвания четем ADC кода и го сумираме с предишните проби;
- отчитане на времето за осредняване (брой осредняващи проби);
- когато се достигне определеният брой проби, запазваме общата стойност на ADC кодовете;
- За да получите средната стойност, разделете сумата от ADC кодовете на броя на осредняващите проби.
Задача от учебник по математика за 8 клас. Ето скица на програмата, двуканален волтметър със средна стойност.
// програма за измерване на средно напрежение
// на аналогови входове А0 и А1
#включи
#define MEASURE_PERIOD 500 // период на измерване време
#define R1 15. // съпротивление на резистор R1
#define R2 4.22 // съпротивление на резистор R2
int timeCount; // брояч на време
дълго sumU1, sumU2; // променливи за сумиране на ADC кодове
дълга средна U1, средна U2; // сума от ADC кодове (средна стойност * 500)
булев флаг Ready; // индикатор за готовност на измервателните данни
void setup() (
Serial.begin(9600); // инициализирайте порта, скорост 9600
MsTimer2::set(1, timerInterupt); // таймер прекъсва, период 1 ms
MsTimer2::start(); // разрешаване на прекъсване
}
void loop() (
if (flagReady == true) (
flagReady= невярно;
// преобразуване в напрежение и прехвърляне към компютър
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);
}
}
// обработка на прекъсване 1 ms
void timerInterrupt() (
timeCount++; // +1 осредняващ брояч на проби
sumU1+= analogRead(A0); // сумиране на ADC кодове
sumU2+= analogRead(A1); // сумиране на ADC кодове
// проверка на броя на осредняващите проби
if (timeCount >= MEASURE_PERIOD) (
timeCount= 0;
avarageU1= sumU1; // претоварване със средна стойност
avarageU2= sumU2; // претоварване със средна стойност
сума U1= 0;
сума U2= 0;
flagReady=вярно; // резултатът от измерването на знака е готов
}
}
Във формулата за преобразуване на ADC кода в напрежение е добавено /500 - броят на пробите. Заредете, стартирайте монитора на порта (Cntr+Shift+M).
Сега, дори при значително ниво на пулсация, показанията се променят със стотни. Това е само защото напрежението не е стабилизирано.
Броят на пробите трябва да бъде избран, като се вземат предвид:
- броят на пробите определя времето за измерване;
- как по-голям бройпроби, толкова по-малко ще бъде влиянието на шума.
Основният източник на смущения в аналоговите сигнали е 50 Hz мрежа. Поради това е препоръчително да изберете време за усредняване, което е кратно на 10 ms – времето на половин цикъл на 50 Hz мрежа.
Оптимизация на изчисленията.
Изчисленията с плаваща запетая просто консумират ресурсите на 8-битов микроконтролер. Всяка операция с плаваща запетая изисква денормализиране на мантиса, операция с фиксирана запетая, нормализация на мантиса, корекция на реда... И всички операции с 32-битови числа. Следователно е необходимо да се сведе до минимум използването на изчисления с плаваща запетая. Ще ви кажа как да направите това в следващите уроци, но нека поне да оптимизираме нашите изчисления. Ефектът ще бъде значителен.
В нашата програма преобразуването на ADC кода в напрежение е написано по следния начин:
(float) avarageU1 / 500. * 5. / 1024. / R2 * (R1 + R2)
Тук има толкова много изчисления, всички с плаваща запетая. Но повечето от изчисленията са операции с константи. Част от линията:
/ 500. * 5. / 1024. / R2 * (R1 + R2)
(float)avarageU1 * 0,00004447756
Интелигентните компилатори сами разпознават изчисления с константи и ги изчисляват на етапа на компилация. Имам въпрос относно това колко умен е компилаторът на Andruino. Реших да го проверя.
Написах кратка програма. Той изпълнява цикъл от 10 000 преминавания и след това предава времето за изпълнение на тези 10 000 цикъла на компютъра. Тези. позволява ви да видите времето за изпълнение на операциите, поставени в тялото на цикъла.
// проверка на оптимизацията на изчислението
int x= 876;
float y;
unsigned int брой;
неподписан дълго времеТекущо, времеПредишно;
void setup() (
Serial.begin(9600);
}
void loop() (
брой++;
// y= (float)x / 500. * 5. / 1024. / 4.22 * (15. + 4.22);
// y= (float)x * 0.00004447756 ;
ако (брой >= 10000) (
брой = 0;
timeCurrent= millis();
Serial.println(timeCurrent - timePrev);
timePrev= timeCurrent;
}
}
В първия вариант, когато операциите с плаваща запетая в цикъла са коментирани и не се изпълняват, програмата извежда резултат от 34 ms.
Тези. 10 000 празни цикъла се изпълняват за 34 ms.
След това отворих реда:
y= (float)x / 500. * 5. / 1024. / 4.22 * (15. + 4.22);
повтаря нашите изчисления. Резултат от 10 000 преминавания за 922 ms или
(922 – 34) / 10 000 = 88,8 µs.
Тези. завършването на този ред от изчисления с плаваща запетая отнема 89 µs. Мислех, че ще има още.
Сега затворих този ред с коментар и отворих следващия, умножавайки по предварително изчислена константа:
y= (float)x * 0.00004447756;
Резултат от 10 000 преминавания за 166 ms или
(166 – 34) / 10 000 = 13,2 µs.
Удивителен резултат. Спестихме 75,6 μs на ред. Изпълнихме го почти 7 пъти по-бързо. Имаме 2 такива линии, но може да има много повече от тях в програмата.
Заключение - изчисленията с константи трябва да се правят сами на калкулатор и да се използват в програмите като готови коефициенти. Компилаторът Arduino няма да ги изчисли на етапа на компилация. В нашия случай трябва да направим следното:
#define ADC_U_COEFF 0.00004447756 // коефициент на преобразуване на ADC код към напрежение
Serial.print((float)avarageU1 * ADC_U_COEFF, 2);
Оптималната опция за производителност е да прехвърлите ADC кода на компютъра, а заедно с него и всички изчисления с плаваща запетая. В този случай компютърът трябва да получи данни специализирана програма. Порт мониторът от Arduino IDE няма да работи.
Ще говоря за други начини за оптимизиране на програми на Arduino в бъдещи уроци, ако е необходимо. Но без решаването на този проблем е невъзможно да се разработят сложни програми на 8-битов микроконтролер.
На сайта се появи още един урок (), посветен на измерването аналогови сигнали. Той изследва работата на ADC във фонов режим.
В следващия урок ще научим как да работим с вътрешна EEPROM и ще говорим за мониторинг на целостта на данните.
Категория: . Можете да го маркирате.Тази статия показва как да свържете Arduino с компютър и да прехвърлите данни от ADC към компютъра. Програмата за Windows е написана с с помощта на Visual C++ 2008 Express. Програмата за волтметър е много проста и има много място за подобрение. Основната му цел беше да покаже как се работи с COM порт и обмен на данни между компютър и Arduino.
Комуникация между Arduino и компютър:
- Вземането на показания от 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-битовите променливи да се разделят на 2 части от по 8 бита.
Serial.print(напрежение>>8,BYTE);
Serial.print(напрежение%256,BYTE);
Преместваме байтовете на променливата с 8 бита надясно и след това разделяме на 256 и изпращаме резултата на компютъра.
Можете да изтеглите пълния изходен код за софтуера Arduino
Visual C++
Предполагам, че вече имате основни познания по програмиране на C++ за Windows, ако не, използвайте Google. Интернет е пълен с уроци за начинаещи.
Първото нещо, което трябва да направите, е да добавите серийния порт от лентата с инструменти към долната форма. Това ще промени някои важни параметрисериен порт: име на порт, скорост на предаване, битова дълбочина. Това е полезно за добавяне на контроли към прозорец на приложение, промяна на тези настройки по всяко време, без повторно компилиране на програмата. Използвах само опцията за избор на порт.
След търсене на налични серийни портове, първият порт се избира по подразбиране. Как се прави:
масив< String ^>^ serialPorts = nullptr;
serialPorts = serialPort1->GetPortNames();
това->comboBox1->Items->AddRange(serialPorts);
this->comboBox1->SelectedIndex=0;
Серийният порт на компютър може да се използва само от едно приложение в даден момент, така че портът трябва да бъде отворен преди употреба, а не затворен. Прости командиза това:
serialPort1->Open();
serialPort1->Затвори();
За да прочетете правилно данните от сериен порт, трябва да използвате събития (в нашия случай прекъсване). Изберете тип събитие:
Падащ списък кога щракнете двукратно„Получени данни“.
Кодът на събитието се генерира автоматично:
Ако първият байт, пристигнал на серийния порт, е 0xAB, това означава, че останалите байтове носят данни за напрежение.
private: System::Void serialPort1_DataReceived(System::Object^ sender, System::IO::Ports::SerialDataReceivedEventArgs^ e) (
неподписан char данни0, данни1;
if (serialPort1->ReadByte()==0xAB) (
data0=serialPort1->ReadByte();
data1=serialPort1->ReadByte();
напрежение=Math::Round((float(data0*256+data1)/1024*5.00),2);
брой_данни++;
serialPort1->ReadByte();
Записване и четене на данни от сериен порт
Малък проблем за мен беше изпращането на шестнадесетични RAW данни през серийния порт. Използвана е командата Write(); но с три аргумента: масив, номер на начален байт, брой байтове за запис.
private: System::Void button2_Click_1(System::Object^ sender, System::EventArgs^ e) (
неподписан char канал=0;
канал=това->listBox1->SelectedIndex;
масив^старт =(0xAC,(0x10+канал));
масив^стоп =(0xAC,0x00);
serialPort1->Write(start,0,2);
това->бутон2->Текст="Стоп";
) иначе (
serialPort1->Запис(стоп,0,2);
this->button2->Text="Старт";
Това е всичко!
Оригинална статия за английски(превод: Александър Касяновза сайта cxem.net)
Мултифункционалните модули Arduino са от голям интерес за феновете на домашни електронно програмируеми устройства, което им позволява да вдъхнат живот на интересни идеи.
Основното предимство на готовите Arduino схеми е уникалният блоково-модулен принцип: всяка платка може да бъде добавена с допълнителни интерфейси, безкрайно разширявайки възможностите за създаване на различни проекти.
Arduino модулипостроен върху универсален микроконтролерсъс собствен буутлоудър, което улеснява флашването му с необходимото програмен код, без да използвате допълнителни устройства. Програмирането се извършва на стандартния език C++.
Един от най-простите примери за използване на Arduino може да бъде внедряването на волтметър, базиран на този монтаж DC напрежение повишена точностс обхват на измерване от 0 до 30 V.
Аналоговите входове на Arduino са проектирани за постоянно напрежение от не повече от пет волта, следователно използването им при напрежения, надвишаващи тази стойност, е възможно с делител на напрежение.
Схема на свързване на Areduino чрез делител на напрежение Делителят на напрежението се състои от две последователно свързани съпротивления. Изчислява се по формулата:
Външен USB конектор в автомобилното радио 
Здравей, Хабр! Днес искам да продължа темата за „пресичането“ на arduino и android. В предишната публикация, за която говорих, а днес ще говорим за Направи си сам bluetooth волтметър. Друго такова устройство може да се нарече интелигентен волтметър, „умен“ волтметър или просто интелигентен волтметър, без кавички. Фамилното име е неправилно от гледна точка на руската граматика, но често се среща в медиите. В края на статията ще има гласуване по тази тема, но предлагам да започнете с демонстрация на работата на устройството, за да разберете за какво ще бъде статията.
Отказ от отговорност: статията е предназначена за средния ентусиаст на ардуино, който обикновено не е запознат с програмирането за Android, следователно, както в предишната статия, ще създадем приложение за смартфон, използвайки визуалната среда за разработка на приложения за Android App Inventor 2.
За да направим DIY bluetooth волтметър, трябва да напишем две относително независими програми: скица за 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;
плаващо напрежение = 0,0;
поплавък R1 = 100000.0; // Батерия Vin-> 100K -> A0
поплавък R2 = 10000.0; //Battery 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, щракнете върху бутона за създаване, нов проект и от просто плъзгане и пускане на елементи ще създадем нещо като този дизайн:
Направих графиката много проста, ако някой иска по-интересна графика, нека ви напомня, че за това трябва да използвате .png файлове с прозрачен фон вместо .jpeg файлове.
Сега отидете в раздела Блокове и създайте там логиката на приложението нещо подобно:
Ако всичко работи, можете да щракнете върху бутона Build и да запишете .apk на моя компютър, след което да изтеглите и инсталирате приложението на вашия смартфон, въпреки че има и други начини за качване на приложението. тук е по-удобно за всеки. В резултат на това завърших с това приложение:
Разбирам, че малко хора използват средата за визуална разработка App Inventor 2 за приложения за Android в своите проекти, така че може да възникнат много въпроси относно работата в нея. За да отговоря на някои от тези въпроси, направих подробно видео за това как да направите такова приложение „от нулата“ (за да го видите, трябва да отидете в YouTube):
P.S. Колекция от повече от 100 образователни материали за Arduino за начинаещи и професионалисти
