Навчальні конструктори та DIY електроніка

Резистивная панель

2016-01-27

Сенсорная панель управления

Небольшие 4-проводные резистивные сенсорные экраны в настоящее время удивительно недороги: они производятся в таких огромных количествах для мобильных телефонов, КПК, и в особенности портативных игровых консолей, таких как Nintendo DS, что их можно купить новыми за менее 10 чем долларов США.

Большие сенсорные экраны также стремительно теряют в цене. Популярность нетбуков с экранами размером от 7 до 10 дюймов привело к здоровой ситуации на рынке сенсорных экранов, которые могут быть модернизированы с их помощью и подключены к внутреннему порту USB. Несмотря на то, что они поставляются с управляющей электроникой и интерфейсом USB, эти экраны являются преимущественно 4-проводными резистивными устройствами, поэтому если вы отбросите модуль управления, который поставляется с ними и будете работать непосредственно с экраном, вы можете получить 10-дюймовый сенсорный экран на Arduino! И если вы хотите пойти еще дальше, на eBay часто доступны 15-, 17- и 19-дюймовые комплекты экранов по цене ниже $ 150.

Заметим, однако, что то, что рекламируется, как "сенсорный экран" на самом деле не полноценный экран с ЖК-дисплеем. Это всего лишь прозрачные стеклянные и пластиковые панели, которые устанавливаются перед соответствующего размера дисплеем так, чтобы процессор мог определить координаты точки на экране, к которой касаются в настоящий момент. Если вы хотите чтобы ваша Arduino отображала информацию на экране и давала выбирать её или управлять ею касанием, вам придётся выполнить немного больше работы по созданию ЖКИ, что выходит за рамки обсуждения сенсорных экранов.

И всё-же, сенсорный экран очень удобное устройство. Они очень тонкие и могут быть смонтированы на любой плоской поверхности, а не только на ЖКИ, так что они отлично подходят для создания маленьких пользовательских панелей управления с "кнопками", напечатанной на выходящем за пределы сенсорного экрана поле. Все что вам нужно -
это сделать карту X/Y-координат кнопок и ваша Arduino сможет выяснить какая кнопка была нажата путем сопоставления координат. Конечно, панель управления может представлять ещё что-нибудь, а не только кнопки. Вы могли бы поместить на неё ползунок чтобы выбирать громкость или температуру, прикоснувшись где-то на изображённой линейке , или это может быть план дома, так-что вы могли-бы управлять освещением в разных комнатах, прикоснувшись к выбранной частью поэтажного плана.

В рамках данного проекта мы смонтируем сенсорную панель от Nintendo DS на подрозетнике от стеновой электрической розетки для создания сенсорной панели управления, которая может связываться с системой домашней автоматизации. Методика описанная здесь, должна работать с почти любой доступной 4-проводной резистивной сенсорной панелью, но стоить отметить, что некоторые сенсорные экраны изготовлены с использованием других технологий, таких как емкостные и ИК, поэтому убедитесь, что точно покупаете резистивный экран. Необходимые компоненты показаны на рисунке 8-1, а схема приведена подключения - на рисунке 8-2.

Тач-панель

Рис. 8-1. Компоненты, необходимые для подключения резистивной сенсорной панели

Требуемые компоненты:

  • 1 шт Arduino Duemilanove, Mini, Pro Mini, или подобная
  • 1 шт сенсорная панель Nintendo DS
  • 1 шт терминальная плата для сенсорной панели
  • 1 шт подрозетник для стеновой электрической розетки
  • 1шт четырёхштырьковый разъём "папа"
  • Исходный код, доступный по адресу www.practicalarduino.com/projects/touch-control-panel.

Подключение сенсорной панели

 

Указания

Чтение резистивного сенсорного экрана - это не совсем так просто как кажется на первый взгляд, потому что несмотря на то, что вы можете прочитать в Интернете на различных форумах и в блогах Arduino, они не имеют конкретных выходов для считывания значений X и Y. Вы не можете читать X- и Y-оси одновременно: нужно настраивать выводы в одну конфигурацию для чтения значения X, и менять их на другую конфигурацию для чтения значения Y. На практике это может быть сделано настолько быстро, что нет никакого способа, при помощи которого пользователь может сказать вы не читаете значения X и Y одновременно.

