Электрификация

Справочник домашнего мастера

TFT дисплей ардуино

Содержание

Работа с цветными графическими дисплеями TFT (библиотека UTFT)

Библиотека

Для работы с дисплеями Цветной графический дисплей 2.8 TFT 320×240, Цветной графический дисплей 2.8 TFT 320×240 UNO, Цветной графический дисплей 3.2 TFT 480×320 MEGA, Цветной графический дисплей 2.4 TFT 240×320, Цветной графический дисплей 2.2 TFT 320×240 отлично подойдет библиотека UTFT. Библиотеку необходимо скачать с нашего сайта, так как в неё добавлена поддержка дисплеев 2.8 TFT 320×240 UNO, 3.95 TFT 480×320 UNO, 3.2 TFT 480×320 MEGA.

Поддерживаемые дисплеи

Дисплеи Инициализация
Цветной графический дисплей 2.8 TFT 320х240 Данный дисплей совместим с любыми Arduino.

UTFT myGLCD(TFT01_24SP, 6, 5, 4, 3, 2);

Дисплей можно подключать к любым выводам Arduino указав № выводов при объявлении объекта myGLCD библиотеки UTFT:
UTFT myGLCD(TFT01_24SP, SDI/MOSI, SCK, CS, RESET, DC/RS);

На дисплее установлен преобразователь уровней, так что его можно подключать и к 3В и к 5В логике.

Описание работы с сенсорным экраном находится в разделе Wiki работа с TouchScreen

Цветной графический дисплей 3.5 TFT 480×320 MEGA

Цветной графический дисплей 3.2 TFT 480×320 MEGA.

Данный дисплей совместим только с Arduino Mega.

UTFT myGLCD(TFT32MEGA, 38, 39, 40, 41); // дисплей на чипе ILI9341.
или
UTFT myGLCD(TFT32MEGA_2, 38, 39, 40, 41); // дисплей на чипе HX8357C.

Дисплеи поставляются на базе чипа ILI9341 или HX8357C. Если изображение на дисплее отображается зеркально, то измените тип дисплея: укажите либо TFT32MEGA, либо TFT32MEGA_2.

Если Вы не планируете использовать SD карту, то выводы 50-53 можно использовать для подключения других модулей.

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

Цветной графический дисплей 2.8 TFT 320×240 UNO
Данный дисплей совместим только с Arduino Uno.

UTFT myGLCD(TFT28UNO, A2, A1, A3, A4, A0);

Если Вы не планируете использовать SD карту, то выводы 10-13 можно использовать для подключения других модулей.

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

Описание работы с сенсорным экраном находится в разделе Wiki работа с TouchScreen

Цветной графический дисплей 2.4 TFT 240×320
Данный дисплей совместим с любыми Arduino.

UTFT myGLCD(TFT01_24SP, 5, 4, 8, 7, 6);

Дисплей можно подключать к любым выводам Arduino указав № выводов при объявлении объекта myGLCD библиотеки UTFT:
UTFT myGLCD(TFT01_24SP, SDI/MOSI, SCK, CS, RESET, DC/RS);

Уровень логической «1» на входах дисплея ≤ 3,3 В.
Если Вы используете 5 В логику, то подключайте входы дисплея через делители:

При питании от 3,3 В необходимо замкнуть перемычку J1 на обратной стороне платы дисплея.

Если Вы желаете использовать SD-карту, то выводы SD_CS, SD_MOSI, SD_MISO и SD_SCK необходимо подключить к Arduino по аппаратной шине SPI:

Если аппаратный вывод CS(SS) Arduino занят, то вывод SD_CS можно подключить к любому другому выводу Arduino, указав его номер в скетче (см пример в файле image_SD библиотеки UTFT).

TouchScreen можно подключать к любым выводам Arduino указав № выводов при объявлении объекта myTouch библиотеки URTouch:
URTouch myTouch( T_CLK, T_CS, T_DIN, T_OUT, T_IRQ);
Например: URTouch myTouch(13, 12, 11, 10, 9);

Указанные в примере выводы Arduino для подключения TouchScreen пересекаются с выводами аппаратной шины SPI на платах Arduino Uno, Pro Mini, Nano и т.д. Если Вы желаете использовать на этих платах и TouchScreen, и SD-карту, то для TouchScreen нужно выбрать другие выводы Arduino, например, аналоговые выводы A0-A4, указав их в скетче при объявлении объекта:
URTouch myTouch(A0, A1, A2, A3, A4);

Описание работы с сенсорным экраном со встроенным контроллером функций TouchScreen находится в разделе Wiki работа с TouchScreen по последовательной шине данных.

Цветной графический дисплей 2.2 TFT 320×240

Цветной графический дисплей 1.8 TFT 128×160

Данный дисплей совместим с любыми Arduino.

UTFT myGLCD(TFT01_22SP, 5, 4, 8, 7, 6);

UTFT myGLCD(TFT18SHLD, 5, 4, 8, 7, 6);

Дисплей можно подключать к любым выводам Arduino указав № выводов при объявлении объекта myGLCD библиотеки UTFT:
UTFT myGLCD(TFT01_22SP, SDI/MOSI, SCK, CS, RESET, DC/RS);

Уровень логической «1» на входах дисплея ≤ 3,3 В.
Если Вы используете 5 В логику, то подключайте входы дисплея через делители:

Если Вы желаете использовать SD-карту, то выводы SD_CS, SD_MOSI, SD_MISO и SD_SCK необходимо подключить к Arduino по аппаратной шине SPI:

Если аппаратный вывод CS(SS) Arduino занят, то вывод SD_CS можно подключить к любому другому выводу Arduino, указав его номер в скетче (см пример в файле image_SD библиотеки UTFT).

Если Вы собираетесь использовать библиотеку UTFT для работы с другими дисплеями, то закомментируйте строку с названием Вашего дисплея в файле «memorysaver.h». А для экономии памяти, раскомментируйте остальные строки кода файла «memorysaver.h».

#1 Пример

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

#include <UTFT.h> // подключаем библиотеку UTFT extern uint8_t SmallFont; // подключаем маленький шрифт extern uint8_t BigFont; // подключаем большой шрифт extern uint8_t SevenSegNumFont; // подключаем цифровой шрифт // UTFT myGLCD(TFT395UNO, A2,A1,A3,A4,A0); // тип дисплея 3,95 UNO (480×320 chip ILI9327) // UTFT myGLCD(TFT32MEGA, 38,39,40,41); // тип дисплея 3,2 MEGA (480×320 chip ILI9481) // UTFT myGLCD(TFT32MEGA_2, 38,39,40,41); // тип дисплея 3,2 MEGA (480×320 chip HX8357C) UTFT myGLCD(TFT28UNO, A2,A1,A3,A4,A0); // тип дисплея 2,8 UNO (320×240 chip ILI9341) // UTFT myGLCD(TFT01_24SP, 5,4,8,7,6); // тип дисплея 2,8 TFT (240×320 chip ILI9341) // UTFT myGLCD(TFT01_24SP, 5,4,8,7,6); // тип дисплея 2,4 TFT (240×320 chip ILI9341) // UTFT myGLCD(TFT01_22SP, 5,4,8,7,6); // тип дисплея 2,2 TFT (320×240 chip ILI9340) // UTFT myGLCD(TFT18SHLD, 5,4,8,7,6); // тип дисплея 1,8 TFT (128×160 chip ST7735S) void setup() { myGLCD.InitLCD(); // инициируем дисплей (в качестве параметра данной функции можно указать ориентацию дисплея: PORTRAIT или LANDSCAPE), по умолчанию LANDSCAPE — горизонтальная ориентация } void loop() { //Стираем все с экрана myGLCD.clrScr(); // стираем всю информацию с дисплея myGLCD.setFont(SmallFont); // устанавливаем маленький шрифт myGLCD.setColor(VGA_WHITE); // устанавливаем цвет текста myGLCD.print(«iarduino.ru | SmallFont», CENTER, 50); // выводим текст на дисплей myGLCD.setFont(BigFont); // устанавливаем большой шрифт myGLCD.setColor(VGA_BLUE); // устанавливаем цвет текста myGLCD.print(«BigFont», CENTER, 100); // выводим текст на дисплей myGLCD.print(«iarduino.ru», CENTER, 115); // выводим текст на дисплей myGLCD.setFont(SevenSegNumFont); // устанавливаем цифровой шрифт myGLCD.setColor(VGA_FUCHSIA); // устанавливаем цвет текста myGLCD.print(«1234567890», CENTER, 150); // выводим текст на дисплей delay(20000); }

#2 Пример

Заливаем весь дисплей различными цветами:

#include <UTFT.h> // подключаем библиотеку UTFT // UTFT myGLCD(TFT395UNO, A2,A1,A3,A4,A0); // тип дисплея 3,95 UNO (480×320 chip ILI9327) // UTFT myGLCD(TFT32MEGA, 38,39,40,41); // тип дисплея 3,2 MEGA (480×320 chip ILI9481) // UTFT myGLCD(TFT32MEGA_2, 38,39,40,41); // тип дисплея 3,2 MEGA (480×320 chip HX8357C) UTFT myGLCD(TFT28UNO, A2,A1,A3,A4,A0); // тип дисплея 2,8 UNO (320×240 chip ILI9341) // UTFT myGLCD(TFT01_24SP, 5,4,8,7,6); // тип дисплея 2,8 TFT (240×320 chip ILI9341) // UTFT myGLCD(TFT01_24SP, 5,4,8,7,6); // тип дисплея 2,4 TFT (240×320 chip ILI9341) // UTFT myGLCD(TFT01_22SP, 5,4,8,7,6); // тип дисплея 2,2 TFT (320×240 chip ILI9340) // UTFT myGLCD(TFT18SHLD, 5,4,8,7,6); // тип дисплея 1,8 TFT (128×160 chip ST7735S) void setup() { myGLCD.InitLCD(); // инициируем дисплей (в качестве параметра данной функции можно указать ориентацию дисплея: PORTRAIT или LANDSCAPE), по умолчанию LANDSCAPE — горизонтальная ориентация myGLCD.clrScr(); // стираем всю информацию с дисплея } void loop() { myGLCD.fillScr(VGA_RED ); delay(1000); // заливаем экран красным цветом myGLCD.fillScr(VGA_GREEN ); delay(1000); // заливаем экран зелёным цветом myGLCD.fillScr(VGA_BLUE ); delay(1000); // заливаем экран синим цветом myGLCD.fillScr(VGA_SILVER); delay(1000); // заливаем экран серебристым цветом myGLCD.fillScr(VGA_MAROON); delay(1000); // заливаем экран бордовым цветом myGLCD.fillScr(VGA_NAVY ); delay(1000); // заливаем экран тем. синим цветом }

