Arduino ldr: урок по использованию светозависимого сенсора

Урок 42. Шкала визуализации для аналоговых датчиков

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

Нам понадобится:

Для реализации проекта нам необходимо установить библиотеки:

  • LiquidCrystal_I2C – для работы с символьными ЖК дисплеями.
  • Wire – для работы с аппаратной шиной I2C (библиотека входит в стандартный набор Arduino IDE).

О том как устанавливать библиотеки, Вы можете ознакомиться на странице Wiki – Установка библиотек в Arduino IDE.

Схема подключения:

Дисплей LCD1602 I2C подключается к аппаратной шине I2C. Аналоговый датчик подключается к любому аналоговому входу Arduino Uno (в примере используется вывод A0).

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

#include // Подключаем библиотеку для работы с шиной I2C
#include // Подключаем библиотеку для работы с LCD дисплеем по шине I2C
LiquidCrystal_I2C lcd(0x27,16,2); // Объявляем объект библиотеки, указывая параметры дисплея (адрес I2C = 0x27, количество столбцов = 16, количество строк = 2) Если дисплей не отвечает, то измените адрес на 0x3F
uint8_t symbol[8] = {31,31,31,31,31,31,31,31}; // Определяем массив который содержит полностью закрашенный символ
const uint8_t pinSensor = A0; // Определяем константу для хранения номера аналогового входа с которого будут браться данные
uint16_t valSensor; // Объявляем переменную для хранения данных с аналогового входа pinSensor //
void setup(){ // lcd.init(); // Инициируем работу с LCD дисплеем lcd.backlight(); // Включаем подсветку LCD дисплея lcd.createChar(1, symbol); // Загружаем символ из массива symbol в первую ячейку ОЗУ дисплея
} // Так как символ был загружен в 1 ячейку, то для его отображения на дисплее нужно вывести символ с кодом 1 // Если бы мы загрузили символ во 2 ячейку, то для его отображения на дисплее нужно было бы вывести символ с кодом 2
void loop(){ // valSensor = analogRead(pinSensor); // Читаем данные с аналогового входа pinSensor в переменную valSensor lcd.setCursor(6, 1); lcd.print(” “); // Устанавливаем курсор дисплея на 6 символ 1 строки и выводим 4 пробела начиная с той позиции, куда ранее был установлен курсор. lcd.setCursor(6, 1); lcd.print(valSensor); // Устанавливаем курсор дисплея на 6 символ 1 строки и выводим значение переменной valSensor на дисплей (начиная с той позиции, куда ранее был установлен курсор) lcd.setCursor(0, 0); // Устанавливаем курсор дисплея на 0 символ 0 строки для вывода шкалы, дальнейший вывод символов начнётся именно с этой позиции uint8_t j=map(valSensor,0,1023,0,17); // Определяем переменную j которой присваиваем значение valSensor преобразованное от диапазона 0…1023 к диапазону 0…17 for(uint8_t i=0; ii? 1:32); // Выводим на дисплей символ по его коду, либо 1 (символ из 1 ячейки ОЗУ дисплея), либо 32 (символ пробела) } // После вывода каждого символа, курсор дисплея сдвигается автоматически
}

Алгоритм работы:

До кода «Setup» подключаются библиотеки, объявляются объекты, переменные и константы. Формируется массив «symbol», данные которого являются символом для закрашивания шкалы визуализации.

В коде «Setup» инициируется работа с дисплеем, включается его подсветка, а в 1 ячейку его ОЗУ записывается символ из ранее созданного массива «symbol», после чего начинает постоянно выполняться код «loop».

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

Те же данные (из переменной «valSensor») присваиваются переменной «j», только преобразуются функцией «map» от диапазона 0…1023 к диапазону 0…17. Диапазон 0…

1023 охватывает все возможные значения переменной «valSensor», которые читаются с аналогового входа Arduino Uno. Диапазон 0…

17 охватывает все возможные значения для переменной «j» и позволяет рассчитать сколько символов, из 16 символов шкалы, требуется закрасить, а сколько оставить. Почему выбран диапазон 0…17, а не 0…16 – рассказано ниже, в разделе «примечание».

Шкала визуализации выводится посимвольно в цикле «for». При каждом проходе этого цикла увеличивается значение переменной «i» (от 0 до 15 включительно), которое внутри цикла сравнивается в условии оператора «?» со значением переменной «j». Единственная строка внутри цикла предназначена для вывода одного символа на экран дисплея.

Если значение переменной «j» больше значения переменной «i» (как это описано в условии оператора «?»), то будет выведен символ с кодом 1, иначе символ с кодом 32. Символ с кодом 1 – это символ который находится в 1 ячейке ОЗУ дисплея, а символ с кодом 32 – это пробел.