Как только вы поймете физическое строение сенсорного экрана, вы поймете почему они не имеют простых подключений к питанию, земле, X, Y и, как хотело-бы большинство людей.

Как работает резистивный экран

Резистивная сенсорная панель состоит из нескольких слоёв пластика на стеклянной подложке, которая обеспечивает жёсткость всей конструкции. Над этой подложкой расположена тонкая пластиковая пластинка с резистивным покрытием. В некоторых сенсорных панелях резистивный слой наносится непосредственно на стеклянную подложку, что даёт тот-же результат. Над ней располагается слой пластика с микроточками, которые представляют собой крошечные распорки, установленные на поверхности для поддержки второго слоя пластика, также покрытого резистивным материалом (см .рис. 8-3).

Принцип работы сенсорного дисплея

 

Когда к экрану не прикасаются, микроточки отделяют два резистивных слоя друг от друга, что оставляет их не соединёнными. Если к верхнему слою прикоснуться, он деформируется и вступит в контакт с нижний слоем, что позволяет проводить электричество из одного слоя в другой. Каждая из четырех сторон сенсорного экрана содержит проводящий электрод, который расположен по всей длине ребра и подключается к резистивной поверхности на верхнем или нижнем слое, совпадающем по оси. Например, левый и правый края могут соединяться с лицевым слоем, в то время как верхняя и нижняя кромки подключаться к заднему слою (рис. 8-4).

 

Координаты на сенсорном экране
Рис. 8-4. Электроды осей X и Y в резистивной сенсорной панели

Эти четыре электрода выведены на разъём сенсорной панели как X1, X2, Y1 и Y2, хотя порядок нумерации на разъеме может варьироваться в зависимости от конкретной марки и модели сенсорного экрана. Если у вас есть сенсорный экран без каких-либо данных к нему, вы можете выяснить пары соединений путем измерения сопротивления между ними мультиметром в то время, когда к экрану не прикасаются. Каждые соответствующие пары будут иметь сопротивление между ними где-то около 1K или ниже,
в то время как несоответствующие электроды будут разомкнуты.

Чтобы прочитать одну ось координаты касания к экрану, один из слоев подключается к GND с одной стороны и +5 В с другой для обеспечения непрерывно изменяющегося напряжения на поверхности этого слоя. Затем один из выводов на другом слое считывается с помощью аналогового ввода для определения относительного положения
контакта между двумя краями: если ближе к краю GND, будет читаться меньшее напряжение, а если коснуться ближе к краю с +5 V, то читаемое напряжение будет выше. При этом контакты, подключенные к первому слою, должны быть настроены как цифровой выход и подключены к GND и +5 В, в то время как один из контактов, подключенных к другому слою, должен быть настроен как аналоговый вход для считывания прикосновения.

Чтение других осей требуется переключения между выводами таким образом, чтобы слой, ранее подключённый к аналоговому входу, был переключен на GND и +5V, а один из электродов другого слоя, был включён на аналоговый вход для чтения из него данных.

С Arduino это довольно легко, так как выводы аналогового входа на самом деле являются и выводами цифрового ввода-вывода общего назначения, и их режим может переключаться в программе при необходимости. Нам не нужно тратить время и линии ввода-вывода для внешней коммутации подключения к сенсорной панели к аналоговому входу или GND и +5 В. При подключении выводов X1, X2, Y1 и Y2 сенсорного экрана прямо на 4 аналоговых входа мы можем использовать программное обеспечение для переключения режимов коммутации между показаниями и использовать их как цифровые выходы, которые обеспечивают GND и +5 В на любом слое так, как требуется в данный момент.

В разъёме сенсорной панели Nintendo DS выводы расположены в следующем в порядке: Y1, X2, Y2 и X1. Для максимального упрощения физических соединений мы проведём подключение к аналоговым входам от A0 до A3 соответственно, как показано ниже:

Y1 к A0
X2 к A1
Y2 к A2
X1 к A3

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

Начнём с определения переменных для хранения прочитанных с экрана значений:

int xVal = 0; 
int yVal = 0; 

Далее мы настраиваем последовательное подключение к компьютеру для передачи значений X и Y, как показано ниже:

void setup() 
{ 
  Serial.begin(38400); 
  Serial.println("Starting up touch screen reader"); 
} 

