Разница между TFT и LCD. TFT-дисплей: описание, принцип работы Что такое tft lcd

TFT и IPS матрицы: особенности, преимущества и недостатки

В современном мире мы регулярно сталкиваемся с дисплеями телефонов, планшетов, мониторами ПК и телевизоров. Технологии производства жидкокристаллических матриц не стоят на месте, связи с чем у многих людей возникает вопрос, что лучше выбрать TFT или IPS?

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

TFT матрицы

Thin Film Transistor (TFT) – это система производства жидкокристаллических дисплеев, в основе которой лежит активная матрица из тонкопленочных транзисторов. При подаче напряжения на такую матрицу, кристаллы поворачиваются друг к другу, что приводит к образованию черного цвета. Отключение электричества дает противоположный результат — кристаллы образовывают белый цвет. Изменения подаваемого напряжения позволяет формировать любой цвет на каждом отдельно взятом пикселе.

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

Недостатки TFT дисплеев:

- низкая цветопередача. Технология имеет ограничение в 6 бит на один канал;
- спиральное расположение кристаллов негативно сказывается на контрастности изображение;
- качество изображения заметно снижается при изменении угла обзора;
- высокая вероятность появления «битых» пикселей;
- относительно низкое энергопотребление.

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

IPS матрицы

Матрица IPS является усовершенствованным продолжением дисплеев, разработанных по технологии TFT. Главным различием между этими матрицами является то, что в TFT жидкие кристаллы расположены по спирали, а в IPS кристаллы лежат в одной плоскости параллельно друг другу. Кроме того, при отсутствии электричества они не поворачиваются, что положительно сказалось на отображении черного цвета.

Преимущества IPS матриц:

углы обзора, при которых качество изображения не снижается, увеличены до 178 градусов;
улучшенная цветопередача. Количество данных, передаваемых на каждый канал увеличено до 8 бит;
существенно улучшенная контрастность;
снижено энергопотребление;
низкая вероятность появления «битых» или выгоревших пикселей.

Изображение на IPS матрице выглядит более живим и насыщенным, но это не означает, что эта технология лишена недостатков. В сравнении с предшественником у IPS значительно снижена яркость изображения. Также, вследствие изменения управляющих электродов, пострадал такой показатель, как время отклика матрицы. Последним, но не менее значимым недостатком, является относительно высокая цена на устройства, в которых используются IPS дисплеи. Как правило, они на 10-20% дороже аналогичных с TFT матрицей.

Что выбрать: TFT или IPS?

Стоит понимать, что TFT и IPS матрицы, несмотря на существенные различия в качестве изображения, технологии очень похожие. Они обе созданы на основе активных матриц и используют одинаковые по структуре жидкие кристаллы. Многие современные производители отдают свое предпочтение IPS матрицам. Во многом благодаря тому, что они могут составить более достойную конкуренцию плазменным матрицам и имеют весомые перспективы в будущем. Тем не менее TFT матрицы также развиваются. Сейчас на рынке можно встретить TFT-TN и TFT-HD дисплеи. Они практически не уступают в качестве изображения IPS матрицам, но при этом имеет более доступную стоимость. Но на данный момент устройств с такими мониторами не так много.

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

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

В этой статье вы узнаете, как использовать TFT LCD с платами Arduino. Мы постараемся освятить базовые команды, а также расскажем про профессиональные дизайны и технику. По планам поле статьи можно будет научиться:

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

Из Википедии : Жидкокристаллический дисплей с активной матрицей (TFT LCD, англ. thin-film transistor - тонкоплёночный транзистор) - разновидность жидкокристаллического дисплея, в котором используется активная матрица, управляемая тонкоплёночными транзисторами.

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

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

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

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

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

Какого размера? Какой контроллер?

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

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

3,5" дюйма 480 × 320,
2,8" дюйма 400 × 240,
2,4" дюйма 320 × 240,
1,8" дюйма 220 × 176.

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

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

Драйверы и библиотеки

В электронике / компьютерном оборудовании драйвер дисплея обычно представляет собой полупроводниковую интегральную схему (но может альтернативно содержать конечную машину, состоящую из дискретной логики и других компонентов), который обеспечивает функцию интерфейса между микропроцессором, микроконтроллером, ASIC или периферийным интерфейсом общего назначения и конкретным типом устройства отображения, например LCD, LED, OLED, ePaper, CRT, Nixie и т.п.

Драйвер дисплея обычно принимает команды и данные с использованием стандартного универсального последовательного или параллельного интерфейса общего назначения, такого как TTL, CMOS, RS232, SPI, I2C и т.д. и генерирует сигналы с подходящим напряжением, током, временем и демультиплексированием, чтобы реализовать на дисплее отображение нужного текста или изображения.

Производители ЖК-дисплеев используют разные драйверы в своих продуктах. Некоторые из них более популярны, а некоторые из них неизвестны. Чтобы легко запускать ваш экран, вы должны использовать библиотеки LCD Arduino и добавить их в свой код. В противном случае запуск дисплея может быть очень осложнен. В Интернете есть много бесплатных библиотек, но важным моментом в библиотеках является их совместимость с драйвером ЖК-дисплея. Драйвер вашего ЖК-дисплея должен быть известен вашей библиотеке. В этой статье мы используем библиотеку Adafruit GFX и библиотеку MCUFRIEND KBV и примеры кода. Вы сможете скачать их по сопутствующим ссылкам.

Разархивируйте MCUFRIEND KBV и откройте MCUFRIEND_kbv.CPP. Вы увидите список драйверов, которые поддерживаются библиотекой MCUFRIEND.

Откройте папку с примерами (англ. - Example). Существует несколько примеров кода, которые вы можете запустить на Arduino. Подключите ЖК-дисплей и проверьте некоторые примеры.

Список комплектующих

Для реализации многих проектов, связанных с TFT LCD нам понадобится набор некоторых комплектующих, которые мы уже обсудили выше:

3.5-дюймовый цветной TFT-дисплей ElectroPeak × 1
2,4-дюймовый дисплей TFT LCD ElectroPeak × 1
Arduino UNO R3 × 1
Arduino Mega 2560 × 1
Arduino DUE × 1

Программное обеспечение

Также для работы с Ардуино нам обычно нужна .

Код

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

