Как преобразовать аналоговый сигнал в битовой arduino. Arduino. Работа с АЦП. Подключение переменного резистора. Более точная работа аналогового входа
Система Arduino поддерживает обработку аналоговых сигналов. Для входных сигналов мы имеем АЦП (аналогово-цифровой преобразователь), в случае выходного сигнал — возможна модуляция ШИМ (широтно-импульсная модуляция).
В Arduino, сердцем которой является микроконтроллер Atmega, имеется один 10-битный АЦП. Это означает, что считанное значение напряжения может находиться в диапазоне от 0 — 1023. В зависимости от опорного напряжения 1024 значений будут распределены на соответствующий диапазон. В результате мы можем получить различную точность и различный диапазон напряжений, считываемых аналого-цифровым преобразователем.
Если выбрать опорное напряжение равное 1,024В, то каждое последующее значение, считанное с аналогового входа будет соответствовать 1мВ. Если опорное напряжение задать равным 5В, то каждое последующее значение будет соответствовать приблизительно 5 мВ.
Следует отметить, что аналого-цифровые преобразователи не имеют идеальной линейной характеристики. Это означает, что в определенных интервалах может быть разница между фактическим и считанным значением напряжения. Из вышеизложенного вытекает, что увеличивая диапазон измерения, мы теряем на качестве измерения, уменьшая диапазон, мы увеличиваем точность измерения.
Примечание: Arduino имеет несколько (в зависимости от версии) аналоговых входов, однако АЦП в ней только один. Это означает, что одновременно может быть считано значение только с одного из датчиков, подключенных к аналоговым входам A0… A5 (A0… A15 для Arduino MEGA).
Функция analogReference()
Для правильной работы АЦП требуется опорное напряжение (эталон). Для Arduino опорное напряжение может быть в диапазоне 0…5В (или 0… 3,3В для Arduino с напряжением питания 3,3В). В зависимости от типа используемого микроконтроллера у нас могут быть разные виды опорного напряжения.
Мы можем использовать внутренний или внешний источник опорного напряжения. Функция AnalogReference() предназначена для того, чтобы установить соответствующий источник опорного напряжения. Доступны следующие параметры этой функции:
- DEFAULT: опорное напряжение составляет 5В или 3,3В (в зависимости от питания) — то есть, оно равно напряжению питания микроконтроллера;
- INTERNAL: опорное напряжения составляет 1,1В для ATmega168, ATmega328 и 2,56В для ATmega8;
- INTERNAL1V1: опорное напряжение составляет 1,1В — только для Arduino MEGA;
- INTERNAL2V56: опорное напряжение составляет 2,56В — только для Arduino MEGA;
- EXTERNAL: внешнее опорное напряжение, приложенное к выводу AREF — от 0 до 5В.
Параметр DEFAULT выбираем, когда хотим воспользоваться опорным напряжением 5В (питание системы). Это самый простой и одновременно наименее точный способ. Здесь требуется хорошая стабильность питания.
Использование INTERNAL является хорошим вариантом, в ситуации, когда мы создаем проект, предназначенный для конкретной версии Arduino. Внутренние опорное напряжение является относительно стабильным и достаточным в большинстве случаев.
Наиболее точным вариантом является использование внешнего источника опорного напряжения. Существуют специальные источники опорного напряжения (ИОН). Плюсом является возможность получения необходимого точного опорного напряжения, например, 1,024В или 2,048В, что облегчает интерпретацию данных, считываемых АЦП. К недостаткам применения внешнего источника опорного напряжения можно отнести возможное увеличение стоимости проекта.
Синтаксис функции analogReference() показан в следующем примере:
AnalogReference(DEFAULT); //опорное напряжение = напряжение питания analogReference(INTERNAL); //опорное напряжение = 1,1В или 2,56В analogReference(EXTERNAL); //опорное напряжение = напряжение на AREF выводе
Функция analogRead()
Функция analogRead() обеспечивает считывание значения с одного из аналоговых входов. Считанное значение находится в диапазоне 0 — 1023 (10-битный АЦП). Необходимо указать номер аналогового входа, с которого будет происходить чтение данных.
Следующий пример иллюстрирует использование аналоговых входов:
#define analogPin 0 // потенциометр подключен к A0 int val = 0; // val — переменная, хранящая считанное значение void setup() { Serial.begin(9600); // инициализация последовательного порта } void loop() { val = analogRead(analogPin); // чтение значения напряжения с порта A0 Serial.println(val); // отправка измеренной величины на терминал }
Как видно, на приведенном выше примере, считанное значение напряжения передается через последовательный порт на компьютер.
В примере не использована функция analogReference(), так как по умолчанию система использует опорное напряжение от источника питания. Однако, лучше указывать в функции setup() явный выбор опорного напряжения (в нашем случае это analogReference(DEFAULT)), так как это облегчает понимание кода и его модификацию в будущем.
Функция analogWrite()
Функция analogWrite() позволяет управлять выходом с помощью сигнала ШИМ. ШИМ часто используется в качестве замены обычного аналогового сигнала. Количество доступных выводов ШИМ зависит от типа используемого микроконтроллера в Arduino.
Так у Arduino на микроконтроллере:
- Atmega8 — выводы 9, 10, 11;
- Atmega128, Atmega168 и Atmega328 — выводы 3, 5, 6, 9, 10, 11;
- Atmega1280 — выводы 2…13 и 44…46.
Частота переключения ШИМ большинства контактов составляет 490 Гц. Степень заполнения формируется числом от 0 до 255 (0 — без заполнения, 255 – полное заполнение).
Если мы подключим светодиод к контакту PWM и будем менять заполнение ШИМ, мы увидим изменение интенсивности свечения светодиода. Ниже приведен пример программы изменения свечения светодиода при помощи потенциометра:
#define ledPin 11 // светодиод подключен к контакту 9 #define analogPin 0 // потенциометр на А0 int val = 0; // val — переменная, хранящая значение A0 void setup() { pinMode(ledPin, OUTPUT); // устанавливаем контакт 9 как выход } void loop() { val = analogRead(analogPin); // чтение с потенциометра analogWrite(ledPin, val / 4); // пишем в ШИМ }
Как вы можете видеть, значение, считанное с аналогового входа, преобразуется в соответствующее значение ШИМ.
Чтобы ШИМ работал пропорционально вращению потенциометра, значение, полученное с A0, следует разделить на четыре. Это связано с тем, что данные с потенциометра лежат в диапазоне от 0 до 1024, а ШИМ принимает диапазон данных от 0 до 255.
В этом примере используется простое деление. В Arduino IDE имеется специальная функция map(), которая предназначена для пропорционального преобразования данных в новый диапазон значений.
Цель работы: Рассмотрение особенностей ввода и отображения широкополосных сигналов.
Задача работы: Построение канала ввода, обработки и отображения сигналов на максимальной частоте преобразования АЦП контроллера Arduino.
Приборы и принадлежности: Контроллер Arduino UNO, пакет Simulink МатЛАБ (R2012).
ВВЕДЕНИЕ
Разработка программных средств для наблюдения, анализа и обработки сигналов на уровне контроллеров требует значительных временных затрат. Подключение контроллера к специализированной среде высокого уровня (Рис. 1) позволяет значительно сократить время проектирования алгоритма для контроллера с учетом ограничений его ресурсов.Хорошим примером мощной специализированной среды для работы с сигналами является МатЛАБ. Для анализа сигналов зачастую требуется наблюдать его спектр в максимально широкой полосе частот. Для этого контроллер должен принимать сигналы на максимальной частоте преобразования АЦП.
Построение рабочего канала «Arduino UNO – МатЛАБ» для наблюдения и обработки сигналов в реальном времени на предельной частоте преобразования АЦП подробно излагается в этой работе. Особенностью этого канала является то, что такты реального времени задаются не МатЛАБ, а контроллером Arduino. Такое построение не требует компиляции Simulink модели с библиотекой реального времени (rtwin.tlc), что позволяет использовать в модели практически любые блоки библиотеки Simulink.
Рис. 1. Сравнение средств разработки алгоритмов. Для проектирование алгоритмов на уровне специализированной среды необходим канал передачи данных между контроллером и средой проектирования.
ОБЩИЕ СВЕДЕНИЯ
Средства накопления, анализа, обработки и отображения сигналовВ этой работе используется среда Simulink для приёма и отображения данных контроллера Arduino.
Simulink – это интерактивная среда и язык программирования для имитационного моделирования, позволяющая при помощи блок-диаграмм строить динамические модели процессов. Simulink интегрирована в среду MatLAB. Интеграция позволяет использовать уже готовые библиотеки блоков, встроенные математические алгоритмы, мощные средства обработки и графического отображения данных для решения всего спектра задач от разработки концепции модели до тестирования, проверки, генерации кода и аппаратной реализации.
Состав пакетов расширения библиотеки Simulink на примере пакета цифровой обработки сигнала “DSP System Toolbox” показан на Рис. 2.
Рис. 2. Пример дополнительного пакета расширения Simulink для моделирования систем обработки сигналов: DSP System Toolbox . В пакете используются новейшие алгоритмы спектрального анализа. Выделено содержимое раздела Power Spectrum Estimation - блоки для спектральной оценки сигнала.
Потоковая передача данных
Использование двух буферов для накопления и передачи данных позволяет организовать без разрывов сбор, обработку и визуализацию данных (для избежания потери данных скорость последующего процесса должна быть не ниже скорости предыдущего процесса).
Примером применения такой организации может быть модуль E14-440 для многоканального ввода, вывода и обработки аналоговой и цифровой информации, подключаемый к компьютеру через шину USB.
Входные данные сначала заносятся в первую половинку FIFO буфера АЦП. После ее заполнения данные начинают передаваться в PC, в тоже время не прекращается сбор данных во вторую половинку FIFO буфера. После накопления данных во второй половинке FIFO буфера опять начинается передача данных в PC и параллельно продолжается сбор данных уже в первую половинку.
ПОСТРОЕНИЕ ОСЦИЛЛОГРАФА НА БАЗЕ КОНТРОЛЛЕРА ARDUINO
Максимальная скорость накопления данных АЦПИспользуя вывод результата на монитор редактора Arduino на максимальной частоте (57600 бит/с) напишем программу подсчета преобразований АЦП за фиксированный период.
Программа измерения скорости преобразования АЦП:
Void setup() {
Serial.begin (57600); // 9600, 19200, 38400, 57600 and 115200 bit/s
}
Void loop(){
time_start = millis();
for (int i = 0; i < 1024; i++) {
}
time_end = millis();
Serial.println(period);
Рис. 3. Время (в мсек) 1024 и 512 преобразований АЦП. Среднее время преобразования АЦП: 0.1123 мсек (как 115/1024).
Время масштабирования данных АЦП
Для перевода 10 разрядных данных АЦП в 8 разрядные используется функция
map(val, 0, 1023, 0, 255);
где val – int переменная c 10 значимыми разрядами.
Программа измерения времени преобразования АЦП с масштабированием и записи в массив:
Const int adc_5 = A5; // ADC port number
unsigned long time_start; // Start of capturing, ms
unsigned long time_end; // End of capturing, ms
Void setup() {
}
Void loop(){
time_start = millis();
for (int i = 0; i < 1024; i++) {
int val = analogRead(adc_5);
}
time_end = millis();
int period = time_end - time_start;
Serial.println(period);
}
Рис. 4. Время (в мсек) 1024 преобразований АЦП, перевода 10 р. данных в 8 разрядные и запись в массив. Период АЦП преобразования с масштабированием: 0.1611 мсек (как 165/1024).
Поскольку время преобразования АЦП 0.13 мсек, то один перевод 10 разрядных данных в байтовый формат (масштабирование) составляет 0.0424 мсек.
Скорость канала последовательной передачи данных
Для определения скорости побайтовой передачи в последовательный канал в цикле передается код символа Serial.write(1) который не отображается на мониторе.
Основной блок программы определения скорости передачи:
Void loop(){ //Do stuff here
Serial.write(1);
rate = rate + 1;
if (time > set_time) {
set_time = set_time + 30; // 30 ms RT clock
Serial.println(rate);
rate = 0;
}
}
Рис. 5. Тестовые данные: количество переданных байт в последовательный канал за 30 мсек на скорости 57600 бит/сек.
Тест показал, что передача 173 байт занимает 30 мсек, с другой стороны за 30 мсек на скорости 57600 бит/с можно передать 1728 бит. Следовательно, на передачу одного байта расходуется время передачи 10 бит. Используя это отношение для режима передачи
Data bits: 8
Parity: none
Stop bits: 1
Flow control: none
можно подсчитать время потоковой передачи массива данных на разных скоростях.
Передача, например, 256 байт на скорости 9600 бод (бит/c) занимает 267 мсек, на скорости 57600 бод – 44 мсек; и на скорости 115200 бод – 22 мсек (как 256*10/115200).
Размер массива для накопления и передачи данных
Размер оперативной (SRAM) памяти Arduino UNO составляет 2 Кбайт. Тестирование программы циклического считывания АЦП, масштабирования 10 разрядных данных до 8 разрядных, тактирования и побайтной передачи данных показало, что максимальный размер массива для накопления и отправки данных не должен превышать 1800 байт.
Более сложные программы могут потребовать и большей дополнительной памяти SRAM. Поэтому массив для накопления и передачи данных АЦП ограничен 1024 байтами или 512 словами.
Рис. 6. Кусок провода, подсоединенный к аналоговому входу А5 контроллера Arduino для усиления наблюдаемой наводки сети 50 Гц.
Таблица 1
. Времена операций программы с учетом нестабильности циклов 
Пример настройки канала отображения 256 масштабированных значений АЦП при максимальной скорости накопления и передачи данных.
Код программы контроллера Arduino:
const int adc_5 = A5; // ADC port number
byte adc_bytes; // Buffer for scaled ADC data
Void setup() {
}
Void loop(){
// ADC data capturing
for (int i = 0; i < 256; i++) {
int val = analogRead(adc_5);
adc_bytes[i] = map(val, 0, 1023, 0, 255);
}
for (int i = 0; i < 256; i++) {
Serial.write(adc_bytes[i]);
}
If (time > set_time) {
set_time = set_time + 70; // RT clock is 70 ms
}
}
Рис. 7. Определение номера порта а среде Arduino.
Рис. 8. Simulink модель для приёма АЦП данных контроллера, масштабирования вектора данных по времени, отображения данных в реальном времени и сохранения потока данных в памяти workspace.
Рис. 9. Параметры COM порта в среде Simulink (блок модели: Serial Configuration)
Рис. 10. Параметры блоков Simulink модели и режима моделирования.
Модель запускается нажатием на кнопку Start simulation:
Рис. 11. Кнопка запуска модели.
Рис. 12. Вид сетевой наводки (подключение показано на Рис. 6) с наложением кадров (левое окно) и в отдельном кадре (правое окно). Причина смещения сигнала при наложении кадров – отсутствие синхронизации отображения. Примечание: Simulink имеет достаточно средств для построения канала синхронизации.
ПРИМЕРЫ ПОЛУЧЕНИЯ ПРОВЕРЕННЫХ РЕЗУЛЬТАТОВ И ВАРИАНТЫ ДЛЯ САМОКОНТРОЛЯ
Задание 1 . Накопление, передача и отображение отмасштабированных данных (см. пример и таблицу времён на стр. 8).1. Напишите для контроллера Arduino UNO программу циклического считывания показаний АЦП, масштабирования, записи данных в массив 1024 байт и передачи массива в последовательный канал. Программа должна выполняться с максимальной скоростью. Символ A – заголовок передаваемого массива.
Пример программы:
Const int adc_5 = A5; // ADC port number
unsigned long set_time; // Time of next clock
byte adc_bytes; // Buffer for ADC data
Void setup() {
Serial.begin (115200); // bit/s
}
Void loop(){
unsigned long time = millis(); // Current time in ms
// ADC data capturing
for (int i = 0; i < 1024; i++) {
int val = analogRead(adc_5);
adc_bytes[i] = map(val, 0, 1023, 0, 255);
}
// send ADC data into serial port
Serial.print(«A»); // «A» is header
for (int i = 0; i < 1024; i++) {
Serial.write(adc_bytes[i]);
}
If (time > set_time) {
set_time = set_time + 270; // RT clock is 270 ms
}
}
2. В среде МатЛАБ составьте программу из Simulink блоков для приема и отображения данных контроллера в реальном времени. Скорость, размер пакета, период принимаемых данных и такт работы модели должны соответствовать соответствующим параметрам контроллера. Отмасштабируйте время отображаемых данных.
Рис. 13. Simulink модель для приема данных на максимальной частоте: 115200 бод. Объединение векторов (Vector Concatenate) используется для масштабирования сигнала по шкале времени кадра (frame).
3. Проверьте качество канала «Вход АЦП – дисплей МатЛАБ», например по периоду сетевой 50 Гц наводки на входе АЦП. Для увеличения амплитуды наводки ко входу АЦП подсоедините кусок провода (см. Рис. 6). Амплитуда наводки зависит от расстояния между проводом и вашей рукой.
Рис. 14. Наложение 4 кадров при сканировании частоты 50Гц на входе АЦП контроллера Arduino.
Рис. 15. Частота сети на входе АЦП контроллера, 4 кадр.
Задание 2
. Накопление, передача и отображение 10 разрядных данных АЦП.
1. Для контроллера Arduino UNO напишите программу циклического считывания показаний АЦП, записи данных в массив 512 слов и побайтной передачи данных массива в последовательный канал. Программа должна выполняться с максимальной скоростью.
Пример программы:
Const int adc_5 = A5; // ADC port number
unsigned long set_time; // Time of next clock in ms
word adc_int; // Buffer for ADC data
int val;
byte val_Lo, val_Hi;
Void setup() {
Serial.begin (115200); // bit/s
}
Void loop(){
unsigned long time = millis();
// ADC data capturing
for (int i = 0; i < 512; i++) {
adc_int[i] = analogRead(adc_5);
}
// send ADC data into serial port
// first low bytes then high bytes
Serial.print(«A»); // «A» is header
for (int i = 0; i < 512; i++) {
val = adc_int[i];
val_Lo = (val << 1) & 0xFE;
Serial.write(val_Lo); // Lo byte
}
for (int i = 0; i < 512; i++) {
val = adc_int[i];
val_Hi = (val >> 6) & 0xE;
Serial.write(val_Hi); // Hi byte
}
If (time > set_time) {
set_time = set_time + 160; // RT clock is 160 ms
}
}
2. Составьте программу Simulink для приема восстановления и отображения АЦП данных контроллера. Скорость, размер пакета и период принимаемых данных должны соответствовать соответствующим параметрам контроллера. Отмасштабируйте время отображаемых данных.
Рис. 16. Программа Simulink для приёма, восстановления и отображения массива данных АЦП контроллера Arduino UNO.
3. Запишите сетевые 50 Гц наводки.
Рис. 17. Наложение 15 кадров при сканировании сетевой наводки 50Гц на входе АЦП контроллера. Период программы: 160 мсек. Время заполнения массива данными АЦП: 58 мсек. Время передачи 512х2 байт на частоте 115200 бод: 89 мсек.
Рис. 18. Последний 15 кадр. Время 3.5 циклов 50 Гц сигнала: 70 мсек.
Задание 3
. Обработка сигнала m-программой МатЛАБ
1. Сохраните отображаемые в реальном времени данные в workspace памяти МатЛАБ, например, при помощи блока simout (см. Рис. 13).
2. Скопируйте сохраненные данные в рабочий каталог, например:
save("simout_50Hz","simout");
3. Разработайте m-программу МатЛАБ для отображения архивного АЦП сигнала контроллера.
Пример кода:
Clear all
load("simout_50Hz");
size_frame = size(simout.Data,1);
sampling = d_frame/(size_frame + 163*4); % dt
data_size = size(simout.Data,1)*size(simout.Data,2)*size(simout.Data,3);
% time = (0:data_size-1)*sampling;
time = ;
for i = 1:length(simout.Time)
time = ;
end
Adc = uint8();
for i = 1:size(simout.Data,3)
adc = ;
end
% frame_num = length(simout.Time) % or size(adc,3) % is 54 frame
If 1 %
figure
plot(time, adc, "b")
grid on
xlabel("Time, s");
end
Рис. 19. Покадровое изменение 50 Гц наводки на входе АЦП контроллера Arduino UNO: 24 кадра по 0.27 сек.
4. Разработайте m-программу для вычисления параметров сигнала, например, периода в заданном кадре.
Пример кода:
Clear all
load("simout_50Hz");
D_frame = simout.Time(2)-simout.Time(1);
sampling = d_frame/((256 + 176)*4); % dt
data_size = size(simout.Data,1)*size(simout.Data,2)*size(simout.Data,3); % <256 x 1 x 54>
%FRAME number
i = 5;
time = (0:1023)*sampling+simout.Time(i);
adc = simout.Data(:,:,i)";
if 1 %
figure
plot(time, adc, "b")
grid on
xlabel("Time, s");
ylabel("ADC , bit");
title("8 bit ADC frame against Time");
end
% period
comp_level = 60;
j = 1;
for i = 2:length(adc)
if (adc(i) >= comp_level) && (adc(i-1) < comp_level)
cell_num(j) = i;
j = j + 1;
end
end
s_period = diff(time(cell_num));
Рис. 20. Непрерывное и поточечное изменение сигнала в выбранном кадре. Время 5 кадра: 1.08… 1.24 сек. Размер вектора: 1024 байт. Следовательно время одного считывания и масштабирования сигнала АЦП: 0.156 мсек.
Рис. 21. Период наводки сети 5 кадра: 19.2… 19.4 мсек.
Задание 4
. Построение спектра сигнала в реальном времени.
1. Для наблюдения частотного спектра сигнала подключите к отображаемому сигналу модели блок быстрого преобразования Фурье (Spectrum Scope: FFT) из раздела библиотеки Simulink > DSP System Toolbox > Sinks.
Рис. 22. Модель со спектроскопом.
Рис. 23. Спектр сетевой наводки. Сигнал кадра включает 1024 амплитуды и 163x4 нулевых значений.
2. Выделите основную гармонику сигнала: 50 Гц. 
Рис. 24. Гармоника сигнала на частоте 50 Гц.
3. Подключите блок Spectrum Scope: FFT к неотмасштабированному (по времени) сигналу.
Рис. 25. Перенос точки подключения спектрографа. На входе неотмасштабированный сигнал с меньшей зоной нулевых значений в конце массива (вектора).
4. Настройте блок. Выберите тип отображаемого спектра: Spectrum Type.
Рис. 26. Параметры спектрометра неотмасштабированного сигнала из 1024 амплитуд.
Задание 5
. Построение канала скоростной потоковой передачи и обработки 8р данных в реальном времени без пропуска данных.
1. Напишите для контроллера Arduino UNO программу циклического считывания показаний АЦП, масштабирования и передачи в последовательный канал 2048 байт с заголовком. Программа должна считывать показания АЦП на постоянной частоте без перерывов.
Пример программы:
const int adc_5 = A5; // ADC port number
Void setup() {
Serial.begin (115200); // bit/s
}
Void loop(){
for (int i = 0; i < 2048; i++) {
if (i == 0) Serial.print(«A „); // “A» is header
int val = analogRead(adc_5);
byte adc_byte = map(val, 0, 1023, 0, 255);
Serial.write(adc_byte);
}
}
2. Настройте модель Simulink (МатЛАБ) на прием данных контроллера. 
Рис. 27. Пример модели для отображения непрерывного потока данных. Кадр содержит 2048 байт.
3. Настройте время моделирования модели (Меню > Simulation > Configuration Parameters > Solver > Fixed-step size) и такт блока Serial Receive > Block Sample Time, (см. Рис. 10) по периоду 50 Гц сети.
Расчетное время кадра по данным Таблица 1: 254 мсек (для 1024 байт) => 508 мсек для 2048 байт, В действительности, время кадра программы (в которой считывание АЦП и передача выполняются поочередно) составляет 375 мсек.
Рис. 28. Кадр графопостроителя Vector Scope. В кадре 18.75 периодов 50 Гц волны. Следовательно, время кадра должно быть 375 мсек, а период преобразования АЦП, масштабирования и передачи данных: 0.1831 мсек.
4. В командном окне МатЛАБ наберите команду формирования 5 кадрового сигнала.
sgnl = ;
5. Постройте график 5 первых кадров сигнала. 
Рис. 29. Пять кадров входного сигнала модели.
6. Рассмотрите качество стыков кадров. 
Рис. 30. Стыки пяти кадров. Имеются заметные искажения в первом байте каждого кадра. Заменой первых байт средними значениями между ближайшими точками можно существенно снизить искажения.
7. Подключите ко входному сигналу модели анализатор спектра. Наблюдайте спектр сигнала в реальном времени. 
Рис. 31. Модель отображения спектра входного сигнала (АЦП Arduino UNO) в реальном времени.
Рис. 32. Спектр сетевой наводки на входе АЦП контроллера Arduino.
8. Подключите ко входному сигналу модели осциллограф Time Scope из библиотеки Simulink > DSP System Toolbox > Sinks. 
Рис. 33. Осциллограф в модели для отображения входного сигнала контроллера Arduino.
9. Настройте осциллограф на отображение содержимого текущего кадра и частоты сигнала. 
Рис. 34. Настройка осциллографа Time Scope > Menu > View > Properties.
10. Запустите модель и наблюдайте стабильность сигнальных параметров. 
Рис. 35. Отображение сигнала и его параметров в реальном времени на осциллографе Simulink модели.
Последний вариант канала контроллер Arduino – МатЛАБ в сравнении с предыдущими вариантами имеет следующие преимущества.
не используется память контроллера для накопления АЦП данных;
обеспечивается малый такт преобразования АЦП с масштабированием, который чуть больше такта преобразования АЦП с масштабированием при отсутствии передачи;
не требуется масштабирование сигнала по времени в Simulink модели;
модель содержит меньше блоков;
практически не ограничен размер вектора и время кадра.
Задание 6. Увеличение частоты сэмплирования сигнала АЦП.
Частоту сэмплирования АЦП контроллера Arduino можно повысить до 15 кГц в 10-разрядном режиме и до 77 кГц в 8-разрядном режиме , заменив библиотечные функции на более быстрый вариант использования регистров микроконтроллера.
Функцию пользователя можно создать в программе *.ino или в системном файле контроллера
...\arduino-1.0.6\hardware\arduino\cores\arduino\ wiring_analog.c, зарегистрировав её в
...\arduino-1.0.6\hardware\arduino\cores\arduino\ Arduino.h
Для построения 8-разрядного высокоскоростного канала Arduino – МатЛАБ необходимо выполнить следующее.
1. Напишите программу определения времени заполнения массива АЦП данными с отображением результата в окне «Serial Monitor». Размер массива должен быть достаточно большим, например, в половину памяти SRAM. Для увеличения точности следует измерять время многократного заполнения массива.
Пример программы:
void setup() {
Serial.begin (57600); // bit/s
ADCSRA = (1 << ADEN) // Включение АЦП
|(1 << ADPS2); // Установка предделителя преобразователя на 8
ADMUX = (1<< ADLAR) | (1 << REFS0) // Подключение внешнего ИОН
|(1 << MUX2) |(0 << MUX1) |(1 << MUX0); // подключение АЦП A5 == 101
}
Void loop(){
unsigned long time_start = millis();
for (int j = 0; j < 100; j++) {
for (int i = 0; i < 1024; i++) {
ADCSRA |= (1 << ADSC); // Запуск преобразования АЦП
while ((ADCSRA & (1 << ADIF)) == 0);//Ожидание флага окончания преобразования
adc_bytes[i] = ADCH; // Считывание полученного значения
}
}
unsigned long time_end = millis();
unsigned int dt = time_end - time_start;
Serial.println (dt);
}
Сто заполнений массива из 1024 байт выполнено за 1542 мсек .
2. Дополните однократное заполнение массива данными АЦП последующей передачей всего массива в последовательный порт на максимальной скорости.
Пример программы:
Byte adc_bytes; // Резервирование массива для АЦП данных
Void setup() {
Serial.begin (115200); // bit/s
ADCSRA = (1 << ADEN) // Включение АЦП
|(1 << ADPS2); // Установка предделителя преобразователя на 8
ADMUX = (1<< ADLAR) | (1 << REFS0) // Подключение внешнего ИОН
|(1 << MUX2) |(0 << MUX1) |(1 << MUX0); // подключение АЦП A5 == 101
}
Void loop(){
for (int i = 0; i < 1024; i++) {
ADCSRA |= (1 << ADSC); // Запуск преобразования АЦП
while ((ADCSRA & (1 << ADIF)) == 0); //Ожидание флага окончания преобразования
adc_bytes[i] = ADCH; // Считываем полученное значение
}
// send ADC data into serial port
Serial.print(«A»); // «A» is header
for (int i = 0; i < 1024; i++) {
Serial.write(adc_bytes[i]);
}
}
3. В модели Simulink (Рис. 36) в формате 0.01542 пропишите экспериментальное значение времени записи в массив, а именно, в строке “Block sample time” блока “Serial Receive” и в строке меню > simulation > Configuration Parameters > Fixed-step size (fundamental sample time).
Рис. 36. Модель Simulink для приема и отображения данных из COM порта.
4. Подключите на вход АЦП тестовый сигнал. Запустите программу Arduino и, затем, модель Simulink (MatLAB). Сравните известные параметры сигнала с параметрами наблюдаемого сигнала. Проверить работу тракта можно по отображению поочередно подключаемых выходных напряжений платы Arduino: 0В; 3.3В и 5В.
Рис. 37. Отображение в реальном времени сетевой 50 Гц наводки. Кадр включает 1024 точки. Время кадра 15.42 мсек. Частота сэмплирования 66 КГц (как 1/(0.01542_сек/1024)). Отображаемый сигнал имеет разрывы: процесс записи прерывается передачей кадра в последовательный канал.
Рис. 38. Отображения в режиме реального времени пилообразного сигнала 0… 3.3 В, сформированного на контроллере Teensy 3.1 с 12 разрядным ЦАП и подключенного к шестому АЦП (A5) контроллера Arduino.
Рис. 39. Сигнал 500 Гц контроллера Teensy 3.1. Ошибка такта (15.42 мсек) Simulink модели без дополнительной корректировки меньше 1% (как 100%*(504.72Гц - 500Гц)/500Гц). Погрешность можно уменьшить корректировкой RT такта, как показано в п.3 этого задания.
КОНТРОЛЬНЫЕ ВОПРОСЫ
1. Сравните периоды преобразования АЦП первого и последнего заданий.2. Почему для построения спектра сигнала рекомендуется брать выборку размером кратную двум?
3. Какова задержка потоковой передачи 1024 байт на частоте 115200 бит/c при следующих параметрах передачи?
Data bits: 8
Parity: none
Stop bits: 1
Flow control: none
ADS1115 это 16-разрядный Аналого-Цифровой Преобразователь, который может прекрасно расширить разрешающие и измерительные возможности Вашей Arduino. Он имеет внутренний ИОН (Источник Опорного Напряжения), 4 аналоговых входа, которые могут быть настроены в единичный, дифференциальный и сравнительный режимы измерения.
Важно:
АЦП выдает 16-разрядное знаковое значение напряжения на входе. Т. е. максимальная величина шкалы напряжения не 65535 а 32768. Соответственно если необходимо использовать шкалу на все 16-бит можно только при условии дифференциального измерения, где на один из входов будет подключен внешний источник опорного напряжения а второй будет являться измерительным.
ОЧЕНЬ ВАЖНО!!!: Этот модуль очень боится перенапряжения как по входам, так и по питанию. Превышение напряжения более чем на 5% от напряжения питания его моментально сожжет.
Система установки адреса I2C ADS1115
Данное устройство предполагает установку адреса для I2C шины при помощи замыкания вывода ADDR
на цифровые сигнальные выводы или выводы шины питания. Установка различных адресов I2C предназначена для того, чтоб при подключении двух и более различных устройств не происходило конфликта между ними, т. к. в лучшем случае модули у которых адреса совпадут просто не будут работать, а в худшем - работа всех модулей на шине может стать непредсказуемой. Как выглядит выбор адреса показано на рисунке ниже.
Схема подключения АЦП ADS1115 к Arduino
Данная схема показывает каким образом можно измерить напряжение с внутреннего стабилизатора на 3.3В
Подключив ADS1115 I2C АЦП к ардуино по вышеприведенной схеме, Вы можете попробовать в действии его уже прямо сейчас!
Для этого необходимо всего лишь выбрать в выпадающем списке ниже, Вашу плату, указать порт и нажать Run on Arduino .
Самую свежую библиотеку с примерами кода можно скачать из репозитория GITHUB
Следующий код представляет собой образец программы выводящей в последовательный порт значение на входе 0 АЦП в виде целого (относительной шкалы), и пересчитанное в напряжение.
Если Вы испытываете затруднения с определением адреса устройства или не можете определить причину неработоспособности Вашего модуля i2c, запустите следующий код на Вашей Arduino Uno/Mega. Данная программа является сканером I2C порта управляемым через отладочный порт в режиме диалога. Она отображает на каких адресах есть устройства, а на каких их нет, а также поддерживаемые скорости общения (если вешаете несколько устройств, нужно выбирать скорость порта по самому медленному устройству, иначе при общении с более быстрым медленное может воспринять команды на себя и работа станет непредвиденной). Если подключение по I2C шине верное - данная программа это покажет.
Предлагаю полный спектр услуг по разработке систем автоматики и автоматизации бытового и промышленного направления. Имею в наличии готовые модульные решения для системы «умный дом»: вентиляция, отопление, освещение, дистанционное управление. Поверьте, «Умный дом», сегодня, уже не роскошь, а вполне ДОСТУПНАЯ для каждого из нас РЕАЛЬНОСТЬ!)))
Аналоговые входы платы Ардуино.
Плата 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 измерение идет относительно так называемого источника эталонного напряжения (который иногда называют ИОН - источник опорного напряжения ).
Выбор этого источника происходит при вызове функции 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 весьма неплохо!