Основной цикл программы читает значения X и Y при каждом проходе. При чтении значения X вывода аналогового входа, соответствующие оси Y, переключаются на цифровой вывод, а затем происходит чтение аналогового значения. Один дополнительный шаг, который мы делаем здесь, это ожидание 2 мс после настройки выводов для стабилизации установленного напряжения. Аналоговые выводы Arduino очень чувствительны к вихревым токам и напряжения, индуцированные поблизости
переключаемых выходов в непосредственной близости от аналогового входа, могут привести к получению ложных данных. Добавление задержки в несколько миллисекунд позволяет вводу стабилизироваться и даёт более устойчивое чтение.

void loop() 
{ 
  pinMode( 15, INPUT );     // Аналоговый вывод 1 
  pinMode( 17, INPUT );     // Аналоговый вывод 3 
  pinMode( 14, OUTPUT );    // Аналоговый вывод 0 
  digitalWrite( 14, LOW );  // Используем аналоговый вывод 0 как подключение к GND
  pinMode( 16, OUTPUT );    // Аналоговый вывод 2 
  digitalWrite( 16, HIGH ); // Используем аналоговый вывод 2 как подключение к +5V connection  
  delay(2);                 // Ждём стабилизации напряжения
  xVal = analogRead( 1 );   // Читаем значение X

На данный момент у нас есть значение с оси X, но еще нет значения с оси Y. Далее нам нужно переключить режимы выводов и сделать то же самое для оси Y.

  pinMode( 14, INPUT );     // Аналоговый вывод 0 
  pinMode( 16, INPUT );     // Аналоговый вывод 2 
  pinMode( 15, OUTPUT );    // Аналоговый вывод 1 
  digitalWrite( 15, LOW );  // Используем аналоговый вывод 1 как подключение к GND
  pinMode( 17, OUTPUT );    // Аналоговый вывод 3 
  digitalWrite( 17, HIGH ); // Используем аналоговый вывод 3 как подключение к +5V 
  delay(2);                 // Ждём стабилизации напряжения 
  yVal = analogRead( 0 );   // Читаем значение Y

Теперь у нас есть значения координаты по обеим осям, так-что мы наконец передаём их компьютеру по USB-соединению и немного ждём перед повторением действий, как показано ниже:

  Serial.print(xVal);  
 
  Serial.print(",");  
  Serial.println(yVal);  
 
  delay (200);  
}  

Вот и все! На самом деле не так трудно когда понятно что происходит. Полный исходный код для этого скетча можно получить на странице проекта на веб-сайте Practical Arduino и называется TouchscreenCoordinates.

Простой тест подключения сенсорной панели

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

В примере на рис. 8-5 показан разъём от SparkFun с защёлкой, удерживающей шлейф в разъёме. Перед тем как шлейф может быть вставлен, следует освободить фиксаторы, сдвинув их навстречу шлейфу. После того, как вы вставите шлейф, фиксаторы следует задвинуть обратно в разъём.

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

Ещё одна вещь, на которую следует обратить внимание, это толщина шлейфа сенсорной панели. Разъём создан для прочного удерживания шлейфов толщиной 0,3 мм, но большинство их у сенсорных панелей имеют толщину 0,1 мм и будут вываливаться из разъёма если у них нет утолщающей прокладки на конце. По некоторым причинам сенсорные панели могут поставляться с наклеенной на шлейф прокладкой или без, и вы не узнаете есть-ли она на панели пока не купите эту панель.

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

Вы можете припаять соединительные провода или ленточный шлейф из проводов к терминальной плате, или вы можете припаять на ней 4-хконтактный штырьковый разъём чтобы включать его в прямо в дочернюю плату или в Arduino.

Терминальные платы SparkFun проводят контакты с сенсорных экранов в том же порядке, в каком они выведены на шлейфе, то есть Y1, X2, Y2, и X1. Например, ранее показанный код также использует этот порядок, так что для простой проверки испытаний связи вы можете подключить его прямо в аналоговые входы от 0 до 3.

Рис. 8-5 показывает подключение панели Nintendo DS к Arduino Pro с использованием терминальной платы SparkFun. Обратите внимание, что в этой картинке сенсорный экран перевёрнут вверх ногами для получения доступа к его поверхности когда он будет установлен над Arduino.

Сенсорная панель и Arduino