Перейдите на нашего сайта или на сайт www.arduino.cc/en/Main/Software и загрузите программное обеспечение для вашей ОС. Установите программное обеспечение в соответствии с инструкциями.
Запустите среду разработки Arduino, очистите текстовый редактор и скопируйте код в текстовый редактор.
Перейдите к эскизу и включите библиотеки. Нажмите "добавить ZIP-библиотеку" и добавьте библиотеки.
Выберите плату в "Tools and Boards", выберите свою плату Arduino.
Подключите Arduino к компьютеру и установите COM-порт в "Tools and port".
Нажмите кнопку «Загрузить» (стрелка).
Теперь все настроено!

После загрузки кода примера пришло время узнать, как создавать изображения на ЖК-дисплее.

Библиотека

#include "Adafruit_GFX.h" #include "MCUFRIEND_kbv.h"

В первой строке добавлена основная графическая библиотека для дисплеев (написанная Adafruit).

Вторая добавляет библиотеку, которая поддерживает драйверы экранов дисплея MCUFRIEND Arduino.

#include "TouchScreen.h" // только если вы хотите использовать сенсорный экран #include "bitmap_mono.h" // когда вы хотите отображать растровое изображение из библиотеки #include "bitmap_RGB.h" // когда вы хотите отображать растровое изображение из библиотеки #include "Fonts/FreeSans9pt7b.h" // когда вам нужны другие шрифты #include "Fonts/FreeSans12pt7b.h" // когда вам нужны другие шрифты #include "Fonts/FreeSerif12pt7b.h" // когда вам нужны другие шрифты #include "FreeDefaultFonts.h" // когда вам нужны другие шрифты #include "SPI.h" // использование sdcard для отображения растрового изображения #include "SD.h"

Эти библиотеки сейчас не нужны, но вы можете их добавить.

Основные команды

Класс и объект

//(int CS=A3, int RS=A2, int WR=A1, int RD=A0, int RST=A4) MCUFRIEND_kbv tft(A3, A2, A1, A0, A4);

Эта строка делает объект с именем TFT из класса MCUFRIEND_kbv и обеспечивает связь SPI между ЖК-дисплеем и Arduino.

Запуск ЖК-дисплея

uint16_t ID = tft.readID(); tft.begin(ID);

Функция tft.readID считывает ID с дисплея и помещает его в переменную идентификатора. Затем функция tft.begin получает идентификатор и ЖК-дисплей готов к работе.

Разрешение экрана

tft.width(); //int16_t width(void); tft.height(); //int16_t height(void);

По этим двум функциям вы можете узнать разрешение дисплея. Просто добавьте их в код и поместите выходные данные в переменную uint16_t . Затем прочитайте его из последовательного порта Serial.println(); . Сначала добавьте Serial.begin (9600); в setup() .

Цвет экрана

tft.fillScreen(t); //fillScreen(uint16_t t);

Функция fillScreen меняет цвет экрана на цвет t . Это должна быть 16-битная переменная, содержащая код цвета UTFT .

#define BLACK 0x0000 #define NAVY 0x000F #define DARKGREEN 0x03E0 #define DARKCYAN 0x03EF #define MAROON 0x7800 #define PURPLE 0x780F #define OLIVE 0x7BE0 #define LIGHTGREY 0xC618 #define DARKGREY 0x7BEF #define BLUE 0x001F #define GREEN 0x07E0 #define CYAN 0x07FF #define RED 0xF800 #define MAGENTA 0xF81F #define YELLOW 0xFFE0 #define WHITE 0xFFFF #define ORANGE 0xFD20 #define GREENYELLOW 0xAFE5 #define PINK 0xF81F

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

Заполнение пикелей

tft.drawPixel(x,y,t); //drawPixel(int16_t x, int16_t y, uint16_t t) tft.readPixel(x,y); //uint16_t readPixel(int16_t x, int16_t y)

Функция drawPixel заполняет пиксель в x и y по цвету t.

Функция readPixel считывает цвет пикселя в местоположении x и y.

Рисование линий

tft.drawFastVLine(x,y,h,t); //drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t t) tft.drawFastHLine(x,y,w,t); //drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t t) tft.drawLine(xi,yi,xj,yj,t); //drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t t)

Функция drawFastVLine рисует вертикальную линию, которая начинается с местоположения x, y, ее длина - h пикселей, а цвет - t.

Функция drawFastHLine рисует горизонтальную линию, которая начинается с местоположения x и y, длина равна w пикселей, а цвет - t.

Функция drawLine рисует строку, начинающуюся с xi, yi и до xj, yj, цвет - t.

For (uint16_t a=0; a<5; a++) { tft.drawFastVLine(x+a, y, h, t);} for (uint16_t a=0; a<5; a++) { tft.drawFastHLine(x, y+a, w, t);} for (uint16_t a=0; a<5; a++) { tft.drawLine(xi+a, yi, xj+a, yj, t);} for (uint16_t a=0; a<5; a++) { tft.drawLine(xi, yi+a, xj, yj+a, t);}

Эти три блока кода рисуют линии, подобные предыдущему коду с 5-пиксельной толщиной.

Tft.fillRect(x,y,w,h,t); //fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t t) tft.drawRect(x,y,w,h,t); //drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t t) tft.fillRoundRect(x,y,w,h,r,t); //fillRoundRect (int16_t x, int16_t y, int16_t w, int16_t h, uint8_t R , uint16_t t) tft.drawRoundRect(x,y,w,h,r,t); //drawRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, uint8_t R , uint16_t t)

Функция fillRect рисует заполненный прямоугольник в координатах x и y, w - ширина, h - высота, t - цвет прямоугольника.

Функция drawRect рисует прямоугольник в координатах x и y с шириной w, высотой h и цветом t.

Функция fillRoundRect рисует заполненный прямоугольник с радиусом углов r, в координатах x и y, шириной w и высотой h, цветом t.

Функция drawRoundRect рисует прямоугольник с r радиальными закругленными углами по x и y, с шириной w и высотой h и цветом t.

Рисуем круги

tft.drawCircle(x,y,r,t); //drawCircle(int16_t x, int16_t y, int16_t r, uint16_t t) tft.fillCircle(x,y,r,t); //fillCircle(int16_t x, int16_t y, int16_t r, uint16_t t)

Функция drawCircle рисует круг по координатам x и y, с радиусом r и цветом t.

Функция fillCircle рисует заполненный круг по координатам x и y, радиусом r и цветом t.

For (int p = 0; p < 4000; p++) { j = 120 * (sin(PI * p / 2000)); i = 120 * (cos(PI * p / 2000)); j2 = 60 * (sin(PI * p / 2000)); i2 = 60 * (cos(PI * p / 2000)); tft.drawLine(i2 + 160, j2 + 160, i + 160, j + 160, col[n]); }