#3 Пример

Рисуем различные графические элементы:

#include <UTFT.h> // подключаем библиотеку UTFT // UTFT myGLCD(TFT395UNO, A2,A1,A3,A4,A0); // тип дисплея 3,95 UNO (480×320 chip ILI9327) // UTFT myGLCD(TFT32MEGA, 38,39,40,41); // тип дисплея 3,2 MEGA (480×320 chip ILI9481) // UTFT myGLCD(TFT32MEGA_2, 38,39,40,41); // тип дисплея 3,2 MEGA (480×320 chip HX8357C) UTFT myGLCD(TFT28UNO, A2,A1,A3,A4,A0); // тип дисплея 2,8 UNO (320×240 chip ILI9341) // UTFT myGLCD(TFT01_24SP, 5,4,8,7,6); // тип дисплея 2,8 TFT (240×320 chip ILI9341) // UTFT myGLCD(TFT01_24SP, 5,4,8,7,6); // тип дисплея 2,4 TFT (240×320 chip ILI9341) // UTFT myGLCD(TFT01_22SP, 5,4,8,7,6); // тип дисплея 2,2 TFT (320×240 chip ILI9340) // UTFT myGLCD(TFT18SHLD, 5,4,8,7,6); // тип дисплея 1,8 TFT (128×160 chip ST7735S) void setup() { myGLCD.InitLCD(); // инициируем дисплей (в качестве параметра данной функции можно указать ориентацию дисплея: PORTRAIT или LANDSCAPE), по умолчанию LANDSCAPE — горизонтальная ориентация } void loop() { myGLCD.clrScr(); // стираем всю информацию с дисплея myGLCD.setColor(VGA_RED); // Устанавливаем красный цвет myGLCD.drawLine(10,10,150,10); // рисуем линию (через точки с координатами 10×10 — 150×10) myGLCD.drawRect(10,20,150,80); // рисуем прямоугольник (с противоположными углами в координатах 10×20 — 150×80) myGLCD.drawRoundRect(10,90,150,160); // рисуем прямоугольник со скруглёнными углами (с противоположными углами в координатах 10×90 — 150×160) myGLCD.fillRect(10,170,150,230); // рисуем закрашенный прямоугольник (с противоположными углами в координатах 10×170 — 150×230) myGLCD.drawCircle(260,60,40); // рисуем окружность (с центром в точке 260×60 и радиусом 40) myGLCD.fillCircle(260,160,40); // рисуем закрашенную окружность (с центром в точке 260×160 и радиусом 40) delay(20000); }

Базовые функции:

Все функции:

  • InitLCD(); – Инициирует начало работы с дисплеем. Необязательный параметр может принимать одно из двух значений: PORTRAIT (вертикальная ориентация) или LANDSCAPE (горизонтальная ориентация — по умолчанию).
  • clrScr(); – Очищает дисплей, стирая всю отображаемую на дисплее информацию и заливая дисплей черным цветом.
  • fillScr(color); – Очищает дисплей, стирая всю отображаемую на дисплее информацию и заливая его указанным в качестве параметра цветом фона.
  • getDisplayXSize(); – Возвращает количество пикселей дисплея по горизонтали, число типа int.
  • getDisplayYSize(); – Возвращает количество пикселей дисплея по вертикали, число типа int.
  • setColor(color); – Выбор цвета для текста и фигур, выводимых после данной функции.
  • getColor(); – Возвращает установленный цвет для текста и фигур в формате RGB565, число типа word.
  • setBackColor(color); – Выбор цвета для фона текста, выводимого после данной функции.
  • getBackColor(); – Возвращает установленный цвет для фона текста в формате RGB565, число типа word.
  • setFont(fontName); – Выбор шрифта для текста выводимого после данной функции.
  • getFont(); – Возвращает указатель на выбранный шрифт.
  • getFontXsize(); – Возвращает количество пикселей в одном символе шрифта, по ширине.
  • getFontYsize(); – Возвращает количество пикселей в одном символе шрифта, по высоте.
  • print(str,x,y); – Вывод на дисплей строк или содержимого строковых переменных.
  • printNumI(int,x,y]); – Вывод на дисплей целого числа или содержимого целочисленной переменной.
  • printNumF(float,dec,x,y]]); – Вывод на дисплей вещественного числа или содержимого переменной вещественного типа
  • drawPixel(x,y); – Вывод на дисплей точки. Цвет точки определяется текущим значением цвета, устанавливаемым командой setColor().
  • drawLine(x1,y1,x2,y2); – Вывод на дисплей линии, заданной координатами двух точек.
  • drawRect(x1,y1,x2,y2); – Вывод на дисплей прямоугольника, противоположные углы которого заданы координатами двух точек.
  • drawRoundRect(x1,y1,x2,y2); – Вывод на дисплей прямоугольника со скругленными углами.
  • fillRect(x1,y1,x2,y2); – Вывод на дисплей закрашенного прямоугольника.
  • drawCircle(x,y,R); – Вывод на дисплей окружности, определяемую координатами центра и радиусом.
  • fillCircle(x,y,R); – Вывод на дисплей закрашенной окружности.
  • drawBitmap(x1,y1,x2,y2,data); – Вывод на дисплей картинки из массива.
  • Для вывода на дисплей картинки из файла с SD-карты нужно вызвать функцию load(x1,y1,x2,y2,data); объекта библиотеки UTFT_SdRaw.
    Для работы функции load, нужно установить и подключить библиотеки: UTFT_SdRaw и SdFat.

Инициализация работы с дисплеем:

InitLCD( );
Инициализация работы с дисплеем, с указанием его положения.

InitLCD(PORTRAIT); // инициализация (вертикальное положение)

Параметр:

    Положение может быть горизонтальным или вертикальным:

  • положение: PORTRAIT — вертикальное
  • положение: LANDSCAPE — горизонтальное (по умолчанию)

void setup(){ myGLCD.InitLCD(); } // инициируем дисплей без параметра, значит он горизонтально ориентирован (как если бы в качестве параметра было указано LANDSCAPE)

Очистка экрана:

myGLCD.clrScr(); // очистка экрана с заливкой черным цветом myGLCD.fillScr(VGA_RED); // заливаем весь экран красным цветом myGLCD.fillScr(0xF800); // заливаем весь экран красным цветом (формат RGB565) myGLCD.fillScr(255,0,0); // заливаем весь экран красным цветом (формат RGB)

Выбор цвета:

myGLCD.setColor(VGA_BLUE); // устанавливаем синий цвет для текста и фигур myGLCD.setBackColor(VGA_WHITE); // устанавливаем белый цвет заливки текста // выводим текст или фигуру // выводимые фигуры будут синими, а текст синим на белом фоне

Выбор шрифта:

setFont( fontName );
Выбор шрифта для текста выводимого после данной функции.

setFont(SmallFont); // маленький шрифт

Параметр:

    По умолчанию в библиотеке есть 3 шрифта:

  • fontName: SmallFont — маленький шрифт
  • fontName: BigFont — большой шрифт
  • fontName: SevenSegNumFont — шрифт имитирующий семисегментный индикатор

#include <UTFT.h> // подключаем библиотеку UTFT extern uint8_t BigFont; // обязательно подключаем шрифт // UTFT myGLCD(TFT395UNO, A2,A1,A3,A4,A0); // тип дисплея 3,95 UNO (480×320 chip ILI9327) // UTFT myGLCD(TFT32MEGA, 38,39,40,41); // тип дисплея 3,2 MEGA (480×320 chip ILI9481) // UTFT myGLCD(TFT32MEGA_2, 38,39,40,41); // тип дисплея 3,2 MEGA (480×320 chip HX8357C) UTFT myGLCD(TFT28UNO, A2,A1,A3,A4,A0); // тип дисплея 2,8 UNO (320×240 chip ILI9341) // UTFT myGLCD(TFT01_24SP, 5,4,8,7,6); // тип дисплея 2,8 TFT (240×320 chip ILI9341) // UTFT myGLCD(TFT01_24SP, 5,4,8,7,6); // тип дисплея 2,4 TFT (240×320 chip ILI9341) // UTFT myGLCD(TFT01_22SP, 5,4,8,7,6); // тип дисплея 2,2 TFT (320×240 chip ILI9340) // UTFT myGLCD(TFT18SHLD, 5,4,8,7,6); // тип дисплея 1,8 TFT (128×160 chip ST7735S) void setup() { myGLCD.InitLCD (); // инициируем дисплей (по умолчанию горизонтальная ориентация) myGLCD.clrScr (); // стираем всю информацию с дисплея myGLCD.setFont (BigFont); // устанавливаем большой шрифт myGLCD.setColor(VGA_BLUE); // устанавливаем синий цвет текста myGLCD.print («BigFont», CENTER, 100); // выводим текст «BigFont» на дисплей } void loop(){ }

Вывод текста:

#include <UTFT.h> // подключаем библиотеку UTFT extern uint8_t BigFont; // обязательно подключаем шрифт // UTFT myGLCD(TFT395UNO, A2,A1,A3,A4,A0); // тип дисплея 3,95 UNO (480×320 chip ILI9327) // UTFT myGLCD(TFT32MEGA, 38,39,40,41); // тип дисплея 3,2 MEGA (480×320 chip ILI9481) // UTFT myGLCD(TFT32MEGA_2, 38,39,40,41); // тип дисплея 3,2 MEGA (480×320 chip HX8357C) UTFT myGLCD(TFT28UNO, A2,A1,A3,A4,A0); // тип дисплея 2,8 UNO (320×240 chip ILI9341) // UTFT myGLCD(TFT01_24SP, 5,4,8,7,6); // тип дисплея 2,8 TFT (240×320 chip ILI9341) // UTFT myGLCD(TFT01_24SP, 5,4,8,7,6); // тип дисплея 2,4 TFT (240×320 chip ILI9341) // UTFT myGLCD(TFT01_22SP, 5,4,8,7,6); // тип дисплея 2,2 TFT (320×240 chip ILI9340) // UTFT myGLCD(TFT18SHLD, 5,4,8,7,6); // тип дисплея 1,8 TFT (128×160 chip ST7735S) void setup() { myGLCD.InitLCD (); // инициируем дисплей (по умолчанию горизонтальная ориентация) myGLCD.clrScr (); // стираем всю информацию с дисплея myGLCD.setFont (SmallFont); // устанавливаем маленький шрифт myGLCD.setColor (VGA_RED); // устанавливаем красный цвет текста myGLCD.print («iarduino.ru»,0,0) // выводим текст «iarduino.ru» myGLCD.printNumI(123456,0,100); // выводим целое число myGLCD.printNumF(-234.3442, 0, 200); // выводим вещественное число } void loop(){ }