Рис. 8-5. Сенсорная панель Nintendo DS подключена к Arduino Pro при помощи терминальной платы SparkFun с припаянным к ней штырьковым разъёмом

Подключение непосредственно к Arduino, вероятно, не очень удобно, так что удобно иметь под рукой короткий удлинитель, состоящий из 4-проводного шлейфа с разъёмами "мама" на одном конце и "папа" на другим.

Чтобы проверить сенсорную панель, подключите её к Arduino, затем загрузите предыдущий скетч примера в Arduino IDE, скомпилируйте его, и выгрузить на Arduino. Затем активируйте последовательный монитор в IDE и убедитесь что он установлен в 38400 bps чтобы вы могли видеть значения, полученные от Arduino при нажатии различных частей сенсорного экрана. Попробуйте подвигать пальцем или стилусом по экрану чтобы увидеть как изменяется координата при перемещении вдоль одной оси, а также изменения значений по другой оси.

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

Библиотека Arduino TouchScreen

Предыдущий скетч - отличный способ понять как работать с сенсорными экранами и как взаимодействовать с ним, но фрагменты кода, которые переключают аналоговые выводы немного болезненны и повторяемы. Чтобы облегчить написание программ, которые используют сенсорные экраны, мы создали библиотеку Arduino, которая содержит все тезисы подробной информации о себе. Библиотека называется TouchScreen и вы можете найти ссылку на неё на страницах веб-сайта проекта Practical Arduino.

После того, как вы скачали и установили библиотеку TouchScreen, вы можете работать с экраном ещё более простым скетчем, который включён в библиотеку как пример. В интегрированной среде разработки Arduino выберите "File" -> " Sketchbook" -> "Examples" -> "Library-TouchScreen" -> "ReadTouchscreen" для его загрузки. Этот пример имеет ту-же функциональность что и программа, которую мы рассматривали раньше, но он более выразителен.

#include <TouchScreen.h>
TouchScreen ts(3, 1, 0, 2); 
void setup() 
{ 
  Serial.begin(38400); 
} 
void loop() 
{ 
  int coords[2]; 
  ts.Read(coords); 
  Serial.print(coords[0]); 
  Serial.print(","); 
  Serial.println(coords[1]); 
  delay (200); 
}

Намного аккуратнее!

Подробное пояснение как была написана библиотека TouchScreen, размещено в главе 16, "Написание библиотеки для Arduino".

Управляющая программа на Processing

Рассматривать голые числа на экране интересно первые 20 секунд, а для того чтобы сделать что-то более видимое, мы написали маленькую демонстрационную программу на языке Processing для преобразования эти координаты в визуализацию 3D-куба. Processing - это родственный Arduino проект: в то время как Arduino контролирует физические события, Processing выполняет всё, что связанно с визуализацией, обработкой изображения и представляет события графически. Фактически среда разработки Arduino основана на среде разработки Processing, так-что если вы знакомы с одной, то будете чувствовать себя как дома и в другой.

Чтобы запустить программу 3D-куба, вам требуется скачать последнюю версию Processing с www.processing.org и установить у себя на компьютере. Вы можете скачать скетч TouchCube с сайта проекта Practical Arduino.

Программы Processing следуют простой структуре, очень сходной с программами Arduino. Они имеют функцию setup() в начале, но вместо главного программного цикла, именуемого loop(), они имеют другой - draw().

Первое, что делает программа TouchCube, это включает класс последовательного порта и создаёт экземпляр объекта этого класса с именем myPort.

import processing.serial.*; 
Serial myPort;

Далее мы устанавливаем переменные для хранения значение из Arduino и текущее положение камеры.

int touchX;        // Значение координаты X, полученное по последовательному порту
int touchY;        // Значение координаты Y, полученное по последовательному порту
float xPos = 512;    // Координата X текущего положения камеры
float yPos = 512;    // Координата Y текущего положения камеры

Функция setup определяет какой величины окно мы будем использовать для визуализации используя функцию size(), устанавливает цвет заполнения заднего плана, а затем открывает последовательный порт для ожидания значений от платы Arduino.

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

void setup() 
{ 
  size( 800, 600, P3D ); 
  fill( 204, 104, 0 ); 
  myPort = new Serial(this, Serial.list()[0], 38400); 
  myPort.bufferUntil('\n'); 
} 

