Напряжение преобразовать в частоту arduino. Функции работы с АЦП
Аналоговые входы платы Ардуино.
Плата 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ми разрядном микроконтроллере.
На сайте появился еще один урок (
Описание портов, работающих как аналоговые входы, платформы Arduino (Atmega8, Atmega168, Atmega328, или Atmega1280)
Аналого-цифровой преобразователь
Микроконтроллеры Atmega, используемые в Arduino, содержат шестиканальный аналого-цифровой преобразователь (АЦП). Разрешение преобразователя составляет 10 бит, что позволяет на выходе получать значения от 0 до 1023. Основным применением аналоговых входов большинства платформ Arduino является чтение аналоговых датчиком, но в тоже время они имеют функциональность вводов/выводов широкого применения (GPIO) (то же, что и цифровые порты ввода/вывода 0 - 13).
Таким образом, при необходимости применения дополнительных портов ввода/вывода имеется возможность сконфигурировать неиспользуемые аналоговые входы.
Цоколевка
Выводы Arduino, соответствующие аналоговым входам, имеют номера от 14 до 19. Это относится только к выводам Arduino, а не к физическим номерам выводов микроконтроллера Atmega. Аналоговые входы могут использоваться как цифровые выводы портов ввода/вывода. Например, код программы для установки вывода 0 аналогового входа на порт вывода со значением HIGH:
pinMode(14, OUTPUT);
digitalWrite(14, HIGH);
Подтягивающие резисторы
Выводы аналоговые входов имеют подтягивающие резисторы работающие как на цифровых выводах. Включение резисторов производится командой
digitalWrite(14, HIGH); // включить резистор на выводе аналогового входа 0
пока вывод работает как порт ввода.
Подключение резистора повлияет на величину сообщаемую функцией analogRead() при использовании некоторых датчиков. Большинство пользователей использует подтягивающий резистор при применении вывода аналогового входа в его цифровом режиме.
Подробности и предостережения
Для вывода, работавшего ранее как цифровой порт вывода, команда analogRead будет работать некорректно. В этом случае рекомендуется сконфигурировать его как аналоговый вход. Аналогично, если вывод работал как цифровой порт вывода со значением HIGH, то обратная установка на ввод подключит подтягивающий резистор.
Руководство на микроконтроллер Atmega не рекомендует производить быстрое переключение между аналоговыми входами для их чтения. Это может вызвать наложение сигналов и внести искажения в аналоговую систему. Однако после работы аналогового входа в цифровом режиме может потребоваться настроить паузу между чтением функцией analogRead() других входов.
Arduino имеет несколько аналоговых входов, используя которые можно измерять параметры аналоговых величин. Это может быть напряжение, ток, сопротивление, температура, свет и так далее. В некоторых случаях для преобразования физических величин в электрические сигналы могут потребоваться специальные датчики. Сегодня я расскажу об использовании и проведу тест производительности аналого-цифрового преобразователя (АЦП) Arduino . Тест я буду производить, используя оригинальную плату Arduino Mega 2560, в основе которой лежит микроконтроллер ATMega 2560, работающий на частоте 16 Мгц. Микроконтроллер ATMega328 , на котором основаны Arduino Uno и Arduino Nano , также работает на частоте 16 МГц, так что все вышеизложенное, скорее всего, справедливо и для этих и аналогичных плат.
analogRead
Давайте посмотрим сколько же времени занимает аналого-цифровое преобразование с использованием стандартной функции analogRead .
Для определения моментов начала и конца преобразования я буду использовать 12 вывод в качестве маркера. Для начала повторим эксперимент, который я описывал в статье . Будем изменять уровень напряжения на 12 цифровом пине между состояниями LOW и HIGH . Для чистоты эксперимента я помещу внутрь loop бесконечный цикл.
Скетч, реализующий простые переключения на 12 цифровом выводе выглядит следующим образом:
void setup() { DDRB = B01000000; //устанавливаем 12 пин в режим выхода } void loop() { while(1) { PORTB = B01000000; // устанавливаем пин 12 в состояние HIGH PORTB = B00000000; // устанавливаем пин 12 в состояние LOW } }
Воспользуемся осциллографом и посмотрим на временные параметры работы этой программы:
Отсюда видно, что время переключения состояния пина занимает у нас 62 нс (длительность положительного импульса).
Теперь немного изменим скетч и добавим между переключениями функцию чтения аналогового сигнала analogRead на 3 аналоговом пине:
int analogPin = 3; // входной аналоговый пин int analogValue = 0; void setup() { DDRB = B01000000; // устанавливаем 12 пин в режим выхода } void loop() { while(1) { PORTB = B01000000; // устанавливаем пин 12 в состояние HIGH analogValue = analogRead(analogPin); // читаем аналоговый сигнал PORTB = B00000000; // устанавливаем пин 12 в состояние LOW analogValue = analogRead(analogPin); // читаем аналоговый сигнал } }
int analogPin = 3 ; // входной аналоговый пин int analogValue = 0 ; // значение аналогового сигнала void setup () DDRB = B01000000 ; // устанавливаем 12 пин в режим выхода void loop () while (1 ) PORTB = B01000000 ; // устанавливаем пин 12 в состояние HIGH // читаем аналоговый сигнал PORTB = B00000000 ; // устанавливаем пин 12 в состояние LOW analogValue = analogRead (analogPin ) ; // читаем аналоговый сигнал |
Осцилограмма сигнала на 12 цифровом пине теперь будет выглядеть следующим образом:
Длительность переключения в 62 нс и время циклического возврата к началу работы программы в 124 нс не превышают погрешность измерения на этом временном масштабе и мы можем пренебречь этими временными промежутками. Отсюда видно, что время, которое затрачивается на аналого-цифровое преобразование примерно равно 112 мкс, поэтому максимальная частота выборки при использовании функции analogRead не превышает 8.9 кГц.
Недостатком использования analogRead является еще и то, что Arduino не может выполнять другой код во время ожидания результата преобразования.
Используем прерывания АЦП
Так как ATMega2560 не использует ядро процессора при захвате аналоговых сигналов, то это пустая трата возможностей обработки. Особенно, когда нам необходима непрерывная выборка сигнала. Такую выборку можно реализовать несколько более сложным способом, используя прерывания. Так как нет встроенной функции для установки аналогового преобразования с прерываниями, то регистры, связанные с АЦП, должны быть обработаны вручную.
Разовая выборка
Разовая выборка — это на самом деле то, что Arduino делает при вызове функции analogRead . Мы не сможем получить значительных преимуществ, реализовав разовую выборку с помощью других средств. Поскольку перед запуском АЦП, в первую очередь проверяется флаг готовности АЦП, то это означает, что проверка флага в цикле ничем не отличается от того, что делает Arduino.
Непрерывная выборка
Хорошей идеей при непрерывной выборке сигнала является использование прерываний. Микроконтроллеры ATMega328 и ATMega2560 могут быть переведены в режим непрерывной выборки (free running mode ). В этом режиме АЦП запускается автоматически после завершения предыдущей обработки. Каждый раз преобразование заканчивается генерированием прерывания, которое вызывает функцию обработки прерывания ISR (ADC_vect) , в которой результат аналого-цифрового преобразования может быть считан и обработан.
Для включения режима непрерывной выборки необходимо установить три регистра: ADMUX , ADCSRA и ADCSRB . Детальное описание этих регистров можно найти в технических руководствах к микроконтроллерам.
Внутреннее опорное напряжение 1.1 В и входной аналоговый канал ADC3 выбираются при помощи ADMUX . Тактовая частота задается при помощи ADCSRA и в нашем примере установлена в виде делителя ÷16. Одно аналоговое преобразование занимает 13 тактовых периодов. Частота дискретизации может быть вычислена, исходя из тактовой частоты микроконтроллера: 16 Мгц/(16*13) ≈ 77 кГц. Установкой 6 бита регистра ADCSRA в состояние HIGH , запускается непрерывная выборка.
Результат аналого-цифрового преобразования считывается в функцию обработки прерывания ISR (ADC_vect) . Поскольку, результат имеет длину 10 бит, то он делится на два регистра ADCL и ADCH , размером в один байт каждый. Для корректного чтения значения сначала нужно считать значение регистра ADCL , а затем — регистра ADCH .
Пример скетча, в котором результат, полученный из АЦП копируется в целочисленную переменную analogValue:
int analogValue = 0; // значение аналогового сигнала void setup() { DDRB = B01000000; // pin 12 в режиме OUTPUT DIDR0 = 0x3F; // отключаем цифровые входы ADMUX = 0x43; // измеряем на ADC3, используем внутреннее опорное напр.= 1.1В ADCSRA = 0xAC; // включаем АЦП, разрешаем прерывания, делитель = 16 ADCSRB = 0x40; // включаем АЦ коналы MUX, режим скользящей выборки bitWrite(ADCSRA, 6, 1); sei(); // устанавливаем флаг прерывания } void loop() { } /*** Процедура обработки прерывания АЦП ***/ ISR(ADC_vect) { PORTB = B00000000; // пин 12 переводим в состояние LOW analogValue = ADCL; // сохраняем младший байт результата АЦП analogValue += ADCH << 8; // сохраняем старший байт АЦП PORTB = B01000000; // пин 12 переводим в состояние HIGH }
int analogValue = 0 ; // значение аналогового сигнала void setup () DDRB = B01000000 ; // pin 12 в режиме OUTPUT DIDR0 = 0x3F ; // отключаем цифровые входы ADMUX = 0x43 ; // измеряем на ADC3, используем внутреннее опорное напр.= 1.1В ADCSRA = 0xAC ; // включаем АЦП, разрешаем прерывания, делитель = 16 ADCSRB = 0x40 ; // включаем АЦ коналы MUX, режим скользящей выборки bitWrite (ADCSRA , 6 , 1 ) ; // Запускаем преобразование установкой бита 6 (=ADSC) в ADCSRA sei () ; // устанавливаем флаг прерывания void loop () /*** Процедура обработки прерывания АЦП ***/ ISR (ADC_vect ) PORTB = B00000000 ; // пин 12 переводим в состояние LOW analogValue = ADCL ; // сохраняем младший байт результата АЦП analogValue + = ADCH << 8 ; // сохраняем старший байт АЦП PORTB = B01000000 ; // пин 12 переводим в состояние HIGH |
Результат работы программы на экране осциллографа:
Для измерения времени выполнения мы переводим состояние пина в LOW , затем считываем АЦП, после чего вновь устанавливаем высокий уровень. На вызов обработчика прерывания требуется время, с этим и связана достаточно большая продолжительность положительной части периода.
Цикл loop теперь полностью свободен и может использоваться для обработки какого-либо кода.
Опорное напряжение
Для измерения аналогового сигнала у нас должен быть некоторый уровень напряжения, с которым мы будем производить сравнение. В микроконтроллерах ATMega328 и ATMega2560 , которые используются в Arduino опорное напряжение также является максимальным напряжением, которое может быть измерено. Напряжения всегда измеряются относительно земли. В Arduino есть три возможных источника опорного напряжения: AV cc — которое соединяется с цифровой линией питания 5 В, внутреннее напряжение 1.1 В (для Arduino Mega возможен еще вариант 2.56 В) и внешний источник опорного напряжения. Из-за того, что измерение входных напряжений производятся относительно опорного напряжения, флуктуации опорного напряжение оказывают влияние на результат.
Опорное напряжение можно установить, используя функцию или при помощи битов REFT в регистре ADMUX .
Опорное напряжение AV cc
AV cc является опорным напряжением по умолчанию и оно используется когда измеряемые напряжения напрямую зависят от напряжения источника питания. Например, в случае, где нужно измерить напряжение в резисторном полумосте, как показано на рисунке ниже.
Использование опорного напряжения 5В при измерении сопротивления в полумосте
Если по каким-то причинам напряжение источника питания упадет, то и напряжение в точке соединения двух резисторов упадет пропорционально. Из-за того, что теперь опорное и входное напряжение изменяются пропорционально, то и результат АЦП останется таким же.
Внутренне опорное напряжение 1.1 В
Используйте внутреннее опорное напряжение 1.1 В для точных измерений внешних напряжений. Опорное напряжение 1.1 В более стабильно и не зависит от изменения напряжения питания или температуры. Таким образом, можно производить измерения абсолютных значений. В Arduino Mega также возможен вариант опорного напряжения 2.56 В. примере на рисунке ниже используется опорное напряжение 1.1 В и делитель напряжения 10:1 для измерения внешнего напряжения в диапазоне от 0 до 11 В.
Использование внешнего опорного напряжения или внутреннего напряжения 1.1 В при измерении внешних напряжений
Погрешность
В соответствии с техническим руководством для микроконтроллеров ATMega328 и ATMega2560 опорное напряжение составляет 1.1 ± 0.1 В. Это достаточно большой допуск. Измеренное опорное напряжение тестируемой Arduino Mega 2560 было 1.089 В при температуре окружающего воздуха 21 °С и температура корпуса микроконтроллера была 29 ºC.
Я охладил корпус микроконтроллера, не проводящим ток охлаждающим спреем Kontakt Chemie FREEZE 75/200 до температуры -18 °С, при этом измеренное опорное напряжение снизилось до 1.084 В. Таким образом, температурный дрейф составил примерно 100 ppm (миллионных долей) / °C.
Тестовый скетч:
int analogPin = 3; // входной аналоговый пин void setup() { analogReference(INTERNAL1V1); // выбираем внутреннее опорное напряжение 1.1В Serial.begin(9600); } void loop() { int analogValue = analogRead(analogPin); // читаем значение на аналоговом входе Serial.println(analogValue); // выводим его в последовательный порт delay(300); }
int analogPin = 3 ; // входной аналоговый пин void setup () // выбираем внутреннее опорное напряжение 1.1В Serial . begin (9600 ) ; void loop () // читаем значение на аналоговом входе Serial . println (analogValue ) ; // выводим его в последовательный порт delay (300 ) ; |
Аналоговый пин 3 был подключен к источнику напряжения 0.545 В. При температуре 29 °C результат должен быть: (0.545/1.089)*1024 = 512 (реально полученное значение — 511). При температуре -18 °C должно быть (0.545/1.084) * 1024 = 515 (реально полученное значение тоже 515).
Как показал эксперимент, температурный дрейф небольшой и для точных измерений при использовании Arduino его нужно откалибровать из-за его большой общей неопределенности опорного напряжения, составляющей около 10%.
Шум
Одним из способов измерить уровень шума является определение разброса значений, получаемых с АЦП. Для этого подадим стабилизированное постоянное напряжение на один из аналоговых входов и преобразованные при помощи АЦП значения используем для построения гистограммы.
Тестовая цепь
Схема на рисунке ниже обеспечивает тестовое напряжение для Arduino .
Схема, подающая регулируемое постоянное напряжение на аналоговый вход Arduino
Стабилизированный регулируемый источник питания выдает напряжение 0.55 В, что составляет половину от опорного напряжения в 1.1 В. На фотографии ниже видно, что встроенный в мой регулируемый источник питания вольтметр явно привирает, показывая напряжение на выходе 0.4 В.
Сигнал дополнительно фильтруется при помощи цепочки R1 , C1 , C2 и подключается через резистор R2 , имеющий сопротивление 100 Ом к аналоговому входу A3 Arduino . Земля подключается к пину GND Arduino .
Шумовая составляющая на входе Arduino выглядит следующим образом:
Отсюда видно, что среднеквадратическое значение амплитуды переменной составляющей измеряемого напряжения на входе АЦП Arduino составляет лишь единицы милливольт.
Биннинг
АЦП микроконтроллеров ATMega328 и ATMega2560 имеет разрешение 2 10 = 1024 бита. Идея биннинга состоит в подсчете частоты наблюдения определенного значения. Создается массив со 1024 значениями, называемых бинами, которые представляют каждое из возможных значений АЦП. Так как доступная память ограничена, могут быть созданы бины только размером в байт. Число отсчетов, следовательно, ограничивается 255.
Программы
Протестируем шум, используя функцию analogRead , а затем используем прерывания. Две программы, по сути, делают одно и то же: определяют массив, состоящий из 1024 бин. В функции setup все бины инициализируются нулем и выбирается опорное напряжение 1.1 В.
Обе программы производят 10000 фиктивных операций чтения аналогового значения. После этого запускается биннинг и на каждом результате АЦП, соответствующий бин увеличивается на единицу. Если один из 1024 бинов достигнет максимума из 255 значений, выборка останавливается и все 1024 значения бина отправляются на компьютер.
Код примера биннинга измеренных значений, используя функцию analogRead :
Показать/скрыть код
int analogPin = 3; // входной аналоговый пин int sendStatus = 0; // статус передачи int startDelay = 0; byte valueBin; // значения бинов void setup() { analogReference(INTERNAL1V1); // выбираем опорное напряжение 1.1В for (int i=0; i<=1023; i++) valueBin[i] = 0; // очищаем бины Serial.begin(9600); Serial.println("Start"); } void loop() { int analogValue = analogRead(analogPin); // выборка аналогового входа if (sendStatus == 0) { // ничего не делаем первые 10000 выборок if (startDelay < 10000) startDelay++; else { valueBin += 1; // увеличиваем значение бина if (valueBin == 255) sendStatus = 1; } } if (sendStatus == 1) { for (int i=0; i<=1023; i++) { // выводим значение бина Serial.print(i); Serial.print("\t"); Serial.println(valueBin[i]); } Serial.println("Done"); sendStatus = 2; } }
int analogPin = 3 ; // входной аналоговый пин int sendStatus = 0 ; // статус передачи int startDelay = 0 ; byte valueBin [ 1024 ] ; // значения бинов void setup () analogReference (INTERNAL1V1 ) ; // выбираем опорное напряжение 1.1В for (int i = 0 ; i <= 1023 ; i ++ ) valueBin [ i ] = 0 ; // очищаем бины Serial . begin (9600 ) ; void loop () int analogValue = analogRead (analogPin ) ; // выборка аналогового входа if (sendStatus == 0 ) // ничего не делаем первые 10000 выборок if (startDelay < 10000 ) startDelay ++ ; else valueBin [ analogValue ] + = 1 ; // увеличиваем значение бина // останавливаемся, если бин полон if (valueBin [ analogValue ] == 255 ) sendStatus = 1 ; if (sendStatus == 1 ) for (int i = 0 ; i <= 1023 ; i ++ ) // выводим значение бина Serial . print (i ) ; Serial . print ("\t" ) ; Serial . println (valueBin [ i ] ) ; Serial . println ("Done" ) ; sendStatus = 2 ; |
Код примера биннинга измеренных значений, используя прерывания:
Показать/скрыть код
int sendStatus = 0; // статус передачи int startDelay = 0; byte valueBin; // значения бинов void setup() { TIMSK0 = 0x00; // отключаем таймер (из-за прерываний) DIDR0 = 0x3F; // отключаем цифровые входы ADMUX = 0xC3; // измеряем на ADC3, без корректировки, внутр.опорное напр. 1.1В ADCSRA = 0xAC; // включаем АЦП, разрешаем прерывания, делитель = 128 ADCSRB = 0x40; // Включаем каналы MUX АЦП, режим постоянной выборки bitWrite(ADCSRA, 6, 1); // Запускаем преобразование установкой бита 6 (=ADSC) в ADCSRA sei(); // устанавливаем глобальный флаг прерываний for (int i=0; i<=1023; i++) valueBin[i] = 0; // очищаем бины Serial.begin(9600); Serial.println("Start"); } void loop() { if (sendStatus == 1) { for (int i=0; i<=1023; i++) { // выводим значения бинов Serial.print(i); Serial.print("\t"); Serial.println(valueBin[i]); } Serial.println("Done"); sendStatus = 2; } } /*** Процедура обработки прерывания АЦП ***/ ISR(ADC_vect) { int analogValue = ADCL; // сохраняем младший байт АЦП analogValue += ADCH << 8; // сохраняем старший байт АЦП if (sendStatus == 0) { // ничего не делаем первые 10000 выборок if (startDelay < 10000) startDelay++; else { valueBin += 1; // увеличиваем значение бина if (valueBin == 255) sendStatus = 1; { // останавливаемся, если бин полон } } }
int sendStatus = 0 ; // статус передачи int startDelay = 0 ; byte valueBin [ 1024 ] ; // значения бинов void setup () TIMSK0 = 0x00 ; // отключаем таймер (из-за прерываний) DIDR0 = 0x3F ; // отключаем цифровые входы ADMUX = 0xC3 ; // измеряем на ADC3, без корректировки, внутр.опорное напр. 1.1В ADCSRA = 0xAC ; // включаем АЦП, разрешаем прерывания, делитель = 128 ADCSRB = 0x40 ; // Включаем каналы MUX АЦП, режим постоянной выборки bitWrite (ADCSRA , 6 , 1 ) ; // Запускаем преобразование установкой бита 6 (=ADSC) в ADCSRA sei () ; // устанавливаем глобальный флаг прерываний for (int i = 0 ; i <= 1023 ; i ++ ) valueBin [ i ] = 0 ; // очищаем бины Serial . begin (9600 ) ; Serial . println ("Start" ) ; void loop () if (sendStatus == 1 ) for (int i = 0 ; i <= 1023 ; i ++ ) { // выводим значения бинов Serial . print (i ) ; Serial . print ("\t" ) ; Serial . println (valueBin [ i ] ) ; } Serial . println ("Done" ) ; sendStatus = 2 ; // останавливаемся, если бин полон} } } |
Тестируемые частоты
Тест проводился с использованием функции analogRead и используя режим непрерывной выборки. Так как в последнем случае частоту выборки можно изменять, то тестировались четыре различные частоты выборки, задаваемые путем изменения значения в строке ADCSRA = 0xAC . Тестируемые частоты: 9.6 кГц (тактовая частота clk ÷128), 19.2 кГц (clk ÷64), 38.4 кГц (clk ÷32) и 76.9 кГц (clk ÷16). Частота выборки при использовании функции analogRead , как мы выяснили выше примерно равна 8.9 кГц.
Результаты
Результаты для обоих способов и различных частот выборки оказались похожими. Выборки разделились на 2 бина и лишь некоторые выборочные значения попали в третий бин. Это значит, что уровень шума во всех случаях достаточно низкий.
Переключение между входами
Выбор аналогового входа осуществляется в строке analogPin =n где n является номером аналогового пина или изменением битов выбора аналогового канала MUX в регистре ADMUX . Особое внимание должно быть уделено при использовании режима непрерывной выборки: аналоговый канал нужно выбрать перед стартом нового аналогового преобразования. В процедуре обработки прерывания выбирается аналоговый вход, который будет считываться в момент следующего прерывания.
Чтобы проверить уровень шума и погрешность при переключении входов, нужно немного изменить представленные выше программы. Второе напряжение подается на аналоговый вход 5. Кроме того, производится биннинг измеренных значений как и при тестировании шума.
= 0xC3 ;int analogValue = ADCL ;
. . .
Результаты
Оба измеренных напряжения видны как два выступа на гистограммах. На рисунке ниже представлены гистограммы пяти тестов: с использованием функции analogRead , непрерывная выборка с clk ÷128, clk ÷64, clk ÷32 и clk ÷16. Измеренные значения первого напряжения (результат обработки АЦП = 511) не отклоняются от предыдущего теста шума. Измерение по-прежнему точное. Окружающих бинов очень мало, это означает, что уровень шума не увеличился.
На каждой из пяти гистограмм показаны две области с выступами, представляющие два измеренных напряжения
Частота выборки и разрешение
Коды, реализующие биннинг использованы и для анализа разрешения и частоты выборки. Для этого теста к аналоговому входу Arduino был подключен генератор функций, как показано на рисунке ниже.
Генератор функций подает с напряжением размаха в 25 мВ и напряжением смещения (= среднему значению) в 0.55 В. На каждом измерении частота сигнала выбирается таким образом, чтобы частота выборки была в 163 раза выше.
Треугольный сигнал выбран из-за того, что каждое значение при квантовании встречается одинаково часто. При биннинге такого сигнала каждое значение бина с минимальным и максимальным значениями напряжения может иметь то же самое число повторений.
Результаты
Результаты тестирования показали, что функция analogRead , работающая с низкой частотой дискретизации и непрерывная выборка с частотой clk ÷128 имеют достаточную плоскую вершину: все значения в диапазоне встречаются с одним и тем же числом повторений. Но на более высоких частотах дискретизации (clk ÷64, clk ÷32 и clk ÷16) возникают провалы в области биннинга и с ростом частоты ситуация ухудшается.
Большая частота выборки приводит к провалам
В технических описаниях на микроконтроллеры ATmega
На этом занятии рассмотрим, аналоговые порты Arduino A0-A5. Разберем принцип работы аналоговых портов, что к ним можно подключать. Соберем с помощью макетной платы схему светильника с управляемой яркостью, чтобы с помощью потенциометра (переменного резистора) можно было изменять яркость свечения светодиода. Рассмотрим директиву #define и analogRead в языке Ардуино IDE.
Устройство и принцип работы потенциометра
Переменный резистор (потенциометр) поворотом ручки изменяет сопротивление в электрической цепи от нуля до номинального сопротивления в 10 кОм. Потенциометр сделан состоит из токопроводящей поверхности — плоского постоянного резистора с двумя контактами и скользящего по поверхности токосъемника. Потенциометр предназначен для регулировки напряжения в электрической цепи.
Переменный резистор имеет прочную токопроводящую поверхность, поскольку положение настройки потенциометра изменяется постоянно. Переменный резистор служит для регулярного применения, например, для изменения уровня громкости.
Подстроечный резистор служит для точной настройки работы электронных устройств. Положение настройки, как правило, в течении всего срока эксплуатации устройства не изменяется. Поэтому, перемещение скользящего контакта производится с помощью отвертки, а прочность проводящего слоя не имеет большого значения.
Аналоговые входы на Ардуино
Микроконтроллер Atmega в Arduino , содержит шестиканальный аналого-цифровой преобразователь (АЦП). Разрешение преобразователя составляет 10 бит, что позволяет получать значения от 0 до 1023. Основным применением аналоговых входов Ардуино (A0 — A5 в Arduino UNO) является снятие значений с аналоговых датчиков. Рассмотрим применение аналогового входа для снятия показаний с потенциометра.
Небольшая цена деления шкалы позволяет с большой точностью получать значения практически любой физической величины. Чтобы считать показания на аналоговом входе следует использовать функцию analogRead . Аналоговые порты, как цифровые Ардуино можно сделать с помощью команды digitalRead — используется для считывания данных с кнопки и digitalWrite — можно подключить светодиод.
Светильник с управляемой яркостью
На этом занятии мы соберем электрическую схему светильника с управляемой яркостью. С помощью потенциометра мы сможем изменять яркость светодиода, подключенного к пину 9. Потенциометр подключается крайними ножками к портам 5V и GND, со средней ножки снимается значение напряжения на аналоговый вход A0.
Для занятия нам понадобятся следующие детали:
- плата Arduino Uno / Arduino Nano / Arduino Mega;
- макетная плата;
- потенциометр;
- 1 светодиод и резистор 220 Ом;
- провода «папа-папа».
Соберите электрическую цепь, как на рисунке. Средняя ножка переменного резистора подключается к аналоговому порту A0, чтобы снимать показания напряжения. Какую из крайних ножек подключить к портам 5V и GND значения не имеет, изменится лишь направление вращения ручки потенциометра для увеличения яркости светодиода. После сборки схемы, подключите Arduino к компьютеру и загрузите следующий скетч.
Скетч для Ардуино и потенциометра
// Присваиваем имя для пина со светодиодом (англ. «led») #define LED_PIN 9 // Присваиваем имя для пина с потенциометром (англ. «potentiometer») #define POT_PIN A0 void setup () { // пин со светодиодом будет выходом (англ. «output») pinMode (LED_PIN, OUTPUT ); // пин с потенциометром будет входом (англ. «input») pinMode (POT_PIN, INPUT ); // Запускаем монитор последовательного порта // снимите комментарий // Serial.begin(9600); } void loop () { // заявляем, что будем использовать 2 переменные - rotation и brightness // хранить в переменных будем только целые числа (англ. «integer») int rotation, brightness; // rotation равна значениям с потенциометра в интервале от 0 до 1023 rotation = analogRead (POT_PIN); // переменная brightness будет равна rotation делённое на 4 // brightness может быть только целым числом, дробная часть будет отброшена // в итоге переменная brightness будет находится в пределах от 0 до 255 brightness = rotation / 4; // выдаём напряжение, рассчитанное по формуле brightness = rotation / 4 analogWrite (LED_PIN, brightness); // Выдаем значение rotation на монитор последовательного порта // снимите комментарий // Serial.println(rotation); // снимите комментарий // delay(1000); }Пояснения к коду:
Несколько слов в продолжение рассуждений о точности АЦП (см. предыдущую ). На эту тему написан не один десяток хороших книг, поэтому выделим основную проблему: для АЦП Arduino измерение идет относительно так называемого источника эталонного напряжения (который иногда называют ИОН - источник опорного напряжения ).
Выбор этого источника происходит при вызове функции analogReference(type) , где type может принимать одно из трех значений:
- DEFAULT : напряжение питания, около 5 Вольт (по умолчанию, после старта скетча);
- INTERNAL : встроенный ИОН - 1.1 Вольт для ATmega168 и 2.56 Вольт для ATmega8;
- EXTERNAL : напряжение на пине AREF.
Это подводит нас к грустному, но неотвратимому выводу - точность лучше одного вольта при использовании DEFAULT нам заказана . Может быть, нам поможет INTERNAL?
Тут нас будет ждать второе разочарование - дело в том, что внутренний источник опорного напряжения ATmega требует предварительной калибровки . Надо взять эталонный источник напряжения, подать его на аналоговый пин и сравнить с внутренним, получив таким образом поправку, компенсирующую т.н. систематическую погрешность. Полученное значение надо сохранить в EEPROM микроконтроллера, поскольку оно индивидуально для каждого конкретного чипа, а в скетче считывать после старта. Немного занудно, но ничего сложного. Но, быть может, есть более простой путь?
Надо каким-то образом подать внешнее опорное напряжение на наш АЦП, да поточнее (это вариант EXTERNAL). В этом нам могут помочь:
Этот прием я использовал в схеме SMPReaderUSB , для измерения напряжения внутренней литиевой батареи модуля МПО-10. Резистор R9 22К выбран с таким расчетом, чтобы через LM385 протекал небольшой ток, как и положено по его документации. Измеряемый вход BATT притянут через R10 22K к земле на тот случай, если модуль не подключен и вход ADC0 повис в воздухе.
Далее, происходит считывание с двух аналоговых пинов - к одному подключен измеряемый источник напряжения BATT (ADCm), к другому - LM385 (ADC385). Оба значения передаются в хост-программу на PC, которая вычисляет пропорцию:
Um = ADCm * 1,235 / ADC385
Значение опорного напряжения в этой формуле не участвует, и хотя зависимость по-прежнему есть, выведя это значение из формулы мы понизили его влияние на пару порядков (речь про ошибку квантования). Такой способ позволяет улучшить точность до 0,03 В, что - согласитесь - для Arduino весьма неплохо!