Таким образом, при j=0 – все символы шкалы будут состоять из пробелов, а при j>=16 – все символы шкалы будут состоять из символов с кодом 1.

Примечание:

Как было сказано ранее, переменной «j» присваивается значение переменной «valSensor» преобразованное от диапазона 0…1023 к диапазону 0…17, это значит:

  • при значении «valSensor» от 0 до 60 – значение «j» будет равно 0
  • при значении «valSensor» от 61 до 120 – значение «j» будет равно 1
  • …
  • при значении «valSensor» от 963 до 1022 – значение «j» будет равно 16
  • при значении «valSensor» равном 1023 – значение «j» будет равно 17

Значит что «j» может принимать значение 17 не в диапазоне значений «valSensor», а только если значение «valSensor» точно равно 1023, вот почему выбран диапазон от 0 до 17, а не от 0 до 16. Иначе последний символ шкалы никогда бы не закрашивался символом с кодом 1.

Ссылки:

Источник: https://lesson.iarduino.ru/page/Visualization_scale_for_analog_sensors

Arduino Light Sensor Circuit using LDR

We all want our home appliances to be controlled automatically based on some conditions and that's called Home automation.

Today we are going to control the light based of darkness outside, the light turns ON automatically when it is dark outside and turns off when it gets bright.

For this, we need a light sensor to detect the light condition and some circuitry to control the Light sensor. It’s like Dark and light Detector circuit but this time we are using Arduino to get more control over light.

In this circuit, we are making a Light Sensor using LDR with Arduino to control a bulb/CFL as per light condition of the room or outside area.

Material Required

  • Arduino UNO
  • LDR (Light Dependent Resistor)
  • Resistor (100k-1;330ohm-1)
  • LED – 1
  • Relay module – 5v
  • Bulb/CFL
  • Connecting wires
  • Breadboard

Circuit Diagram

LDR

LDR is Light Dependent Resistor. LDRs are made from semiconductor materials to enable them to have their light-sensitive properties. There are many types but one material is popular and it is cadmium sulfide (CdS). These LDRs or PHOTO RESISTORS works on the principle of “Photo Conductivity”.

Now what this principle says is, whenever light falls on the surface of the LDR (in this case) the conductance of the element increases or in other words, the resistance of the LDR falls when the light falls on the surface of the LDR.

This property of the decrease in resistance for the LDR is achieved because it is a property of semiconductor material used on the surface.

We previously made many Circuits using LDR, which use LDR to automate the lights according to requirement.

 

Working of LDR controlled LED using Arduino

As per the circuit diagram, we have made a voltage divider circuit using LDR and 100k resistor. The voltage divider output is feed to the analog pin of the Arduino.

The analog Pin senses the voltage and gives some analog value to Arduino. The analog value changes according to the resistance of LDR.

So, as the light falls on the LDR the resistance of it get decreased and hence the voltage value increase.

Intensity of light ↓ – Resistance↑ – Voltage at analog pin↓ – Light turns ON

As per the Arduino code, if the analog value falls below 700 we consider it as dark and the light turns ON. If the value comes above 700 we consider it as bright and the light turns OFF.

Code Explanation:

Complete Arduino Code and Demonstration Video is given at the end of this project.

Here, we are defining the Pins for Relay, LED and LDR.

#define relay 10
int LED = 9;
int LDR = A0;

Setting up the LED and Relay as Output pin, and LDR as input pin.

pinMode(LED, OUTPUT);
pinMode(relay, OUTPUT);
pinMode(LDR, INPUT);

Reading the voltage analog value through the A0 pin of the Arduino. This analog Voltage will be increased or decreased according to the resistance of LDR.

int LDRValue = analogRead(LDR);

Giving the condition for dark and bright. If the value is less than 700 then it is dark and the LED or Light turns ON. If the value is greater than 700 then it is bright and the LED or light turns OFF.

Читайте также:  Топ-5 инженерных профессий, которые востребованы прямо сейчас - arduino+

