Ардуино аналоговый вход как цифровой

Arduino работа с аналоговыми входами. Простое повышение точности АЦП Arduino

ардуино аналоговый вход как цифровой

На этом занятии рассмотрим, аналоговые порты 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 A0void 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 имеет несколько аналоговых входов, используя которые можно измерять параметры аналоговых величин. Это может быть напряжение, ток, сопротивление, температура, свет и так далее. В некоторых случаях для преобразования физических величин в электрические сигналы могут потребоваться специальные датчики.

Сегодня я расскажу об использовании и проведу тест производительности аналого-цифрового преобразователя (АЦП) Arduino. Тест я буду производить, используя оригинальную плату Arduino Mega 2560, в основе которой лежит микроконтроллер ATMega2560, работающий на частоте 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); // читаем аналоговый сигнал }}

intanalogPin=3;// входной аналоговый пинintanalogValue=0;// значение аналогового сигналаvoidsetup()DDRB=B01000000;// устанавливаем 12 пин в режим выходаvoidloop()while(1)PORTB=B01000000;// устанавливаем пин 12 в состояние HIGH// читаем аналоговый сигналPORTB=B00000000;// устанавливаем пин 12 в состояние LOWanalogValue=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

Источник: https://musfight.ru/foto-i-video/arduino-rabota-s-analogovymi-vhodami-prostoe-povyshenie-tochnosti-acp-arduino/

Функция arduino pinMode

ардуино аналоговый вход как цифровой

pinMode в Arduino помогает установить режим работы пина для выполнения операций считывания или записи. Как правило, эта функция используется внутри метода setup () и выполняется один раз при запуске программы. Неправильное выставление режима  входов и выходов ардуино может сказать на работоспособности проекта и платы. В этой статье мы узнаем, как пользоваться pinMode, в каких случаях ее можно опустить, а в каких она обязательна.

Синтаксис функции

pinMode(, )

Функция не возвращает значения.

Описание параметров

В параметре указываем порт, который хотим сконфигурировать. Как правило, функция используется для установки цифровых пинов, т.к. аналоговые пины ардуино чаще всего используются как входные, а входной режим используется Arduino по умолчанию.

В параметре указываем тип режима работы пина (более подробно о возможных режимах мы поговорим чуть позже).

Константы INPUT, OUTPUT и INPUT_PULLUP

В Ardino предусмотрены константы, обозначающие варианты типов:

  • INPUT (значение по умолчанию);
  • OUPUT;
  • INPUT_PULLUP.

Примеры использования

  • pinMode(13, OUTPUT); // Установили 13 пин как выход
  • pinMode(2, INPUT);      // Так делать не надо. По умолчанию, все пины работают в режиме входа.

Зачем нужна функция pinMode

Режимы работы портов и функция pinMode входят в число первых вопросов, возникающих у начинающих ардуинщиков. Действительно, зачем нам нужно определять самим тип порта и почему микроконтроллер не может это сделать самостоятельно?

Для ответа на вопрос нам нужно немного окунуться в электронику. Вспомните, что мы пишем программу не для абстрактного компьютера, а для вполне конкретного устройства, схема которого может кардинально отличаться от проекта к проекту.

Вы можете подключить к плате Arduino огромное количество разнообразных устройств с совершенно разными характеристиками (сопротивление, емкость и т.п.). Присоединив их к Arduino,  вы создаете совершенно новую электрическую схему, в которой  должны быть уже учтены параметры, как самой платы, так и внешних устройств.

Так, например, подключение двигателя, который потребляет высокий ток (особенно в момент старта и остановки) будет сильно отличаться по схеме от подключения какого-либо датчика.

В некоторых случаях Ардуино становится источником питания, в некоторых – просто  вольтметром, а это совершенно разные режимы работы: в первом случае нужно по возможности снизить внутреннее сопротивление (можно придумать такую аналогию – мы громко говорим, нужно чтобы ничего не мешало) а во втором – наоборот, максимально поднять (мы слушаем, рот можно закрыть).

Электрическое сопряжение – очень непростое дело и самостоятельно новичку разобраться во всех нюансах было бы очень не просто. Тем более, что для работы с каждым типом устройств желательно создавать свою уникальную схему подключения и подбирать радиоэлементы (резисторы, конденсаторы), обеспечивающие наиболее безопасный и энергоэффективный режим работы.

К счастью, в некоторых случаях Arduino берет часть работы на себя, подключая или отключая необходимый способ сопряжения, если вы укажете ему прямо в программе, в каком режиме работы должны находиться пины. Именно это и делается с помощью функции ардуино pinMode. Указав номер порта и тип подключения, вы тем самым заставляете Arduino задействовать или отключать необходимые элементы платы.

Полученный результат в большинстве случаев достаточно хорошо решает проблему сопряжения нескольких электронных компонентов.

Режимы работы пинов Arduino

Как правило, каждый пин платы Arduino работает в двух возможных режимах: или в качестве входа или в качестве выхода.  Для установки режима работы Arduino в основном используется два варианта параметров: INPUT и OUTPUT. Но иногда при работе с датчиками нужно выставить пин в режим с неявно подключенным внутренним резистором, поэтому  в нашем арсенале есть еще одна константа, определяющая тип пина: INPUT_PULLUP.

Pin INPUT

Режим INPUT определяет высокоимпедансное состояние пина для работы с внешними источниками сигналов (как правило, это различные варианты датчиков, от которых поступают показания, отсюда слово INPUT). Другими словами, в этом состоянии вы можете подключить практически любую нагрузку, потому что к входу неявным образом подключается высокоомный (десяток мегаом) резистор.

ЭТО ИНТЕРЕСНО:  Как устроен двигатель постоянного тока

Для установки режима INPUT нужно использовать следующую команду:

pinMode(, INPUT);

По умолчанию, все пины Arduino установлены в режим INPUT, поэтому указывать это явно не требуется и команда с такой константной практически не встречается в реальных проектах.

Pin OUTPUT

В режиме OUTPUT Arduino поддерживает пин в низкоимпедансном состоянии, при котором на внешнее устройство выдается максимально возможный ток (плата, по сути, становится  источником тока).

В этом режиме обычно работают пины Arduino с подключенными светодиодами, сервоприводами (маломощными), пьезоизлучателями,  реле, драйверами двигателей и другими внешними устройствами, являющимися для Arduino внешними (отсюда слово OUTPUT).

  Для установки пина в режим OUTPUT нужно использовать следующую команду:

pinMode(, OUTPUT);

Pin INPUT_PULLUP

В режиме INPUT_PULLUP пин работает в режиме входа, но Arduino неявно для нас подключает к входной цепи внутренний подтягивающий резистор. При этом поступление сигнала с датчика будет «инвертироваться», т.е. высокий уровень будет приводить к нулю на входе, низкий, наоборот, оставит на пине высокое напряжение.

Режим INPUT_PULLUP широко используется при работе с кнопками в Ардуино. В не нажатом состоянии подключенная к пину кнопка создает неопределенное состояние (а провод, ведущий к Arduino выступает в роли своеобразной антены, усиливающей все наводки). Для исправления ситуации в схему добавляют подтягивающий резистор. Использование команды pinMode с параметром INPUT_PULLUP позволяет обойтись без дополнительного внешнего сопротивления, используя внутренний резистор Arduino.

Альтернативным способом использования INPUT_PULLUP является подача высокого уровня напряжения на вход, находящийся в режиме INPUT. Команда digitalWrite(10, HIGH) для пина 10, установленного в режим INPUT, включит внутренний резистор так же, как это сделала бы команда pinMode(10, INPUT_PULLUP).

Теперь для вас должно стать понятно, почему даже в простых схемах ваши светодиоды иногда светились очень тускло: вы просто забывали установить для них тип OUTPUT, а когда включали c помощью команды digitalWrite, вы подсоединяли встроенный резистор, тем самым ограничивая ток и степень свечения светодиода.

Источник: https://arduinomaster.ru/program/funktsiya-pinmode/

Аналоговые входы Arduino

ардуино аналоговый вход как цифровой
Подробности Категория: Arduino 29.11.2013 14:41 Admin 12358

Ниже приведено описание портов, которые работают, как аналоговые входы платы Arduino с микроконтроллерами

  • Atmega 1280;
  • Atmega 328;
  • Atmega 168;
  • Atmega 8.

Все данные микроконтроллеры содержат 16-ти канальный аналогово-цифровой преобразователь, который имеет разрешение в 10 бит и способен выдавать 1024 символов значений.

В большинстве случаев, входы платформы Arduino используются для подключения аналоговых датчиков, но вместе с этим, их можно использовать, как и цифровые порты ввода/вывода – выводить или вводить информацию широкого применения (GPIO). Таким образом, при недостаточном количестве цифровых портов, имеется возможность сконфигурировать ненужные в процессе работы аналоговые порты.

Расположение аналоговых входов

Выводы платы Arduino, с номерами от 14 до 19 соответствуют аналоговым портам. Но стоить помнить, что эти номера относятся только к выводам платы, а не к физическим номерам выводов микроконтроллера. Эти аналоговые порты могут использоваться как цифровые порты ввода-вывода информации, например, они могут быть задействованы для установки вывода 0 аналогового порта, на порт вывода со значением HIGH .

Подтягивающие резисторы

Каждый аналоговый вывод имеет подтягивающие резисторы, задача которых такая же, как и при работе на цифровых выводах. Для включения данных резисторов нужно набрать команду: digitalWrite(14, HIGH); , что приведет к включению резистора на выводе аналогового порта 0.

Кроме того, при использовании некоторых датчиков и подключении резистора, будет изменена величина, сообщаемая функцией analogRead().

По этому, много пользователей платы Arduino, используют подтягивающий резистор только при применении вывода аналогового порта в цифровом режиме.

Предостережения при написании программ для Arduino

Также не стоит забывать, что если ранее выводы работали как цифровые порты, то в этом случае команда analogRead будет некорректной. Для правильной работы стоить сконфигурировать их как аналоговые входы. Аналогично, если порт выступал цифровым со значением HIGH, то его обратная установка подключит подтягивающий резистор.

В руководстве микроконтроллера, установленного на плате Arduino, идет речь о том, что не стоить осуществлять быстрое переключение между аналоговыми портами для их чтения, ведь это может привести к наложению сигналов, что приведет к искажению всей системы. А после работы аналогового порта в качестве цифрового, стоить внести паузу в настройку между чтением функцией analogRead().

Источник: https://radio-magic.ru/arduino-projects/71-analog-input

Аналоговые входы

В прошлом уроке мы разобрали измерение и вывод цифрового сигнала с микроконтроллера, а в этом разберём аналоговый сигнал. Как мы уже не раз говорили ранее, у микроконтроллера есть аналоговые входы, т.е. входы, подключенные к АЦП – аналогово-цифровому преобразователю (ADC).

На платах Ардуино это пины, маркированные буквой А. Я не просто так написал название в кавычках, потому что не все пины являются только аналоговыми: например на плате Nano пины A0-A5 являются также обычными цифровыми, и у них есть возможность измерять аналоговый сигнал как доп. функция.

Пины A6 и A7 являются чисто аналоговыми.

Зачем нужно читать аналоговый сигнал? Микроконтроллер может выступать в роли вольтметра, измерять собственное напряжение питания, например от аккумулятора, может измерять ток через шунт (если вы знаете закон Ома), можно измерять сопротивление, а также работать с потенциометрами (крутильными, линейными, джойстиками), которые являются очень удобными органами управления.

