Бывают моменты, когда вы хотите проверить напряжение или какую-то точку в цепи, но у вас нет вольтметра или мультиметра под рукой? Бежать покупать? Это долго и дорого. Прежде чем вы это сделаете, как насчет того, чтобы создать вольтметр самому? На самом деле с помощью простых компонентов вы можете сделать его сами.
Шаг 1: Готовим компоненты
- В уроке мы использовали плату совместимую с Ардуино - SunFounder Uno / Mars (http://bit.ly/2tkaMba)
- USB-кабель для передачи данных
- 2 потенциометра (50k)
- LCD1602 - http://bit.ly/2ubNEfi
- Макетная плата - http://bit.ly/2slvfrB
- Несколько перемычек
Перед подключением, давайте сначала разберем как это работает.
Используйте плату SunFounder Uno для основной части обработки данных вольтметра, LCD1602 в качестве экрана, потенциометр для регулировки контрастности ЖК-дисплея, а другой - для разделения напряжения.
Когда вы вращаете потенциометр, подключенный к плате Uno, резистор потенциометра изменяется, тем самым изменяя напряжение на нем. Сигнал напряжения будет отправлен на плату Uno через контакт A0, а Uno преобразует полученный аналоговый сигнал в цифровую форму и записывает на ЖК-дисплей. Таким образом, вы можете увидеть значение напряжения при текущем сопротивлении емкости.
LCD1602 имеет два режима работы: 4-битный и 8-битный. Когда IO MCU недостаточны, вы можете выбрать 4-битный режим, при котором используются только контакты D4 ~ D7.
Следуйте таблице, чтобы подключить их.
Шаг 4: Подключаем потенциометр к LCD1602
Подключите средний контакт потенциометра к контакту Vo на LCD1602, а любой из остальных контактов - к GND.
Подсоедините средний контакт потенциометра к контакту A0 от SunFounder Uno, а один из остальных - к 5V, когда другой - к GND.
Шаг 6: Загружаем код
Такой код:
#include /****************************************************/ const int analogIn = A0;//potentiometer attach to A0 LiquidCrystal lcd(4, 6, 10, 11, 12, 13);//lcd(RS,E,D4,D5,D6.D7) float val = 0;// define the variable as value=0 /****************************************************/ void setup() { Serial.begin(9600);//Initialize the serial lcd.begin(16, 2);// set the position of the characters on the LCD as Line 2, Column 16 lcd.print("Voltage Value:");//print "Voltage Value:" } /****************************************************/ void loop() { val = analogRead(A0);//Read the value of the potentiometer to val val = val/1024*5.0;// Convert the data to the corresponding voltage value in a math way Serial.print(val);//Print the number of val on the serial monitor Serial.print("V"); // print the unit as V, short for voltage on the serial monitor lcd.setCursor(6,1);//Place the cursor at Line 1, Column 6. From here the characters are to be displayed lcd.print(val);//Print the number of val on the LCD lcd.print("V");//Then print the unit as V, short for voltage on the LCD delay(200); //Wait for 200ms }
Вращайте потенциометр, чтобы проверить напряжение на LCD1602 в режиме реального времени.
Вот хитрая штука. После того, как я запустил код, на ЖК-дисплее отобразились символы. Затем я отрегулировал контрастность экрана (постепенное изменение от черного до белого), вращая потенциометр по часовой стрелке или против часовой стрелки, пока экран не отобразил символы четко.
Возьмите две батареи, чтобы измерить их напряжение: 1,5 В и 3,7 В. Отцепите соединение второго потенциометра с контактом A0 и GND, что означает удаление потенциометра из цепи. Зажмите конец провода A0 до анода батареи и цепь GND на катод. НЕ подключайте их обратно, иначе получите короткое замыкание на батарее. Значение 0V - это обратное соединение.
Итак, напряжение аккумулятора отображается на ЖК-дисплее. Может быть некоторая погрешность между значением и номинальным, поскольку батарея не полностью заряжена. И именно поэтому мне нужно измерить напряжение, чтобы понять могу я использовать аккумулятор или нет.
PS: Если у вас проблемы с отображением на дисплее - смотрите этот FAQ для ЖК-дисплеев - http://wiki.sunfounder.cc/index.php?title=LCD1602/I2C_LCD1602_FAQ.
Аналоговые входы платы Ардуино.
Плата Arduino UNO содержит 6 аналоговых входов предназначенных для измерения напряжения сигналов. Правильнее сказать, что 6 выводов платы могут работать в режиме, как дискретных выводов, так и аналоговых входов.
Эти выводы имеют номера от 14 до 19. Изначально они настроены как аналоговые входы, и обращение к ним можно производить через имена A0-A5. В любой момент их можно настроить на режим дискретных выходов.
pinMode(A3, OUTPUT); // установка режима дискретного вывода для A3
digitalWrite(A3, LOW); // установка низкого состояния на выходе A3
Чтобы вернуть в режим аналогового входа:
pinMode(A3, INPUT); // установка режима аналогового входа для A3
Аналоговые входы и подтягивающие резисторы.
К выводам аналоговых входов, так же как и к дискретным выводам, подключены подтягивающие резисторы. Включение этих резисторов производится командой
digitalWrite(A3, HIGH); // включить подтягивающий резистор к входу A3
Команду необходимо применять к выводу настроенному в режиме входа.
Надо помнить, что резистор может оказать влияние на уровень входного аналогового сигнала. Ток от источника питания 5 В, через подтягивающий резистор, вызовет падение напряжения на внутреннем сопротивлении источника сигнала. Так что лучше резистор отключать.
Аналого-цифровой преобразователь платы Ардуино.
Собственно измерение напряжение на входах производится аналого-цифровым преобразователем (АЦП) с коммутатором на 6 каналов. АЦП имеет разрешение 10 бит, что соответствует коду на выходе преобразователя 0…1023. Погрешность измерения не более 2 единиц младшего разряда.
Для сохранения максимальной точности (10 разрядов) необходимо, чтобы внутреннее сопротивление источника сигнала не превышало 10 кОм. Это требование особенно важно при использовании резисторных делителей, подключенных к аналоговым входам платы. Сопротивление резисторов делителей не может быть слишком большим.
Программные функции аналогового ввода.
int analogRead(port)
Считывает значение напряжения на указанном аналоговом входе. Входное напряжение диапазона от 0 до уровня источника опорного напряжения (часто 5 В) преобразовывает в код от 0 до 1023.
При опорном напряжении равном 5 В разрешающая способность составляет 5 В / 1024 = 4,88 мВ.
Занимает на преобразование время примерно 100 мкс.
int inputCod; // код входного напряжения
float inputVoltage; // входное напряжение в В
inputCod= analogRead(A3); // чтение напряжения на входе A3
inputVoltage= ((float)inputCod * 5. / 1024.); // пересчет кода в напряжение (В)
void analogReference(type)
Задает опорное напряжение для АЦП. Оно определяет максимальное значение напряжения на аналоговом входе, которое АЦП может корректно преобразовать. Величина опорного напряжения также определяет коэффициент пересчета кода в напряжение:
Напряжение на входе = код АЦП * опорное напряжение / 1024.
Аргумент type может принимать следующие значения:
- DEFAULT – опорное напряжение равно напряжению питания контроллера (5 В или 3,3 В). Для Arduino UNO R3 – 5 В.
- INTERNAL – внутреннее опорное напряжение 1,1 В для плат с контроллерами ATmega168 и ATmega328, для ATmega8 – 2,56 В.
- INTERNAL1V1 – внутреннее опорное напряжение 1,1 В для контроллеров Arduino Mega.
- INTERNAL2V56 – внутреннее опорное напряжение 2,56 В для контроллеров Arduino Mega.
- EXTERNAL – внешний источник опорного напряжения, подключается к входу AREF.
analogReference(INTERNAL); // опорное напряжение равно 1,1 В
Двухканальный вольтметр на Ардуино.
В качестве примера использования функций аналогового ввода создадим проект простого цифрового вольтметра на Ардуино. Устройство должно измерять напряжения на двух аналоговых входах платы, и передавать измеренные значения на компьютер по последовательному порту. На примере этого проекта я покажу принципы создания простых систем измерения и сбора информации.
Решим, что вольтметр должен измерять напряжение в пределах не меньше 0…20 В и разработаем схему подключения входов вольтметра к плате Arduino UNO.
Если мы зададим опорное напряжение равным 5 В, то аналоговые входы платы будут измерять напряжение в пределах 0…5 В. А нам надо как минимум 0…20 В. Значит надо использовать делитель напряжения.
Напряжение на входе и выходе делителя связаны соотношением:
Uвыхода = (Uвхода / (R1 + R2)) * R2
Коэффициент передачи:
K = Uвыхода / Uвхода = R2 / (R1 + R2)
Нам необходим коэффициент передачи 1/4 (20 В * 1/4 = 5 В).
Для сохранения максимальной точности (10 разрядов) необходимо, чтобы внутреннее сопротивление источника сигнала не превышало 10 кОм. Поэтому выбираем резистор R2 равным 4,22 кОм. Рассчитываем сопротивление резистора R1.
0,25 = 4,22 / (R1 + 4,22)
R1 = 4,22 / 0.25 – 4,22 = 12,66 кОм
У меня с ближайшим номиналом нашлись резисторы сопротивлением 15 кОм. С резисторами R1 = 15 кОм и R2 = 4,22:
5 / (4,22 / (15 + 4,22)) = 22,77 В.
Схема вольтметра на базе Ардуино будет выглядит так.
Два делителя напряжения подключены к аналоговым входам A0 и A1. Конденсаторы C1 и C2 вместе с резисторами делителя образуют фильтры нижних частот, которые убирают из сигналов высокочастотные шумы.
Я собрал эту схему на макетной плате.
Первый вход вольтметра я подключил к регулируемому источнику питания, а второй к питанию 3,3 В платы Ардуино. Для контроля напряжения к первому входу я подключил вольтметр. Осталось написать программу.
Программа для измерения напряжения с помощью платы Ардуино.
Алгоритм простой. Надо:
- с частотой два раза в секунду считывать код АЦП;
- пересчитывать его в напряжение;
- посылать измеренные значения по последовательному порту на компьютер;
- программой монитор порта Arduino IDE отображать полученные значения напряжений на экране компьютера.
Приведу скетч программы сразу полностью.
// программа измерения напряжения
// на аналоговых входах A0 и A1
#include
время периода измерения
#define R1 15. // сопротивление резистора R1
#define R2 4.22 // сопротивление резистора R2
float u1, u2; // измеренные напряжения
void setup() {
Serial.begin(9600); //
MsTimer2::start(); // разрешение прерывания
}
void loop() {
// период 500 мс
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 мс
void timerInterupt() {
timeCount++;
}
Поясню строчку, в которой пересчитывается код АЦП в напряжение:
// чтение кода канала 1 и пересчет в напряжение
u1= ((float)analogRead(A0)) * 5. / 1024. / R2 * (R1 + R2);
- Считывается код АЦП: analogRead(A0) .
- Явно преобразуется в формат с плавающей запятой: (float) .
- Пересчитывается в напряжение на аналоговом входе: * 5. / 1024. Точка в конце чисел показывает, что это число с плавающей запятой.
- Учитывается коэффициент передачи делителя: / R2 * (R1 + R2) .
Загрузим программу в плату, запустим монитор последовательного порта.
Два бегущих столбика показывают значения измеренных напряжений. Все работает.
Измерение среднего значения сигнала.
Подключим первый канал нашего вольтметра к источнику напряжения с большим уровнем пульсаций. Увидим такую картину на мониторе.
Значения напряжения первого канала на экране монитора все время дергаются, скачут. А показания контрольного вольтметра вполне стабильны. Это объясняется тем, что контрольный вольтметр измеряет среднее значение сигнала, в то время как плата Ардуино считывает отдельные выборки каждые 500 мс. Естественно, момент чтения АЦП попадает в разные точки сигнала. А при высоком уровне пульсаций амплитуда в этих точках разная.
Кроме того, если считывать сигнал отдельными редкими выборками, то любая импульсная помеха может внести значительную ошибку в измерение.
Решение – сделать несколько частых выборок и усреднить измеренное значение. Для этого:
- в обработчике прерывания считываем код АЦП и суммируем его с предыдущими выборками;
- отсчитываем время усреднения (число выборок усреднения);
- при достижении заданного числа выборок – сохраняем суммарное значение кодов АЦП;
- для получения среднего значения сумму кодов АЦП делим на число выборок усреднения.
Задача из учебника математики 8 класса. Вот скетч программы, двух канального вольтметра среднего значения.
// программа измерения среднего напряжения
// на аналоговых входах A0 и A1
#include
#define MEASURE_PERIOD 500 // время периода измерения
#define R1 15. // сопротивление резистора R1
#define R2 4.22 // сопротивление резистора R2
int timeCount; // счетчик времени
long sumU1, sumU2; // переменные для суммирования кодов АЦП
long avarageU1, avarageU2; // сумма кодов АЦП (среднее значение * 500)
boolean flagReady; // признак готовности данных измерения
void setup() {
Serial.begin(9600); // инициализируем порт, скорость 9600
MsTimer2::set(1, timerInterupt); // прерывания по таймеру, период 1 мс
MsTimer2::start(); // разрешение прерывания
}
void loop() {
if (flagReady == true) {
flagReady= false;
// пересчет в напряжение и передача на компьютер
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 мс
void timerInterupt() {
timeCount++; // +1 счетчик выборок усреднения
sumU1+= analogRead(A0); // суммирование кодов АЦП
sumU2+= analogRead(A1); // суммирование кодов АЦП
// проверка числа выборок усреднения
if (timeCount >= MEASURE_PERIOD) {
timeCount= 0;
avarageU1= sumU1; // перегрузка среднего значения
avarageU2= sumU2; // перегрузка среднего значения
sumU1= 0;
sumU2= 0;
flagReady= true; // признак результат измерений готов
}
}
В формулу пересчета кода АЦП в напряжение добавилось /500 – число выборок. Загружаем, запускаем монитор порта (Cntr+Shift+M).
Теперь, даже при значительном уровне пульсаций, показания меняются на сотые доли. Это только потому, что напряжение не стабилизировано.
Число выборок надо выбирать, учитывая:
- число выборок определяет время измерения;
- чем больше число выборок, тем меньше будет влияние помех.
Основным источником помех в аналоговых сигналах является сеть 50 Гц. Поэтому желательно выбирать время усреднения кратное 10 мс – времени полупериода сети частотой 50 Гц.
Оптимизация вычислений.
Вычисления с плавающей запятой просто пожирают ресурсы 8ми разрядного микроконтроллера. Любая операция с плавающей запятой требует денормализацию мантиссы, операцию с фиксированной запятой, нормализацию мантиссы, коррекцию порядка… И все операции с 32 разрядными числами. Поэтому необходимо свести к минимуму употребление вычислений с плавающей запятой. Как это сделать я расскажу в следующих уроках, но давайте хотя бы оптимизируем наши вычисления. Эффект будет значительный.
В нашей программе пересчет кода АЦП в напряжение записан так:
(float)avarageU1 / 500. * 5. / 1024. / R2 * (R1 + R2)
Сколько здесь вычислений, и все с плавающей запятой. А ведь большая часть вычислений – операции с константами. Часть строки:
/ 500. * 5. / 1024. / R2 * (R1 + R2)
(float)avarageU1 * 0.00004447756
Умные компиляторы сами распознают вычисления с константами и рассчитывать их на этапе компиляции. У меня возник вопрос, насколько умный компилятор Андруино. Решил проверить.
Я написал короткую программу. Она выполняет цикл из 10 000 проходов, а затем передает на компьютер время выполнения этих 10 000 циклов. Т.е. она позволяет увидеть время выполнения операций, размещенных в теле цикла.
// проверка оптимизации вычислений
int x= 876;
float y;
unsigned int count;
unsigned long timeCurrent, timePrev;
void setup() {
Serial.begin(9600);
}
void loop() {
count++;
// y= (float)x / 500. * 5. / 1024. / 4.22 * (15. + 4.22);
// y= (float)x * 0.00004447756
;
if (count >= 10000) {
count= 0;
timeCurrent= millis();
Serial.println(timeCurrent - timePrev);
timePrev= timeCurrent;
}
}
В первом варианте, когда в цикле операции с плавающей запятой закомментированы и не выполняются, программа выдала результат 34 мс.
Т.е. 10 000 пустых циклов выполняются за 34 мс.
Затем я открыл строку:
y= (float)x / 500. * 5. / 1024. / 4.22 * (15. + 4.22);
повторяет наши вычисления. Результат 10 000 проходов за 922 мс или
(922 – 34) / 10 000 = 88,8 мкс.
Т.е. эта строка вычислений с плавающей запятой требует на выполнение 89 мкс. Я думал будет больше.
Теперь я закрыл эту строку комментарием и открыл следующую, с умножением на заранее рассчитанную константу:
y= (float)x * 0.00004447756 ;
Результат 10 000 проходов за 166 мс или
(166 – 34) / 10 000 = 13,2 мкс.
Потрясающий результат. Мы сэкономили 75,6 мкс на одной строке. Выполнили ее почти в 7 раз быстрее. У нас таких строк 2. Но ведь их в программе может быть и гораздо больше.
Вывод – вычисления с константами надо производить самим на калькуляторе и применять в программах как готовые коэффициенты . Компилятор Ардуино их на этапе компиляции не рассчитает. В нашем случае следует сделать так:
#define ADC_U_COEFF 0.00004447756 // коэффициент перевода кода АЦП в напряжение
Serial.print((float)avarageU1 * ADC_U_COEFF, 2);
Оптимальный по быстродействию вариант – это передать на компьютер код АЦП, а вместе с ним и все вычисления с плавающей запятой. При этом на компьютере принимать данные должна специализированная программа. Монитор порта из Arduino IDE не подойдет.
О других способах оптимизации программ Ардуино я буду рассказывать в будущих уроках по мере необходимости. Но без решения этого вопроса невозможно разрабатывать сложные программы на 8ми разрядном микроконтроллере.
На сайте появился еще один урок () посвященный измерению аналоговых сигналов. В нем рассматривается работа АЦП в фоновом режиме.
В следующем уроке научимся работать с внутренним EEPROM, поговорим о контроле целостности данных.
Рубрика: . Вы можете добавить в закладки.В этой статье показано как связать Arduino и ПК и передавать на ПК данные с АЦП. Программа для Windows написана с использованием Visual C++ 2008 Express. Программа вольтметра очень проста и имеет обширное поле для улучшений. Основной её целью было показать работу с COM-портом и обмен данными между компьютером и Arduino.
Связь между Arduino и ПК:
- Снятие показаний с АЦП начинается, когда компьютер посылает Arduino команды 0xAC и 0x1y. у – номер канала АЦП (0-2);
- Снятие показаний прекращается после получения Arduino команд 0xAC и 0×00;
- Во время снятия показаний Arduino раз в 50 мс посылает компьютеру команды 0xAB 0xaa 0xbb, где aa и bb максимальные и минимальные результаты измерения.
Программа для Arduino
Подробнее о последовательной связи Вы можете прочесть на arduino.cc. Программа достаточно проста, большую её часть занимает работа с параллельным портом. После окончания снятия данных с АЦП мы получаем 10 битное значение напряжения (0×0000 – 0×0400) в виде 16-битных переменных (INT). Последовательный порт (RS-232) позволяет передавать данные в пакетах по 8 бит. Необходимо разделить 16-битные переменные на 2 части по 8 бит.
Serial.print(voltage>>8,BYTE);
Serial.print(voltage%256,BYTE);
Мы смещаем байты переменной на 8 бит вправо и потом делим на 256 и результат отправляем на компьютер.
Полный исходник ПО для Arduino вы можете скачать
Visual C++
Я предполагаю, что у Вас уже есть базовые знания в области программирования на C + + для Windows, если нет, то используйте Google. Интернет полон уроков для начинающих.
Первое, что нужно сделать, это добавить последовательный порт из панели инструментов в нижнюю форму. Это позволит изменить некоторые важные параметры последовательного порта: имя порта, скорость передачи данных, битность. Это полезно для добавления элементов управления в окно приложения, для изменения этих настроек в любое время, без перекомпиляции программы. Я использовал только возможность выбора порта.
После поиска доступных последовательных портов первый порт выбирается по умолчанию. Как это сделано:
array< String ^>^ serialPorts = nullptr;
serialPorts = serialPort1->GetPortNames();
this->comboBox1->Items->AddRange(serialPorts);
this->comboBox1->SelectedIndex=0;
Последовательный порт на ПК может быть использован только одним приложением одновременно, так что порт должен быть открыт перед использованием и не закрываться. Простые команды для этого:
serialPort1->Open();
serialPort1->Close();
Для правильного чтения данных из последовательного порта необходимо использовать события (в нашем случае прерывание). Выберите тип события:
Раскрывающийся список при двойном нажатии "DataReceived".
Код события генерируется автоматически:
Если первый байт прибывший по последовательному порту 0xAB, если это означает, что остальные байты несут данные о напряжении.
private: System::Void serialPort1_DataReceived(System::Object^ sender, System::IO::Ports::SerialDataReceivedEventArgs^ e) {
unsigned char data0, data1;
if (serialPort1->ReadByte()==0xAB) {
data0=serialPort1->ReadByte();
data1=serialPort1->ReadByte();
voltage=Math::Round((float(data0*256+data1)/1024*5.00),2);
data_count++;
serialPort1->ReadByte();
Запись и чтение данных последовательного порта
Для меня небольшой проблемой было послать шестнадцатиричные RAW-данные через последовательный порт. Была использованна команда Write(); но с тремя аргументами: массив, номер стартового байта, кол-во байтов для записи.
private: 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);
this->button2->Text="Stop";
} else {
serialPort1->Write(stop,0,2);
this->button2->Text="Start";
На этом все!
Оригинал статьи на английском языке (перевод: Александр Касьянов для сайта cxem.net)
Широкий интерес для любителей самодельных электронно-программируемых устройств представляют многофункциональные сборки Arduino, позволяющие воплощать в жизнь интересные задумки.
Основное преимущество готовых схем Arduino заключается в уникальном блочно-модульном принципе: каждая плата может быть добавлена дополнительными интерфейсами, бесконечно расширяя возможности для создания различных проектов.
Модули Arduino построены на универсальном микроконтроллере с собственным загрузчиком, что позволяет легко прошивать его необходимым программным кодом, без использования дополнительных устройств. Программирование осуществляется на стандартном языке С++.
Одним из простейших примеров использования Arduino может стать реализация на базе этой сборки вольтметра постоянного напряжения повышенной точности с диапазоном измерения от 0 до 30 В.
Аналоговые входы Arduino предназначены для постоянного напряжения не более пяти вольт, поэтому, использование их при превышающих это значение напряжениях возможно с делителем напряжения.
Схема подключения Areduino через делитель напряжения Делитель напряжения состоит из двух последовательно соединенных сопротивлений. Расчет его производится по формуле:
Внешний USB-разъем в автомагнитоле
Привет, Хабр! Сегодня хочу продолжить тему «скрещивания» arduino и android. В предыдущей публикации я рассказал про , а сегодня речь пойдет про DIY bluetooth вольтметр. Еще такой девайс можно назвать смарт вольтметр, «умный» вольтметр или просто умный вольтметр, без кавычек. Последнее название является неправильным с точки зрения грамматики русского языка, тем не менее частенько встречается в СМИ. Голосование на эту тему будет в конце статьи, а начать предлагаю с демонстрации работы устройства, чтобы понять о чем же пойдет речь в статье.
Disclaimer: статья рассчитана на среднестатистического любителя arduino, который обычно не знаком с программированием под android, поэтому как и в прошлой статье, приложение для смартфона мы будем делать, используя среду визуальной разработки android-приложений App Inventor 2.
Чтобы сделать DIY bluetooth вольтметр нам нужно написать две относительно независимых друг от друга программы: скетч для ардуино и приложение для андроид.Пожалуй начнем со скетча.
Для начала следует знать, что существует три основных варианта измерения напряжения при помощи ардуино, не зависимо от того куда нужно выводить информацию: в com-порт, на подключенный к ардуино экранчик, или на смартфон.
Первый случай: измерения напряжения до 5 вольт. Здесь достаточно одной-двух строк кода, а напряжение подается напрямую на пин А0:
int value = analogRead(0);// читаем показания с А0
voltage = (value / 1023.0) * 5; // верно только если Vcc = 5.0 вольт
Второй случай: для измерения напряжения более 5 вольт используется делитель напряжения. Схема очень простая, код тоже.
Скетч
int analogInput = A0;
float val = 0.0;
float voltage = 0.0;
float R1 = 100000.0; //Battery Vin-> 100K -> A0
float R2 = 10000.0; //Battery Gnd -> Arduino Gnd and Arduino Gnd -> 10K -> A0
int value = 0;
Void setup() {
Serial.begin(9600);
pinMode(analogInput, INPUT);
}
Void loop() {
value = analogRead(analogInput);
val = (value * 4.7) / 1024.0;
voltage = val / (R2/(R1+R2));
Serial.println(voltage);
delay(500);
}
Arduino Uno
Блютуз модуль
Третий случай. Когда нужно получить более точные о напряжении в качестве опорного напряжения нужно использовать не напряжение питания, которое может немного меняться при питании от акб, например, а напряжение внутренного стабилизатора ардуино 1.1 вольт.Тут схема такая же, но код чуть длиннее. Подробно этот вариант разбирать не буду, так как он и так хорошо описан в тематических статьях, а мне вполне и достаточно второго способа, поскольку питание у меня стабильное, от usb-порта ноутбука.
Итак с измерением напряжения мы разобрались, теперь перейдем ко второй половине проекта: созданию андроид-приложения. Приложение будем делать прямо из браузера в среде визуальной разработки android-приложений App Inventor 2. Заходим на сайт appinventor.mit.edu/explore , авторизуемся с помощью гугл-аккаунта, нажимаем кнопку create, new project, и путем простого перетаскивания элементов создаем примерно такой дизайн:
Я сделал графику очень простой, если кому-то захочется более интересной графики, напомню, что для этого нужно использовать вместо.jpeg файлов, файлы формата.png с прозрачным фоном.
Теперь переходим во вкладку Blocks и создаем там логику работы приложения примерно так:
Если все получилось можно нажимать кнопку Build и save .apk to my computer, а затем уже скачиваем и устанавливаем приложение на смартфон, хотя есть и другие способы заливки приложения. тут уж кому как удобнее. В итоге у меня получилось вот такое приложение:
Понимаю, что мало кто использует среду визуальной разработки android-приложений App Inventor 2 в своих проектах, поэтому может возникнуть много вопросов по поводу работы в ней. Чтобы снять часть таких вопросов, я сделал подробное видео, о том как сделать такое приложение «с нуля»(для просмотра нужно перейти на ютуб):
P.S. Сборник из более 100 обучающих материалов по ардуино для начинающих и профи
