Arduino:Знакомство с Arduino/Знакомство с TFT-модулем Arduino

Материал из Онлайн справочника
Перейти к навигации Перейти к поиску

{{#setlogo:ArduinoCommunityLogo.png}}

Перевод: Максим Кузьмин (Cubewriter) Контакты:</br>* Skype: cubewriter</br>* E-mail: cubewriter@gmail.com</br>* Максим Кузьмин на freelance.ru
Проверка/Оформление/Редактирование: Мякишев Е.А.


Знакомство с TFT-модулем Arduino[1]

TFT-модуль Arduino – это TFT LCD дисплей с функцией подсветки и слотом для SD-карты (она расположен сзади). На этом дисплее можно рисовать текст, изображения и различные фигуры, и все это делается при помощи библиотеки TFT.

ImageOnTFT 1.jpg

Распиновка TFT-модуля Arduino выполнена таким образом, чтобы соответствовать контактам на сокете Arduino Esplora и Arduino Robot. Впрочем, его можно использовать и с любой другой платой Arduino.

Библиотека TFT уже включена в IDE Arduino версии 1.0.5 и выше.

Библиотека

Библиотека Arduino TFT – это расширенная версия библиотек Adafruit GFX и Adafruit STL7735. Библиотека GFX отвечает за функции рисования, а STL7735 – за функции, характерные для экрана, которым оснащен TFT-модуль Arduino. Сверх этого разработчиками Arduino были внесены специальные дополнения, чтобы библиотека TFT работала максимально похоже на Processing API.

Библиотека TFT обладает обратной совместимостью, благодаря чему вы по-прежнему можете пользоваться функциями Adafruit, описанными здесь.

Кроме того, библиотека TFT полагается на библиотеку SPI, поэтому ее нужно подключать ко всем скетчам, где используется TFT-модуль. Если вы собираетесь использовать SD-карту, то вам, к тому же, нужно будет подключить библиотеку SD.

Особенности экрана

По умолчанию экран ориентирован так, что его ширина больше, чем высота. Верх экрана – это там, где находится надпись «SD CARD». В таком положении ширина экрана составляет 160 пикселей, а высота – 128 пикселей.

Чтобы понять, что такое координаты экрана, представьте решетку. Каждый квадратик в этой решетке – это пиксель, и координаты позволяют определить месторасположение этого пикселя, а также любого другого пикселя на экране. Точка в левом верхнем углу экрана имеет координаты «0, 0». Если бы эта точка переместилась в правый верхний угол экрана, у нее были бы координаты «0, 159». Если в левый нижний угол – «127, 0». Если в правый нижний – «127, 159».

Впрочем, экран можно использовать и в вертикальном (его также называют «портретным») режиме, и это делается вызовом функции setRotation(0). После того, как вы вызовете эту функцию, оси X и Y поменяются местами, а функции screen.width() и screen.height() – ролями.

Цвета

Экран способен показывать 16-битный цвет: глубина цвета для синего и красного составляет 5 бит (32 уровня), а для зеленого – 6 бит (64 уровня). Все вместе – как раз 16 бит. Чтобы оставаться совместимой с другими приложениями, библиотека работает с 8-битной глубиной цвета (для всех трех каналов – синего, красного и зеленого). Следовательно, цветовым диапазоном для всех трех цветов будет «0-255» (потому что 8 бит – это 256 уровней). Таким образом, библиотека как бы подтягивает 5 (для синего), 5 (для красного) и 6 (для зеленого) бит до необходимых 8 бит.

SPI-интерфейс – аппаратный и программный

Использование экрана можно настроить двумя способами. Первый – через аппаратный SPI-интерфейс Arduino. Второй – через ручное объявление всех необходимых контактов. Функциональной разницы между двумя этими методами нет, но если использовать аппаратный SPI-интерфейс, рисование происходит значительно быстрее.

Если вы планируете работать с SD-картой, то должны использовать именно аппаратный SPI-интерфейс.

Все примеры ниже написаны для аппаратного SPI-интерфейса.

Подключение экрана

GLCD pinUse 2.png

Подключение к Esplora

Сокет для TFT-модуля находится в самом центре Esplora. Вставьте модуль в сокет таким образом, чтобы синяя надпись «SD CARD» была рядом с USB-портом.

Esplora GTFT 3.png

Подключение к другим Arduino

Чтобы подключить TFT-модуль к другой плате Arduino, читайте это руководство.

Пишем первый скетч

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

Сначала будут описаны инструкции для Uno, Leonardo и других подобных плат. Инструкции для Esplora будут описаны чуть ниже.

Итак, начинаем скетч. Первым делом объявляем контакты, которые будем использовать, подключаем необходимые библиотеки и создаем экземпляр TFT-библиотеки:

 1 #include <TFT.h> // библиотека для используемого устройства
 2 #include <SPI.h>
 3 
 4 #define CS   10
 5 #define DC   9
 6 #define RESET  8  
 7 
 8 // объявляем контакты для Leonardo:
 9 // #define CS   7
10 // #define DC   0
11 // #define RESET  1 
12 
13 TFT myScreen = TFT(CS, DC, RESET);

В блоке setup() запускаем библиотеку при помощи функции begin() и «обнуляем» экран, заливая его черным цветом – это делается при помощи функции background().

1 void setup(){
2   myScreen.begin();  
3   myScreen.background(0,0,0);  // заливаем экран черным цветом
4   delay(1000);  // пауза для драматического эффекта
5 }

В блоке loop() рисуем линию – это делается функцией line(). Она принимает 4 аргумента: стартовые координаты X и Y, а также конечные координаты X и Y. Чтобы нарисовать прямоугольник, воспользуемся функцией rect(). Она тоже принимает 4 аргумента: координаты X и Y для левого верхнего угла, а также ширину и высоту (оба – в пикселях). Работа с цветом осуществляется с помощью функций stroke() и fill() – они вызываются перед функциями создания прямоугольников. Функция stroke() меняет цвет линии прямоугольника, т.е. его контур. Функция fill() меняет цвет прямоугольника. Функция noStroke() отменяет рисование контура у всех прямоугольников, которые будут созданы после ее вызова. Если после этого снова вызвать функцию stroke(), то контуры снова начнут рисоваться.

 1 void loop(){
 2   myScreen.stroke(255, 0, 0); // делаем цвет контура красным
 3   myScreen.line(0, 10, myScreen.width(), 10); // рисуем на экране линию
 4   delay(1000);
 5 
 6   myScreen.noStroke(); // не рисуем контур для нижеследующих прямоугольников
 7   myScreen.fill(0,255,0); // делаем цвет прямоугольника зеленым
 8   myScreen.rect(0,20,myScreen.width(),10); // рисуем прямоугольник
 9   delay(1000);
10 
11   myScreen.fill(0,0,255); // делаем цвет прямоугольника синим
12   myScreen.stroke(255,255,255); // рисуем для прямоугольника белый контур
13   myScreen.rect(0,45,myScreen.width(),45); // рисуем более толстый прямоугольник
14   delay(1000);
15 
16   myScreen.background(0,0,0); // перед тем, как начать снова, очищаем экран
17   delay(1000); 
18 }

Если вы используете Esplora, структура скетча будет той же самой. Поскольку Esplora имеет сокет под TFT-модуль, контакты для дисплея – фиксированные. Кроме того, вы можете обращаться к дисплею, подключенному к Esplora, через объект EsploraTFT.

Никаких контактов объявлять не нужно, а объект EsplloraTFT создается автоматически.

 1 #include <TFT.h> // библиотека для используемого устройства
 2 #include <SPI.h>
 3 #include <Esplora.h>
 4 
 5 void setup(){
 6   EsploraTFT.begin();  
 7   EsploraTFT.background(0,0,0);  // заливаем экран черным цветом
 8   delay(1000);  // пауза для драматического эффекта
 9 }
10 
11 void loop(){
12   EsploraTFT.stroke(255, 0, 0); // делаем цвет линии красным
13   EsploraTFT.line(0, 10, EsploraLCD.width(), 10); // рисуем линию на экране
14   delay(1000);
15 
16   EsploraTFT.noStroke(); //  у следующего прямоугольника контур не рисуем
17   EsploraTFT.fill(0,255,0); //  делаем цвет прямоугольника зеленым
18   EsploraTFT.rect(0,20,EsploraTFT.width(),20); //  рисуем прямоугольник
19   delay(1000);
20 
21   EsploraTFT.fill(0,0,255); // делаем следующий прямоугольник синим
22   EsploraTFT.stroke(255,255,255); // добавляем ему белый контур
23   EsploraTFT.rect(0,45,EsploraTFT.width(),50); // рисуем более толстый прямоугольник
24   delay(1000);
25 
26   EsploraTFT.background(0,0,0); // очищаем экран перед тем, как начать заново
27   delay(1000); 
28 }

Перемещение объектов по экрану

Чтобы создать иллюзию движения, объекты нужно рисовать и тут же стирать, а потом снова рисовать, но уже в другом месте. Если вы используете Processing на мощном компьютере, то можете рисовать объекты с помощью функции draw() и затем стирать их функцией background(), а после снова рисовать эти объекты функцией draw(), но уже на новых позициях. Arduino, однако, работает не так быстро – ей нужно некоторое время, чтобы очистить экран вызовом функции background() из библиотеки TFT.

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

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

 1 #include <TFT.h> // библиотека для используемого устройства
 2 #include <SPI.h>
 3 
 4 #define CS   10
 5 #define DC   9
 6 #define RESET  8  
 7 
 8 // контакты для Leonardo
 9 // #define CS   7
10 // #define DC   0
11 // #define RESET  1 
12 
13 TFT myScreen = TFT(CS, DC, RESET);
14 
15 // начальная позиция точки в середине экрана:
16 int xPos = 80;
17 int yPos = 64;
18 
19 // направление и скорость:
20 int xDir = 1;
21 int yDir = 1;
22 
23 // переменные для отслеживания месторасположения точки:
24 int xPrev = xPos;
25 int yPrev = yPos;
26 
27 void setup(){
28   myScreen.begin();  
29   myScreen.background(0,0,0); // очищаем экран
30 }

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

 1 void loop(){
 2   // обновляем месторасположение точки:
 3   xPos = xPos + xDir;
 4   yPos = yPos + yDir;
 5 
 6   // проверяем, отличается ли текущая локация от предыдущей:
 7   if(xPos != xPrev || yPos != yPrev){
 8     myScreen.stroke(0,0,0); // делаем цвет точки черным 
 9     myScreen.point(xPrev, yPrev); // закрашиваем точку, находящуюся на прежних координатах 
10   }
11 
12   // рисуем точку на текущих координатах:
13   myScreen.stroke(255,255,255);
14   myScreen.point(xPos, yPos);
15 
16   // если координаты X или Y вышли за пределы экрана, реверсируем направление:
17   if(xPos >= 160 || xPos <= 0){
18     xDir = xDir*-1;
19   }
20   if(yPos >= 128 || yPos <= 0){
21     yDir = yDir*-1;
22   }
23 
24   // обновляем предыдущее расположение точки:
25   xPrev=xPos;
26   yPrev=yPos;
27 
28   // делаем задержку в 33 миллисекунды – это значит, что экран будет обновляться 30 раз в секунду:
29   delay(33);
30 
31 }

А вот версия для Esplora:

 1 #include <TFT.h> // библиотека для используемого устройства (т.е. для TFT-модуля)
 2 #include <SPI.h>
 3 #include <Esplora.h>
 4 
 5 // начальная позиция точки (в середине экрана):
 6 int xPos = 80;
 7 int yPos = 64;
 8 
 9 // направление движения и скорость:
10 int xDir = 1;
11 int yDir = 1;
12 
13 // переменные для отслеживания месторасположения точки:
14 int xPrev, yPrev;
15 
16 void setup(){
17   EsploraTFT.begin();  
18   EsploraTFT.background(0,0,0);
19 }
20 
21 void loop(){
22   // обновляем месторасположение точки:
23   xPos = xPos + xDir;
24   yPos = yPos + yDir;
25 
26   // проверяем, отличается ли текущее месторасположение от предыдущего:
27   if(xPos != xPrev || yPos != yPrev){
28     EsploraTFT.stroke(0,0,0); // делаем цвет строки черным 
29     EsploraTFT.point(xPrev, yPrev); // закрашиваем точку на предыдущих координатах 
30   }
31 
32   // рисуем точку на текущих координатах: EsploraTFT.stroke(255,255,255);
33   EsploraTFT.point(xPos, yPos);
34 
35   // если координаты X или Y находятся за пределами экрана, реверсируем направление точки:
36   if(xPos >= 160 || xPos <= 0){
37     xDir = xDir*-1;
38   }
39   if(yPos >= 128 || yPos <= 0){
40     yDir = yDir*-1;
41   }
42 
43   // обновляем предыдущее расположение точки:
44   xPrev=xPos;
45   yPrev=yPos;
46 
47   // небольшая пауза:
48   delay(33);
49 
50 }

Рисуем текст

В библиотеку TFT уже встроен шрифт, с помощью которого на экране можно рисовать текст. По умолчанию ширина символов составляет 5 пикселей, а высота – 8 пикселей. Впрочем, эти размеры можно поменять на 10x16, 15x24 и 20х32.

Дополнительную информацию о возможностях шрифта читайте в этой статье о графических примитивах на сайте Adafruit.

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

Далее переходим к setup() и указываем здесь статический текст, т.е. текст, который меняться не будет. С помощью функции setTextSize() можно увеличить некоторые символы, тем самым выделив их на фоне другого текста. Динамический текст следует хранить в символьном массиве. Лучше всего для этого подойдет класс String – c его помощью легко обновлять находящийся в массиве текст.

 1 #include <TFT.h> // библиотека для используемого устройства (т.е. для TFT-модуля)
 2 #include <SPI.h>
 3 
 4 #define CS   10
 5 #define DC   9
 6 #define RESET  8   
 7 
 8 // контакты для Leonardo:
 9 // #define CS   7
10 // #define DC   0
11 // #define RESET  1 
12 
13 TFT myScreen = TFT(CS, DC, RESET);
14 
15 // переменная для отслеживания истекшего времени:
16 int counter = 0;
17 // символьный массив, из которого будут браться данные для отображения времени:
18 char printout[4];
19 
20 void setup(){
21   myScreen.begin();  
22   myScreen.background(0,0,0); // очищаем экран
23   myScreen.stroke(255,0,255);
24   // Статический текст:
25   myScreen.text("Running for",0,0);
26   myScreen.text("seconds",0,30);  
27   // Увеличиваем размер экрана для текста в loop(): 
28   myScreen.setTextSize(3);
29 }

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

 1 void loop(){
 2     // берем истекшее время:
 3     counter = millis();
 4     // конвертируем его в строку:
 5     String elapsedTime = String(counter/1000);
 6     // добавляем в массив:
 7     elapsedTime.toCharArray(printout,4);
 8     // показываем и стираем:
 9     myScreen.stroke(255,255,255);
10     myScreen.text(printout,0,10);
11     delay(1000);
12     myScreen.stroke(0,0,0);
13     myScreen.text(printout,0,10);
14 }

Код для Esplora:

 1 #include <TFT.h> // библиотека для используемого устройства (т.е. для TFT-модуля)
 2 #include <SPI.h>
 3 #include <Esplora.h>
 4 
 5 // переменная для отслеживания истекшего времени:
 6 long counter = 0;
 7 // символьный массив, из которого будут браться данные для отображения времени:
 8 char printout[4];
 9 
10 void setup(){
11   EsploraTFT.begin();  
12   EsploraTFT.background(0,0,0); // очищаем экран
13   EsploraTFT.stroke(255,0,255);
14   // Статический текст:
15   EsploraTFT.text("Running for",0,0);
16   EsploraTFT.text("seconds",0,30);  
17   // увеличиваем размер шрифта для текста в loop(): 
18   EsploraTFT.setTextSize(3);
19 }
20 
21 void loop(){
22     // берем истекшее время:
23     counter = millis();
24     // конвертируем его в строку:
25     String elapsedTime = String(counter/1000);
26     // добавляем в массив:
27     elapsedTime.toCharArray(printout,4);
28     // показываем и стираем:
29     EsploraTFT.stroke(255,255,255);
30     EsploraTFT.text(printout,0,10);
31     delay(1000);
32     EsploraTFT.stroke(0,0,0);
33     EsploraTFT.text(printout,0,10);
34 }

Рисуем изображение с SD-карты

В библиотеке TFT есть функционал для считывания с SD-карты BMP-файлов и их отображения на дисплее. Разрешение этих изображений может быть больше или меньше разрешения TFT-дисплея (160x128), однако в языке Arduino нет функции для того, чтобы подгонять показываемое изображение под экран. Таким образом, перед тем, как загружать на SD-карту какие-либо изображения, их нужно сначала вручную подогнать под нужное разрешение.

В примере ниже будет использован BMP-файл «arduino.bmp» c разрешением 160х128, хранящийся в корневой директории SD-карты. Соответственно, когда этот файл будет прочитан библиотекой и выведен на экран, он займет всю его площадь.

Вдобавок к библиотекам, которые вы указывали ранее (т.е. SPI и TFT), вам нужно будет также добавить библиотеку SD. Кроме того, для SD-слота нужно будет указать CS-контакт.

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

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

 1 // подключаем необходимые библиотеки:
 2 #include <SPI.h>
 3 #include <SD.h>
 4 #include <TFT.h> // библиотека для используемого устройства (т.е. для TFT-модуля)
 5 
 6 // Контакты для Uno: 
 7 #define SD_CS  11
 8 #define LCD_CS 10
 9 #define DC    9
10 #define RESET    8  
11 
12 // Контакты для Leonardo:
13 // #define SD_CS  8
14 // #define LCD_CS 7
15 // #define DC   0
16 // #define RESET  1
17 
18 TFT myScreen = TFT(LCD_CS, DC, RESET);
19 
20 // эта переменная будет представлять изображение, которое будет выведено на экран:
21 PImage image;
22 
23 void setup() {
24   // Инициируем последовательный порт:
25   Serial.begin(9600);
26   while (!Serial) {
27     // ждем открытия порта (нужно для Leonardo)
28   }
29 
30   // пытаемся получить доступ к SD-карте:
31   Serial.print("Initializing SD card...");  // "Инициализация SD-карты..."
32   if (!SD.begin(SD_CS)) {
33     Serial.println("failed!");  // "Неуспешно!"
34     return;
35   }
36   Serial.println("OK!");
37 
38   // Инициализируем и очищаем LCD-экран:
39   myScreen.begin();
40   myScreen.background(255, 255, 255);
41 
42   // загружаем изображение с SD-карты:
43   image = myScreen.loadImage("arduino.bmp");
44 
45   // проверяем, правильно ли загрузилось изображение:
46   if (image.isValid() != true) {
47     Serial.println("error while loading arduino.bmp");  //  "ошибка при загрузке arduino.bmp"
48   }
49 
50   // рисуем изображение на экране:
51   myScreen.image(image, 0, 0);
52 }
53 
54 void loop(){
55 // тут ничего не происходит
56 }

Для Esplora:

 1 // подключаем необходимые библиотеки:
 2 #include <SPI.h>
 3 #include <SD.h>
 4 #include <TFT.h> // библиотека для используемого устройства (т.е. для TFT-модуля)
 5 #include <Esplora.h>
 6 
 7 // CS-контакт (т.е. контакт для сигнала «выбор кристалла») для SD-карты:
 8 #define SD_CS    8
 9 
10 // эта переменная для изображения, которое будет нарисовано:
11 PImage image;
12 
13 void setup() {
14   // инициализируем последовательный порт:
15   Serial.begin(9600);
16   while (!Serial) {
17     // ждем открытия последовательного порта
18   }
19 
20   // пытаемся получить доступ к SD-карте
21   Serial.print("Initializing SD card..."); // "Инициализация SD-карты..."
22   if (!SD.begin(SD_CS)) {
23     Serial.println("failed!"); // "Неуспешно!"
24     return;
25   }
26   Serial.println("OK!");
27 
28   // инициализируем и очищаем LCD-экран:
29   EsploraTFT.begin();
30   EsploraTFT.background(255, 255, 255);
31 
32   // загружаем изображение с SD-карты:
33   image = EsploraTFT.loadImage("arduino.bmp");
34 
35   // проверяем, правильно ли загрузилось изображение:
36   if (image.isValid() != true) {
37     Serial.println("error while loading arduino.bmp"); // "ошибка при загрузке arduino.bmp"
38   }
39 
40   // рисуем изображение на экране:
41   EsploraTFT.image(image, 0, 0);
42 }
43 
44 void loop(){
45 // здесь ничего не происходит
46 }

Что дальше

Теперь, когда мы разобрались с базовым функционалом TFT-модуля, можно приступить к более углубленному изучению темы. Здесь можно почитать об API библиотеки TFT и найти другие скетчи-примеры. Здесь можно более подробно почитать о различных компонентах дисплея. Здесь можно прочесть о функциях графической библиотеки Adafruit, которые не были описаны в этом руководстве.

См.также

Внешние ссылки