Чтение сигнала

“Аналоговые” пины могут принимать напряжение от 0 (GND) до опорного напряжения и преобразовывать его в цифровое значение, просто в какие-то условные единицы. АЦП у нас имеет разрядность в 10 бит, т.е. мы получаем измеренное напряжение в виде числа от 0 до 1023.

Функция, которая оцифровывает напряжение, называется analogRead(pin), данная функция принимает в качестве аргумента номер аналогового пина и возвращает полученное значение. Сам пин должен быть сконфигурирован как INPUT (вход), напомню, что по умолчанию все пины так и настроены.

Пин кстати указывается “аналоговый”:

  • Просто номером А-пина (например, )
  • Номером с буквой А (например, А0)
  • Порядковым номером GPIO: А0 – 14 пин, A1 – 15 пин А7 – 21

Вот пример, опрашивающий пин А0.

int value1 = analogRead(0); // считать напряжение с пина A0int value2 = analogRead(A0); // считать напряжение с пина A0int value3 = analogRead(14); // считать напряжение с пина A0

Хранить полученное значение разумно в переменной типа int, потому что значение варьируется от 0 до 1023.

Опорное напряжение

Опорное напряжение играет главную роль в измерении аналогового сигнала, потому что именно от него зависит максимальное измеряемое напряжение и вообще возможность и точность перевода полученного значения 0-1023 в Вольты. Изучим следующую функцию – analogReference(mode), где mode:

  • DEFAULT: опорное напряжение равно напряжению питания МК. Активно по умолчанию

Источник: https://alexgyver.ru/lessons/analog-pins/

Arduino.ru

Описание портов, работающих как аналоговые входы, платформы 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);

Подробности и предостережения

Для вывода, работавшего ранее как цифровой порт вывода, команда analogRead будет работать некорректно. В этом случае рекомендуется сконфигурировать его как аналоговый вход. Аналогично, если вывод работал как цифровой порт вывода со значением HIGH, то обратная установка на ввод подключит подтягивающий резистор. 

Руководство на микроконтроллер Atmega не рекомендует производить быстрое переключение между аналоговыми входами для их чтения. Это может вызвать наложение сигналов и внести искажения в аналоговую систему. Однако после работы аналогового входа в цифровом режиме может потребоваться настроить паузу между чтением функцией analogRead() других входов.

Источник: http://arduino.ru/Tutorial/AnalogInputPins

Аналоговые измерения с Arduino | РОБОТОША

Arduino имеет несколько аналоговых входов, используя которые можно измерять параметры аналоговых величин. Это может быть напряжение, ток, сопротивление, температура, свет и так далее. В некоторых случаях для преобразования физических величин в электрические сигналы могут потребоваться специальные датчики.

Сегодня я расскажу об использовании и проведу тест производительности аналого-цифрового преобразователя (АЦП) Arduino. Тест я буду производить, используя оригинальную плату Arduino Mega 2560, в основе которой лежит микроконтроллер ATMega2560, работающий на частоте 16 Мгц.

Микроконтроллер ATMega328, на котором основаны Arduino Uno и Arduino Nano, также работает на частоте 16 МГц, так что все вышеизложенное, скорее всего, справедливо и для этих и аналогичных плат.

analogRead

Давайте посмотрим сколько же времени занимает аналого-цифровое преобразование с использованием стандартной функции analogRead.

Для определения моментов начала и конца преобразования я буду использовать 12 вывод в качестве маркера. Для начала повторим эксперимент, который я описывал в статье Оптимизируем digitalWrite на Arduino. Будем изменять уровень напряжения на 12 цифровом пине между состояниями LOW и HIGH. Для чистоты эксперимента я помещу внутрь loop бесконечный цикл.

Скетч, реализующий простые переключения на 12 цифровом выводе выглядит следующим образом:

void setup() { DDRB = B01000000; //устанавливаем 12 пин в режим выхода} void loop() { while(1) { PORTB = B01000000; // устанавливаем пин 12 в состояние HIGH   PORTB = B00000000; // устанавливаем пин 12 в состояние LOW }}

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); // читаем аналоговый сигнал }}

123456789101112131415161718 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); // читаем аналоговый сигнал}}

Осцилограмма сигнала на 12 цифровом пине теперь будет выглядеть следующим образом:

Длительность переключения в 62 нс и время циклического возврата к началу работы программы в 124 нс не превышают погрешность измерения на этом временном масштабе и мы можем пренебречь этими временными промежутками. Отсюда видно, что время, которое затрачивается на аналого-цифровое преобразование примерно равно 112 мкс, поэтому максимальная частота выборки при использовании функции analogRead не превышает 8.9 кГц.

Недостатком использования analogRead является еще и то, что Arduino не может выполнять другой код во время ожидания результата преобразования.

Аналоговые выводы (пины)

09.07.2014 11:54:00

Продолжим знакомство с платформой Arduino и в данной статье рассмотрим аналоговые входы.

Основным применением аналоговых входов в тематике Arduino является чтение значений аналоговых датчиков. В тоже время стоит не забыть упомянуть, что аналоговые входы могут использоваться как цифровые порты входов/выходов рассмотренные в предыдущем уроке (об этом в конце статьи). 

На плате Arduino UNO их 6 (A0-A5). У других плат количество может отличаться, смотрите в спецификации.

Благодаря встроенному АЦП (аналого-цифровой преобразователь), данные входы могут считывать напряжение подаваемое на них. Микроконтроллеры Atmega 328, используемые в Arduino UNO, содержат шестиканальный АЦП, разрешение которого составляет 10 бит. Это позволяет на выходе получать значения от 0 до 1023 (всего 1024 градации). 