Этот код рисует дугу. Можно изменить значение в «for» между 0 и 4000.

Рисование треугольников

tft.drawTriangle(x1,y1,x2,y2,x3,y3,t); //drawTriangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3,// uint16_t t) tft.fillTriangle(x1,y1,x2,y2,x3,y3,t); //fillTriangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3,// uint16_t t)

Функция drawTriangle рисует треугольник с тремя угловыми координатами x, y и z и t цветом.

Функция fillTriangle рисует заполненный треугольник с тремя угловыми координатами x, y, z и t цветом.

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

tft.setCursor(x,y); //setCursor(int16_t x, int16_t y)

Этот код устанавливает позицию курсора на x и y.

Tft.setTextColor(t); //setTextColor(uint16_t t) tft.setTextColor(t,b); //setTextColor(uint16_t t, uint16_t b)

Первая строка задает цвет текста. Следующая строка задает цвет текста и его фона.

Tft.setTextSize(s); //setTextSize(uint8_t s)

Этот код устанавливает размер текста величиной s . Само число s меняется в диапазоне от 1 до 5.

Tft.write(c); //write(uint8_t c)

Этот код отображает символ.

Tft.println("www.Electropeak.com"); tft.print("www.Electropeak.com");

Первая функция отображает строку и перемещает курсор на следующую строку.

Вторая функция просто отображает строку.

ShowmsgXY(x,y,sz,&FreeSans9pt7b,"www.Electropeak.com"); //void showmsgXY(int x, int y, int sz, const GFXfont *f, const char *msg) void showmsgXY(int x, int y, int sz, const GFXfont *f, const char *msg) { uint16_t x1, y1; uint16_t wid, ht; tft.setFont(f); tft.setCursor(x, y); tft.setTextColor(0x0000); tft.setTextSize(sz); tft.print(msg); }

Эта функция изменяет шрифт текста. Вы должны добавить эту функцию и библиотеки шрифтов.

For (int j = 0; j < 20; j++) { tft.setCursor(145, 290); int color = tft.color565(r -= 12, g -= 12, b -= 12); tft.setTextColor(color); tft.print("www.Electropeak.com"); delay(30); }

Эта функция может заставить текст исчезать. Вы должны добавить её в свой код.

Вращение экрана

tft.setRotation(r); //setRotation(uint8_t r)

Этот код поворачивает экран. 0 = 0°, 1 = 90°, 2 = 180°, 3 = 270°.

Инвертирование цветов экрана

tft.invertDisplay(i); //invertDisplay(boolean i)

Этот код инвертирует цвета экрана.

Tft.color565(r,g,b); //uint16_t color565(uint8_t r, uint8_t g, uint8_t b)

Этот код передает код RGB и получает цветовой код UTFT.

Прокрутка экрана

for (uint16_t i = 0; i < maxscroll; i++) { tft.vertScroll(0, maxscroll, i); delay(10);}

Этот код прокручивает ваш экран. Maxroll - максимальная высота прокрутки.

Сброс

tft.reset();

Этот код сбрасывает экран.

Отображение монохромных изображений