Главный цикл программы, называемый draw(), не требует ничего, так как всё сделано в обработчике событий. Но мы всё-таки должны объявить его:

void draw() {  
  // Здесь нечего делать! 
}

Следующая часть может походить на волшебство, поскольку мы объявляем функцию, которую не вызываем нигде в коде. Однако объект serial использует эту функцию как перехватчик событий, который запускается автоматически при наступлении события. В данном случае она вызывается когда последовательный порт буферизировал некоторые данные, а затем получил символ перевода строки, как было указано в функции setup() при помощи bufferUntil('\n'). Когда это происходит, вызывается функция serialEvent() и ей передаётся объект последовательного порта (с именем myPort), так-чтобы обработчик мог с ним работать.

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

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

void serialEvent( Serial myPort ) 
{ 
  String inString = myPort.readStringUntil( '\n' );

Далее, если мы получили какие-то данные, а не просто один символ перевода строки без других символов, мы продолжаем обрабатывать их. Мы также должны обрезать пробельные символы без цифр или букв при помощи функции trim(), как показано ниже:

if( inString != null ) 
  { 
    inString = trim( inString );

В этом месте мы имеем значение, которое будет выглядеть подобно "32,874", сохранённое в переменной, так-что нам требуется разделить его, используя как разделитель запятую и поместить получившиеся кусочки в массив.

int[] coordinates = int( split( inString, ',' ) );

Наконец мы разделили координаты X и Y и теперь можем что-нибудь сделать с ними. Так как сенсорная панель, к которой не прикасались, вернёт очень большое или очень маленькое значение в диапазоне от 0 до 1023, мы сузим границы диапазона. Таким образом, мы будем обновлять значение если к экрану прикасались и оставлять его без изменений - если нет.

touchX = coordinates[0]; 
    if( touchX > 20 && touchX < 1000 ) {

При выгрузке координаты мы применяем некоторые хитрости для масштабирования, основанного на размере окна, которое мы создали раньше. Функция map получает входящую переменную и два диапазона: первый - допустимый диапазон для ввода, а второй - требуемый диапазон вывода. Что мы и делаем здесь - берём значение touchX и говорим что оно находится между 0 и 1023, но нам надо перенести его его в диапазон от 0 до величины ширины окна.

    xPos = map( touchX, 0, 1023, 0, width ); 
    }

Далее мы делаем то-же самое с координатой Y.

    touchY = int( coordinates[1] ); 
    if( touchY > 20 && touchY < 900 ) { 
      yPos = map( touchY, 0, 1023, 0, height ); 
    } 

Мы почти готовы нарисовать куб! Следующий раздел активирует свет в окне и устанавливает фон.

    lights(); 
    background( 51 ); 

И наконец мы устанавливаем положение камеры на основании извлечённых координат и рисуем 3D-куб.

    camera( xPos, yPos, 100.0, // eyeX, eyeY, eyeZ 
         0.0, 0.0, 0.0,        // centerX, centerY, centerZ 
         0.0, 1.0, 0.0 );      // upX, upY, upZ 
    noStroke(); 
    box( 150 ); 
    stroke( 255 ); 
    line( -100, 0, 0, 100, 0, 0 ); 
    line( 0, -100, 0, 0, 100, 0 ); 
    line( 0, 0, -100, 0, 0, 100 ); 
  } 
}

С подключённой платой Arduino и запущенным скетчами TouchscreenCoordinates или ReadTouchscreen, описанными ранее и запущенной на компьютере программой TouchCube вы сможете при помощи движения пальцем по поверхности сенсорной панели Nintendo изменять положение нарисованного куба. Только одно замечание: отключите монитор последовательного порта в Arduino IDE. В противном случае Processing не сможет открыть порт для получения координат. Вы можете заметить, что изображение изменяется рывками, поскольку оно обновляется немедленно после получения новой координаты. Чтобы уменьшить этот эффект, можно использовать маленький FIFO-буфер (First In, First
Out - первый вошёл, первый вышел), который содержит, например, три последних координаты и вычисляет из них положение камеры методом усреднения.

Постройка аппаратной части системы автоматизации дома

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