Для того чтобы считать показание на аналоговом входе следует вызвать функцию

  // Производим чтение с аналогового входа A0   analogRead(0);

Данная функция возвращает значение от 0 до 1023 пропорционально напряжению на аналоговом входе

В качестве первого примера работы с аналоговыми входами подключим потенциометр. 

Для нашей задачи отлично подойдут однообортные потенциометры изображенные на картинке. Не смотря на столь значительные внешние отличия, они мало чем отличаются. Для примера можно использовать любой из них. Большим потенциометром с крутилкой конечно удобнее пользоваться, но он обладает толстыми ножками которые быстро расшатывают контакты макетной платы. В случае, если под рукой имеется отвертка, то, при работе с макетной платой, лучше воспользоваться квадратным потенциометром.

Для эксперимента нам понадобятся:

Плата Arduino, соединительные провода «папа-папа», макетная плата на 400 контактов, потенциометр 10кОм

Описание примера:

Потенциометр  это резистор меняющий свое сопротивление в зависимости от угла поворота крутилки. Он имеет 3 вывода. На крайние выводы подаем 5V и GND (полярность не имеет особого значения, если выводы поменять местами, значения просто инвертируются). Между крайними выводами расположено резистивное вещество, по которому движется ползунок соединенный со средним выводом. При повороте крутилки изменяется сопротивление, а вместе с тем и напряжение. 

На реальной макетной плате всё будет выглядеть следующим образом:

Пример программного кода:

void setup(){  Serial.begin(9600); // Задаем скорость работы монитор порта } void loop(){  int analogValue = analogRead(0); // Задаем переменную analogValue для считывания показаний   Serial.println(analogValue); // Выводим полученое значение в порт  delay(500); // Ждем пол секунды}

ЭТО ИНТЕРЕСНО:  Как выбрать аккумулятор для автомобиля

Перевод значения аналогового сигнала в вольты

Для перевода получившегося значения в вольты достаточно вычислить шаг и умножить его на получаемое значение.

Для вычисления шага поделим опорное напряжение на 1024 градации

5В / 1024 =  0.0049 Вольт

Т.е. При получаемом аналоговом значении в 500, на порт контроллера приходит ( 500 * 0.0049) 2.45В.

пример программного кода:

float Step = 5.0F / 1024; // Вычисляем шаг Uопорн / на градацию void setup() { Serial.begin(9600); // Задаем скорость работы монитор порта }  void loop() { int analogValue = analogRead(0); // Задаем переменную analogValue для считывания показаний float voltageValue = analogValue * Step; // Переводим в вольты (показание * шаг) Serial.println(voltageValue); // Выводим значение в вольтах в порт delay(500); // Ждем пол секунды }

Более точная работа аналогового входа 

Для того чтобы добиться более точных показаний с аналогового входа можно использовать 2 варианта:

• Функция analogReference()​

Задает опорное напряжение относительно которого происходят аналоговые измерения. 

analogReference(type);

Возможные настройки (type):

DEFAULT: установлено по умолчанию. при данной конфигурации опорное напряжение автоматически принимается за напряжение питания платы Arduino. 5В (на платформах с напряжением питания 5 В) или за 3.3 В (на платформах с напряжением питания 3.3В)   

На платформах Arduino «из коробки» вывод AREF не задействован. В этом случае при настройке DEFAULT к выводу подключается внутреннее напряжение AVCC. Соединение является низко-импедансным и любое напряжение подведенное к выводу в этот момент может повредить микросхему ATmega.

INTERNAL: встроенное опорное напряжение 1.1В на микроконтроллерах ATmega168 и ATmega328, и 2.56В на ATmega8.

Это может пригодиться для более точного измерения напряжения лежащего в пределах ниже 1.1В либо 2.56В. Болле точная работа достигается за счет меньшего шага 5/1024 против 1.1/1024. Значения соответствующее или превышающее 1.1В (2.56В) будут конвертироваться АЦП в 1023. 

EXTERNAL: внешний источник опорного напряжения, подключенный к выводу AREF. 

После того как мы задали функцию, происходит отключение обоих внутренних источников. Теперь можно подключить внешнее напряжение, которое и будет являться опорным для АЦП. Внешнее напряжение рекомендуется подключать к выводу AREF через резистор 5 кОм.

• Ручная установка опорного напряжения

Актуальна для измерения крайне малого напряжения   

Искажения при работе с аналоговыми входами появляются по причине того, что по дефолту за опорное напряжение принимается 5В, в то время как стабилизаторы напряжения на плате Arduino могут немного отклоняться от эталонного значения и выдавать к примеру 4.85В.   4.85 / 1024 = 0.0047 (при эталонном шаге в 0.0049)

В случае, если под рукой имеется точный мультиметр, то можно попросту замерить питающее напряжение и вбить его в расчет, который рассматривался выше. 

float Step = 4.85F / 1024; // Вычисляем шаг Uопорн / на градацию

Использование аналоговых входов в качестве цифровых выводов

Аналоговые входы могут использоваться как цифровые порты входов/выходов рассмотренные в предыдущем уроке

Для этого, для UNO, в коде их нужно записывать как цифровые с 14 по 19. К примеру, для A0 

  // Инициализируем аналоговый pin 0 как выход  pinMode(14, OUTPUT);  // Инициализируем аналоговый pin 0 как вход   pinMode(14, INPUT);

Читать ранее:

•  Урок 1. Цифровые выводы

В данный момент еще реализованы не все элементы нашего сообщества. Мы активно работаем над ним и в ближайшее время возможность комментирования статей будет добавлена.

Источник: http://zelectro.cc/arduino_lesson_2

Arduino — функции — аналоговый вход/выход

Система Arduino поддерживает обработку аналоговых сигналов. Для входных сигналов мы имеем АЦП (аналогово-цифровой преобразователь), в случае выходного сигнал — возможна модуляция ШИМ (широтно-импульсная модуляция).

В Arduino, сердцем которой является микроконтроллер Atmega, имеется один 10-битный АЦП. Это означает, что считанное значение напряжения может находиться в диапазоне от 0 — 1023. В зависимости от опорного напряжения 1024 значений будут распределены на соответствующий диапазон. В результате мы можем получить различную точность и различный диапазон напряжений, считываемых аналого-цифровым преобразователем.

Если выбрать опорное напряжение равное 1,024В, то каждое последующее значение, считанное с аналогового входа будет соответствовать 1мВ. Если опорное напряжение задать равным 5В, то каждое последующее значение будет соответствовать приблизительно 5 мВ.

Следует отметить, что аналого-цифровые преобразователи не имеют идеальной линейной характеристики. Это означает, что в определенных интервалах может быть разница между фактическим и считанным значением напряжения. Из вышеизложенного вытекает, что увеличивая диапазон измерения, мы теряем на качестве измерения, уменьшая диапазон, мы увеличиваем точность измерения.

Примечание: Arduino имеет несколько (в зависимости от версии) аналоговых входов, однако АЦП в ней только один. Это означает, что одновременно может быть считано значение только с одного из датчиков, подключенных к аналоговым входам A0 A5 (A0 A15 для Arduino MEGA).

Для правильной работы АЦП требуется опорное напряжение (эталон). Для Arduino опорное напряжение может быть в диапазоне 05В (или 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 — выводы 213 и 4446.

Частота переключения ШИМ большинства контактов составляет 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(), которая предназначена для пропорционального преобразования данных в новый диапазон значений.

Источник: http://www.joyta.ru/10781-arduino-funkcii-analogovyj-vxodvyxod/

Использование аналоговых входов/выходов на Arduino

Помимо цифровых сигналов, Arduino может использовать и аналоговые входные и выходные сигналы.

Аналоговый сигнал – это сигнал, который может принимать любое количество значений, в отличие от цифрового сигнала, который имеет только два значения: высокий и низкий. Для измерения значения аналоговых сигналов в Arduino имеется встроенный аналого-цифровой преобразователь (АЦП). АЦП преобразует аналоговое напряжение в цифровое значение.

Функция, которая используется для получения значения аналогового сигнала: analogRead(pin). Данная функция преобразует значение напряжения на аналоговом входном выводе и возвращает цифровое значение от 0 до 0123, относительно опорного значения. Для большинства Arduino опорное напряжение составляет 5В, 7В для Arduino Mini и Nano, и 15В для Arduino Mega.

Она принимает лишь один параметр: номер вывода.

Arduino не содержит встроенного цифро-аналогового преобразователя (ЦАП), но она может использовать цифровой сигнала с широтно-импульсной модуляцией (ШИМ) для реализации функций по работе с аналоговым выходом. Функция, используемая для вывода ШИМ сигнала: analogWrite(pin, value). pin – это номер вывода, используемого для ШИМ выхода.

value – это число, пропорциональное коэффициенту заполнения сигнала. Когда value = 0, на выходе всегда логический ноль. Когда value = 255, на выходе всегда логическая единица. На большинстве плат Arduino, ШИМ функции доступны на выводах 3, 5, 6, 9, 10 и 11. Частота ШИМ сигнала на большинстве выводов составляет примерно 490 Гц.

На Uno и подобных платах выводы 5 и 6 работают на частоте примерно 980 Гц. Выводы 3 и 11 на Leonardo также работают честоте на 980 Гц.

Чтобы сопоставить аналоговое входное значение, которое находится в диапазоне от 0 до 1023, с выходным ШИМ сигналом, который находится в диапазоне от 0 до 255, вы можете использовать функцию map(value, fromLow, fromHigh, toLow, toHigh). Данная функция имеет пять параметров: в первом хранится аналоговое значение, а остальные равны соответственно 0, 1023, 0 и 255.

Эксперимент 1: управление яркостью светодиода

В данном эксперименте мы будем управлять яркостью светодиода с помощью ШИМ сигнала на аналоговом выходном выводе.

Схема соединений

Как показано на схеме ниже, светодиод подключается к выводу 2 Arduino. Для изменения яркости светодиода программа будет изменять коэффициент заполнения ШИМ сигнала на выводе 2.

Код программы

const int pwm = 2; // обозначение вывода 2, как переменная ‘pwm’ void setup() { pinMode(pwm,OUTPUT); // установить режим вывода 2, как выход } void loop() { analogWrite(pwm,25); // установка коэффициента заполнения, равным 25 delay(50); // задержка 50 мс analogWrite(pwm,50); delay(50); analogWrite(pwm,75); delay(50); analogWrite(pwm,100); delay(50); analogWrite(pwm,125); delay(50); analogWrite(pwm,150); delay(50); analogWrite(pwm,175); delay(50); analogWrite(pwm,200); delay(50); analogWrite(pwm,225); delay(50); analogWrite(pwm,250); }

Эксперимент 2: управление яркостью светодиода с помощью потенциометра

В данном эксперименте мы будем управлять яркостью светодиода, используя потенциометр. Мы воспользуемся функцией analogRead() для чтения напряжения и функцией analogWrite() для вывода ШИМ сигнала, коэффициент заполнения которого пропорционален аналоговому напряжению.

Теги

ArduinoАналоговый вход

На сайте работает сервис комментирования DISQUS, который позволяет вам оставлять комментарии на множестве сайтов, имея лишь один аккаунт на Disqus.com.

В случае комментирования в качестве гостя (без регистрации на disqus.com) для публикации комментария требуется время на премодерацию.

Источник: https://radioprog.ru/post/113

Разработка устройства на Arduino

 Казалось бы, вот стоит у нас задача поуправлять реле модулем, как известно он управляется цифровым выводом. Так в чем проблема? К примеру, на плате Arduino UNO у нас их аж целых  14, так лепи к какому хочешь. Ну вот и начнем по порядку. Пусть будет D0. С одной стороны верно, работать то будет.

Но вот одним вечером мы решаем, что теперь нам хочется управлять нашей релюшкой дистанционно, возьмем к примеру блютуз. Вот тут и возникает проблема, ведь он работает по интерфейсу UART, а это цифровые пины 0 и 1.  Теперь придется переподключать.

Если собрано на беспаечной макетке, то особых проблем быть не может, но вот если мы уже что-то куда-то подпаяли, то начинается веселая жизнь)

В связи с этим, перед началом разработки, было бы очень хорошо понимать какие выводы у нас приоритетные т.е. могут быть задействованы для передачи данных, управления сервоприводами и т.д, а какие просто пустышки способные выполнять только основные функции цифровых либо аналоговых пинов.

В данной статье произведем разбор полетов для Arduino UNO. Она имеет на своем борту 14 цифровых входов/выходов и 6 аналоговых входов. Начнем наш рассказ, пожалуй, с пинов отвечающих за интерфейсы.

1. Интерфейсы

На мой взгляд, в категорию «неприкасаемых, пока есть другие свободные» следует, в первую очередь, отнести выводы отвечающие за интерфейсы.

ЭТО ИНТЕРЕСНО:  Как работает сварочный инвертор

Раз уж заговорили про UNO, то и рассмотрим на примере контроллера который установлен в нем — ATmega328. 

ATmega328 имеет 3 интерфейса:

UART

D0 — RX (Прием данных)

D1 — TX  (Отправка данных)

SPI

D13 — CSK (Выход тактирования данных)

D12 — MISO  (Вход данных для последовательного программирования)

D11 — MOSI  (Выход данных для последовательного программирования)

I2C

A4 — SDA (последовательная линия данных)

A5 — SCL  (последовательная линия тактирования)

Вот уже 5 цифровых из 14ти и 2 аналоговых из 6ти можно зарезервировать на самый крайний случай.

2. Цифровые выводы с поддержкой ШИМ (PWM)

Источник: https://arduino-e.ru/razrabotka-ustroystva-na-arduino

Arduino аналоговые входы как цифровые выходы — Вместе мастерим

  • Уроки
  • Базовые уроки Arduino
  • Аналоговые входы

“Аналоговые” пины

В прошлом уроке мы разобрали измерение и вывод цифрового сигнала с микроконтроллера, а в этом разберём аналоговый сигнал. Как мы уже не раз говорили ранее, у микроконтроллера есть аналоговые входы, т.е. входы, подключенные к АЦП – аналогово-цифровому преобразователю (ADC).

На платах Ардуино это пины, маркированные буквой А. Я не просто так написал название в кавычках, потому что не все пины являются только аналоговыми: например на плате Nano пины A0-A5 являются также обычными цифровыми, и у них есть возможность измерять аналоговый сигнал как доп. функция.

Пины A6 и A7 являются чисто аналоговыми.

Зачем нужно читать аналоговый сигнал? Микроконтроллер может выступать в роли вольтметра, измерять собственное напряжение питания, например от аккумулятора, может измерять ток через шунт (если вы знаете закон Ома), можно измерять сопротивление, а также работать с потенциометрами (крутильными, линейными, джойстиками), которые являются очень удобными органами управления.

Аналоговые выводы

Вольтметр
01.Basics: AnalogReadSerial
Serial Plotter
01.Basics: ReadAnalogVoltage
Светодиод с плавной регулировкой
03.Analog: AnalogInput
03.Analog: AnalogInOutSerial
03.Analog: Smoothing
05.Control: IfStatementConditional

На плате UNO есть шесть выводов, которые подписаны от A0 до A5 (у других плат может быть другое число выводов). Они работают с напряжением от 0 до 5V. Благодаря встроенному АЦП (аналого-цифровой преобразователь), данные входы могут считывать напряжение подаваемое на них. Микроконтроллеры Atmega328, используемые в Arduino UNO, содержат шестиканальный АЦП, разрешение которого составляет 10 бит. Это позволяет на выходе получать значения от 0 до 1023 (всего 1024 градации).

Для чтения показания напряжения есть встроенный метод analogRead(), возвращающий значение от 0 до 1023. Значение 0 относится к 0V, а 1023 к 5V. Таким образом, если мы хотим конвертировать значение от 0 до 5, то нужно произвести деление 1023/5 = 204.6

Имеется также функция analogReference(type)​. Она задаёт опорное напряжение, относительно которого происходят аналоговые измерения. В проектах для новичков она не используется, поэтому не будем обращать на неё внимания.

Кроме того, аналоговые выходы могут работать как цифровые и обозначаются как 14, 15, 16, 17, 18, 19 вместо A0..A5.

И, наоборот, цифровые порты с символом тильды ~ (3, 5, 6, 9, 10, 11) могут работать как аналоговые выходы, используя ШИМ.

Аналоговые выводы, в отличие от цифровых, не нужно объявлять как вход или выход в начале программы.

Изучим простой пример с одним проводом и аналоговым выводом. Соединим проводом порты A0 и 3.3V. Напишем скетч.

int analogPin = A0; void setup() { Serial.begin(9600);} void loop() { int rawReading = analogRead(analogPin); float volts = rawReading / 204.6; Serial.println(volts); delay(1000);}

Откройте окно Serial Monitor и наблюдайте за показаниями. Должны выводиться числа, близкие к значению 3.3: 3.1, 3.2, 3.3. Если, не закрывая программу, вытащить конец провода из порта 3.3V и вставить в порт 5V, то показания изменятся, а на экране появятся числа 5.0. Если перекинуть конец провода на GND, то увидим значения 0.

Таким образом мы видим, что можем получать значения напряжения из аналоговых портов.

Вольтметр

Если мы можем снимать значения из аналоговых портов, то можем использовать микроконтроллер как вольтметр. Достаточно вставить провода в выводы GND и A0 и соединить их с контактами на батарее (минус и плюс соответственно).

Вообще такой способ не является суперточным. Хотя он и показывал правдоподобные результаты на пальчиковой батарее 1.5 В и «Кроне» на 9 В, но также показывал результаты, когда провода вообще ни к чему не были присоединены.

Но для общего развития оставлю.

/* The simplest voltmeter*/const int analogIn = A0; int raw = 0;float voltage = 0; void setup() { pinMode(analogIn, INPUT); Serial.begin(9600);} void loop() { raw = analogRead(analogIn); voltage = (raw * 5.0 ) / 1024.0; Serial.print(«Raw Value = » ); Serial.print(raw); Serial.print(«\t Voltage = «); Serial.println(voltage, 3); // 3 цифры после запятой delay(500);}

01.Basics | AnalogReadSerial (Чтение аналоговых выводов через потенциометр)

С помощью потенциометра мы можем менять напряжение и считывать данные с выводов.

Продолжим изучение работы с аналоговыми выводами через пример AnalogReadSerial из меню File | Examples | 01.Basics. Цель урока — плавно изменять напряжение и подавать его на аналоговый вывод, чтобы получить с него текущее значение напряжения.

Нам понадобятся плата Arduino, потенциометр и несколько проводов (или перемычек). Соединяем парные ножки с выводами на плате 5V и GND. Среднюю ножку необходимо соединить с аналоговым выводом на плате, помеченную как A0.

Не важно, какая из крайних ножек потенциометра будет подключена к 5V, а какая к GND, поменяется только направление, в котором нужно крутить ручку для изменения напряжения. Сам сигнал считывается со средней ножки, которая связана с аналоговым портом. Для считывания аналогового сигнала, принимающего широкий спектр значений, а не просто 0 или 1, подходят только порты, помеченные на плате как ANALOG IN. Они все пронумерованы с префиксом A (A0-A5).

Схема готова. Вращая регулятором потенциометра, мы можем менять сопротивление от 5 Вольт до 0. Arduino позволяет считывать текущее напряжение, которое подаётся на среднюю ножку при помощи аналогового вывода. Результаты могут колебаться от 0 до 1023.

Код

void setup() { // инициализируем соединение на скорости 9600 бит в секунду: Serial.begin(9600);} void loop() { // Считываем данные с аналогового вывода A0 int sensorValue = analogRead(A0); // получаем текущее значение Serial.

println(sensorValue); // выводим результат на монитор delay(1); // небольшая задержка для стабильности вывода результатов}

Код очень простой. При инициализации устанавливаем нужную скорость связи: Serial.begin(9600);. Далее в цикле мы постоянно считываем данные, поступающие с потенциометра при помощи метода analogRead().

Так как значения будут находиться в диапазоне от 0 до 1023, мы можем использовать тип int для переменной sensorValue.

Полученный результат будем выводить в окно последовательного монитора.

Проверка (Serial Monitor)

Запустите программу, а также откройте окно последовательного монитора. Вращая регулятором потенциометра, вы можете наблюдать, как в окне будут меняться значения от 0 до 1023.

Пример интересен своей универсальностью. Потенциометр является ручным делителем напряжения. Существуют другие детали, которые выполняют такую же работу. Например, фоторезистор меняет напряжение в зависимости от освещённости.

Также напряжение может меняться от нажатия, от температуры и т.д. При этом нам не нужно менять программу, просто одну деталь меняем на другую и код будет выполняться.

Единственное различие будет в выводимых результатах — каждый делитель напряжения имеет свои характеристики и, соответственно, будет давать свои показания.

Проверка (Serial Plotter)

Начиная с версии Arduino IDE 1.6.6, в настройках появился новый инструмент Plotter (Tools | Serial Plotter), позволяющий выводить простенький график. Обратите внимание, что он не может работать одновременно с последовательным монитором, который следует закрыть.

Вращая ручку потенциометра, можем наблюдать изменение графика.

01.Basics | ReadAnalogVoltage (Напряжение аналоговых выводов через потенциометр)

Рассмотрим урок ReadAnalogVoltage из меню File | Examples | 01.Basics. Он практически идентичен примеру AnalogReadSerial, только мы будем конвертировать значения от аналогового вывода (01023) в значения напряжения (05). Для примера нам понадобится потенциометр. Цель урока — плавно изменять напряжение и подавать его на аналоговый вывод, чтобы получить текущее значение напряжения.

Схема прежняя, ничего не меняем. Соединяем парные ножки с выводами на плате 5V и GND. Среднюю ножку необходимо соединить с аналоговым выводом на плате, помеченную как A0.

Схема готова. Вращая регулятором потенциометра, мы можем менять сопротивление от 5 Вольт до 0. Arduino позволяет считывать текущее напряжение, которое подаётся на среднюю ножку при помощи аналогового вывода. Результаты могут колебаться от 0 до 1023.

Светодиод с плавной регулировкой

Усложним конструкцию, добавив светодиод. Первую часть схему можно было не трогать. Но для экономии в предыдущем примере я соединил ножку потенциометра сразу с портом GND. На этот раз сделаем соединение из двух проводов. Это необходимо, чтобы светодиод тоже мог соединиться с заземлением. Поэтому финальный макет будет следующим.

Принципиальная схема.

Напишем код.

int potPin = A0;int ledPin = 9; void setup() { // порт для светодиода на выход pinMode(ledPin, OUTPUT); // пин с потенциометром — вход // мы хотим считывать напряжение, // выдаваемое им pinMode(potPin, INPUT); Serial.begin(9600);} void loop() { // значение напряжения с потенциометра int rotation; // значение яркости int brightness; // считываем напряжение с потенциометра от 0 до 1023 // пропорциональное углу поворота ручки rotation = analogRead(potPin); // в brightness записываем полученное ранее значение rotation // делённое на 4. Дробная часть от деления будет отброшена. // В итоге мы получим целое число от 0 до 255 brightness = rotation / 4; // выдаём результат на светодиод analogWrite(ledPin, brightness); // выводим результат в Serial Monitor Serial.println(brightness); delay(1); // задержка для стабильности}

Практически все инструкции вам знакомы. Тут нужно уяснить момент, что яркость светодиода управляется нашим кодом, а не подачей напряжения через потенциометр. Мы считываем показания потенциометра, как в первом варианте и переводим получаемые значения в диапазон от 0 до 255.

Затем воспроизводим старый пример с плавной регулировкой светодиода и подаём ему нужные значения. Теперь при вращении ручки потенциометра мы одновременно управляем степенью накала светодиода.

Напомню, что светодиод следует подключить к портам с тильдой, например, ~9

Небольшая модификация примера с миганием светодиода. Частота мигания будет зависеть от показаний потенциометра. Можно использовать встроенный светодиод или установить свой. Общая схема остаётся как у первого примера.

int sensorPin = A0; // аналоговый вывод A0 для потенциометраint ledPin = 13; // вывод для светодиодаint sensorValue = 0; // значение, поступаемое от потенциометра void setup() { // устанавливаем режим для светодиода pinMode(ledPin, OUTPUT);} void loop() { // считываем показание с потенциометра sensorValue = analogRead(sensorPin); // включаем светодиод digitalWrite(ledPin, HIGH); // делаем задержку на значение от потенциометра в мсек delay(sensorValue); // выключаем светодиод digitalWrite(ledPin, LOW); // делаем задержку на значение от потенциометра в мсек delay(sensorValue);}

Получая показания от потенциометра в интервале 0-1023 мы регулируем задержку между миганием светодиода в интервале от 0 до 1.023 секунд.

Считываем данные с потенциометра и распределяем их в интервале от 0 до 255 с помощью функции map(). Данный интервал удобно использовать для выводов с PWM (ШИМ). Применим получаемые значения для управления яркостью светодиода, а также будем выводить информацию в Serial Monitor.

Источник: http://developer.alexanderklimov.ru/arduino/analogreadserial.php

Arduino. Демонстрация работы аналогового входа

Демонстрация работы аналогового входа Arduino, воспользуемся примером с сайта arduino.cc, так же пример есть в приложении arduino в разделе «Файл — Образцы — 03. Analog — AnalogInput».

Описание

При помощи изменения сопротивления потенциометра, подключенного к аналоговому входу, меняем скорость мигания светодиода.

Для реализации потребуется

  1. Arduino;
  2. Отладочная плата;
  3. Потенциометр 10 КОм;
  4. Соединительные провода типа «Папа-Папа»;
  5. Резистор 220 Ом;
  6. Светодиод.

* Можно обойтись встроенным светодиодом, тогда можно исключить пункты 5 и 6.

Реализация

Подключаем провода:

  1. Аналоговый вход A0 подключаем к центральному контакту потенциометра;
  2. 5v и GND подключаем к боковым контактам потенциометра;
  3. К D13 подключить резистор 220 Ом, к резистору подключаем анод светодиода, катод подключаем к выходу GND.

Код можно найти там же, где и примеры.

Код сопровождается исчерпывающими комментариями, но отдельно отмечу: на аналоговый вход подается напряжение от 0 до 5 вольт, которое будет  функцией  analogRead() преобразовано в значение от 0 до 1023, это 1024 шага с изменением 0.0049 Вольт.

/* Analog Input Demonstrates analog input by reading an analog sensor on analog pin 0 and turning on and off a light emitting diode(LED) connected to digital pin 13. The amount of time the LED will be on and off depends on the value obtained by analogRead(). The circuit: * Potentiometer attached to analog input 0 * center pin of the potentiometer to the analog pin * one side pin (either one) to ground * the other side pin to +5V * LED anode (long leg) attached to digital output 13 * LED cathode (short leg) attached to ground * Note: because most Arduinos have a built-in LED attached to pin 13 on the board, the LED is optional. Created by David Cuartielles modified 30 Aug 2011 By Tom Igoe This example code is in the public domain. http://arduino.cc/en/Tutorial/AnalogInput */ int sensorPin = A0; // select the input pin for the potentiometer int ledPin = 13; // select the pin for the LED int sensorValue = 0; // variable to store the value coming from the sensor void setup() { // declare the ledPin as an OUTPUT: pinMode(ledPin, OUTPUT); } void loop() { // read the value from the sensor: sensorValue = analogRead(sensorPin); // turn the ledPin on digitalWrite(ledPin, HIGH); // stop the program for milliseconds: delay(sensorValue); // turn the ledPin off: digitalWrite(ledPin, LOW); // stop the program for for milliseconds: delay(sensorValue); }

После выгрузки программы, получаем, что требовалось.

Камера не совсем верно передает частоту мерцания, но видно, что она меняется.

Источник: https://guesto.ru/arduino-demonstratsiya-raboty-analogovogo-vkhoda/

Понравилась статья? Поделиться с друзьями:
220 вольт
Как отремонтировать наушники от телефона

Закрыть