Вывод изображений

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

  • Картинки необходимо конвертировать с помощью специальной программы ImageConverter565, которая находится в папке Tools библиотеки UTFT, при сохранении выбрать тип файла «.c» под микроконтроллер AVR.
  • Сохранённый файл «Название.c» нужно поместить в папку со скетчем использующим этот файл. Название массива будет совпадать с названием файла.
  • Файл с массивом используемым в нашем примере вы можете найти в папке examples/дисплей/image_Array библиотеки UTFT.
drawBitmap( x1 , y1 , x2 , y2 , Name );
Вывод на дисплей картинки из массива.
Параметры:

  • x1: координата X, левого верхнего угла дисплея
  • y1: координата Y, левого верхнего угла дисплея
  • x2: размер картинки по оси X
  • y2: размер картинки по оси Y
  • Name: Название массива который содержит изображение
  • Изображение выводиться в прямоугольную область, верхний левый угол которой задан точкой с координатами x1,y1.

#include <UTFT.h> // подключаем библиотеку UTFT для работы с дисплеем // UTFT myGLCD(TFT395UNO, A2,A1,A3,A4,A0); // тип дисплея 3,95 UNO (480×320 chip ILI9327) // UTFT myGLCD(TFT32MEGA, 38,39,40,41); // тип дисплея 3,2 MEGA (480×320 chip ILI9481) // UTFT myGLCD(TFT32MEGA_2, 38,39,40,41); // тип дисплея 3,2 MEGA (480×320 chip HX8357C) UTFT myGLCD(TFT28UNO, A2,A1,A3,A4,A0); // тип дисплея 2,8 UNO (320×240 chip ILI9341) // UTFT myGLCD(TFT01_24SP, 5,4,8,7,6); // тип дисплея 2,8 TFT (240×320 chip ILI9341) // UTFT myGLCD(TFT01_24SP, 5,4,8,7,6); // тип дисплея 2,4 TFT (240×320 chip ILI9341) // UTFT myGLCD(TFT01_22SP, 5,4,8,7,6); // тип дисплея 2,2 TFT (320×240 chip ILI9340) // UTFT myGLCD(TFT18SHLD, 5,4,8,7,6); // тип дисплея 1,8 TFT (128×160 chip ST7735S) // extern unsigned short image_128x64; // объявляем массив image_128x64 который был определён во внешнем файле // файл с массивом должен находиться в той же папке что и скетч void setup(){ // myGLCD.InitLCD(); // инициируем дисплей myGLCD.clrScr(); // стираем всю информацию с дисплея myGLCD.drawBitmap(176,128,128,64,image_128x64); // выводим на дисплей картинку начиная с координаты 176,128 размером 128,64 из массива image_128x64 } // // void loop(){} //

Выводим на дисплей картинки с SD карты:

  • Для вывода картинок, в дополнении к библиотеке UTFT, понадобится установить и подключить библиотеки: и: UTFT_SdRaw и SdFat.
  • Библиотека SdFat предназначена для работы с SD-картами. Поддерживаются SD-карты отформатированные под файловую систему FAT32 (максимальный объем SD-карты 32 ГГб) и FAT16 (максимальный объем SD-карты 2 ГГб).
  • Библиотека UTFT_SdRaw предназначена для вывода изображений на дисплей.
  • Картинки необходимо конвертировать с помощью специальной программы ImageConverter565, которая находится в папке Tools библиотеки UTFT, при сохранении выбрать тип файла «.raw». Сохранённый файл нужно записать на SD-карту.
  • Картинки используемые в нашем примере вы можете найти в папке image библиотеки UTFT.
load( x1 , y1 , x2 , y2 , «fileName.raw» );
Вывод на дисплей картинки из файла на SD карте.
Функция относится к объекту библиотеки UTFT_SdRaw а не UTFT.
Параметры:

  • x1: координата X, левого верхнего угла дисплея
  • y1: координата Y, левого верхнего угла дисплея
  • x2: размер картинки по оси X
  • y2: размер картинки по оси Y
  • NameFile: Название файла изображения на SD карте
  • Изображение выводиться в прямоугольную область, верхний левый угол которой задан точкой с координатами x1,y1.

#include <SPI.h> // подключаем библиотеку SPI для общения с SD-картой по шине SPI #include <SdFat.h> // подключаем библиотеку SdFat для работы с SD-картой #include <UTFT.h> // подключаем библиотеку UTFT для работы с дисплеем #include <UTFT_SdRaw.h> // подключаем библиотеку UTFT_SdRaw для вывода изображений с SD-карты на дисплей #define SD_CHIP_SELECT SS // определяем константу SD_CHIP_SELECT которой присваиваем номер вывода Arduino подключённого к линии выбора CS шины SPI SD-карты (номер используемый по умолчанию хранится в константе SS) // UTFT myGLCD(TFT395UNO, A2,A1,A3,A4,A0); // тип дисплея 3,95 UNO (480×320 chip ILI9327) // UTFT myGLCD(TFT32MEGA, 38,39,40,41); // тип дисплея 3,2 MEGA (480×320 chip ILI9481) // UTFT myGLCD(TFT32MEGA_2, 38,39,40,41); // тип дисплея 3,2 MEGA (480×320 chip HX8357C) UTFT myGLCD(TFT28UNO, A2,A1,A3,A4,A0); // тип дисплея 2,8 UNO (320×240 chip ILI9341) // UTFT myGLCD(TFT01_24SP, 5,4,8,7,6); // тип дисплея 2,8 TFT (240×320 chip ILI9341) // UTFT myGLCD(TFT01_24SP, 5,4,8,7,6); // тип дисплея 2,4 TFT (240×320 chip ILI9341) // UTFT myGLCD(TFT01_22SP, 5,4,8,7,6); // тип дисплея 2,2 TFT (320×240 chip ILI9340) // UTFT myGLCD(TFT18SHLD, 5,4,8,7,6); // тип дисплея 1,8 TFT (128×160 chip ST7735S) SdFat mySD; // объявляем объект mySD класса библиотеки SdFat для работы с его функциями и методами UTFT_SdRaw myFiles(&myGLCD); // объявляем объект myFiles класса библиотеки UTFT_tinyFAT с передачей ссылки на объект myGLCD класса библиотеки UTFT // void setup(){ // myGLCD.InitLCD(); // инициируем дисплей myGLCD.clrScr(); // стираем всю информацию с дисплея while(!mySD.begin(SD_CHIP_SELECT)){} // инициируем работу с SD картой, ожидая завершения инициализации в цикле while (не даём войти в loop пока нет карты) } // // void loop(){ // // ВНИМАНИЕ!!! // файлы картинок лежат в папке image библиотеки UTFT, // их необходимо записать в корень SD карты и установить её в слот на плате дисплея myFiles.load(0,0,320,240,»image_320x240_a.raw»); // выводим на дисплей картинку начиная с координаты 0,0 размером 320,240 из файла image_320x240_a.raw delay(2000); // ждём 2 секунды myFiles.load(0,0,320,240,»image_320x240_b.raw»); // выводим на дисплей картинку начиная с координаты 0,0 размером 320,240 из файла image_320x240_b.raw delay(2000); // ждём 2 секунды } //

Ссылки:

  • Цветной графический дисплей 3.95 TFT 480×320 UNO.
  • Цветной графический дисплей 3.5 TFT 480×320 MEGA.
  • Цветной графический дисплей 3.2 TFT 480×320 MEGA.
  • Цветной графический дисплей 2.8 TFT 320×240 UNO.
  • Цветной графический дисплей 2.8 TFT 320×240.
  • Цветной графический дисплей 2.4 TFT 240×320.
  • Цветной графический дисплей 2.2 TFT 320×240.
  • Цветной графический дисплей 1.8 TFT 128×160.
  • Цветной графический дисплей 2.8 TFT 320×240.
  • Библиотека UTFT для работы с цветными графическими дисплеями.
  • Библиотека UTFT_SdRaw для загрузки изображений в дисплей.
  • Библиотека SdFat для работы с SD-картами.
  • Библиотека TouchScreen для работы с сенсорными экранами (используются аналоговые данные).
  • Библиотека URTouch для работы с сенсорными экранами оснащёнными контроллерами функций TouchScreen.
  • Wiki — Установка библиотек в Arduino IDE.
  • Wiki — Работа с TouchScreen по данным считанным с аналоговых входов.
  • Wiki — Работа с TouchScreen по последовательной шине данных.

Плата расширения Arduino TFT

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

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

Библиотека TFT включается в состав среды разработки Ардуино. начиная с версии 1.0.5.

Библиотека

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

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

Методы библиотеки TFT опираются на функции библиотеки SPI, поэтому во всех программах, работающих с TFT-экраном, должна быть объявлена библиотека SPI. Соответственно, при работе с SD-картой памяти — необходимо объявить библиотеку SD.

Организация экрана

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

Систему координат дисплея лучше всего представить в виде сетки, каждая ячейка которой является отдельным пикселем. Местоположение пикселя задается парой координат. Точка в левом верхнем углу экрана будет иметь координаты 0,0. Если эта точка сместится в верхний правый угол, то ее координаты будут равны 0, 159; в левый нижний угол — 127,0; в правый нижний — 127, 159.

Дисплей можно использовать и в вертикальном положении (также известном как «портретная ориентация»). Для этого достаточно вызвать функцию setRotation(0), после чего оси x и y поменяются местами. После вызова этого метода, функции screen.width() и screen.right() станут возвращать уже другие значения.

Цвета

Экран позволяет передавать цвет глубиной 16 бит. Красная и синяя составляющие цвета могут принимать 32 различных значения (разрядность 5 бит), а зеленая составляющая — 64 значения (разрядность 6 бит). Однако, с целью совместимости с другими программами, библиотека все равно работает с 8-битными значениями красного, зеленого и синего каналов (0 — 255), пропорционально масштабируя их в необходимый диапазон.

Аппаратный и программный интерфейс SPI — что лучше?

Организовать работу с TFT-экраном можно двумя способами. Первый способ — использовать аппаратную шину SPI Ардуино, второй — вручную объявить расположение необходимых выводов. С точки зрения функциональности экрана, нет никакой разницы между первым и вторым способом. Однако скорость работы аппаратного интерфейса SPI значительно выше.

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

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

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

На лицевой стороне Arduino Esplora есть специальный разъем для подключения экрана. Вставьте экран Ардуино в этот разъем так, чтобы синяя надпись «SD Card» была расположена возде порта USB.

Подключение к другим платам Ардуино

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

Пишем первую программу

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

В примерах вначале будут приведены листинги программ для Arduino Uno, Leonardo и др. моделей. Листинги для Arduino Esplora будут приведены ниже.

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