if (LDRValue

Источник: https://circuitdigest.com/microcontroller-projects/arduino-light-sensor-using-ldr

Управляемый Arduino датчик освещенности

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

Светочувствительный резистор, или фоторезистор, – это датчик, сопротивление которого уменьшается по мере увеличения количества падающего на него света. Когда темно, сопротивление фоторезистора может достигать нескольких МОм. Однако, когда светло, сопротивление фоторезистора может быть столь же низким, до нескольких сотен Ом.

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

В зависимости от значения, которое прочитает Arduino, программа затем установит на выводе 3 высокий или низкий логический уровень, чтобы включить или выключить светодиоды ночника. Пороговое значение равно 150.

Когда показание аналогового значения меньше 150, Arduino включит светодиоды. Когда показание аналогового значения больше 150, Arduino выключит светодиоды.

Необходимые комплектующие

  • 1 x фоторезистор;
  • 2 x светодиод;
  • 2 x резистор 470 Ом;
  • 1 x резистор 1 кОм;
  • 1 x Arduino Mega2560;
  • 1 x макетная плата;
  • перемычки.

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

Подключите компоненты, как показано на рисунке ниже. Подключите светодиоды к выводу 3 платы Arduino. Два резистора 470 Ом – токоограничивающие резисторы. Один вывод фоторезистора подключен к шине +5V, а другой – к одному из выводов резистора 1 кОм. Второй вывод резистора 1 кОм соединен с землей GND.

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

Схема соединений датчика освещенности на Arduino

Ниже показан собранный макет датчика освещенности.

Макет датчика освещенности на Arduino

Сборка

  1. Подключите один из двух выводов фоторезистора к линии +5V, а второй к линии GND через резистор 1 кОм.
  2. Подключите один конец перемычки в аналоговому выводу A1, а второй – к точке соединения фоторезистора и резистора 1 кОм.

  3. Подключите два светодиода параллельно, каждый через резистор 470 Ом, отрицательным выводом (катодом) на землю, как показано на схеме выше.
  4. Подключите вывод 3 к положительным выводам (анодам) светодиодов через резисторы 470 Ом.

  5. Подключите линию земли на макетной плате к выводу GND платы Arduino.
  6. Подключите плату Arduino с помощью USB кабеля к компьютеру и загрузите программу с помощью Arduino IDE.
  7. Подайте питание на плату Arduino, используя источник питания, батарею или USB кабель.

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

Код

const int led=3; // переменная, которая хранит номер вывода void setup() { pinMode(led, OUTPUT); // настраивает вывод 3 на выход } void loop() { int sensor_value = analogRead(A0); if (sensor_value < 150) // точка, в которой меняется состояние светодиодов { digitalWrite(led, HIGH); // зажечь светодиоды } else { digitalWrite(led,LOW); // погасить светодиоды } }

Видео

Оригинал статьи:

  • Tim Youngblood. An Arduino-Controlled Light Sensor

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

Урок 1: iBoard Pro и дисплейный модуль – калибровка тачскрина, работа с RTC (часы)

Для сегодняшнего урока нам потребуется:

В результате нашего урока должно получиться примерно следующее:

Обратите внимание, что для корректной работы модулю часов реального времени (RTC) обязательно требуется резервная батарейка (очень желательно иметь “свежую” батарейку, чтобы не отлавливать “глюки” в работе часиков, связанную с разряженным резервным источником питания). 

Для установки этого резервного источника питания RTC на плате iBoard Pro предусмотрен соответствующий слот. Подходит батарейка CR1225 или CR1220.

Плата iBoard Pro с установленным дисплеем является серьезным потребителем электричества (и питания от USB-порта точно не хватит) – возьмите подходящий блок питания (например, от ноутбука с подходящим напряжением и разъемом).

В анонсе мы озвучили, что будем использовать дисплей ITDB02-2.

4E, но при подготовке было решено, что для большей наглядности (и чтобы не ломать глаза мелким шрифтом), воспользуемся другим, более крупным дисплеем ITDB02-3.2S (по возможностям он полностью идентичный: то же разрешение 320*240, но обладает экранчиком в 3.2 дюйма по диагонали).

В скетчах будут присутствовать строки для подключения как “маленького”, так и “большого” дисплея – достаточно будет закомментировать одну строчку и раскомментировать – другую. Итак, начинаем.

Сначала необходимо скачать и установить необходимые библиотеки:

  • UTFT – библиотека для работы с TFT-дисплеем
  • UTouch – библиотека для работы с тач-скрином
  • RTC – библиотека для модуля часов реального времени

Установка библиотек очень простая – загруженные файлы с библиотеками нужно распаковать (появятся одноименные папки) и эти папки поместить в каталог libraries внутри каталога arduino  (со средой разработки). Если Arduino IDE был запущен в процессе установки – то необходимо будет его перезапустить, чтобы библиотеки “подхватились”.

Если все сделали правильно, то в IDE через меню “File”-“Examples” (Файл – Примеры) будут доступны примеры соответствующих библиотек.

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

Можно установить дисплейный модуль на плату iBoard Pro (обращайте внимание на совпадение нумерации на плате дисплея и на “материнской” плате).

Для калибровки необходимо открыть пример UTouch_Calibration (“File”-“Examples” – “UTouch” – “Arduino”).

В примере присутствуют строчки:

В первой строке указываются параметры инициализации дисплея, во второй – модуля тачскрина.

В нашем случае их необходимо изменить следующим образом:

Для дисплея ITDB02-2.4E (8 битный режим):
 Для дисплея ITDB02-2.4E (16 битный режим):
После корректировки скетч можно залить в плату. Если все сделано верно – на экране появится инструкция, как произвести калибровку (потребуется тонкий стилус или можно воспользоваться, например, деревянной зубочисткой.).

Результатом работы скетча будет примерно следующее изображение на экране:В нижней части отображаются калибровочные коэффициенты (зависящие от конкретного экземпляра дисплейного модуля). Эти данные необходимо ввести в файл UTouchCD.h (файл находится в папке arduinolibrariesUTouch).

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

Для проверки следует воспользоваться скетчем UTouch_ButtonTest (естественно, надо подправить конфигурационные строчки, как мы это сделали ранее). Скетч позволяет проверить точность калибровки (нажимая на экранные кнопки).

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

Сразу проверим, что все работает правильно. Для этого откроем в Arduino IDE пример для DS1307 (“File”-“Examples” – “RTClib” – “ds1307”). 

Никаких изменений в этом примере производить не требуется. 

После загрузки скетча в нашу плату можно открыть монитор последовательного порта и если все сделано правильно (и модуль часов работает правильно) – появятся строчки типа:

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

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

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

  1. Создаем в Arduino IDE новый скетч (File – New)
  2. Сохраняем его (пусть он пока будет пустой). Имя файла произвольное (пусть будет “iBoardPro”)
  3. Создадим в нашем проекте еще несколько файлов (rtc, graphics) – для этого проще всего воспользоваться клавиатурным сокращением Ctrl+Shift+N и ввести соответствующее имя файла.

Если все сделано правильно, то ваша среда разработки будет выглядеть примерно так:

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

В дальнейшем наш проект расширится другими дополнительными файлами (о чем мы расскажем в следующих уроках). 

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

В нашей графической библиотеке создадим функцию time2display с несколькими входными параметрами:

  • смещение по x
  • смещение по y
  • секунды (флаг, указывающий, нужно ли выводить секунды)
  • цвет (составляющая R)
  • цвет (составляющая G)
  • цвет (составляющая B)

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

Аналогично сделаем функцию date2display. Входные параметры следующие:

  • смещение по x
  • смещение по y
  • день недели (флаг, указывающий, нужно ли выводить день недели)
  • цвет (составляющая R)
  • цвет (составляющая G)
  • цвет (составляющая B)
  • шрифт (SmallFont или BigFont)
Читайте также:  Arduino nano: преимущества и недостатки, программное обеспечение

Для отрисовки экрана создадим функцию myDisplay. Временно эту функцию сделаем предельно простой – включим туда вызовы наших функций для вывода времени и даты в разных вариантах. Позже мы эту функцию модифицируем.

Теперь достаточно написать простую функцию setup(), где производим инициализацию всей используемой периферии:

И простую функцию loop() – основной цикл:
Если все сделано правильно, увидим картинку, схожую с этой:

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

Материалы по нашему уроку (тестовые и результирующий скетч) можно скачать по ссылке.

Продолжение следует…

Следите за обновлениями!

Источник: http://devicter.blogspot.com/2013/03/1-iboard-pro-rtc.html

Работа с сенсорным экраном на Arduino DUE

В предыдущей статье «Работа с TFT дисплеем на ARDUINO DUE» мы подробно рассмотрели команды базовой библиотеки UTFT, предназначенной для работы с TFT дисплеями на Arduino.

В этой статье мы рассмотрим Utouch – дополнение к базовой библиотеке, позволяющее работать с сенсорным экраном.

Это дополнение разработано тем же автором, что и базовая библиотека.

Свежую версию можно скачать здесь:

http://www.henningkarlsen.com/electronics/library.php?id=55

Это дополнение не является самостоятельным и требует подключения базовой библиотеки UTFT. Итак, рассмотрим более подробно дополнение Utouch, предназначенное для работы с сенсорным экраном, которым оборудовано большинство TFT дисплеев.

2. Начало работы с сенсорным экраном

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

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

#include<\p>
UTFT myGLCD(CTE32HR,25,26,27,28); Теперь подгружаем дополнение и создаем объект – сенсорный экран с именем myTouch.

В качестве параметров команде инициализации передаются номера пинов, к которым подключены сигналы TCLK, TCS, TDIN, TDOUT и IRQ. Эти параметры следует выяснить у производителя дисплея или шильда, посредством которого дисплей подключен к контроллеру.

В нашей модели сенсорного экрана вышеупомянутые сигналы подключены, соответственно, к пинам 6, 5, 4, 3 и 2. Напоминаем, что схему шильда, при помощи которого подключается дисплей можно найти здесь:

http://coldtears.lin3.siteonlinetest.com/files/CTE_DUE_shield.zip

а схему самого дисплейного модуля – здесь:

http://coldtears.lin3.siteonlinetest.com/files/3.2b.zip

Итак для нашего дисплея мы должны вставить в программу следующие строки:

#include<\p>
UTouch myTouch(6,5,4,3,2); Далее необходимо проинициализировать в процедуре void setup() дисплей и сенсорный экран:

void setup() {

myGLCD.InitLCD();
myTouch.InitTouch();
} Команда InitTouch также, как и команда InitLCD базовой библиотеки, задает вертикальную или горизонтальную ориентацию дисплея. По умолчанию задается горизонтальная ориентация. Все, теперь можно работать с нашим сенсорным экраном. Рассмотрим совсем простой пример, при помощи которого мы сможем убедиться, что сенсорный экран заработал. Скомпилируем следующую программу и загрузим ее в память контроллера:#include
UTFT myGLCD(CTE32HR,25,26,27,28);
#include
UTouch myTouch(6,5,4,3,2);
void setup() { myGLCD.InitLCD(); myTouch.InitTouch(); myGLCD.clrScr(); myGLCD.fillScr(255,0,0);
}
void loop() {
if (myTouch.dataAvailable()) {
myGLCD.fillScr(0,255,0);
}else {myGLCD.fillScr(255,0,0);}
}
При старте программы дисплей закрашивается красным цветом. Теперь коснемся экрана в любой точке – и дисплей окрасится в зеленый цвет.

3. Калибровка сенсорного экрана

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

Для выполнения калибровки необходимо открыть этот пример через меню: «Файл->Примеры->UTouch->Arduino->UTouch_Calibration». ВНИМАНИЕ! Перед компиляцией не забудьте заменить строки UTFT myGLCD(….) и UTouch myTouch(….) на те, что нужны для нашего дисплея.

Также при калибровке необходимо правильно выбрать параметр TOUCH_ORIENTATION. Информацию о значении этого параметра для используемой модели дисплея можно найти в файле UTouch_Supported_display_modules.pdf, который поставляется вместе с библиотекой Utouch и размещается в ее корневой папке.

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

ВНИМАНИЕ! Это значение необходимо устанавливать только при калибровке сенсорного экрана, в дальнейшем ориентация экрана должна совпадать с ориентацией дисплейного модуля. При запуске программа выводит на дисплей пояснительный текст и ждет прикосновения к сенсорному экрану.

Затем на дисплее отображается 8 меток-крестиков по краям дисплея и красное окно с надписью PRESS в центре.

Инструкция разработчиков сообщает, что необходимо коснуться подсвеченного крестика и удерживать касание до тех пор, пока подсветка на нем не погаснет, а на красном поле в центре не появится сообщение «RELEASE». Эту несложную операцию необходимо повторить для всех крестиков по очереди.

Кстати, разработчики советуют выполнять эту операцию стилусом или заостренной палочкой, не используя пальцы, это позволит повысить точность калибровки. По окончании калибровки на дисплей будут выведены три числа в 16-ричном формате. Например, вот такие:

CAL_X 0xBD95ECC8UL

CAL_Y 0x5EBC8000UL
CAL_S 0x0013F1DFUL Эти три значения необходимо поместить в файл UTouch_CD.h, находящийся в корневой папке дополнения UTouch вместо тех значений CAL_X, CAL_Y и CAL_S, которые там указаны изначально. После этого дисплей будет работать правильно. Теперь рассмотрим более подробно команды дополнения UTouch:

UTouch – создает базовый класс сенсорного экрана с заданным именем, в качесте параметров указывается способ подключения.

Команда имеет следующий вид:

Utouch _NAME_ (TCLK, TCS, TDIN, TDOUT, IRQ);

где _NAME_ — произвольное имя объекта «сенсорный экран», которое будет использоваться в качестве префикса при любом обращении к нему, а TCLK, TCS, TDIN, TDOUT и IRQ – номера пинов, которым подключаются соответствующие сигналы сенсорного дисплея.

Строка с этой командой размещается в области определений и должна предшествовать любым другим командам UTouch. Заданное имя объекта должно использоваться в качестве префикса ко всем последующим командам UTouch.

InitTouch – инициализирует сенсорный экран и задает горизонтальную или вертикальную ориентацию.

В качестве параметра указывается идентификатор ориентации.

Если в этой команде указать PORTRAIT или 0 – будет выбрана вертикальная ориентация, если указать LANDSCAPE или 1 – горизонтальная. Обратите внимание, что ориентация сенсорного экрана должна совпадать с ориентацией дисплея.

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

setPrecision – задает точность определения координат точки прикосновения к сенсорному дисплею.

В качестве параметра передается идентификатор точности.

Всего определено четыре уровня точности, кодируемые числами от 1 до 4: PREC_LOW – низкая точность; PREC_MEDIUM – средняя точность; PREC_HI – высокая точность; PREC_EXTREME – очень высокая точность. Естественно, уровень точности обратно пропорционален времени, затрачиваемому на определение координат.

Оптимальным для большинства задач является уровень PREC_MEDIUM. Разработчики не рекомендуют использовать высокую и очень высокую точность для операций, требующих быстрого реагирования. Разница между уровнями точности может быть проиллюстрирована примером UTouch_QuickDraw, поставляемым вместе с библиотекой UTouch.

Эта программа позволяет рисовать на дисплее при помощи сенсорного экрана:#include
UTFT myGLCD(CTE32HR,25,26,27,28);
#include
UTouch myTouch(6,5,4,3,2);
void setup() { myGLCD.InitLCD(); myGLCD.clrScr(); myTouch.InitTouch(PORTRAIT); myTouch.setPrecision(PREC_MEDIUM);
}
void loop() { long x, y; while (myTouch.dataAvailable() == true) { myTouch.

read(); x = myTouch.getX(); y = myTouch.getY(); if ((x!=-1) and (y!=-1)) { myGLCD.drawPixel (x, y); } }
}
Попробуйте скомпилировать этот пример с различными значениями параметра команды setPrecision и вы сразу же почувствуете разницу.

dataAvailable – функция, возвращающая логическое значение true, eсли в момент ее вызова зафиксировано касание сенсорного экрана. В остальное время – возвращает значение false.

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

if (myTouch.dataAvailable()) {

myGLCD.fillScr(0,255,0);
}else {myGLCD.fillScr(255,0,0);} содержала вызов функции dataAvailable, по срабатыванию которой происходило изменение цвета дисплея, которое сохранялось на все время касания. Рассмотрим еще один пример – измерение времени касания в миллисекундах:#include
UTFT myGLCD(CTE32HR,25,26,27,28);
extern uint8_t BigFont[];
#include
UTouch myTouch(6,5,4,3,2);
void setup() {
myGLCD.InitLCD();
myGLCD.setFont(BigFont);
myTouch.InitTouch();
myGLCD.clrScr();
}
void loop() {
unsigned long timeOld;
unsigned long timeNew;
if (myTouch.dataAvailable() == true){
timeOld=millis();
while (myTouch.dataAvailable() == true) {
timeNew=millis();
}
myGLCD.clrScr();
myGLCD.printNumI(timeNew-timeOld, 100, 100);
}
}
в момент касания сенсорного дисплея программа сохраняет текущее значение функции millis в переменной timeOld. Далее, до тех пор, пока касание сохраняется, программа постоянно обновляет текущее значение millis в переменной timeNew. Как только касание прекратилось – на дисплей выводится разность между этими двумя переменными, которая и будет равна времени касания в миллисекундах. Итак, теперь мы умеем работать с событием «касание сенсорного экрана», можем определить момент касания, его продолжительность и момент отпускания. Осталось совсем немного – получить координаты точки касания. Для этого предназначены следующие команды:

read – запускает процедуру определения координат точки касания.

Эта команда не передает никаких параметров и не возвращает никакого значения. Ее следует запускать, когда функция dataAvailable принимает значение true. Полученные координаты в «сыром» виде сохраняются во внутренних переменных TP_X и TP_Y.

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

getX – возвращает значение X-координаты точки касания в пикселях относительно левого края дисплея.

Читайте также:  Raspberry pi foundation анонсировали новый мини-пк raspberry pi 3 model a+

getY – возвращает значение Y-координаты точки касания в пикселях относительно верхнего края дисплея.

При условии правильно выполненной калибровки и достаточной точности сенсорного экрана, координаты точки касания должны совпадать с координатами конкретного пикселя. Тип возвращаемых значений для этих двух функций – int. Следующий пример при касании сенсорного экрана выводит на дисплей координаты точки касания в пикселях и в «сыром» формате:#include
UTFT myGLCD(CTE32HR,25,26,27,28);
extern uint8_t BigFont[];
#include
UTouch myTouch(6,5,4,3,2);
void setup() { myGLCD.InitLCD(); myGLCD.setFont(BigFont); myTouch.InitTouch(); myGLCD.clrScr();
}
void loop() {
int X_RAW;
int Y_RAW;
int X;
int Y;
if (myTouch.dataAvailable() == true){
myTouch.read();
X_RAW=myTouch.TP_X;
Y_RAW=myTouch.TP_Y;
X=myTouch.getX();
Y=myTouch.getY();
myGLCD.clrScr();
myGLCD.print(“X”, 100,80);
myGLCD.print(“Y”, 200,80);
myGLCD.print(“PIX”, 20,100);
myGLCD.print(“RAW”, 20,120);
myGLCD.printNumI(X, 100, 100);
myGLCD.printNumI(Y, 200, 100);
myGLCD.printNumI(X_RAW, 100, 120);
myGLCD.printNumI(Y_RAW, 200, 120);
}
}
Теперь для того, чтобы обработать, например, нажатие экранной кнопки достаточно убедиться, что полученные координаты точки касания находятся внутри области, занимаемой на дисплее данной кнопкой. Вот еще один пример:#include
UTFT myGLCD(CTE32HR,25,26,27,28);
extern uint8_t BigFont[];
#include
UTouch myTouch(6,5,4,3,2);
void setup() { myGLCD.InitLCD(); myGLCD.setFont(BigFont); myTouch.InitTouch(); myGLCD.clrScr();
}
void loop() {
int X;
int Y;
myGLCD.drawRect(100,100,150,150);
if (myTouch.dataAvailable() == true){
myTouch.read();
X=myTouch.getX();
Y=myTouch.getY();
if (X>100 && X100 && Y

Источник: https://habr.com/post/196864/

Датчик отпечатков пальцев R307 и Arduino

Оптические датчики отпечатков пальцев обычно используются в системах безопасности. Эти сенсоры включают в себя DSP чип, который обрабатывает изображение, производит необходимые расчеты для обнаружения соответствия между записанными и текущими данными. Недорогие датчики отпечатка пальцев позволяют записать до 162 разных отпечатков пальцев!

Сенсор поставляется с софтом для Windows, что значительно облегчает его тестирование. С использованием родного софта можно даже отобразить фотографию вашего отпечатка на мониторе! Ну и самое замечательное – есть отдельная библиотека для Arduino, с использованием которой можно настроить датчик меньше чем за 10 минут.

Видео с кратким описанием на английском языке представлено ниже:

Технические характеристики датчика отпечатка пальца

  • Напряжение питания: 3.6 – 6.0 В (постоянный ток);
  • Рабочая сила тока: 120 мА;
  • Максиммальная сила тока: 150 мА;
  • Время обработки изображения отпечатка: < 1.

    0 секунды;

  • Размер окна: 14 мм x 18 мм;
  • Количество одновременно записываемых файлов: 162 файлов;
  • Уровень безопасности (от 1 до 5);
  • Интерфейс (подключение): TTL последовательный;
  • Скорость передачи данных (Baud rate): 9600, 19200, 28800, 38400, 57600 (по умолчанию 57600);
  • Рабочий диапазон температур: от -20 C до +50 C;
  • Допустимый уровень влажности: 40 % – 85 % RH;
  • Габаритные размеры: 56 x 20 x 21.5 мм;
  • Вес: 20 грамм.

Запись в память и поиск данных

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

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

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

Как уже говорилось выше, самый простой путь записи новых данных в память оптического датчика отпечатков пальцев – программа для Windows. К сожалению, для других ОС программное обеспечение не предусмотрено.

Сначала надо подключить сенсор к компьютеру с помощью USB-to-serial конвертера. Загрузите 'blank sketch' на ваш Arduino (Uno или Mega):

// этот скетч дает вам возможность обойти чип Atmega

// и подключить датчик отпечатка пальца непосредственно к USB/Serial конвертеру

// Красный подключается к +5V

// Черный подключается к Ground

// белый подключается к Digital 0

// Зеленый подключается к Digital 1

void setup() {}

void loop() {}

Скетч “blank” не работает на Arduino с чипом ATmega32u4 (Leonardo и Micro). Для этих моделей используйте скетч Leo_passthru!

Если вы используете Leonardo, Micro, Yun, или другой контроллер на базе ATmega32U4, загрузите скетч Leo_passthru вместо скетча “blank”.

//Leo_passthru

// дает возможность Leonardo выполнять роль моста между

// сенсором отпечатков пальцев и Windows.

// Красный подключается к +5V

// Черный подключается к Ground

// Зеленый подключается к Digital 0

// Белый подключается к Digital 1

void setup() {

Serial1.begin(57600);

Serial.begin(57600);

}

void loop()

{

while (Serial.available())

Serial1.write(Serial.read());

while (Serial1.available())

Serial.write(Serial1.read());

}

Датчик отпечатка пальца подключается к Arduino в соответствии с комментариями в скетче после! Загрузки программы на Arduino.

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

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

Запустите программу SFGDemo и выберите в меню пункт Open Device в левом углу. Выберите COM порт, к которому подключен ваш Arduino.

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

Вы можете изменить скорость передачи данных (baund rate) в нижнем левом углу и уровень безопасности (security level – насколько чувствительный датчик), но не рекомендуется трогать эти настройки, пока вы не убедитесь, что все работает.

По умолчанию скорость передачи данных равна 57600 baud, а уровень безопасности равен 3. Если установлены другие значения, установите их на приведенные выше.

Теперь давайте загрузим новый отпечаток пальца! Выберите пункт меню Preview и нажмите кнопку Enroll рядом с ним (Con Enroll значит 'Continuous' (без остановки). Удобная опция, если вы собираетесь записывать много отпечатков пальцев). Когда появится новое меню, укажите ID #, который вы хотите использовать. Вы можете использовать 162 ID номера.

Программа предложит вам приложить палец к сенсору:

Вы можете увидеть превью (если вы нажмете чекбокс preview) вашего отпечатка пальца.

После этого вам надо будет повторить процесс. Используйте тот же палец!

После успешного завершения, вы увидите сообщение:

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

Поиск изображения с помощью софта

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

Когда появится запрос, приложите другой/тот же палец к датчику отпечатка пальца.

Если это тот же палец, должно появится окно с ID #:

Если этого отпечатка нет в базе данных, появится окно с предупреждением:

Подключаем и используем датчик отпечатка пальца с Arduino

После проверки работоспособности, можно переходить к использованию сенсора со скетчем Arduino. Для этого надо перепрошить сенсор. Отключите зеленый и белый контакты и подключите зеленый проводник к контакту digital 2, а белый – к digital 3.

Эти пины можно изменить в дальнейшем, но на данном этапе лучше использовать именно их. На рисунке ниже показан пример подключения датчика отпечатков пальцев к Arduino. Осле подачи питания сенсор подмигнет красным светодиодом.

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

Для тех, кто использует Arduino Leonardo: Leonardo не поддерживает последовательный интерфейс на пинах 2 и 3. Используйте контакты 8 и 9 для подключения и не забудьте внести соответствующие изменения в скетч.

Для тех, кто использует Mega: Mega не поддерживает последовательный интерфейс на пинах 2 и 3. Используйте контакты 10 и 11 и внесите необходимые изменения в скетч.

После подключения, скачайте Adafruit-Fingerprint-Sensor-Library . Для тех, кто устанавливает дополнительные библиотеки впервые, есть полная инструкция по установке библиотек для Arduino.

После установки библиотеки, не забудьте перезагрузить Arduino IDE.

После перезагрузки вы сможете загрузить пример скетча File→Examples→Adafruit_Fingerprint→fingerprint. Загрузите этот скетч на ваш Arduino. Откройте окно серийного монитора, установив скорость передачи данных на 9600 baud и, когда появится запрос, прислоните палец к сенсору отпечатка пальца.

Вы должны увидеть примерно следующее:

Если вам нужен более детальный отчет, замените в пределах цикла loop() функцию getFingerprintIDez() на getFingerprintID(). Эта функция предоставит вам полный отчет о том, что именно сенсор определяет в каждый момент поиска.

Взаимодействие с Arduino

На данном этапе мы уже научились опознавать отпечаток пальца через с использованием Arduino скетча.

Этот процесс не настолько удобный и наглядный как использование софта для Windows, но вполне работоспособный.

Теперь откройте скетч File→Examples→Adafruit_Fingerprint→enroll и загрузите его на ваш Arduino. Подключение датчика отпечатков пальцев остается таким же как и в предыдущем пункте.

Когда вы откроете окно серийного монитора, вам будет предложено ввести ID, под которым будет записываться отпечаток пальца. Используйте строку в верхней части серийного монитора для ввода номера, под которым вы хотите сохранить изображение и нажмите Send.

После этого следуйте инструкциям. Когда загрузка пройдет успешно, отобразится надпись Stored!

После записи не забудьте провести поиск изображения, чтобы убедиться в успешности записи отпечатка пальца!

Источник: http://www.electronica52.in.ua/proekty-arduino/datchik-otpechatkov-palcev-i-arduino-

Оценка статьи:
1 звезда2 звезды3 звезды4 звезды5 звезд (нет голосов)
Загрузка...
Поделиться с друзьями:
Ссылка на основную публикацию
Похожие публикации
Adblock
detector