Мы хотели, чтобы наш прототип вставлялся в стандартный подрозетник для настенных электророзеток. Сенсорный экран Nintendo DS почти точно подходит к размерам панели, так-что поместим его сверху, отметим контур тонким карандашом, затем аккуратно вырежем этот контур ножовкой так, чтобы отверстие было чуть больше экрана и экран мог быть вставлен в панель (см. рис. 8-6).

Подрозетник с сенсорной панелью

Рис. 8-6. Стеновой подрозетник с вырезом для сенсорного экрана

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

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

Приложив немного усилий, вы даже можете создать распознавание таких вещей как круговое движение пальца подобно колёсику управления в iPod: по часовой для увеличения громкости или яркости, против часовой - для уменьшения.

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

Области для нашего прототипа размечены для включения-выключения вытяжного вентилятора, открытия/закрытия электрически управляемых штор и полоска скольжения для регулировки интенсивности освещения (см. рис. 8-8).

Сенсорный дисплей с изображениями

Рис. 8-8. Сенсорная панель с изображением графических кнопок под поверхностью

Фон, однако, не ограничивается статичными элементами. Вы можете просверлить отверстия в подложке и установить светодиоды чтобы показывать текущий статус управляемого элемента или вырезать прямоугольное отверстие и установить 7-сегментный дисплей или даже ЖКИ-модуль в панели.

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

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

Калибровка горячих зон

Подключите собранную панель к вашей Arduino, подключите USB к вашему компьютеру и запустите ранее описанный пример. Откройте последовательный монитор так, чтобы вы могли видеть значения X и Y, переданные Arduino.

Нарисуйте примерный эскиз расположения кнопок, а затем используйте стилус чтобы коснуться диагонально расположенных углов каждой из них. Перепишите значения X и Y в ваш скетч. Для нашего прототипа мы напечатали увеличенную (до 150%) картинку фоновой графики и записали данные прямо на ней (см .рис. 8-9).

Калибровка сенсорной панели

Рис. 8-9. Калибровка сенсорной управляющей панели определением координат X и Y областей кнопок

В итоге вы получите набор координат, определяющий область каждой кнопки. Если вы используете просто прямоугольные области, несложно будет записать их в таблицу, которая показывать диапазоны X и Y для каждой кнопки (см. таблицу 8-1).

Таблица 8-1. Пример координат X и Y для областей кнопок

Кнопка Xmin Xmax Ymin Ymax
Вентилятор вкл 696 866 546 831
Вентилятор выкл 696 866 208 476
Шторы открыть 420 577 540 866
Шторы закрыть 420 577 208 476

Вы заметите, что для нашего прототипа значения X и Y начинаются не с нижнего левого или верхнего левого угла как можно было-бы ожидать. Вообще это не имеет значения и легко настраивается в своей программе, а также может быть изменено переподключением соединений выводов сенсорной панели. В этом случае мы могли изменить координаты, просто повернув панель на 180 градусов, чтобы координата 0,0 была вверху слева. Несмотря на это, она отлично работает в любом положении.

Определив координаты углов кнопок, должно быть достаточно очевидно что необходимо сделать в программном обеспечении для проверки нажатия в горячей зоне: проверить значения X и Y и сравнить их с определенным диапазоном, и если совпадение найдено, то кнопки, как считается, была нажата. С авто-контролем не намного сложнее, и просто в ответ добавляется величина, пропорциональная координатеY-оси в кнопке.

Пример скетча ReadTouchscreen, включённый в библиотеку TouchScreen - хорошая начальная точка для системы считывания нажатий кнопок. Всё, что нам надо, это расширить программу включением значений из координатной таблицы в последовательность сравнений для определения какая кнопка была нажата.

#include <TouchScreen.h>
 
TouchScreen ts(3, 1, 0, 2);  
 
void setup()  
{  
  Serial.begin(38400);  
}  
 