static const uint8_t name PROGMEM = { //Добавьте код изображения здесь. } tft.drawBitmap(x, y, name, sx, sy, 0x0000);

Сначала вы должны преобразовать свое изображение в шестнадцатеричный код. Загрузите программное обеспечение по ссылке ниже. Если вы не хотите изменять настройки программного обеспечения, вы должны инвертировать цвет изображения, отразить изображение горизонтально (зеркально) и повернуть его на 90 градусов против часовой стрелки.

Теперь добавьте его в программное обеспечение и преобразуйте его. Откройте экспортированный файл и скопируйте шестнадцатеричный код в Arduino IDE. x и y - местоположения изображения. sx и sy - размеры изображения. Вы можете изменить цвет изображения на последнем input .

Отображение цветного изображения RGB

const uint16_t name PROGMEM = { //Add image code here. } tft.drawRGBBitmap(x, y, name, sx, sy);

Сначала вы должны преобразовать свое изображение в код. Используйте эту ссылку для преобразования изображения:

Загрузите изображение и скачайте преобразованный файл, с которым могут работать библиотеки UTFT. Теперь скопируйте шестнадцатеричный код в Arduino IDE. x и y - местоположения изображения. sx и sy - размер изображения.

Вы можете ниже качать программу-конвертер изображений в шестнадцатеричный код:

Предварительно созданные элементы

В этом шаблоне мы просто использовали строку и 8 заполненных кругов, которые меняют свои цвета по порядку. Чтобы нарисовать круги вокруг статической точки, вы можете использовать sin(); и cos(); функции. Вы должны задать величину PI. Чтобы изменить цвета, вы можете использовать функцию color565(); и заменить свой код RGB.

#include "Adafruit_GFX.h" #include "MCUFRIEND_kbv.h" MCUFRIEND_kbv tft; #include "Fonts/FreeSans9pt7b.h" #include "Fonts/FreeSans12pt7b.h" #include "Fonts/FreeSerif12pt7b.h" #include "FreeDefaultFonts.h" #define PI 3.1415926535897932384626433832795 int col; void showmsgXY(int x, int y, int sz, const GFXfont *f, const char *msg) { int16_t x1, y1; uint16_t wid, ht; tft.setFont(f); tft.setCursor(x, y); tft.setTextColor(0x0000); tft.setTextSize(sz); tft.print(msg); } void setup() { tft.reset(); Serial.begin(9600); uint16_t ID = tft.readID(); tft.begin(ID); tft.setRotation(1); tft.invertDisplay(true); tft.fillScreen(0xffff); showmsgXY(170, 250, 2, &FreeSans9pt7b, "Loading..."); col = tft.color565(155, 0, 50); col = tft.color565(170, 30, 80); col = tft.color565(195, 60, 110); col = tft.color565(215, 90, 140); col = tft.color565(230, 120, 170); col = tft.color565(250, 150, 200); col = tft.color565(255, 180, 220); col = tft.color565(255, 210, 240); } void loop() { for (int i = 8; i > 0; i--) { tft.fillCircle(240 + 40 * (cos(-i * PI / 4)), 120 + 40 * (sin(-i * PI / 4)), 10, col); delay(15); tft.fillCircle(240 + 40 * (cos(-(i + 1)*PI / 4)), 120 + 40 * (sin(-(i + 1)*PI / 4)), 10, col); delay(15); tft.fillCircle(240 + 40 * (cos(-(i + 2)*PI / 4)), 120 + 40 * (sin(-(i + 2)*PI / 4)), 10, col); delay(15); tft.fillCircle(240 + 40 * (cos(-(i + 3)*PI / 4)), 120 + 40 * (sin(-(i + 3)*PI / 4)), 10, col); delay(15); tft.fillCircle(240 + 40 * (cos(-(i + 4)*PI / 4)), 120 + 40 * (sin(-(i + 4)*PI / 4)), 10, col); delay(15); tft.fillCircle(240 + 40 * (cos(-(i + 5)*PI / 4)), 120 + 40 * (sin(-(i + 5)*PI / 4)), 10, col); delay(15); tft.fillCircle(240 + 40 * (cos(-(i + 6)*PI / 4)), 120 + 40 * (sin(-(i + 6)*PI / 4)), 10, col); delay(15); tft.fillCircle(240 + 40 * (cos(-(i + 7)*PI / 4)), 120 + 40 * (sin(-(i + 7)*PI / 4)), 10, col); delay(15); } }

Классический текст

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

#include "Adafruit_GFX.h" // Core graphics library #include "MCUFRIEND_kbv.h" // Hardware-specific library MCUFRIEND_kbv tft; #include "Fonts/FreeSans9pt7b.h" #include "Fonts/FreeSans12pt7b.h" #include "Fonts/FreeSerif12pt7b.h" #include "FreeDefaultFonts.h" void showmsgXY(int x, int y, int sz, const GFXfont *f, const char *msg) { int16_t x1, y1; uint16_t wid, ht; tft.setFont(f); tft.setCursor(x, y); tft.setTextSize(sz); tft.println(msg); } uint8_t r = 255, g = 255, b = 255; uint16_t color; void setup() { Serial.begin(9600); uint16_t ID = tft.readID(); tft.begin(ID); tft.invertDisplay(true); tft.setRotation(1); } void loop(void) { tft.invertDisplay(true); tft.fillScreen(WHITE); color = tft.color565(40, 40, 40); tft.setTextColor(color); showmsgXY(50, 40, 1, &FreeSerif12pt7b, " I love those who can smile in trouble,"); delay(40); tft.println(" who can gather strength from distress,"); delay(40); tft.println(" and grow brave by reflection."); delay(40); tft.println(" "Tis the business of little minds to shrink,"); delay(40); tft.println(" but they whose heart is firm,"); delay(40); tft.println(" and whose conscience approves their conduct,"); delay(40); tft.println(" will pursue their principles unto death."); delay(40); tft.println(" "); delay(700); for (int j = 0; j < 20; j++) { tft.setCursor(145, 290); color = tft.color565(r -= 12, g -= 12, b -= 12); tft.setTextColor(color); tft.print(" ---- Da Vinci ----"); delay(30); } while (1); }

Представление/презентация логотипа

В этом шаблоне мы преобразовали файл a.jpg в файл .c и добавили его в код, написали строку и использовали отображаемый код затухания. Затем мы использовали код прокрутки, чтобы переместить экран влево. Загрузите файл .h и добавьте его в папку эскиза Arduino.

#include "Adafruit_GFX.h" // Core graphics library #include "MCUFRIEND_kbv.h" // Hardware-specific library MCUFRIEND_kbv tft; #include "Ard_Logo.h" #define BLACK 0x0000 #define RED 0xF800 #define GREEN 0x07E0 #define WHITE 0xFFFF #define GREY 0x8410 #include "Fonts/FreeSans9pt7b.h" #include "Fonts/FreeSans12pt7b.h" #include "Fonts/FreeSerif12pt7b.h" #include "FreeDefaultFonts.h" void showmsgXY(int x, int y, int sz, const GFXfont *f, const char *msg) { int16_t x1, y1; uint16_t wid, ht; tft.setFont(f); tft.setCursor(x, y); tft.setTextSize(sz); tft.println(msg); } uint8_t r = 255, g = 255, b = 255; uint16_t color; void setup() { Serial.begin(9600); uint16_t ID = tft.readID(); tft.begin(ID); tft.invertDisplay(true); tft.setRotation(1); } void loop(void) { tft.invertDisplay(true); tft.fillScreen(WHITE); tft.drawRGBBitmap(100, 50, Logo, 350, 200); delay(1000); tft.setTextSize(2); for (int j = 0; j < 20; j++) { color = tft.color565(r -= 12, g -= 12, b -= 12); tft.setTextColor(color); showmsgXY(95, 280, 1, &FreeSans12pt7b, "ELECTROPEAK PRESENTS"); delay(20); } delay(1000); for (int i = 0; i < 480; i++) { tft.vertScroll(0, 480, i); tft.drawFastVLine(i, 0, 320, 0xffff); // vertical line delay(5);} while (1); }

Точечная диаграмма

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

#include "Adafruit_GFX.h" #include "MCUFRIEND_kbv.h" MCUFRIEND_kbv tft; uint16_t ox=0,oy=0; int ave=0, avec=0, avet=0; //////////////////////////////////////////////////////////////// void aveg(void) {int z=0; Serial.println(ave); Serial.println(avec); avet=ave/avec; Serial.println(avet); avet=avet*32; for (int i=0; i<24; i++){ for (uint16_t a=0; a<3; a++){ tft.drawLine(avet+a, z, avet+a, z+10, 0xFB21);} // thick for (uint16_t a=0; a<2; a++){ tft.drawLine(avet-a, z, avet-a, z+10, 0xFB21);} delay(100); z=z+20; } } ////////////////////////////////////////////////////////////////// void dchart_10x10(uint16_t nx,uint16_t ny) { ave+=nx; avec++; nx=nx*32; ny=ny*48; tft.drawCircle(nx, ny, 10, 0x0517); tft.drawCircle(nx, ny, 9, 0x0517); tft.fillCircle(nx, ny, 7, 0x0517); delay (100); ox=nx; oy=ny; } /////////////////////////////////////////////////////////////////////// void dotchart_10x10(uint16_t nx,uint16_t ny) { ave+=nx; avec++; nx=nx*32; ny=ny*48; int plus=0; float fplus=0; int sign=0; int y=0,x=0; y=oy; x=ox; float xmines, ymines; xmines=nx-ox; ymines=ny-oy; if (ox>nx) {xmines=ox-nx; sign=1;} else sign=0; for (int a=0; a<(ny-oy); a++) { fplus+=xmines/ymines; plus=fplus; if (sign==1) tft.drawFastHLine(0, y, x-plus, 0xBFDF); else tft.drawFastHLine(0, y, x+plus, 0xBFDF); y++; delay(5);} for (uint16_t a=0; a<2; a++){ tft.drawLine(ox+a, oy, nx+a, ny, 0x01E8);} // thick for (uint16_t a=0; a<2; a++){ tft.drawLine(ox, oy+a, nx, ny+a, 0x01E8);} ox=nx; oy=ny; } //////////////////////////////////////////////////////////////////// void setup() { tft.reset(); Serial.begin(9600); uint16_t ID = tft.readID(); tft.begin(ID); } void loop() { tft.invertDisplay(true); tft.fillScreen(0xffff); dotchart_10x10(3, 0); dotchart_10x10(2, 1); dotchart_10x10(4, 2); dotchart_10x10(4, 3); dotchart_10x10(5, 4); dotchart_10x10(3, 5); dotchart_10x10(6, 6); dotchart_10x10(7, 7); dotchart_10x10(9, 8); dotchart_10x10(8, 9); dotchart_10x10(10, 10); dchart_10x10(3, 0); dchart_10x10(2, 1); dchart_10x10(4, 2); dchart_10x10(4, 3); dchart_10x10(5, 4); dchart_10x10(3, 5); dchart_10x10(6, 6); dchart_10x10(7, 7); dchart_10x10(9, 8); dchart_10x10(8, 9); dchart_10x10(10, 10); tft.setRotation(1); tft.setTextSize(2); tft.setTextColor(0x01E8); tft.setCursor(20, 20); tft.print("Average"); int dl=20; for (int i=0;i<6;i++){ for (uint16_t a=0; a<3; a++){ tft.drawLine(dl, 40+a, dl+10, 40+a, 0xFB21);} dl+=16;} tft.setRotation(0); aveg(); while(1); }

Температура

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

#include "Adafruit_GFX.h" #include "MCUFRIEND_kbv.h" #include "Math.h" MCUFRIEND_kbv tft; #include "Temperature.h" #define PI 3.1415926535897932384626433832795 int a=1000,b=3500; int n, f; int j, j2 ,lj; int i, i2 ,li; int pct = 0; int d = {20, 20, 20, 20, 20}; uint16_t col = {0x7006, 0xF986, 0x6905, 0x7FF7, 0x024D}; void setup() { tft.reset(); Serial.begin(9600); uint16_t ID = tft.readID(); tft.begin(ID); tft.invertDisplay(true); tft.setTextSize(2); } void loop() { // put your main code here, to run repeatedly: tft.fillScreen(0xffff); tft.setRotation(1); tft.drawBitmap(350, 70, Temp, 70, 180, 0x0000); tft.fillCircle(385,213,25,tft.color565(255, 0, 0)); for (int p = 0; p < 4000; p++) { j = 120 * (sin(PI * p / 2000)); i = 120 * (cos(PI * p / 2000)); j2 = 110 * (sin(PI * p / 2000)); i2 = 110 * (cos(PI * p / 2000)); tft.drawLine(i2 + 160, j2 + 160, i + 160, j + 160, tft.color565(100, 100, 100)); } ///////////////////////////////////////////////////////////////////// if (b>a){ while (aКруговая диаграмма

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

#include "Adafruit_GFX.h" #include "MCUFRIEND_kbv.h" #include "Math.h" MCUFRIEND_kbv tft; #define PI 3.1415926535897932384626433832795 int n, f; int j, j2; int i, i2; int pct = 0; int d = {10, 60, 16, 9, 10}; uint16_t col = {0x7006, 0xF986, 0x6905, 0x7FF7, 0x024D}; void setup() { tft.reset(); Serial.begin(9600); uint16_t ID = tft.readID(); tft.begin(ID); tft.invertDisplay(true); tft.setTextSize(2); } void loop() { // put your main code here, to run repeatedly: tft.fillScreen(0x0042); tft.setRotation(1); for (int p = 0; p < 4000; p++) { j = 120 * (sin(PI * p / 2000)); i = 120 * (cos(PI * p / 2000)); j2 = 60 * (sin(PI * p / 2000)); i2 = 60 * (cos(PI * p / 2000)); tft.drawLine(i2 + 160, j2 + 160, i + 160, j + 160, col[n]); } n = 0; for (int a = 0; a < 5; a++) { pct += d[n] * 40; f = 4000 - pct; for (int b = 0; b < f; b++) { j = 120 * (sin(PI * b / 2000)); i = 120 * (cos(PI * b / 2000)); j2 = 60 * (sin(PI * b / 2000)); i2 = 60 * (cos(PI * b / 2000)); tft.drawLine(i2 + 160, j2 + 160, i + 160, j + 160, col); } tft.fillCircle(380, 100 + (30 * n), 10, col[n]); tft.setTextColor(0xffff); tft.setCursor(400, 94 + (30 * n)); tft.print(d[n]); tft.print("%"); n++; } while (1); }

Музыка

#include "Adafruit_GFX.h" #include "MCUFRIEND_kbv.h" MCUFRIEND_kbv tft; #include "Volume.h" #define BLACK 0x0000 int a = 0,b = 4000,c = 1000,d = 3000; int s=2000; int j, j2; int i, i2; int White; void setup() { Serial.begin(9600); uint16_t ID = tft.readID(); tft.begin(ID); tft.invertDisplay(true); tft.setRotation(1); } void loop(void) { tft.invertDisplay(true); tft.fillScreen(BLACK); tft.drawRGBBitmap(0, 0, test, 480, 320); White = tft.color565(255, 255, 255); while(1){ if (a < s) { j = 14 * (sin(PI * a / 2000)); i = 14 * (cos(PI * a / 2000)); j2 = 1 * (sin(PI * a / 2000)); i2 = 1 * (cos(PI * a / 2000)); tft.drawLine(i2 + 62, j2 + 240, i + 62, j + 240, White); j = 14 * (sin(PI * (a-300) / 2000)); i = 14 * (cos(PI * (a-300) / 2000)); j2 = 1 * (sin(PI * (a-300) / 2000)); i2 = 1 * (cos(PI * (a-300) / 2000)); tft.drawLine(i2 + 62, j2 + 240, i + 62, j + 240, 0x0000); tft.fillRect(50, 285, 30, 30, 0x0000); tft.setTextSize(2); tft.setTextColor(0xffff); tft.setCursor(50, 285); tft.print(a / 40); tft.print("%"); a++; } if (b < s) { j = 14 * (sin(PI * b / 2000)); i = 14 * (cos(PI * b / 2000)); j2 = 1 * (sin(PI * b / 2000)); i2 = 1 * (cos(PI * b / 2000)); tft.drawLine(i2 + 180, j2 + 240, i + 180, j + 240, White); j = 14 * (sin(PI * (b-300) / 2000)); i = 14 * (cos(PI * (b-300) / 2000)); j2 = 1 * (sin(PI * (b-300) / 2000)); i2 = 1 * (cos(PI * (b-300) / 2000)); tft.drawLine(i2 + 180, j2 + 240, i + 180, j + 240, 0x0000); tft.fillRect(168, 285, 30, 30, 0x0000); tft.setTextSize(2); tft.setTextColor(0xffff); tft.setCursor(168, 285); tft.print(b / 40); tft.print("%"); b++;} if (c < s) { j = 14 * (sin(PI * c / 2000)); i = 14 * (cos(PI * c / 2000)); j2 = 1 * (sin(PI * c / 2000)); i2 = 1 * (cos(PI * c / 2000)); tft.drawLine(i2 + 297, j2 + 240, i + 297, j + 240, White); j = 14 * (sin(PI * (c-300) / 2000)); i = 14 * (cos(PI * (c-300) / 2000)); j2 = 1 * (sin(PI * (c-300) / 2000)); i2 = 1 * (cos(PI * (c-300) / 2000)); tft.drawLine(i2 + 297, j2 + 240, i + 297, j + 240, 0x0000); tft.fillRect(286, 285, 30, 30, 0x0000); tft.setTextSize(2); tft.setTextColor(0xffff); tft.setCursor(286, 285); tft.print(c / 40); tft.print("%"); c++;} if (d < s) { j = 14 * (sin(PI * d / 2000)); i = 14 * (cos(PI * d / 2000)); j2 = 1 * (sin(PI * d / 2000)); i2 = 1 * (cos(PI * d / 2000)); tft.drawLine(i2 + 414, j2 + 240, i + 414, j + 240, White); j = 14 * (sin(PI * (d-300) / 2000)); i = 14 * (cos(PI * (d-300) / 2000)); j2 = 1 * (sin(PI * (d-300) / 2000)); i2 = 1 * (cos(PI * (d-300) / 2000)); tft.drawLine(i2 + 414, j2 + 240, i + 414, j + 240, 0x0000); tft.fillRect(402, 285, 30, 30, 0x0000); tft.setTextSize(2); tft.setTextColor(0xffff); tft.setCursor(402, 285); tft.print(d / 40); tft.print("%"); d++;} if (a > s) { j = 14 * (sin(PI * a / 2000)); i = 14 * (cos(PI * a / 2000)); j2 = 1 * (sin(PI * a / 2000)); i2 = 1 * (cos(PI * a / 2000)); tft.drawLine(i2 + 62, j2 + 240, i + 62, j + 240, White); j = 14 * (sin(PI * (a+300) / 2000)); i = 14 * (cos(PI * (a+300) / 2000)); j2 = 1 * (sin(PI * (a+300) / 2000)); i2 = 1 * (cos(PI * (a+300) / 2000)); tft.drawLine(i2 + 62, j2 + 240, i + 62, j + 240, 0x0000); tft.fillRect(50, 285, 30, 30, 0x0000); tft.setTextSize(2); tft.setTextColor(0xffff); tft.setCursor(50, 285); tft.print(a / 40); tft.print("%"); a--;} if (b > s) { j = 14 * (sin(PI * b / 2000)); i = 14 * (cos(PI * b / 2000)); j2 = 1 * (sin(PI * b / 2000)); i2 = 1 * (cos(PI * b / 2000)); tft.drawLine(i2 + 180, j2 + 240, i + 180, j + 240, White); j = 14 * (sin(PI * (b+300) / 2000)); i = 14 * (cos(PI * (b+300) / 2000)); j2 = 1 * (sin(PI * (b+300) / 2000)); i2 = 1 * (cos(PI * (b+300) / 2000)); tft.drawLine(i2 + 180, j2 + 240, i + 180, j + 240, 0x0000); tft.fillRect(168, 285, 30, 30, 0x0000); tft.setTextSize(2); tft.setTextColor(0xffff); tft.setCursor(168, 285); tft.print(b / 40); tft.print("%"); b--;} if (c > s) { j = 14 * (sin(PI * c / 2000)); i = 14 * (cos(PI * c / 2000)); j2 = 1 * (sin(PI * c / 2000)); i2 = 1 * (cos(PI * c / 2000)); tft.drawLine(i2 + 297, j2 + 240, i + 297, j + 240, White); j = 14 * (sin(PI * (c+300) / 2000)); i = 14 * (cos(PI * (c+300) / 2000)); j2 = 1 * (sin(PI * (c+300) / 2000)); i2 = 1 * (cos(PI * (c+300) / 2000)); tft.drawLine(i2 + 297, j2 + 240, i + 297, j + 240, 0x0000); tft.fillRect(286, 285, 30, 30, 0x0000); tft.setTextSize(2); tft.setTextColor(0xffff); tft.setCursor(286, 285); tft.print(c / 40); tft.print("%"); c--;} if (d > s) { j = 14 * (sin(PI * d / 2000)); i = 14 * (cos(PI * d / 2000)); j2 = 1 * (sin(PI * d / 2000)); i2 = 1 * (cos(PI * d / 2000)); tft.drawLine(i2 + 414, j2 + 240, i + 414, j + 240, White); j = 14 * (sin(PI * (d+300) / 2000)); i = 14 * (cos(PI * (d+300) / 2000)); j2 = 1 * (sin(PI * (d+300) / 2000)); i2 = 1 * (cos(PI * (d+300) / 2000)); tft.drawLine(i2 + 414, j2 + 240, i + 414, j + 240, 0x0000); tft.fillRect(402, 285, 30, 30, 0x0000); tft.setTextSize(2); tft.setTextColor(0xffff); tft.setCursor(402, 285); tft.print(d / 40); tft.print("%"); d--;} } }

Спидометр

#include "Adafruit_GFX.h" // Core graphics library #include "MCUFRIEND_kbv.h" MCUFRIEND_kbv tft; #define BLACK 0x0000 #include "Gauge.h" #include "Fonts/FreeSans9pt7b.h" #include "Fonts/FreeSans12pt7b.h" #include "Fonts/FreeSerif12pt7b.h" #include "FreeDefaultFonts.h" int a = 1000; int b = 4000; int j, j2; int i, i2; void showmsgXY(int x, int y, int sz, const GFXfont *f, const char *msg) { int16_t x1, y1; uint16_t wid, ht; tft.setFont(f); tft.setCursor(x, y); tft.setTextSize(sz); tft.println(msg); } void setup() { Serial.begin(9600); uint16_t ID = tft.readID(); tft.begin(ID); tft.invertDisplay(true); tft.setRotation(1); } void loop(void) { tft.invertDisplay(true); tft.fillScreen(BLACK); tft.drawRGBBitmap(0, 0, test, 480, 320); if (a < b) { while (a < b) { Serial.println(a); j = 80 * (sin(PI * a / 2000)); i = 80 * (cos(PI * a / 2000)); j2 = 50 * (sin(PI * a / 2000)); i2 = 50 * (cos(PI * a / 2000)); tft.drawLine(i2 + 235, j2 + 169, i + 235, j + 169, tft.color565(0, 255, 255)); tft.fillRect(200, 153, 75, 33, 0x0000); tft.setTextSize(3); tft.setTextColor(0xffff); if ((a/20)>99) tft.setCursor(208, 160); else tft.setCursor(217, 160); tft.print(a / 20); a++; } b = 1000; } ////////////////////////////////////////////////////////////////// while (b < a) { j = 80 * (sin(PI * a / 2000)); i = 80 * (cos(PI * a / 2000)); j2 = 50 * (sin(PI * a / 2000)); i2 = 50 * (cos(PI * a / 2000)); tft.drawLine(i2 + 235, j2 + 169, i + 235, j + 169, tft.color565(0, 0, 0)); tft.fillRect(200, 153, 75, 33, 0x0000); tft.setTextSize(3); tft.setTextColor(0xffff); if ((a/20)>99) tft.setCursor(208, 160); else tft.setCursor(217, 160); tft.print(a / 20); a--; } while (1); }

Веселый человечек

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

#include "Adafruit_GFX.h" #include "MCUFRIEND_kbv.h" MCUFRIEND_kbv tft; #include "image.h" #include "Fonts/FreeSans9pt7b.h" #include "Fonts/FreeSans12pt7b.h" #include "Fonts/FreeSerif12pt7b.h" #include "FreeDefaultFonts.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 #define GREY 0x8410 #define ORANGE 0xE880 void showmsgXY(int x, int y, int sz, const GFXfont *f, const char *msg) { int16_t x1, y1; uint16_t wid, ht; tft.setFont(f); tft.setCursor(x, y); tft.setTextColor(WHITE); tft.setTextSize(sz); tft.print(msg); } void setup() { Serial.begin(9600); uint16_t ID = tft.readID(); tft.begin(ID); tft.setRotation(1); tft.invertDisplay(true); tft.fillScreen(tft.color565(0,20,0)); showmsgXY(20, 40, 2, &FreeSans9pt7b, "La Linea"); tft.setRotation(0); } void loop(){ while(1){ tft.drawBitmap(20, 180, Line1, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line2, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line3, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line4, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line5, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line6, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line7, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line8, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line9, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line10, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line11, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line12, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line13, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line14, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line15, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line16, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line17, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128,tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line18, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line19, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line20, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line21, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line22, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line23, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line24, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line25, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128,tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line26, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line27, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); } }

Изображение

В этом шаблоне мы просто показываем некоторые изображения с помощью функций RGBbitmap и bitmap . Просто создайте код для сенсорного экрана и используйте этот шаблон. Загрузите файл.h и добавьте его в папку эскиза Arduino.

#include "Adafruit_GFX.h" // Core graphics library #include "MCUFRIEND_kbv.h" // Hardware-specific library MCUFRIEND_kbv tft; #define BLACK 0x0000 #define RED 0xF800 #define GREEN 0x07E0 #define WHITE 0xFFFF #define GREY 0x8410 #include "images.h" #include "Fonts/FreeSans9pt7b.h" #include "Fonts/FreeSans12pt7b.h" #include "Fonts/FreeSerif12pt7b.h" #include "FreeDefaultFonts.h" int a = 3000; int b = 4000; int j, j2; int i, i2; void showmsgXY(int x, int y, int sz, const GFXfont *f, const char *msg) { int16_t x1, y1; uint16_t wid, ht; // tft.drawFastHLine(0, y, tft.width(), 0xffff); tft.setFont(f); tft.setCursor(x, y); tft.setTextColor(WHITE); tft.setTextSize(sz); tft.print(msg); delay(1000); } void setup() { Serial.begin(9600); uint16_t ID = tft.readID(); tft.begin(ID); tft.invertDisplay(true); tft.setRotation(1); } void loop(void) { tft.invertDisplay(true); tft.fillScreen(BLACK); tft.drawRGBBitmap(0, 0, test, 480, 320); tft.drawBitmap(20, 20, Line1, 45, 45, 0xffff);//battery tft.drawBitmap(65, 20, Line2, 45, 45, 0xffff);//wifi tft.drawBitmap(125, 25, Line3, 45, 45, 0xffff);//mail tft.drawBitmap(185, 25, Line4, 45, 45, 0xffff);//instagram tft.drawBitmap(245, 25, Line6, 45, 45, 0xffff);//power tft.drawBitmap(20, 260, Line5, 45, 45, 0xffff);//twitter tft.drawBitmap(410, 140, Line7, 45, 45, 0xffff);//rain tft.setTextSize(6); tft.setTextColor(0xffff); tft.setCursor(280, 210); tft.print("20:45"); tft.setTextSize(2); tft.setTextColor(0xffff); showmsgXY(330, 280, 1, &FreeSans12pt7b, "Saturday"); showmsgXY(300, 305, 1, &FreeSans12pt7b, "6 October 2018"); while (1); }

Итог

Скачайте архив с файлами .h ниже:

Скорость воспроизведения всех файлов GIF отредактирована, они сделаны быстрее или медленнее для лучшего понимания. Скорость движений зависит от скорости вашего процессора или типа кода, а также от размера и толщины элементов в коде.
Вы можете добавить код изображения на главной странице, но он заполняет всю страницу. Таким образом, вы можете сделать файл a.h и добавить в папку эскиза.
В этой статье мы только что разобрали отображение элементов на ЖК-дисплее. Следите за следующим урокам, чтобы узнать, как используются сенсорные экраны и SD-карты.
Если у вас есть проблемы с включением библиотек, измените знак кавычки "" на <>.

На этом пока всё. Делитесь этим руководством по TFT LCD для Arduino со своими друзьями и коллегами.

Статьи и Лайфхаки

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

Ведь формально под это определение попадают все(!) использующиеся в мобильных устройствах типы матриц. Постараемся внести ясность.

Что такое технология TFT

Аббревиатура TFT (thin-film transistor) в переводе означает всего лишь «тонкопленочный транизистор» - полупроводниковый прибор, изготовленный в виде тончайшей пленки.

Абсолютно никакого отношения к светоизлучающим элементам дисплея он не имеет.

Но зато данная технология повсеместно используется для создания активных управляющих элементов. Ее применяют как во всех типах LCD (TN, IPS, LTPS), так и в .

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

Например, в ЖК дисплеях, изготовленных по on-cell технологии, TFT матрица отделена от сенсорного слоя полимерным изолятором, а в эти слои совмещены для уменьшения толщины.

Что имеется в виду в спецификациях

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

В характеристиках гаджетов, которые можно найти в интернет-магазинах, под типом экрана «TFT» обычно подразумевается матрица, изготовленная по технологии TN+film или попросту TN.

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

Технология TN+film, ее плюсы и минусы

Начнем с того, что этот тип – самый дешевый из современных ЖК дисплеев. Именно поэтому он очень популярен в недорогих мониторах, телевизорах и экранах лэптопов.

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

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

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

Кроме того, TN матрицы имеют существенно худшую контрастность и цветопередачу, чем IPS, не говоря уже об AMOLED.

А есть ли у таких дисплеев плюсы, кроме низкой стоимости производства? Есть – рекордно малое время отклика. Но, учитывая совершенство современных IPS матриц, особого значения этот параметр не имеет.

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

В заключение

Терминологическая путаница – это всегда неприятно, но люди склонны употреблять общепринятое, пусть и неправильное название TFT вместо правильного, но менее распространенного TN.

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

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

И снова путаница понятий. Если вы пытаетесь определить, чем отличаются мониторы или телевизоры, которые кто-то обозвал TFT и LCD — значит, вас ввели в заблуждение. Попробуйте найти отличия между автобусом и Икарусом? Между собакой и соседской Жучкой? Между фруктом и яблоком? Правильно, занятие бесполезное, потому что оба объекта являются одновременно и тем, и другим. Так и с технологиями матриц экранов: LCD — общее название класса дисплеев, к которому относится и TFT.

Определение

TFT-матрица — активная матрица LCD-дисплея, выполненная на основе применения тонкопленочных транзисторов.

LCD — плоский дисплей (и устройство на его базе) на основе жидких кристаллов.

Сравнение

LCD-дисплеи — изобретение не нашего века. Экраны электронных часов, калькуляторов, приборов, плееров — тоже жидкокристаллические, хотя значительно отличаются от привычных нам экранов смартфонов или телевизоров. Правда, поначалу LCD были монохромными, однако с развитием технологий расцвели в гамме RGB. TFT — тоже разновидность LCD-дисплеев, в основе производства которого лежит активная матрица на тонкопленочных транзисторах. Если сравнивать его с более ранним вариантом LCD, пассивной матрицей, то становится очевидным, что качество цветопередачи и время отклика TFT гораздо выше. В качестве кристаллов в пассивных матрицах используется скрученный полимер. Зато энергопотребление и стоимость пассивных матриц, получивших именование STN, могут порадовать любого. Впрочем, монохромные экраны в этом отношении будут выглядеть вообще призовыми, однако желающих смотреть такие телевизоры вряд ли будет много.

Принцип работы TFT заключается в том, что каждый из тонкопленочных транзисторов управляет единственным пикселем. На каждый пиксель приходится три транзистора, соответствующих основным цветам RGB (красному, зеленому и синему). Интенсивность светового потока зависит от поляризации, поляризация — от приложения электрического поля к жидким кристаллам. TFT предполагает повышение уровня быстродействия, контрастности и четкости полученного изображения.

Стоит отметить и недостатки матриц TFT, устраненные в других технологиях. Качество изображения напрямую зависит от внешнего освещения экрана. Транзисторы у любого из пикселей могут выйти из строя, что приводит к появлению “мертвых точек”, или битых пикселей. От этого ни один экран застраховать нельзя. Кроме того, TFT-матрицы в значительной мере энергоемкие, так что их использование в качестве дисплеев для мобильной электроники заставляет поступаться одним из самых важных свойств — автономностью.

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

Выводы сайт

LCD — тип матриц экрана, основанных на жидких кристаллах.
TFT — разновидность активных LCD-матриц.
TFT отличает от других технологий LCD применение тонкопленочных транзисторов.
TFT-матрицы экономичны, обеспечивают качественную картинку, но энергоемкие.

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

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

активная матрица, благодаря которой формируется картинка;
слой жидких кристаллов;
слой подсветки, которая бывает светодиодной или люминесцентной.

На сегодняшний день большинство продаваемых мониторов имеют жидкокристаллический дисплей на тонкопленочных резисторах (TFT-LCD). Существует несколько технологий, по которым производятся современные дисплеи. Попробуем выяснить преимущества и недостатки двух популярных технологий TN+film и IPS .

Преимущества и недостатки TFT TN

Одной из первых технологий, на основании которой и сегодня производятся дисплеи, является TN+film (Twisted Nematic + Film). Это очень распространенный и недорогой вид матриц, который с каждым годом совершенствуется.

Главным преимуществом считается то, что выпуск TN мониторов доведен до совершенства и это позволяет существенно снизить его себестоимость. Малое время отклика матрицы позволяет без искажений просматривать динамические сцены на жидкокристаллических мониторах с технологией TN+film.

Однако у этих мониторов есть ряд отрицательных качеств, таких как:

низкая цветопередача ввиду малого количества данных на каждый канал (6 бит);
малая контрастность из-за особенности расположения жидких кристаллов в дисплее;
низкие показатели по углам обзора экрана;
высокая вероятность появления «битых пикселей».

Преимущества и недостатки TFT IPS

Более новой разработкой в области производства мониторов является технология IPS (in-plane switching). Данный вид дисплеев был изобретен, чтобы устранить недостатки предыдущих моделей.

Основными преимуществами данной технологии являются:

улучшенная цветопередача (8 бит на канал);
расширенные углы обзора, достигающие 178 градусов с любой точки;
почти эталонный черный цвет.

Но все же у мониторов с IPS матрицей есть и негативные стороны, такие как:

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

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