#include <TFT.h> // библиотека для работы с TFT #include <SPI.h> #define CS 10 #define DC 9 #define RESET 8 // объявление выводов для Arduino Leonardo // #define CS 7 // #define DC 0 // #define RESET 1 TFT myScreen = TFT(CS, DC, RESET);

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

void setup(){ myScreen.begin(); myScreen.background(0,0,0); // очищаем экран, заливая его черным цветом delay(1000); // небольшая интригующая пауза }

В блоке loop(), для отрисовки прямой линии на экране необходимо вызвать функцию line(). Функция line() принимает четыре аргумента: начальные координаты x и y, конечные координаты x и y. Чтобы нарисовать прямоугольник, необходимо вызвать функцию rect(), которая также принимает четыре параметра: координаты x и y левого верхнего угла, ширина и высота прямоугольника в пикселях. Между вызовами этих функций можно изменить цвет выводимой фигуры с помощью функций stroke() или fill(). Функция stroke() изменяет цвет линии или контура геометрической фигуры, а функция fill() — изменяет цвет заливки фигуры. После вызова функции noStroke() библиотека не будет отрисовывать границы выводимых фигур. Чтобы отменить действие этой функции, достаточно вызвать метод stroke().

void loop(){ myScreen.stroke(255, 0, 0); // устанавливаем красный цвет кисти myScreen.line(0, 10, myScreen.width(), 10); // рисуем линию через весь экран delay(1000); myScreen.noStroke(); // не будем рисовать контуры вокруг будущего прямоугольника myScreen.fill(0,255,0); // устанавливаем зеленый цвет заливки myScreen.rect(0,20,myScreen.width(),10); //рисуем прямоугольник через экран delay(1000); myScreen.fill(0,0,255); // устанавливаем синий цвет заливки myScreen.stroke(255,255,255); // обводим прямоугольник белой линией myScreen.rect(0,45,myScreen.width(),45); // рисуем плоский прямоугольник delay(1000); myScreen.background(0,0,0); // очищаем экран перед тем, как все нарисовать снова delay(1000); }

Структура программы для Arduino Esplora практически ничем не отличается. В Arduino Esplora предусмотрен отдельный разъем для подключения TFT-экрана, поэтому выводы, взаимодействующие с ним, заданы аппаратно и не подлежат изменению. В программе в этом случае необходимо использовать специальный класс EsploraTFT для работы с экраном.

Именно поэтому в программе не нужно указывать выводы Ардуино, которые будут взаимодействовать с экраном; эта информация автоматически содержится внутри создаваемого объекта:

#include <TFT.h> // библиотека для работы с TFT #include <SPI.h> #include <Esplora.h> void setup(){ EsploraTFT.begin(); EsploraTFT.background(0,0,0); // очищаем экран, заливая его черным цветом delay(1000); // небольшая интригующая пауза } void loop(){ EsploraTFT.stroke(255, 0, 0); // устанавливаем красный цвет кисти EsploraTFT.line(0, 10, EsploraLCD.width(), 10); // рисуем линию через весь экран delay(1000); EsploraTFT.noStroke(); // не будем рисовать контуры вокруг будущего прямоугольника EsploraTFT.fill(0,255,0); // устанавливаем зеленый цвет заливки EsploraTFT.rect(0,20,EsploraTFT.width(),20); //рисуем прямоугольник через экран delay(1000); EsploraTFT.fill(0,0,255); // устанавливаем синий цвет заливки EsploraTFT.stroke(255,255,255); // обводим прямоугольник белой линией EsploraTFT.rect(0,45,EsploraTFT.width(),50); // рисуем плоский прямоугольник delay(1000); EsploraTFT.background(0,0,0); // очищаем экран перед тем, как все нарисовать снова delay(1000); }

Перемещения по экрану

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

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

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

#include <TFT.h> // библиотека для работы с TFT #include <SPI.h> #define CS 10 #define DC 9 #define RESET 8 // объявление выводов, работающих с экраном, для Arduino Leonardo // #define CS 7 // #define DC 0 // #define RESET 1 TFT myScreen = TFT(CS, DC, RESET); // Начальная позиция точки — это середина экрана int xPos = 80; int yPos = 64; // направление и скорость int xDir = 1; int yDir = 1; // переменные для отслеживания позиции точки int xPrev = xPos; int yPrev = yPos; void setup(){ myScreen.begin(); myScreen.background(0,0,0); // очистка экрана }

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

void loop(){ // обновляем позицию точки xPos = xPos + xDir; yPos = yPos + yDir; // проверяем, отличается ли текущее положение точки от предыдущего if(xPos != xPrev || yPos != yPrev){ myScreen.stroke(0,0,0); // задаем черный цвет кисти myScreen.point(xPrev, yPrev); // цвет в предыдущей позиции } // рисуем точку в новой позиции myScreen.stroke(255,255,255); myScreen.point(xPos, yPos); // если x или позиция по x достигла границы экрана, то меняем направление на противоположное if(xPos >= 160 || xPos <= 0){ xDir = xDir*-1; } if(yPos >= 128 || yPos <= 0){ yDir = yDir*-1; } // обновляем предыдущую позицию точки xPrev=xPos; yPrev=yPos; // задержка в 33 мс означает, что экран обновляется 30 раз в секунду delay(33); }

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

#include <TFT.h> // библиотека для работы с TFT #include <SPI.h> #include <Esplora.h> // Начальная позиция точки — это середина экрана int xPos = 80; int yPos = 64; // направление и скорость int xDir = 1; int yDir = 1; // переменные для отслеживания позиции точки int xPrev, yPrev; void setup(){ EsploraTFT.begin(); EsploraTFT.background(0,0,0); void loop(){ // обновляем позицию точки xPos = xPos + xDir; yPos = yPos + yDir; // проверяем, отличается ли текущее положение точки от предыдущего if(xPos != xPrev || yPos != yPrev){ EsploraTFT.stroke(0,0,0); // задаем черный цвет кисти EsploraTFT.point(xPrev, yPrev); // цвет в предыдущей позиции } // рисуем точку в новой позиции EsploraTFT.stroke(255,255,255); EsploraTFT.point(xPos, yPos); // если x или позиция по x достигла границы экрана, то меняем направление на противоположное if(xPos >= 160 || xPos <= 0){ xDir = xDir*-1; } if(yPos >= 128 || yPos <= 0){ yDir = yDir*-1; } // обновляем предыдущую позицию точки xPrev=xPos; yPrev=yPos; // небольшая пауза delay(33); }

Выводим текст

В библиотеке TFT содержится базовый шрифт для вывода текста на экран. По умолчанию, размер символов составляет 5х8 пикселей (5 — в ширину, 8 — в высоту). В библиотеке предусмотрена возможность изменения размера шрифта на 10×16, 15×24 или 20×32. Для получения дополнительной информации о шрифтах см. страницу Adafruit о работе с графическими примитивами.

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

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

#include <TFT.h> // Библиотека для работы с TFT-экраном #include <SPI.h> #define CS 10 #define DC 9 #define RESET 8 // объявление выводов, работающих с экраном, для Arduino Leonardo // #define CS 7 // #define DC 0 // #define RESET 1 TFT myScreen = TFT(CS, DC, RESET); // переменная для хранения прошедшего времени int counter = 0; // массив символов для вывода времени на экран char printout; void setup(){ myScreen.begin(); myScreen.background(0,0,0); // очистка экрана myScreen.stroke(255,0,255); // выводим статический текст myScreen.text(«Running for»,0,0); myScreen.text(«seconds»,0,30); // увеличиваем размер шрифта для текста, выводимого в блоке loop() myScreen.setTextSize(3); }

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

void loop(){ // получаем текущее время, прошедшее с момента запуска программы counter = millis(); // преобразовываем его в строку String elapsedTime = String(counter/1000); // добавляем в массив elapsedTime.toCharArray(printout,4); // выводим на экран и стираем myScreen.stroke(255,255,255); myScreen.text(printout,0,10); delay(1000); myScreen.stroke(0,0,0); myScreen.text(printout,0,10); }

Тот же самый код для Arduino Esplora:

#include <TFT.h> // Библиотека для работы с TFT-экраном #include <SPI.h> // переменная для хранения прошедшего времени int counter = 0; // массив символов для вывода времени на экран char printout; void setup(){ EsploraTFT.begin(); EsploraTFT.background(0,0,0); // очистка экрана EsploraTFT.stroke(255,0,255); // выводим статический текст EsploraTFT.text(«Running for»,0,0); EsploraTFT.text(«seconds»,0,30); // увеличиваем размер шрифта для текста, выводимого в блоке loop() EsploraTFT.setTextSize(3); } void loop(){ // получаем текущее время, прошедшее с момента запуска программы counter = millis(); // преобразовываем его в строку String elapsedTime = String(counter/1000); // добавляем в массив elapsedTime.toCharArray(printout,4); // выводим на экран и стираем EsploraTFT.stroke(255,255,255); EsploraTFT.text(printout,0,10); delay(1000); EsploraTFT.stroke(0,0,0); EsploraTFT.text(printout,0,10); }

Выводим изображение из файла, находящегося на SD-карте памяти

Библиотека TFT позволяет считывать .bmp-файлы с SD-карты памяти и выводить их содержимое на экран. Причем отображаемые картинки могут не соответствовать разрешению TFT-экрана (160×128). Следует иметь ввиду, что Ардуино не может модифицировать изображения, поэтому все необходимые манипуляции с графическими файлами (такие, как масштабирование, обрезка и т.д.) необходимо сделать до их «заливки» на SD-карту.

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

Помимо уже знакомых вам библиотек, в этом примере понадобится подключить еще одну библиотеку — SD. Также необходимо объявить вывод CS, связанный с разъемом SD-карты.

Класс PImage используется для загрузки изображения (этот класс может также использоваться для проверки формата графического файла на предмет его совместимости с библиотекой TFT).

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

// подключаем необходимые библиотеки #include <SPI.h> #include <SD.h> #include <TFT.h> // Библиотека для работы с TFT-экраном // объявление выводов для Arduino Uno #define SD_CS 11 #define LCD_CS 10 #define DC 9 #define RESET 8 // объявление выводов для Leonardo // #define SD_CS 8 // #define LCD_CS 7 // #define DC 0 // #define RESET 1 TFT myScreen = TFT(LCD_CS, DC, RESET); // эта переменная описывает изображение, которое будет выводиться на экран PImage image; void setup() { // инициализируем последовательный интерфейс передачи данных Serial.begin(9600); while (!Serial) { // ожидаем готовности последовательного порта // — необходимо для Arduino Leonardo } // пробуем обратиться к SD-карте памяти Serial.print(«Initializing SD card…»); if (!SD.begin(SD_CS)) { Serial.println(«failed!»); return; } Serial.println(«OK!»); // инициализируем и очищаем GLCD-экран myScreen.begin(); myScreen.background(255, 255, 255); // загружаем изображение с SD-карты image = myScreen.loadImage(«arduino.bmp»); // проверяем, корректно ли загружена картинка if (image.isValid() != true) { Serial.println(«error while loading arduino.bmp»); } //выводим изображение на экран myScreen.image(image, 0, 0); } void loop(){ // здесь ничего не делаем }

Тот же самый код для Arduino Esplora: :

// подключаем необходимые библиотеки #include <SPI.h> #include <SD.h> #include <TFT.h> // Библиотека для работы с TFT-экраном #include <Esplora.h> // Номер вывода для активации SD-карты #define SD_CS 8 // эта переменная описывает изображение, которое будет выводиться на экран PImage image; void setup() { // инициализируем последовательный интерфейс передачи данных Serial.begin(9600); while (!Serial) { // ожидаем готовности последовательного порта } // пробуем обратиться к SD-карте памяти Serial.print(«Initializing SD card…»); if (!SD.begin(SD_CS)) { Serial.println(«failed!»); return; } Serial.println(«OK!»); // инициализируем и очищаем GLCD-экран EsploraTFT.begin(); EsploraTFT.background(255, 255, 255); // загружаем изображение с SD-карты image = EsploraTFT.loadImage(«arduino.bmp»); // проверяем, корректно ли загружена картинка if (image.isValid() != true) { Serial.println(«error while loading arduino.bmp»); } //выводим изображение на экран EsploraTFT.image(image, 0, 0); } void loop(){ // здесь ничего не делаем }

Что дальше?

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

Сообщества ›
Arduino для автомобиля ›
Блог ›
Mega 2560 R3 + 3.95 TFT LCD Touch

Ну вдруг пригодится.
В общем в папке UTFT есть файл DefaultFonts.c, в нём описаны массивы SmallFont, BigFont и SevenSegNumFont. Массив начинается с 4х байт конфигурации, дальше данные о начертании символа.
1й и 2й байт: размер матрицы символа в пикселях, например у SmallFont указано 0x08 и 0x0C — значит для символа отведено 8 бит по горизонтали и 12 бит по вертикали и того 12 байт для символа.
3й байт — это начальное смещение в таблице ASCII, например у SmallFont указано 0x20, тоесть первый описанный в массиве символ имеет код 32, тоесть символ «пробел».
4й байт — это количество описанных символов в массиве, например у SmallFont указано 0x5F, тоесть всего 95 символов. Если собирёшься расширять этот массив до кодов русских символов — соответвтенно этот байт тоже надо будет изменить!

Ну и далее описаны символы, например символ «#» имеет описание 0x00,0x00,0x28,0x28,0xFC,0x28,0x50,0xFC,0x50,0x50,0x00,0x00 если представить это в двоичной системе и каждый байт в своей строке получится матрица 8*12 с начертанием символа
00000000
00000000
00101000
00101000
11111100
00101000
01010000
11111100
01010000
01010000
00000000
00000000

Так например символ «Ю» будет иметь следующий вид: 0x00,0x00,0x98,0xA4,0xA4,0xA4,0xE4,0xA4,0xA4,0x98,0x00,0x00

Только тут есть особенность. Нужно чтобы русские символы в массиве находились на тех же местах, что и в таблице ASCII! Тоесть например символ «Б» имеет код 193, соответственно, с учётом начального смещения, которое описано в 3м байте, его нужно описать в 193 позиции…

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

Такие дела 🙂 Будут вопросы — пиши. Правда я ещё сам начинающий

Библиотека UTFT для цветных TFT дисплеев к arduino

  • Готовые подарки!
  • Контроллеры
  • Роботы и наборы
  • Модули / Shield
  • Сенсоры / Датчики
  • Дисплеи
  • Механика
  • Макетирование
  • Провода и кабели
  • Программаторы
  • Радиодетали
  • Источники питания
  • Инструменты
  • Корпуса и крепежи
  • Разное
  • Упакованные подарки!
  • Raspberry Pi
  • Семейство Arduino
  • Семейство Piranha
  • ESP32 и ESP8266
  • Другие
  • STM8 и STM32
  • Детские наборы с программированием
  • Детские наборы без программирования
  • Наборы по пайке
  • Реле / Силовые ключи
  • Беспроводная связь
  • Драйвер моторов
  • Аудио / Видео
  • GPS
  • RFID
  • Устройства ввода
  • Часы реального времени
  • Интерфейсы
  • Другие
  • Arduino Shields
  • Световые
  • Климатические
  • Тактильные
  • Света и цвета
  • Аудио / Видео
  • Пространства
  • Положения (Акселерометры & Компасы & Гироскопы)
  • Газа
  • Другие
  • Тока / Напряжения
  • Жидкостные
  • Графические
  • Символьные
  • Светодиодные
  • Серия Nextion
  • Сервоприводы
  • Двигатели / Мотор-редукторы
  • Механизмы
  • Шаговые двигатели
  • Платформы роботов
  • Конструктор
  • Соленоиды
  • Другое
  • Колеса
  • Насосы
  • Линейные приводы
  • Макетки (Breadboard)
  • Макетные платы (пайка)
  • Радиоэлементы для макетирования
  • Провода для макетирования
  • Под пайку
  • Для макетирования
  • Комуникации с ПК (USB)
  • Питание
  • Шлейфы
  • Другие
  • Преобразователи USB-UART
  • Программаторы AVR
  • Программаторы STM
  • Микроконтроллеры
  • Микросхемы
  • Резисторы
  • Транзисторы
  • Диоды
  • Конденсаторы
  • Стабилизаторы
  • Панельки
  • Кварц
  • Кнопки и переключатели
  • Светодиоды
  • Разъёмы
  • Другие
  • Блоки питания
  • Преобразователи
  • Батарейки и аккумуляторы
  • Отсеки для батареек
  • Зарядные устройства
  • Ручные инструменты
  • Измерительные
  • Паяльные
  • Органайзеры
  • Корпуса пластиковые
  • Корпуса из ПВХ
  • Стойки
  • Винты
  • Гайки
  • Шайбы
  • RFID Метки
  • Антенны
  • Шланги и переходники
  • Книги и методички
  • Радиаторы
  • Магниты
  • Ручки и колпачки
  • Другое

TFT LCD дисплей 2.8 дюйма и Arduino

Тачскрин дисплей станет украшением для любого проекта на Arduino.

В этой статье мы рассмотрим touchscreen display shield со встроенным слотом для microSD карты. TFT дисплей имеет диагональ 2.8″, подсветку, в которой используется 4 белых светодиода, и возможность отображения 262000 оттенков цветов (18 бит)! Дисплей имеет разрешением 240х320 пикселей с индивидуальным управлением. Обратите внимание, что это гораздо больше, чем, например, у черно-белого LCD дисплея 5110. На шилде встроен резистивный тачскрин, что позволяет определяеть положение пальца при нажатии на экран.

Общая информация и техническые характеристики TFT LCD шилда 2.8″

TFT shield продается в полностью собранном виде, готовый к запуску. Достаточно его просто установить сверху на вашу Arduino и подключить необходимую библиотеку в Arduino IDE. Процедура установки-наладки-первого заруска займет не больше 10 минут!

На TFT шилде есть встроенный контроллер с буферизацией RAM. В результате большинство операций передается имнно шилду, а не грузят контроллер на Arduino. Для подключения шилда TFT дисплея достаточно несколько пинов: 12 пин отвечает за дисплей, 13 — за работу SD карты, если вы ее используете.

Конечно, производители не оставили нас наедине с даташитом и пожеланием «Удачи!». Есть библиотеки, которые значительно облегчат вашу работы с TFT шилдом.

Есть отличная open-source графическая библиотека, которая дает возможность рисовать пиксели, линии, прямоугольники, окружности и текст: .

Кроме того, написана тач-скрин библиотека: , которая определяет координаты x, y и z (давление), в которой есть пример скетча для демонстрации указанных возможностей. Данный скетч написандля Arduino, но может быть адаптирован для других микроконтроллеров!

Технические характеристики TFT дисплея:

  • Диагональ LCD TFT дисплея составляет 2.8″
  • Разрешение 240×320 пикселей, 18-bit (262000) цветовая гамма
  • Контроллер ILI9325 или ILI9328 со встроенным буфером оперативной памяти
  • Цифровой интерфейс на 8 бит, плюс 4 линейки управления
  • Использует цифровые пины 5-13 и аналоговые 0-3. Это значит, что можно использовать цифровые пины 2, 3 и аналоговые 4 и 5. Пин 12 тоже доступен, если вы не используете microSD карту
  • Совместим с любой платой Arduino ‘328 или Mega
  • Совместим с 5В! Может использовать питание логики 3.3 В и 5 В
  • Есть встроенный LDO регулятор 3.3 В @ 300 мА LDO regulator
  • Подсветка из 4 белых светодиодов. По умолчанию включена. Для управления можно подключить транзистор к цифровому пину с подсветкой
  • 4-х проводниковый резистивный сенсорный экран

Дополнительные вопросы и ответы

Я ознакомился с даташитом и обнаружил, что доступен SPI интерфейс. Почему вы используете параллельный интерфейс? SPI ведь лучше, будет задействовано меньше пинов!

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

Задействованы все пины! Как я могу подключить еще что-то к Arduino?

Можно использовать protoshield или proto-screwshield. Вы можете подключить различные i2c датчики или аналоговые сенсоры к аналоговым пинам 4 и 5. Можно использовать i2c плату расширения, чтобы получить больше пинов. Если же пинов надо действительно много, можно использовать 8 пинов для передачи данных пока TFT не записывает данные. Это пины high-z и они не используются, пока пины WR и RD находятся в состоянии high.

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

TFT шилд 2.8 дюйма поставляется от производителей (даже из дешевого Китая) в собранном виде. Для использования достаточно просто установить его сверху на Arduino. Никаких дополнительных проводов, никаких макеток!

Проверка LCD

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

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

Вам понадобится GFX graphics core. Постумаем аналогично. Распаковываем, перекидываем в папку с библиотеками для Arduino IDE.

Если вы используете именно шилд от Adafruit, есть еще один нюанс! Откройте файл TFTLCD.h в папке с библиотеками и раскомментируйте строку, которая находится сверху:

//comment or uncomment the next line for special pinout!

#define USE_ADAFRUIT_SHIELD_PINOUT

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

Библиотека GFX Library от Adafruit

Библиотека TFT LCD library основана на графической библиотеке Adaftui GFX graphics. В GFX есть много готовых функций для основы вашего проекта. Библиотека поддерживает пиксели, линии, прямоугольники, окружности, скругленные прямоугольники, треугольники, отображение текста, поворот. Скачать ее можно по .

Пример рисования на сенсорном дисплее

Данный LCD TFT шилд имеет встроенный 2.8″ 4-х проводниковый резистивный дисплей. Его можно использовать для определения места контакта пальца, стилуса и т.п. Для работы с сенсорным дисплеем вам понадобится 4 пина на Arduino.

Скачать пример вы можете здесь: Github repository. Не забудьте разархивировать скачанный файл и переместить его в папку с библиотеками Arduino IDE.

Сенсорный дисплей подключается к Arduino следущим образом:

  • Y+ подключается к аналоговому пину 1
  • Y- подключается к цифровому пину 7
  • X+ подключается к цифровому пину 6
  • X- подключается к аналоговому пину 2

После подключения загрузите пример tftpaint_shield, который находится в библиотеке TFTLCD library. С правой стороны на экране появятся ‘боксы с цветами’. Вы можете нажать на один из боксов для выбора цвета, которым будете рисовать. Нажав на левую часть экрана вы можете его очистить.

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

Загрузка рисунков

На TFT LCD дисплее 2.8″ дюйма есть встроенный слот для micoSD карты. Этот слот можно использовать для загрузки изображений! Предварительно отформатируйте карту в FAT32 или FAT16 ( более детально особенности работы SD карты с Arduino отображены здесь).

В большинстве скетчей-примеров SD карта не будет работать. Необходимо ее предварительно инициализировать.

Для увеличения скорости обмена данных можно загрузить дополнительную библиотеку здесь: Fixes & Updates to the Arduino SD Library. Не забудьте скопировать распакованную библиотеку в соответствующую папку в Arduino IDE.

Если вы пользуетесь Arduino Mega, внесите некоторые правки в файл SD/utility/Sd2Card.h. Надо снять тег комментария со строки #define MEGA_SOFT_SPI 1. Благодаря этому для обмена данными с SD картой, Arduino Mega сможет использовать те же пины, что и классические Arduino. Для тестировки можете загрузить это изображение тигра: Download this tiger bitmap and save it to the microsd card!

Запустите Arduino IDE и выберите скетч tftbmp_shield. Загрузите его на Arduino и вуаля! На экране отобразится следующее:

Для загрузки подойдут изображения, размер которых меньше 240х320 пикселей. Рисунки надо сохранять в 24-битном BMP формате. Даже если изначально рисунок не имел 24 бита, пересохраните его, так как это самый легкий формат для чтения с помощью Arduino. Можно поворачивать рисунки с использованием процедуры setRotation().

Управление подсветкой

По умолчанию разработчики шилда считают, что вы постоянно будете использовать подсветку. Однако вы можете управлять ее яркость с помощью ШИМ выходов или вообще выключать для экономии энергии. Для этого вам понадобится немного потрудиться. Найдите на задней стороне TFT LCD шилда 2.8″ два коннектора подсветки. С помощью ножа уберите дорожку между клемами VCC и соедините два квадрата, обозначенных Pin3. После этого вы сможете управлять подсветкой с использованием цифрового пина 3.

Как подключить модуль TFT LCD от mcufriend.com

Давным давно покупал я через eBay кучу компонентов для Arduino, в числе которых был TFT LCD дисплей 2,4″ от компании mcufriend.com

Для работы необходимы несколько библиотек. Первая — это библиотека от Adafruit для обработки графики, подходит не только для дисплеев от Adafruit, но и для многих других. Скачать последнюю версию можно отсюда:

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

И библиотека для обработки нажатий:

Подключаем все эти библиотеки в Arduino IDE, загружаем образец graphicstest из TFTLCD-Library и видим белый экран.

Экран, который достался мне, построен на базе чипсета S6D0154, а библиотека Adafruit его не распознает. Нашел библиотеку, которая поддерживает мой чипсет и еще несколько (ILI9341, ILI9327 b ILI9488). Скачать можно отсюда: https://github.com/samuraijap/TFTLCD-Library
Ей заменяем одноименную библиотеку от Adafruit.

По умолчанию библиотека для экранов 2.8″ и на более маленьких экранах пропадает часть изображения. Если размер экрана 2.4″, как и у меня, то в файле TFTLCD-Library/Adafruit_TFTLCD.cpp надо закомментировать строчки:
//#define TFTWIDTH 320
//#define TFTHEIGHT 480
и раскомментировать:
#define TFTWIDTH 240
#define TFTHEIGHT 320

Также, может быть интересна следующая библиотека для чипсета SPFD5408:

По сути, это библиотека от Adafruit, доработанная для SPFD5408. Плюс в ней присутствует возможность калибровки тач-панели.

Сенсорный дисплей TFT 2.4 дюйма

Это какая-то жесть, трэш и хардкор!

С этим экраном без пол-литра разобраться невозможно!

Ну ладно, свое негодование я выразил, теперь можно приступить к инструкции подключения сенсорного экрана к Arduino. Как вы уже догадались из заголовка статьи — подключать мы будем Сенсорный дисплей TFT 2.4 дюйма.

Я взял готовую библиотеку для работы с сенсорным дисплеем — Adafruit_TFTLCD и TouchScreen (их выкладывать не буду, и так много в интернете), и попробовал пример paint из Образцов.

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

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

Вдруг я наткнулся на библиотеку, написанную как раз для данного контроллера SPFD5408 — github или архив на нашем сайте. Попробовав ее запустить, я было вздохнул с облегчением, когда на экране появились надписи, и уже начал ликовать, но и тут меня ждало разочарование — тачскрин не работал. Точнее работал, но только один раз и при тыке в определенное место. Я уж начал грешить на экран, но решил добить все это дело до конца и пошел сравнивать коды библиотек.

В стандартной библиотеке Adafruit_TFTLCD выбор устройства идет с помощью следующего кода:

uint16_t identifier = tft.readID();
if(identifier == 0x9325) {
Serial.println(F(«Found ILI9325 LCD driver»));
} else if(identifier == 0x9328) {
Serial.println(F(«Found ILI9328 LCD driver»));
} else if(identifier == 0x7575) {
Serial.println(F(«Found HX8347G LCD driver»));
} else if(identifier == 0x9341) {
Serial.println(F(«Found ILI9341 LCD driver»));
} else if(identifier == 0x8357) {
Serial.println(F(«Found HX8357D LCD driver»));
} else {
Serial.print(F(«Unknown LCD driver chip: «));
Serial.println(identifier, HEX);
Serial.println(F(«If using the Adafruit 2.8\» TFT Arduino shield, the line:»));
Serial.println(F(» #define USE_ADAFRUIT_SHIELD_PINOUT»));
Serial.println(F(«should appear in the library header (Adafruit_TFT.h).»));
Serial.println(F(«If using the breakout board, it should NOT be #defined!»));
Serial.println(F(«Also if using the breakout, double-check that all wiring»));
Serial.println(F(«matches the tutorial.»));
return;
}
tft.begin(identifier);

Так как у нас драйвер ILI9341, то код, по идее, должен быть 0x9341. Как бы не так. Идентификатор устройства не хочет определяться, и поэтому весь следующий код мы меняем на:

tft.begin(0x9341);

Отлично, теперь попробуем с помощью примера отобразить изображение с флешки.

Код данного примера слишком длинный, поэтому я оставлю его на pastebin

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

И получилось у меня вот что:

Что ж, очень неплохо. Цвета четкие, и отображается все правильно. Пока все хорошо.

Теперь постараемся проверить наш тачпад в действии.

Данный код тоже из образцов, но со стандартным TouchScreen.h он работать отказывался. Поэтому я заменил его на SPFD5408_TouchScreen.h из библиотеки SPFD5408

#include <stdint.h>
#include <SPFD5408_TouchScreen.h>
#define YP A2
#define XM A3
#define YM 8
#define XP 9
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
void setup(void) {
Serial.begin(9600);
}
void loop(void) {
TSPoint p = ts.getPoint();
if (p.z > ts.pressureThreshhold) {
Serial.print(«X = «); Serial.print(p.x);
Serial.print(«\tY = «); Serial.print(p.y);
Serial.print(«\tPressure = «); Serial.println(p.z);
}
delay(100);
}

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

И я начал копаться в коде библиотеки SPFD5408 и в ее примерах.

Нашел кучу багов. Например, дисплей не отдает ширину и высоту, свой идентификатор и много разных данных. Помимо этого x почему-то был y, и наоборот. Все что только возможно было напутано и перепутано.

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

Так как все примеры громоздки я, опять же, залил их на PasteBin (приведенные ниже скетчи работают только с дисплеем 2.4″ (320х240). Ширина и высота там захардкожены.),

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

Сначала нужно коснуться 2-х точек в разных углах экрана

После чего получим данные:

Отсюда нам нужны только 4 числа. Куда их вставлять я расскажу ниже.

TS_MINX 198
TS_MINY 205
TS_MAXX 999
TS_MAXY 942

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

Вот в целом и все. Запоминаем наши данные, а лучше записываем, и переходим к примеру paint. Исправленный код вы можете найти и, единственное, что там нужно изменить, это наши калибровочные данные. Все те переменные, которые мы получили с помощью калибровки, мы вводим в строках 15-18

После запускаем, и получаем отличный paint 😉

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

Дисплей 3,5′ TFT LCD 320х480

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

Для этого нам понадобится:

Что нужно: Кол-во, шт
Контроллер 1
Дисплей 1

Пример кода:

#include <Adafruit_GFX.h> // Ядро графической библиотеки #include <Adafruit_TFTLCD.h> // Специфика аппаратного обеспечения #include <MCUFRIEND_kbv.h> // Специфика работы с разными чипами // Ассоциируем шестнадцатиричные значения цветов в удобочитаемый вид #define BLACK 0x0000 // черный #define BLUE 0x001F // синий #define RED 0xF800 // красный #define GREEN 0x07E0 // зелёный #define CYAN 0x07FF // голубой #define MAGENTA 0xF81F // малиновый #define YELLOW 0xFFE0 // жёлтый #define WHITE 0xFFFF // белый MCUFRIEND_kbv tft; //инициализация объекта дисплея void setup(void) { tft.reset(); //сброс дисплея uint16_t identifier = tft.readID(); //чтение идентификатора чипа tft.begin(identifier); //инициализация дисплея tft.invertDisplay(true); //установка чёрной подсветки для ILI9481 } void loop(void) { for(uint8_t rotation=0; rotation<4; rotation++) { //попеременно установка поворота дисплея tft.setRotation(rotation); //установить поворот //Заливка дисплея цветами tft.fillScreen(BLACK); //черным tft.fillScreen(RED); //красным tft.fillScreen(GREEN); //зелёным tft.fillScreen(BLUE); //синим tft.fillScreen(BLACK); //снова черным //Написание текста tft.setCursor(0, 0); //установить курсор в позицию 0,0 (левый верхний угол) tft.setTextColor(WHITE); //установка цвета текста (белый) tft.setTextSize(1); //установка размера текста tft.println(«Hello World!»); //вывести надпись //Вывод числовых значений tft.setTextColor(YELLOW); //установить цвет текста tft.setTextSize(2); //установить размер текста tft.println(1234.56); //вывести число //Вывод шестнадцатиричного значения tft.setTextColor(RED); //цвет текста (красный) tft.setTextSize(3); //размер текста tft.println(0x9876BEEF, HEX); //вывод значения tft.println(); //вывод пустой строки //Надписи разным шрифтом tft.setTextColor(GREEN); //установка цвета текста tft.setTextSize(5); //размер текста tft.println(«Display»); //надпись tft.setTextSize(3); //размер текста tft.println(«SmartElements»); //надпись tft.setTextColor(BLUE); //цвет текста tft.setTextSize(3); //размер текста tft.println(«Visit our»); //надпись tft.setTextColor(BLUE); //цвет текста tft.setTextSize(2); //размер текста tft.println(«ofificial store:»); //надпись tft.setTextColor(CYAN); //цвет текста tft.setTextSize(2); //размер текста tft.println(«smartelements.ru»); //надпись delay(5000); //задержка 5 секунд //Начертить линию tft.fillScreen(BLACK); //дисплей залить черным // х1 у1 х2 у2 цвет tft.drawLine(0, 0, 0, 100, GREEN); //нарисовать линию от точки 1 и точки 2, цвет tft.drawLine(0, 100, 100, 100, RED); //нарисовать линию от точки 1 и точки 2, цвет tft.drawLine(100, 100, 100, 0, BLUE); //нарисовать линию от точки 1 и точки 2, цвет tft.drawLine(100, 0, 0, 0, MAGENTA); //нарисовать линию от точки 1 и точки 2, цвет delay(5000); //задержка 5 секунд //Быстрые линии (на всю длину или высоту) tft.fillScreen(BLACK); //дисплей залить черным //5 горизонтальных линий int w = tft.width(); tft.drawFastHLine(0, 0, w, GREEN); tft.drawFastHLine(0, 5, w, GREEN); tft.drawFastHLine(0, 10, w, GREEN); tft.drawFastHLine(0, 15, w, GREEN); tft.drawFastHLine(0, 20, w, GREEN); //5 вертикальных линий int h = tft.height(); tft.drawFastVLine(0, 0, h, RED); tft.drawFastVLine(5, 0, h, RED); tft.drawFastVLine(10, 0, h, RED); tft.drawFastVLine(15, 0, h, RED); tft.drawFastVLine(20, 0, h, RED); delay(5000); //задержка 5 секунд //Рисование квадрата tft.fillScreen(BLACK); //дисплей залить черным tft.drawRect(0, 0, 100, 100, YELLOW); //пустой квадрат из точки (0, 0) со сторонами 100 пикселей tft.fillRect(0, 120, 100, 200, CYAN); //заполненный прямоугольник из точки (0, 120) со сторонами по Х — 100, по У — 200 delay(5000); //задержка 5 секунд //Рисование кругов tft.fillScreen(BLACK); //дисплей залить черным tft.fillCircle(100, 100, 50, BLUE); //залитый круг радиусом 50 пикселей из точки (100, 100) tft.drawCircle(100, 100, 100, WHITE); //пустой круг радиусом 100 пикселей из точки (100, 100) delay(5000); //задержка 5 секунд //Рисование треугольников tft.fillScreen(BLACK); //дисплей залить черным tft.fillTriangle( //нарисовать заполненный треугольник 100 , 0, // верхняя точка 50, 100, // нижняя левая 150, 100, // нижняя правая tft.color565(65, 122, 23)); //залить цветом по схеме RGB tft.drawTriangle( 100, 0, // верхняя точка 0, 100, // нижняя левая 200, 100, // нижняя правая tft.color565(0, 0, 255)); //залить цветом по схеме RGB delay(5000); //задержка 5 секунд } }

STM Урок 179. Дисплей TFT 240×320. SPI. Часть 1

На данном уроке мы попробуем к контроллеру STM32 подключить дисплей TFT разрешением 240×320.

С подобным дисплеем мы уже работали в далёком уроке 37, только это был модуль, в котором подключение дисплея к контроллеру происходило по 8-битной шине. Тогда мы использовали для этого FSMC контроллера STM32. Это такой удобный контроллер памяти.

А теперь мы попытаемся подключить модуль с подобным дисплеем, который подключается к контроллеру уже по шине SPI. Данный дисплей также выполнен на контроллере ILI9341. Такой дисплей у меня наконец-то появился. Подключим мы его также к плате STM32F4-Discovery, с которой мы когда-то очень долго работали, причём с дисплеем, подключенным по 8-битной шине, мы также работали, подключая его к такой же отладочной плате. Не каждому удалось заиметь такой дисплей, многие по ошибке, а многие и не по ошибке приобрели дисплей, именно подключенный по шине SPI и просили меня сделать такой урок. Конечно же на такие массовые просьбы я просто не мог не откликнуться, мне прислали именно такой дисплей и мы теперь с ним поработаем, начнём с библиотеки HAL, причём сначала без DMA, потом применим DMA для того, чтобы сравнить, что нам даст эта периферия.

Дисплей выглядит следующим образом

У меня дисплей размером диагонали 2,8 дюймов, могут быть другие размеры, главное, чтобы разрешение было 320×240 и контроллер чтобы был такой же.

Верхние 5 ножек относятся к работе с сенсорной панелью (TouchScreen), поэтому мы их использовать не будем, следующая 6 ножка — MISO тоже не будет нами использована, так как нам нет смысла ничего читать из дисплея, мы знаем, что у нас именно ILI9341, да и не совсем корректно контроллер работает с MISO.

Подключим к нашей отладочной плате только нижние следующим образом

Вот соответствие ножек на плате и на дисплее

STM32F4-Discovery

LCD
5V VCC
GND GND
PA4 CS
PA2 RESET
PA3 DC
PA7 SDI (MOSI)
PA5 SCK
3V

LED

Питание мы подаём 5 вольт, так как на плате модуля есть стабилизатор, а подсветку питаем 3-мя вольтами. С шиной SPI мы работаем постоянно, причём на контроллере STM32F1 мы её прошли вдоль и поперёк, применяя различные библиотеки. Думаю, F4 также не станет исключением и мы с ним также будем работать не только с применением библиотеки HAL, но так как с данной библиотекой мы уже работали с шиной SPI на контроллере STM32F4, то, думаю, нам следует пока её и использовать, чтобы не наделать ошибок.

Запустим проектогенератор Cube MX и создадим новый проект, выбрав соответствующий контроллер

Включим кварцевый резонатор

Выберем отладчик

Настроим тактирование в Closk Configuration

Включим SPI1 и настроим пока небольшую скорость, чтобы не думать, что ошибки из-за слишком высокой скорости, потом прибавим

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

Добавим нашим ножкам скорости

Включим RNG для лучшего формирования случайных чисел

Немного перестроим частоты в Clock Configuration, чтобы получить вот тут 48, только так, чтобы основная частота осталась максимальной

Присвоим имя проекту, выберем среду разработки и удвоим размер стека и кучи

Сгенерируем проект и откроем его в Keil.

Настроим программатор на автоперезагрузку, отключим оптимизацию и создадим два файла — spi_ili9341.c и spi_ili9341.h для работы с нашим дисплеем следующего содержания

spi_ili9341.h C

1 2 3 4 5 6 #ifndef __SPI_ILI9341_H #define __SPI_ILI9341_H //——————————————————————- #include «stm32f4xx_hal.h» //——————————————————————- #endif /* __SPI_ILI9341_H */

spi_ili9341.с C

1 2 #include «spi_ili9341.h» //——————————————————————-

Подключим данную библиотеку в файле main.c

C

1 2 /* USER CODE BEGIN Includes */ #include «spi_ili9341.h»

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

C

1 2 3 4 5 6 //——————————————————————- void TFT9341_ini(uint16_t w_size, uint16_t h_size) { uint8_t data; } //——————————————————————-

Добавим на данную функцию прототип в заголовочном файле и вызовем её в функции main() файла main.c

C

1 2 /* USER CODE BEGIN 2 */ TFT9341_ini(240, 320);

В файле spi_ili9341.h и добавим несколько макросов для управления нашими управляющими ножками

C

В файле spi_ili9341.c опустим ножку выбора в функции инициализации

C

1 2 uint8_t data; CS_ACTIVE();

Выше функции инициализации добавим функцию перезагрузки дисплея

C

1 2 3 4 5 6 7 8 //——————————————————————- void TFT9341_reset(void) { RESET_ACTIVE(); HAL_Delay(5); RESET_IDLE(); } //——————————————————————-

Вызовем её в функции инициализации

C

1 2 CS_ACTIVE(); TFT9341_reset();

Подключим переменную структуры шины SPI и RNG

C

1 2 3 4 5 #include «spi_ili9341.h» //——————————————————————- extern SPI_HandleTypeDef hspi1; extern RNG_HandleTypeDef hrng; //——————————————————————-

Выше функции TFT9341_reset добавим функцию отправки команды в дисплей по шине SPI

C

1 2 3 4 5 6 7 //——————————————————————- void TFT9341_SendCommand(uint8_t cmd) { DC_COMMAND(); HAL_SPI_Transmit (&hspi1, &cmd, 1, 5000); } //——————————————————————-

Ниже добавим подобную функцию отправки данных в дисплей

C

1 2 3 4 5 6 7 //——————————————————————- void TFT9341_SendData(uint8_t dt) { DC_DATA(); HAL_SPI_Transmit (&hspi1, &dt, 1, 5000); } //——————————————————————-

Теперь ниже добавим функцию отправки данных сразу пакетом в определённом количестве

C

В функции инициализации дисплея произведём также программную перезагрузку и подождём 1 секунду

C

1 2 3 4 TFT9341_reset(); //Software Reset TFT9341_SendCommand(0x01); HAL_Delay(1000);

Передадим ряд команд с определёнными параметрами в контроллер дисплея для первоначальной настройки дисплея

C

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

Подождём 120 милисекунд

C

1 2 TFT9341_SendCommand(0x11);//Выйдем из спящего режима HAL_Delay(120);

Добавим несколько нужных макросов в файл spi_ili9341.h

C

Вернёмся в функцию TFT9341_ini файла spi_ili9341.c и включим дисплей, настроив нужную ориентацию экрана

C

1 2 3 4 5 HAL_Delay(120); //Display ON data = TFT9341_ROTATION; TFT9341_SendCommand(0x29); TFT9341_WriteData(data, 1);

Добавим две глобальные переменные для хранения размеров экрана

C

1 2 3 4 5 extern RNG_HandleTypeDef hrng; //——————————————————————- uint16_t TFT9341_WIDTH; uint16_t TFT9341_HEIGHT; //——————————————————————-

В функции TFT9341_ini проинициализируем их данными из аргументов функции

C

1 2 3 TFT9341_WriteData(data, 1); TFT9341_WIDTH = w_size; TFT9341_HEIGHT = h_size;

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

C

Ниже добавим функцию заливки всего экрана определённым цветом

C

1 2 3 4 5 6 //——————————————————————- void TFT9341_FillScreen(uint16_t color) { TFT9341_FillRect(0, 0, TFT9341_WIDTH-1, TFT9341_HEIGHT-1, color); } //——————————————————————-

Добавим на 2 последние функции прототипы в заголовочный файл

C

В функции main() файла main.c зальнём экран каким-нибудь цветом, например, зелёным

C

1 2 TFT9341_ini(240, 320); TFT9341_FillScreen(TFT9341_GREEN);

Соберём код, прошьём контроллер и посмотрим результат

Всё работает, значит мы правильно настроили наш дисплей.

Теперь мы можем немного прибавить скорость шины SPI в Cube MX и перегенерировать проект

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

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

Исправим заливку зелёным цветом в чёрный цвет

TFT9341_FillScreen(TFT9341_BLACK);

Добавим небольшую задержку

C

1 2 TFT9341_FillScreen(TFT9341_BLACK); HAL_Delay(500);

Вернёмся в файл spi_ili9341.c и над функцией инициализации добавим функцию формирования случайного числа с использованием генератора RNG

C

1 2 3 4 5 6 //——————————————————————- uint16_t TFT9341_RandColor(void) { return HAL_RNG_GetRandomNumber(&hrng)&0x0000FFFF; } //——————————————————————-

Мы накладываем маску на младшие 16 бит числа, так как мы используем 16-разрядные цвета.

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

C

1 2 /* USER CODE BEGIN 1 */ uint16_t i,j;

В бесконечном цикле функции main() попробуем позакрашивать экран дисплея различными случайными цветами

C

Соберём код, прошьём контроллер и посмотрим результат

Всё отлично заливается. Скорость, конечно, не такая, как при параллельном подключении, но всё же не так уж и медленнее. Использование DMA, я думаю, нам ещё прибавит скорости.

Подключим наши глобальные переменные размера экрана

C

1 2 3 /* USER CODE BEGIN PV */ extern uint16_t TFT9341_WIDTH; extern uint16_t TFT9341_HEIGHT;

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

C

Проверим, как работает тест

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

C

Посмотрим работу теста

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

Digitrode

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

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

Цифровые фоторамки обычно состоят из четырех основных компонентов; дисплей или экран, запоминающее устройство, микроконтроллер или микропроцессор и источник питания. В сегодняшнем уроке мы будем использовать цветной TFT-дисплей с диагональю 1,8 дюймов под названием ST7735 в качестве нашего дисплея, а Arduino nano – в качестве микроконтроллера. TFT-дисплей представляет собой 1,8-дюймовый дисплей с разрешением 128 × 160 пикселей и может отображать широкий спектр цветов (полный 18-битный цвет, 262 144 оттенка!). Дисплей использует протокол SPI для связи и имеет собственный пиксельно-адресуемый буфер кадров, что означает, что он может использоваться со всеми видами микроконтроллеров, и вам нужно только 4 вывода ввода-вывода. Модуль дисплея также поставляется с разъемом для карты SD, которое мы будем использовать в качестве устройства хранения в рамках этого проекта.

1,8-дюймовый TFT-дисплей ST7735 состоит из двух комплектов выводов. Первый в верхней части состоит из 4 контактов и используется для подключения слота для SD-карты в задней части дисплея.

Второй набор выводов под экраном представляет контакты для управления самим дисплеем. Однако слот для SD-карты и дисплей используют протокол SPI для связи с микроконтроллером, поэтому они будут подключены к одним и тем же контактам на Arduino nano. Единственным отличием будет вывод CS/SS, так как каждый из них будет подключен к другому выводу.

Схема подключения Arduino и дисплея ST7735 следующая:

Для этой схемы мы использовали Fritzing-модель 1,8-дюймового TFT-дисплея ST7735, здесь расположение выводов немного отличается от нашего дисплея. У этой модели контакты слота для SD-карты и дисплея объединены. Чтобы облегчить подключение, вот распиновка:

Arduino – Слот-SD-карты D11 — MOSI/SI D12 — MISO/SO D13 — SCK D4 — CS/SS GND -GND 5V – VIN

Соединения для стороны дисплея TFT почти такие же.

Arduino — 1.8″ TFT D11 — MOSI D12 — MISO/SO D13 — SCK D10 — CS/SS D8 — RST D9 — DC GND -GND 5V – VIN

Изображения, которые будут отображаться на TFT, должны быть в растровом формате, поэтому перед копированием изображений на SD-карту нам необходимо преобразовать их в распознаваемую растровую форму. Для этого мы использовали бесплатное программное обеспечение Paint.net (для Windows), но вы можете использовать любое другое программное обеспечение для редактирования изображений. Загрузите изображения в программное обеспечение по одному и используйте инструмент изменения размера, чтобы уменьшить его разрешение и размер (160 × 128 пикселей).

После этого сохраните изображение на SD-карту с расширением bmp.

Код для этого проекта является слегка измененной версией готового примера SPI TFT, поставляемого с библиотекой ST7735 от Adafruit. Таким образом, код для этого руководства сильно зависит от библиотек Adafruit ST7735 и GFX. В основе кода мы просто вызываем функцию bmpDraw для каждого из изображений, которые мы хотим отобразить, устанавливая подходящее время задержки между каждым из изображений. Функция bmpDraw позволяет очень легко отображать изображения на TFT. Все, что нам нужно сделать, это указать имя файла .bmp, начальные координаты, и она будет использовать эту информацию для извлечения изображения с SD-карты и отображения на экране. Вот полный код проекта показан.

#include <Adafruit_GFX.h> #include <Adafruit_ST7735.h> #include <SPI.h> #include <SD.h> #define TFT_CS 10 #define TFT_RST 8 #define TFT_DC 9 #define SD_CS 4 Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST); void setup(void) { Serial.begin(9600); tft.initR(INITR_BLACKTAB); Serial.print(«Initializing SD card…»); if (!SD.begin(SD_CS)) { Serial.println(«failed!»); return; } Serial.println(«OK!»); tft.setRotation(1); } void loop() { bmpDraw(«logo.bmp», 0, 0); delay(3000); bmpDraw(«mezapos.bmp»,0,0); delay(3000); bmpDraw(«sparti.bmp»,0,0); delay(3000); bmpDraw(«mani.bmp»,0,0); delay(3000); bmpDraw(«lisbon.bmp»,0,0); delay(3000); } #define BUFFPIXEL 20 void bmpDraw(char *filename, uint8_t x, uint8_t y) { File bmpFile; int bmpWidth, bmpHeight; uint8_t bmpDepth uint32_t bmpImageoffset; uint32_t rowSize; uint8_t sdbuffer; uint8_t buffidx = sizeof(sdbuffer); boolean goodBmp = false; boolean flip = true; int w, h, row, col; uint8_t r, g, b; uint32_t pos = 0, startTime = millis(); if((x >= tft.width()) || (y >= tft.height())) return; Serial.println(); Serial.print(«Loading image ‘»); Serial.print(filename); Serial.println(‘\»); if ((bmpFile = SD.open(filename)) == NULL) { Serial.print(«File not found»); return; } if(read16(bmpFile) == 0x4D42) { Serial.print(«File size: «); Serial.println(read32(bmpFile)); (void)read32(bmpFile); bmpImageoffset = read32(bmpFile); Serial.print(«Image Offset: «); Serial.println(bmpImageoffset, DEC); Serial.print(«Header size: «); Serial.println(read32(bmpFile)); bmpWidth = read32(bmpFile); bmpHeight = read32(bmpFile); if(read16(bmpFile) == 1) { bmpDepth = read16(bmpFile); Serial.print(«Bit Depth: «); Serial.println(bmpDepth); if((bmpDepth == 24) && (read32(bmpFile) == 0)) { goodBmp = true; Serial.print(«Image size: «); Serial.print(bmpWidth); Serial.print(‘x’); Serial.println(bmpHeight); // BMP rows are padded (if needed) to 4-byte boundary rowSize = (bmpWidth * 3 + 3) & ~3; // If bmpHeight is negative, image is in top-down order. // This is not canon but has been observed in the wild. if(bmpHeight < 0) { bmpHeight = -bmpHeight; flip = false; } w = bmpWidth; h = bmpHeight; if((x+w-1) >= tft.width()) w = tft.width() — x; if((y+h-1) >= tft.height()) h = tft.height() — y; tft.setAddrWindow(x, y, x+w-1, y+h-1); for (row=0; row<h; row++) { if(flip) // Bitmap is stored bottom-to-top order (normal BMP) pos = bmpImageoffset + (bmpHeight — 1 — row) * rowSize; else // Bitmap is stored top-to-bottom pos = bmpImageoffset + row * rowSize; if(bmpFile.position() != pos) { bmpFile.seek(pos); buffidx = sizeof(sdbuffer); } for (col=0; col<w; col++) { if (buffidx >= sizeof(sdbuffer)) { bmpFile.read(sdbuffer, sizeof(sdbuffer)); buffidx = 0; } b = sdbuffer; g = sdbuffer; r = sdbuffer; tft.pushColor(tft.Color565(r,g,b)); } } Serial.print(«Loaded in «); Serial.print(millis() — startTime); Serial.println(» ms»); } } } bmpFile.close(); if(!goodBmp) Serial.println(«BMP format not recognized.»); } uint16_t read16(File f) { uint16_t result; ((uint8_t *)&result) = f.read(); ((uint8_t *)&result) = f.read(); return result; } uint32_t read32(File f) { uint32_t result; ((uint8_t *)&result) = f.read(); ((uint8_t *)&result) = f.read(); ((uint8_t *)&result) = f.read(); ((uint8_t *)&result) = f.read(); return result; }

Убедитесь, что ваши схемные соединения верны, затем загрузите код в Arduino. Через некоторое время вы должны увидеть изображения, отображаемые как слайд-шоу на TFT-дисплее.

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

admin

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Наверх