void loop()  
{  
  int coords[2];  
  ts.read(coords);  
  Serial.print(coords[0]);  
  Serial.print(",");  
  Serial.print(coords[1]);  
    
  if((coords[0] > 696) && (coords[0] < 866)  
  && (coords[1] > 546) && (coords[1] < 831)) {  
    Serial.print(" Fan ON");  
  }  
  if((coords[0] > 696) && (coords[0] < 866)  
135 

CHAPTER 8   TOUCH CONTROL PANEL 
  && (coords[1] > 208) && (coords[1] < 476)) {  
    Serial.print(" Fan OFF");  
  }  
  if((coords[0] > 420) && (coords[0] < 577)  
  && (coords[1] > 540) && (coords[1] < 866)) {  
    Serial.print(" Drapes OPEN");  
  }  
  if((coords[0] > 420) && (coords[0] < 577)  
  && (coords[1] > 208) && (coords[1] < 476)) {  
    Serial.print(" Drapes CLOSE");  
  }  
  if((coords[0] > 139) && (coords[0] < 327)  
  && (coords[1] > 208) && (coords[1] < 866)) {  
    Serial.print(" Illumination:");  
    Serial.print(map(coords[1], 208, 866, 0, 100));  
    Serial.print("%");  
  }  
    
  Serial.println();  
  delay (1000);  
}  

Как вы можете видеть, ползунок освещённости сообщает не только то, что он был нажат, но и также масштабирует координату Y из области ползунка в диапазон от 0 до 100 чтобы определить процент освещённости, который следует установить для положения нажатия. Касание в верхней его части установит более интенсивную освещённость , в нижней части - менее.

Существует ещё одно улучшение, которые мы можем сделать - это установить чуть большие области вверху и внизу ползунка освещённости для полного включения и выключения. В текущей реализации очень трудно полностью выключить освещение, так как если вы коснётесь самого низа ползунка, всё-равно значение координаты будет 4-5 %, в то время как касание ещё ниже ничего не даст.

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

Также мы можем сделать это в чуть более утончённой форме, используя неявные особенности функции map() для фальсификации значений верха и низа диапазона. Если вы передадите входящее значение функции map(), которое находится вне пределов диапазона - меньше его нижней границы или выше верхней границы диапазона - она вернёт значение, которое находится вне пределов заданного выходного диапазона. Поэтому мы можем изменить раздел кода, относящийся к ползунку освещённости, увеличив нижнюю и уменьшив верхнюю границу чтобы сузить область горячей зоны, как показано ниже:

  if((coords[0] > 139) && (coords[0] < 327)  
  && (coords[1] > 208) && (coords[1] < 866)) {  
    Serial.print(" Illumination:");  
    Serial.print(map(coords[1], 318, 756, 0, 100));  
    Serial.print("%");  
  }

Она вернёт негативные значения для нажатия ниже нижней границы и значения больше 100 процентов для нажатия выше верхней границы диапазона.

Негативные значения и значения больше 100%, очевидно, не имеет смысла, так-что результат должен быть ограничен для попадания в диапазон от 1 до 100. Это делается при помощи функции constrain(), в которую можно "завернуть" функцию map() как показано ниже:

  if((coords[0] > 139) && (coords[0] < 327)  
  && (coords[1] > 208) && (coords[1] < 866)) {  
    Serial.print(" Illumination:");  
    Serial.print(constrain(map(coords[1], 318, 756, 0, 100), 0, 100));  
    Serial.print("%");  
  }

Полная версия этого скетча, TouchControlPanel, доступна для скачивания на страницах проекта на сайте Practical Arduino.

Далее следует определиться с тем, какие кнопки вы хотите сделать. Вы можете управлять устройствами прямо с Arduino или подключить дочернюю плату Ethernet или WiFi и отправлять команды системе автоматики дома при помощи веб-служб.

Просто для развлечения мы создали соответствующую программу на Processing с именем TouchControlPanelDisplay, также доступную для скачивания на странице проекта Practical Arduino. Если вы запустите скетчи TouchControlPanel на плате Arduino и TouchControlPanelDisplay на компьютере, вы получите визуальное представление текущего состояния "горячих зон" сенсорного экрана.

Установка Arduino

Из-за того, что подрозетники имеют мало места и вам требуется только четыре аналоговых входа для чтения сенсорного экрана, этот проект отлично подходит для плат Arduino небольшого форм-фактора, таких как Pro Mini или Arduino Nano. Удостоверьтесь что терминальная плата, подключённая к сенсорному экрану, надёжно укреплена и используйте короткие провода для подключения к разъёмов к аналоговым входам Arduino. Оставшуюся часть установки мы оставляем на вашу изобретательность, поскольку у вас наверняка будут отличные от наших места установки и требования к ней.

Автор: hobbytech


Залишити відповідь

Ваша e-mail адреса не оприлюднюватиметься. Обов’язкові поля позначені *


© HobbyTech 2016