Я потому и спрашиваю что в библиотеке
#define LCD_CS A3 // Chip Select goes to Analog 3
#define LCD_CD A2 // Command/Data goes to Analog 2
#define LCD_WR A1 // LCD Write goes to Analog 1
#define LCD_RD A0 // LCD Read goes to Analog 0
#define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin
А на дисплее LS020 нет выводов
LCD_CD
LCD_WR
LCD_RD
поэтому и спрашиваю чему соответствуют эти выводы если соеденять с LS020
с китайского телефона 2009-10 чтоль года (времен нокии N9) - когда пошли первые смартфоны 2х симочные еще с теликом аналоговым (антенка выдвигалась) - это те, которые подделывали аля бренды всех марок и мастей
этот вроде nexus7 обзывался (клон)
в общем он работал полностью - у него лет 5 назад сдох сенсор, а замена стоила как такойже телефон. с тех пор и валялся на полке пыль собирал...
//кстати на удивление но углы экрана шикарные, прядка 160 градусов без искажений и зизменений цвета практически....
Всем привет . Решил хоть ,что то изобрести или повторить за кем то хоть какую нибудь фитюльку. Обажаю паять и повторять за кем то какие то интересные поделки . Решил подключить дисплей от сотового телефона к ардуино . Была мобилка и умерла . Остался живой LSD c маркировкой TXDT350DH-111.Не могу найти распиновку . Если я не туда пишу , то подскажите куда обратиться с вопросом . ТУТ ПРОСТО Я ВПЕРВЫЕ .
чтото нифига толком не выходит, такое впечатление, что библиотека вообще не верно формирует запрос цвета... как я понял ДШ - на 948* цвет отправлять надо за 2 захода - а библиотека только 1 раз шлет - вот и не проходит полный цвет...
ну тут моих знаний уже не хватает это переписать...
На каком у тебя запустился? На 9488 ?
https://drive.google.com/file/d/1oMNJmfqJ3j1AiVxAJY5vqb9etbaHzF2i/view?usp=sharing https://drive.google.com/file/d/1pNr2JbChzjxZlRiuMWlYWBeUp0lfMb0D/view?usp=sharing https://drive.google.com/file/d/10JXPxplUQTyOQm-eyAiU5JWyBQAxxCB0/view?usp=sharing
Добрый день! вот фото ....Лучше не получается ...Извините.
только на 0x9341
как я понял - в библиотеке работает этот блок
writeRegister8(0x36, 0x00) попробуй так изменить
kalugin77 не нашел нормального reset.
Разводка такая
0,1,2,3 как обычно, либо RD,WR,DC,CS , либо наоборот. Подсветка у тебя больше 3В.
С ней разберешься после. Сначала подключай без нее и считывай.
RESET сначала подключи к 7, попробуй считать и выкладывай.
Если считает фигню, подключи ресет к 8.
Хочу проверить дисплей LS020 рабочий или нет подключив к ардуино уно или мега . Нашёл в интернете скетч читалку V5.2
Там идёт по SPI а в скетче
LSD_CS
LSD_CD
LSD_WR
LSD_RD
LSD_RESET
какие ножки прописать куда Если брать уно или мега .
в SPI каким выводам соответствуют например LSD_WR или LSD_RD и так далее
сМОТРИ БИБЛИОТЕКИ ДЛЯ АРДУИНО. тАМ ОН ДОЛЖЕН БЫТЬ. тАМ ЖЕ И ПОДКЛЮЧЕНИЕ.
Я потому и спрашиваю что в библиотеке
#define LCD_CS A3 // Chip Select goes to Analog 3
#define LCD_CD A2 // Command/Data goes to Analog 2
#define LCD_WR A1 // LCD Write goes to Analog 1
#define LCD_RD A0 // LCD Read goes to Analog 0
#define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin
А на дисплее LS020 нет выводов
LCD_CD
LCD_WR
LCD_RD
поэтому и спрашиваю чему соответствуют эти выводы если соеденять с LS020
Ищи в библиотеке подключение по SPI, а ты смотришь про параллельное.
Если б я это всё знал мне бы и обрашаться не нужно было ) Там про подключение только
#define LCD_CS A3 // Chip Select goes to Analog 3
#define LCD_CD A2 // Command/Data goes to Analog 2
#define LCD_WR A1 // LCD Write goes to Analog 1
#define LCD_RD A0 // LCD Read goes to Analog 0
#define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin
// use these 8 data lines to the LCD: // For the Arduino Uno, MEGA //
D0 connects to digital pin 8
D1 connects to digital pin 9
D2 connects to digital pin 2
D3 connects to digital pin 3
Теперь так что ли
#define LCD_CS 8
#define LCD_CD 9
#define LCD_WR 2
#define LCD_RD 3
#define LCD_RESET A4
?
Я запутался )
Как это всё соеденить с ардуино и дисплеем
Спасибо!
writeRegister8(0x36, 0x00) попробуй так изменить
тоже не дало никакого результата
вообще удалил из библиотеки этот блок - оно работает по прежнему....
завтра буду думать что я не так делаю....
нужно с библиотекой разбираться.
ELITE а откуда ты снял этот дисплей?
А можете подсказать как прописывать два диспа в скетче? Пока показывают одно и тоже...
нужно с библиотекой разбираться.
writeRegister8(0x36, 0x0A) попробуй
А можно на пальцах что и куда в скетче. Сильно не пинайте только осваиваю)
001
/***************************************************
002
This is a library for the Adafruit 1.8" SPI display.
003
004
This library works with the Adafruit 1.8" TFT Breakout w/SD card
005
----> <a href="http://www.adafruit.com/products/358" title="http://www.adafruit.com/products/358" rel="nofollow">http://www.adafruit.com/products/358</a>
006
The 1.8" TFT shield
007
----> <a href="https://www.adafruit.com/product/802" title="https://www.adafruit.com/product/802" rel="nofollow">https://www.adafruit.com/product/802</a>
008
The 1.44" TFT breakout
009
----> <a href="https://www.adafruit.com/product/2088" title="https://www.adafruit.com/product/2088" rel="nofollow">https://www.adafruit.com/product/2088</a>
010
as well as Adafruit raw 1.8" TFT display
011
----> <a href="http://www.adafruit.com/products/618" title="http://www.adafruit.com/products/618" rel="nofollow">http://www.adafruit.com/products/618</a>
012
013
Check out the links above for our tutorials and wiring diagrams
014
These displays use SPI to communicate, 4 or 5 pins are required to
015
interface (RST is optional)
016
Adafruit invests time and resources providing this open source code,
017
please support Adafruit and open-source hardware by purchasing
018
products from Adafruit!
019
020
Written by Limor Fried/Ladyada for Adafruit Industries.
021
MIT license, all text above must be included in any redistribution
022
****************************************************/
023
024
#include <Adafruit_GFX.h> // Core graphics library
025
#include <Adafruit_ST7735.h> // Hardware-specific library
026
#include <SPI.h>
027
028
029
// For the breakout, you can use any 2 or 3 pins
030
// These pins will also work for the 1.8" TFT shield
031
#define TFT1_CS 53
032
#define TFT2_CS 50
033
#define TFT1_RST 8 // you can also connect this to the Arduino reset
034
// in which case, set this #define pin to -1!
035
#define TFT2_RST 8 // you can also connect this to the Arduino reset
036
// in which case, set this #define pin to -1!
037
#define TFT1_DC 9
038
#define TFT2_DC 9
039
// Option 1 (recommended): must use the hardware SPI pins
040
// (for UNO thats sclk = 13 and sid = 11) and pin 10 must be
041
// an output. This is much faster - also required if you want
042
// to use the microSD card (see the image drawing example)
043
//Adafruit_ST7735 tft1 = Adafruit_ST7735(TFT1_CS, TFT1_DC, TFT1_RST);
044
//Adafruit_ST7735 tft2 = Adafruit_ST7735(TFT2_CS, TFT2_DC, TFT2_RST);
045
046
// Option 2: use any pins but a little slower!
047
#define TFT1_SCLK 52 // set these to be whatever pins you like!
048
#define TFT2_SCLK 52 // set these to be whatever pins you like!
049
050
#define TFT1_MOSI 51 // set these to be whatever pins you like!
051
#define TFT2_MOSI 51 // set these to be whatever pins you like!
052
Adafruit_ST7735 tft1 = Adafruit_ST7735(TFT1_CS, TFT1_DC, TFT1_MOSI, TFT1_SCLK, TFT1_RST);
053
Adafruit_ST7735 tft2 = Adafruit_ST7735(TFT2_CS, TFT2_DC, TFT2_MOSI, TFT2_SCLK, TFT2_RST);
054
055
float
p = 3.1415926;
056
057
void
setup
(
void
) {
058
Serial
.begin(9600);
059
Serial
.print(
"Hello! ST7735 TFT Test"
);
060
//writeRegister8(0x36, 0x0A) //попробуй
061
// Use this initializer if you're using a 1.8" TFT
062
tft1.initR(INITR_BLACKTAB);
// initialize a ST7735S chip, black tab
063
tft2.initR(INITR_BLACKTAB);
// initialize a ST7735S chip, black tab
064
065
Serial
.println(
"Initialized"
);
066
067
uint16_t time = millis();
068
tft1.fillScreen(ST7735_BLACK);
069
tft2.fillScreen(ST7735_GREEN);
070
time = millis() - time;
071
072
Serial
.println(time, DEC);
073
delay(500);
074
075
// large block of text
076
tft1.fillScreen(ST7735_RED);
077
testdrawtext(
"HELLO PEOPLE "
, ST7735_GREEN);
078
delay(11000);
079
// large block of text
080
tft2.fillScreen(ST7735_BLUE);
081
testdrawtext(
"HELLO World "
, ST7735_RED);
082
delay(11000);
083
084
// a single pixel
085
tft1.drawPixel(tft1.width()/2, tft1.height()/2, ST7735_GREEN);
086
delay(500);
087
// a single pixel
088
tft2.drawPixel(tft2.width()/2, tft2.height()/2, ST7735_GREEN);
089
delay(500);
090
091
tft1.fillScreen(ST7735_BLACK);
092
delay(500);
093
tft2.fillScreen(ST7735_WHITE);
094
delay(500);
095
096
Serial
.println(
"done"
);
097
delay(1000);
098
}
099
100
void
loop
() {
101
tft1.fillScreen(ST7735_RED);
102
testdrawtext(
"HELLO WORLD "
, ST7735_GREEN);
103
104
tft2.fillScreen(ST7735_RED);
105
testdrawtext(
"HELLO PEOPLE "
, ST7735_GREEN);
106
}
107
108
void
testdrawtext(
char
*text, uint16_t color) {
109
tft1.setCursor(0, 0);
110
tft1.setTextColor(color);
111
tft1.setTextWrap(
true
);
112
tft1.print(text);
113
114
tft2.setCursor(0, 0);
115
tft2.setTextColor(color);
116
tft2.setTextWrap(
true
);
117
tft2.print(text);
118
}
ELITE а откуда ты снял этот дисплей?
с китайского телефона 2009-10 чтоль года (времен нокии N9) - когда пошли первые смартфоны 2х симочные еще с теликом аналоговым (антенка выдвигалась) - это те, которые подделывали аля бренды всех марок и мастей
этот вроде nexus7 обзывался (клон)
в общем он работал полностью - у него лет 5 назад сдох сенсор, а замена стоила как такойже телефон. с тех пор и валялся на полке пыль собирал...
//кстати на удивление но углы экрана шикарные, прядка 160 градусов без искажений и зизменений цвета практически....
writeRegister8(0x36, 0x0A) попробуй
спасибо, утром буду пробовать - все железки на работе валяются, домой не таскаю, на работе времени больше свободного, чем дома
2354resd
Сигналы на CS у тебя разведены на 2 разные ноги.
Инициализируешь дисплеи. Можно одновременно. Поднимаешь оба CS вверх.
Затем опускаешь CS 1 дисплея и пишешь в него. Поднимаешь CS.
Опускаешь CS 2 дисплея и пишешь в него. Поднимаешь CS.
ELITE Нужно искать по инициализациям или даташитам похожие команды у контроллеров.
Основные команды могут совпадать, а регистры, отвечающие за цветность и инверсию
могут быть отличными от 0х36. Начни с записи в 0х36 сначала 00, затем FF. Если ничего не поменяется, то
нужно искать, как писал выше.
2354resd
Сигналы на CS у тебя разведены на 2 разные ноги.
Инициализируешь дисплеи. Можно одновременно. Поднимаешь оба CS вверх.
Затем опускаешь CS 1 дисплея и пишешь в него. Поднимаешь CS.
Опускаешь CS 2 дисплея и пишешь в него. Поднимаешь CS.
Если не сложно поправьте пожалуйста в скетче как примерно должно быть..
Не могу разобраться. При одной инициализации оба показывают одно и тоже, прописываю оба один который tft1 молчит второй работает.
Я не пишу для ардуино. Наверное так.
void
loop
() {
digitalWrite(TFT1_CS, HIGH);
digitalWrite(TFT2_CS, HIGH);
digitalWrite(TFT1_CS, LOW); // пишем в 1 дисплей
tft1.fillScreen(ST7735_RED);
testdrawtext(
"HELLO WORLD "
, ST7735_GREEN);
digitalWrite(TFT1_CS, HIGH);
digitalWrite(TFT2_CS, LOW); // пишем во 2 дисплей
tft1.fillScreen(ST7735_BLUE);
testdrawtext(
"HELLO PEOPLE "
, ST7735_GREEN);
digitalWrite(TFT2_CS, HIGH);
}
Не помогло. Один работает, второй при запуске пишет Hello черно белым и перевернутым и все белый фон
Тогда начни с изучения библиотеки, которой пользуешься. Когда поймешь, как она работает,
напишешь что хочешь.
Тогда начни с изучения библиотеки, которой пользуешься. Когда поймешь, как она работает,
напишешь что хочешь.
Текст пишет на одном дисплее сразу оба варианта один поверх другого... Библиотека пока совсем потемки для меня
Я не знаю, как написана библиотека. Поэтому не смогу помочь. Жди, может появится кто разбирается,
посоветует что-нибудь.
для кеонтроля сделал вывод в порт
но результатов нет, на команды не реагирует никак
01
{
02
Serial
.println(
"***********use minimal init 2************"
);
03
// от ili9488
04
writeRegister8(0x11, 0);
//Exit Sleep
05
delay(150);
06
// writeRegister8(0x00, 0x00);// очень важен, иначе перевернуто и цветопередача не та
07
writeRegister8(0x3A, 0x05);
// очень важен, иначе черно-белые кракозябры
08
writeRegister8(0x29, 0);
//display on
09
writeRegister8(0x2c, 0);
//write end
10
}
пробовал и 0х0А и вообще разные варианты и даже просто закоментировал - экран не реагирует никак на эти манипуляции :(
хотя в порт выводит сообщение, что подтверждает, что и менно эта часть кода включается
Посмотри инициализации на контроллеры ILI. 93хх , 94хх. Разрешение у тебя скорее всего 240х320.
Больше для 3,2 дюймов врятли. Если в инициализации есть регистры 0х11 0х29, то смотри по даташитам
какие регистры отвечают за поворот и цветность (RGB - BGR) дисплея. И в них пытайся поменять в
соответствии с даташитом. У табя сейчас инициализируется режим BGR, поэтому цвета не те.
320*480 это точно, тк рисует толинейно в этом размере точно по пикселам и во весь экран
writeRegister8(0x36, 0x10)
дало правильную ориентацию :)
теперь цветность осталось победить
Всем привет . Решил хоть ,что то изобрести или повторить за кем то хоть какую нибудь фитюльку. Обажаю паять и повторять за кем то какие то интересные поделки . Решил подключить дисплей от сотового телефона к ардуино . Была мобилка и умерла . Остался живой LSD c маркировкой TXDT350DH-111.Не могу найти распиновку . Если я не туда пишу , то подскажите куда обратиться с вопросом . ТУТ ПРОСТО Я ВПЕРВЫЕ .
Вот ссылки с фото на дисплей :
https://pp.userapi.com/c841534/v841534794/6cc03/EhsILuCvHBE.jpg
сделал тест с авто подставой значений
и чтото мне кажется, что у меня картинка в негативе именно идет, тк вебый выводит черным и наоборот
Если 320х480, то посмотри даташиты на ILI 9481(86,88). В них с картинками описывается
какой бит в этом регистре за что отвечает. Возможно инверсия изображения лежит в другом регистре.
В даташите в принципе и без знания языка все понятно.
TonitoCampos
Пока его можно включить только на 9 или 18 бит. Попробуй считать ID контроллера
подключив D0-D7. 0123 это RD,WR,DC,CS или наоборот
Спасибо.. Опробуем ) Еще раз спасибо ...
если 9488 то выбор или 3 бит или 16 и 24 бит цветность
лежат в 3А блоке - но тут пробовал - или искажено или черно-белое или без картинки вобще
но по идее он умеет по SPI 3 и 4 работать (что немного обнадеживает)
чтото нифига толком не выходит, такое впечатление, что библиотека вообще не верно формирует запрос цвета... как я понял ДШ - на 948* цвет отправлять надо за 2 захода - а библиотека только 1 раз шлет - вот и не проходит полный цвет...
ну тут моих знаний уже не хватает это переписать...
у 9488 в 36 регистре есть бит переворачивающий цветность RGB --BGR
да, это я пробовал - цвета меняются, но он меняет всего 2 варианта - но конечный итог не идет
вместо желтого у меня или красный или синий
итого не хватает части зеленого
по ДШ выходит что зеленый 2 раза отправляется
RG + GB пара
при перевороте выходит BG + GR
но видимо отправка библиотекой идет только первой части
Ты запускаешь библиотеку в 8 битном или 16 битном режиме? Если в 16 битном, то она посылает два байта цвета
одновременно на D0-D15. Тогда ты теряешь часть зеленого плюс синий или красный цвет.
Какой скетч ты запускаешь?
001
#include <Adafruit_GFX.h> // Core graphics library
002
#include <Adafruit_TFTLCD.h> // Hardware-specific library
003
004
#define LCD_CS A3 // Chip Select goes to Analog 3
005
#define LCD_CD A2 // Command/Data goes to Analog 2
006
#define LCD_WR A1 // LCD Write goes to Analog 1
007
#define LCD_RD A0 // LCD Read goes to Analog 0
008
#define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin
009
010
// use these 8 data lines to the LCD:
011
// For the Arduino Uno, MEGA
012
// D0 connects to digital pin 8 (Notice these are
013
// D1 connects to digital pin 9 NOT in order!)
014
// D2 connects to digital pin 2
015
// D3 connects to digital pin 3
016
// D4 connects to digital pin 4
017
// D5 connects to digital pin 5
018
// D6 connects to digital pin 6
019
// D7 connects to digital pin 7
020
021
// Assign human-readable names to some common 16-bit color values:
022
#define BLACK 0x0000
023
#define BLUE 0x001F
024
#define RED 0xF800
025
#define GREEN 0x07E0
026
#define CYAN 0x07FF
027
#define MAGENTA 0xF81F
028
#define YELLOW 0xFFE0
029
#define WHITE 0xFFFF
030
031
032
Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
033
034
035
void
setup
(
void
) {
036
Serial
.begin(9600);
037
tft.reset();
038
039
uint16_t identifier ;
// 0x9341;
040
uint8_t minimal;
041
identifier = 0x9341;
042
minimal=2;
// флаг использовать минимальный инит и рисование через регистры как в ili9341
043
// минимальный инит для часто встречающихся контроллеров , подобных ili9341 ili9327 ili9486 ili9488 HX835x R61581 ,...
044
// у которых setXY через 2Ah 2Bh + 2Ch
045
// (0x11, 0); ВЫХОД ИЗ СНА
046
// delay(150);
047
// (0x36, 0x48); очень важен, иначе перевернуто и цветопередача не та
048
// (0x3A, 0x05); очень важен, иначе черно-белые кракозябры
049
// (0x29, 0); ВКЛЮЧЕНИЕ ДИСПЛЕЯ
050
// (0x2c, 0); конец записи , необязательно но желательно
051
052
tft.begin(identifier, minimal);
053
054
//tft.setRotation(1);
055
056
}
057
int
iii=0x10;
058
void
loop
(
void
) {
059
// for(uint8_t rotation=0; rotation<4; rotation++) { tft.setRotation(rotation); }
060
//tft.reset();
061
//tft.begin(0x9341, iii-0x10);
062
iii++;
Serial
.print(
"* test "
);
Serial
.println(iii-0x10);
063
testText(iii-0x10);
064
delay(100);
065
// testFillScreen();
066
// delay(1000);
067
// testFilledRoundRects();
068
// delay(2000);
069
// testFilledTriangles();
070
// delay(2000);
071
}
072
073
unsigned
long
testFillScreen() {
074
unsigned
long
start = micros();
075
tft.fillScreen(BLACK);
076
tft.fillScreen(RED);
077
tft.fillScreen(GREEN);
078
tft.fillScreen(BLUE);
079
tft.fillScreen(BLACK);
080
return
micros() - start;
081
}
082
083
unsigned
long
testText(
int
i) {
084
tft.fillScreen(BLACK);
085
unsigned
long
start = micros();
086
tft.setCursor(0, 0);
087
tft.setTextColor(WHITE); tft.setTextSize(1);
088
tft.println(
"Hello World! v5.3"
);
089
tft.setTextColor(YELLOW); tft.setTextSize(2);
090
tft.println(1234.56);
091
tft.setTextColor(RED); tft.setTextSize(3);
092
tft.println(0xDEADBEEF, HEX);
093
tft.println();
094
/* tft.setTextColor(GREEN); tft.setTextSize(5); tft.println("GREEN");
095
tft.setTextColor(RED); tft.setTextSize(5); tft.println("RED");
096
tft.setTextColor(BLUE); tft.setTextSize(5); tft.println("BLUE");
097
tft.setTextColor(BLACK); tft.setTextSize(5); tft.println("BLACK");
098
tft.setTextColor(WHITE); tft.setTextSize(5); tft.println("WHITE");*/
099
tft.setTextColor(i); tft.setTextSize(5); tft.println(
"color"
);
100
tft.setTextColor(BLACK); tft.setTextSize(5); tft.println(i);tft.println(i, BIN);tft.println(i, HEX);
101
tft.setTextColor(WHITE); tft.setTextSize(5); tft.println(i);tft.println(i, BIN);tft.println(i, HEX);
102
tft.setTextSize(2);
103
tft.println(
"I implore thee,"
);
104
tft.setTextSize(1);
105
tft.println(
"my foonting turlingdromes."
);
106
tft.println(
"And hooptiously drangle me"
);
107
tft.println(
"with crinkly bindlewurdles,"
);
108
tft.println(
"Or I will rend thee"
);
109
tft.println(
"in the gobberwarts"
);
110
tft.println(
"with my blurglecruncheon,"
);
111
tft.println(
"see if I don't!"
);
112
return
micros() - start;
113
}
114
115
unsigned
long
testLines(uint16_t color) {
116
unsigned
long
start, t;
117
int
x1, y1, x2, y2,
118
w = tft.width(),
119
h = tft.height();
120
121
tft.fillScreen(BLACK);
122
123
x1 = y1 = 0;
124
y2 = h - 1;
125
start = micros();
126
for
(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
127
x2 = w - 1;
128
for
(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
129
t = micros() - start;
// fillScreen doesn't count against timing
130
131
tft.fillScreen(BLACK);
132
133
x1 = w - 1;
134
y1 = 0;
135
y2 = h - 1;
136
start = micros();
137
for
(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
138
x2 = 0;
139
for
(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
140
t += micros() - start;
141
142
tft.fillScreen(BLACK);
143
144
x1 = 0;
145
y1 = h - 1;
146
y2 = 0;
147
start = micros();
148
for
(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
149
x2 = w - 1;
150
for
(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
151
t += micros() - start;
152
153
tft.fillScreen(BLACK);
154
155
x1 = w - 1;
156
y1 = h - 1;
157
y2 = 0;
158
start = micros();
159
for
(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
160
x2 = 0;
161
for
(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
162
163
return
micros() - start;
164
}
165
166
unsigned
long
testFastLines(uint16_t color1, uint16_t color2) {
167
unsigned
long
start;
168
int
x, y, w = tft.width(), h = tft.height();
169
170
tft.fillScreen(BLACK);
171
start = micros();
172
for
(y=0; y<h; y+=5) tft.drawFastHLine(0, y, w, color1);
173
for
(x=0; x<w; x+=5) tft.drawFastVLine(x, 0, h, color2);
174
175
return
micros() - start;
176
}
177
178
unsigned
long
testRects(uint16_t color) {
179
unsigned
long
start;
180
int
n, i, i2,
181
cx = tft.width() / 2,
182
cy = tft.height() / 2;
183
184
tft.fillScreen(BLACK);
185
n = min(tft.width(), tft.height());
186
start = micros();
187
for
(i=2; i<n; i+=6) {
188
i2 = i / 2;
189
tft.drawRect(cx-i2, cy-i2, i, i, color);
190
}
191
192
return
micros() - start;
193
}
194
195
unsigned
long
testFilledRects(uint16_t color1, uint16_t color2) {
196
unsigned
long
start, t = 0;
197
int
n, i, i2,
198
cx = tft.width() / 2 - 1,
199
cy = tft.height() / 2 - 1;
200
201
tft.fillScreen(BLACK);
202
n = min(tft.width(), tft.height());
203
for
(i=n; i>0; i-=6) {
204
i2 = i / 2;
205
start = micros();
206
tft.fillRect(cx-i2, cy-i2, i, i, color1);
207
t += micros() - start;
208
// Outlines are not included in timing results
209
tft.drawRect(cx-i2, cy-i2, i, i, color2);
210
}
211
212
return
t;
213
}
214
215
unsigned
long
testFilledCircles(uint8_t radius, uint16_t color) {
216
unsigned
long
start;
217
int
x, y, w = tft.width(), h = tft.height(), r2 = radius * 2;
218
219
tft.fillScreen(BLACK);
220
start = micros();
221
for
(x=radius; x<w; x+=r2) {
222
for
(y=radius; y<h; y+=r2) {
223
tft.fillCircle(x, y, radius, color);
224
}
225
}
226
227
return
micros() - start;
228
}
229
230
unsigned
long
testCircles(uint8_t radius, uint16_t color) {
231
unsigned
long
start;
232
int
x, y, r2 = radius * 2,
233
w = tft.width() + radius,
234
h = tft.height() + radius;
235
236
// Screen is not cleared for this one -- this is
237
// intentional and does not affect the reported time.
238
start = micros();
239
for
(x=0; x<w; x+=r2) {
240
for
(y=0; y<h; y+=r2) {
241
tft.drawCircle(x, y, radius, color);
242
}
243
}
244
245
return
micros() - start;
246
}
247
248
unsigned
long
testTriangles() {
249
unsigned
long
start;
250
int
n, i, cx = tft.width() / 2 - 1,
251
cy = tft.height() / 2 - 1;
252
253
tft.fillScreen(BLACK);
254
n = min(cx, cy);
255
start = micros();
256
for
(i=0; i<n; i+=5) {
257
tft.drawTriangle(
258
cx , cy - i,
// peak
259
cx - i, cy + i,
// bottom left
260
cx + i, cy + i,
// bottom right
261
tft.color565(0, 0, i));
262
}
263
264
return
micros() - start;
265
}
266
267
unsigned
long
testFilledTriangles() {
268
unsigned
long
start, t = 0;
269
int
i, cx = tft.width() / 2 - 1,
270
cy = tft.height() / 2 - 1;
271
272
tft.fillScreen(BLACK);
273
start = micros();
274
for
(i=min(cx,cy); i>10; i-=5) {
275
start = micros();
276
tft.fillTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
277
tft.color565(0, i, i));
278
t += micros() - start;
279
tft.drawTriangle(cx, cy - i, cx - i, cy + i, cx + i, cy + i,
280
tft.color565(i, i, 0));
281
}
282
283
return
t;
284
}
285
286
unsigned
long
testRoundRects() {
287
unsigned
long
start;
288
int
w, i, i2,
289
cx = tft.width() / 2 - 1,
290
cy = tft.height() / 2 - 1;
291
292
tft.fillScreen(BLACK);
293
w = min(tft.width(), tft.height());
294
start = micros();
295
for
(i=0; i<w; i+=6) {
296
i2 = i / 2;
297
tft.drawRoundRect(cx-i2, cy-i2, i, i, i/8, tft.color565(i, 0, 0));
298
}
299
300
return
micros() - start;
301
}
302
303
unsigned
long
testFilledRoundRects() {
304
unsigned
long
start;
305
int
i, i2,
306
cx = tft.width() / 2 - 1,
307
cy = tft.height() / 2 - 1;
308
309
tft.fillScreen(BLACK);
310
start = micros();
311
for
(i=min(tft.width(), tft.height()); i>20; i-=6) {
312
i2 = i / 2;
313
tft.fillRoundRect(cx-i2, cy-i2, i, i, i/8, tft.color565(0, i, 0));
314
}
315
316
return
micros() - start;
317
}
и библиотеку подправил так
0001
// IMPORTANT: LIBRARY MUST BE SPECIFICALLY CONFIGURED FOR EITHER TFT SHIELD
0002
// OR BREAKOUT BOARD USAGE. SEE RELEVANT COMMENTS IN Adafruit_TFTLCD.h
0003
0004
// Graphics library by ladyada/adafruit with init code from Rossum
0005
// MIT license
0006
0007
#if defined(__SAM3X8E__)
0008
#include <include/pio.h>
0009
#define PROGMEM
0010
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
0011
#define pgm_read_word(addr) (*(const unsigned short *)(addr))
0012
#endif
0013
#ifdef __AVR__
0014
#include <avr/pgmspace.h>
0015
#endif
0016
#include "pins_arduino.h"
0017
#include "wiring_private.h"
0018
#include "Adafruit_TFTLCD.h"
0019
#include "pin_magic.h"
0020
0021
#define TFTWIDTH 320
0022
#define TFTHEIGHT 480
0023
0024
//#define TFTWIDTH 240
0025
//#define TFTHEIGHT 320
0026
0027
// LCD controller chip identifiers
0028
#define ID_932X 0
0029
#define ID_7575 1
0030
#define ID_9341 2
0031
#define ID_HX8357D 3
0032
#define ID_UNKNOWN 0xFF
0033
0034
#include "registers.h"
0035
0036
// Constructor for breakout board (configurable LCD control lines).
0037
// Can still use this w/shield, but parameters are ignored.
0038
Adafruit_TFTLCD::Adafruit_TFTLCD(
0039
uint8_t cs, uint8_t cd, uint8_t wr, uint8_t rd, uint8_t reset) :
0040
Adafruit_GFX(TFTWIDTH, TFTHEIGHT) {
0041
0042
#ifndef USE_ADAFRUIT_SHIELD_PINOUT
0043
// Convert pin numbers to registers and bitmasks
0044
_reset = reset;
0045
#ifdef __AVR__
0046
csPort = portOutputRegister(digitalPinToPort(cs));
0047
cdPort = portOutputRegister(digitalPinToPort(cd));
0048
wrPort = portOutputRegister(digitalPinToPort(wr));
0049
rdPort = portOutputRegister(digitalPinToPort(rd));
0050
#endif
0051
#if defined(__SAM3X8E__)
0052
csPort = digitalPinToPort(cs);
0053
cdPort = digitalPinToPort(cd);
0054
wrPort = digitalPinToPort(wr);
0055
rdPort = digitalPinToPort(rd);
0056
#endif
0057
csPinSet = digitalPinToBitMask(cs);
0058
cdPinSet = digitalPinToBitMask(cd);
0059
wrPinSet = digitalPinToBitMask(wr);
0060
rdPinSet = digitalPinToBitMask(rd);
0061
csPinUnset = ~csPinSet;
0062
cdPinUnset = ~cdPinSet;
0063
wrPinUnset = ~wrPinSet;
0064
rdPinUnset = ~rdPinSet;
0065
#ifdef __AVR__
0066
*csPort |= csPinSet;
// Set all control bits to HIGH (idle)
0067
*cdPort |= cdPinSet;
// Signals are ACTIVE LOW
0068
*wrPort |= wrPinSet;
0069
*rdPort |= rdPinSet;
0070
#endif
0071
#if defined(__SAM3X8E__)
0072
csPort->PIO_SODR |= csPinSet;
// Set all control bits to HIGH (idle)
0073
cdPort->PIO_SODR |= cdPinSet;
// Signals are ACTIVE LOW
0074
wrPort->PIO_SODR |= wrPinSet;
0075
rdPort->PIO_SODR |= rdPinSet;
0076
#endif
0077
pinMode(cs, OUTPUT);
// Enable outputs
0078
pinMode(cd, OUTPUT);
0079
pinMode(wr, OUTPUT);
0080
pinMode(rd, OUTPUT);
0081
if
(reset) {
0082
digitalWrite(reset, HIGH);
0083
pinMode(reset, OUTPUT);
0084
}
0085
#endif
0086
0087
init();
0088
}
0089
0090
// Constructor for shield (fixed LCD control lines)
0091
Adafruit_TFTLCD::Adafruit_TFTLCD(
void
) : Adafruit_GFX(TFTWIDTH, TFTHEIGHT) {
0092
init();
0093
}
0094
0095
// Initialization common to both shield & breakout configs
0096
void
Adafruit_TFTLCD::init(
void
) {
0097
0098
#ifdef USE_ADAFRUIT_SHIELD_PINOUT
0099
CS_IDLE;
// Set all control bits to idle state
0100
WR_IDLE;
0101
RD_IDLE;
0102
CD_DATA;
0103
digitalWrite(5, HIGH);
// Reset line
0104
pinMode(A3, OUTPUT);
// Enable outputs
0105
pinMode(A2, OUTPUT);
0106
pinMode(A1, OUTPUT);
0107
pinMode(A0, OUTPUT);
0108
pinMode( 5, OUTPUT);
0109
#endif
0110
0111
setWriteDir();
// Set up LCD data port(s) for WRITE operations
0112
0113
rotation = 0;
0114
cursor_y = cursor_x = 0;
0115
textsize = 1;
0116
textcolor = 0xFFFF;
0117
_width = TFTWIDTH;
0118
_height = TFTHEIGHT;
0119
}
0120
0121
// Initialization command tables for different LCD controllers
0122
#define TFTLCD_DELAY 0xFF
0123
static
const
uint8_t HX8347G_regValues[] PROGMEM = {
0124
0x2E , 0x89,
0125
0x29 , 0x8F,
0126
0x2B , 0x02,
0127
0xE2 , 0x00,
0128
0xE4 , 0x01,
0129
0xE5 , 0x10,
0130
0xE6 , 0x01,
0131
0xE7 , 0x10,
0132
0xE8 , 0x70,
0133
0xF2 , 0x00,
0134
0xEA , 0x00,
0135
0xEB , 0x20,
0136
0xEC , 0x3C,
0137
0xED , 0xC8,
0138
0xE9 , 0x38,
0139
0xF1 , 0x01,
0140
0141
// skip gamma, do later
0142
0143
0x1B , 0x1A,
0144
0x1A , 0x02,
0145
0x24 , 0x61,
0146
0x25 , 0x5C,
0147
0148
0x18 , 0x36,
0149
0x19 , 0x01,
0150
0x1F , 0x88,
0151
TFTLCD_DELAY , 5 ,
// delay 5 ms
0152
0x1F , 0x80,
0153
TFTLCD_DELAY , 5 ,
0154
0x1F , 0x90,
0155
TFTLCD_DELAY , 5 ,
0156
0x1F , 0xD4,
0157
TFTLCD_DELAY , 5 ,
0158
0x17 , 0x05,
0159
0160
0x36 , 0x09,
0161
0x28 , 0x38,
0162
TFTLCD_DELAY , 40 ,
0163
0x28 , 0x3C,
0164
0165
0x02 , 0x00,
0166
0x03 , 0x00,
0167
0x04 , 0x00,
0168
0x05 , 0xEF,
0169
0x06 , 0x00,
0170
0x07 , 0x00,
0171
0x08 , 0x01,
0172
0x09 , 0x3F
0173
};
0174
0175
static
const
uint8_t HX8357D_regValues[] PROGMEM = {
0176
HX8357_SWRESET, 0,
0177
HX8357D_SETC, 3, 0xFF, 0x83, 0x57,
0178
TFTLCD_DELAY, 250,
0179
HX8357_SETRGB, 4, 0x00, 0x00, 0x06, 0x06,
0180
HX8357D_SETCOM, 1, 0x25,
// -1.52V
0181
HX8357_SETOSC, 1, 0x68,
// Normal mode 70Hz, Idle mode 55 Hz
0182
HX8357_SETPANEL, 1, 0x05,
// BGR, Gate direction swapped
0183
HX8357_SETPWR1, 6, 0x00, 0x15, 0x1C, 0x1C, 0x83, 0xAA,
0184
HX8357D_SETSTBA, 6, 0x50, 0x50, 0x01, 0x3C, 0x1E, 0x08,
0185
// MEME GAMMA HERE
0186
HX8357D_SETCYC, 7, 0x02, 0x40, 0x00, 0x2A, 0x2A, 0x0D, 0x78,
0187
HX8357_COLMOD, 1, 0x55,
0188
HX8357_MADCTL, 1, 0xC0,
0189
HX8357_TEON, 1, 0x00,
0190
HX8357_TEARLINE, 2, 0x00, 0x02,
0191
HX8357_SLPOUT, 0,
0192
TFTLCD_DELAY, 150,
0193
HX8357_DISPON, 0,
0194
TFTLCD_DELAY, 50,
0195
};
0196
0197
static
const
uint16_t ILI932x_regValues[] PROGMEM = {
0198
ILI932X_START_OSC , 0x0001,
// Start oscillator
0199
TFTLCD_DELAY , 50,
// 50 millisecond delay
0200
ILI932X_DRIV_OUT_CTRL , 0x0100,
0201
ILI932X_DRIV_WAV_CTRL , 0x0700,
0202
ILI932X_ENTRY_MOD , 0x1030,
0203
ILI932X_RESIZE_CTRL , 0x0000,
0204
ILI932X_DISP_CTRL2 , 0x0202,
0205
ILI932X_DISP_CTRL3 , 0x0000,
0206
ILI932X_DISP_CTRL4 , 0x0000,
0207
ILI932X_RGB_DISP_IF_CTRL1, 0x0,
0208
ILI932X_FRM_MARKER_POS , 0x0,
0209
ILI932X_RGB_DISP_IF_CTRL2, 0x0,
0210
ILI932X_POW_CTRL1 , 0x0000,
0211
ILI932X_POW_CTRL2 , 0x0007,
0212
ILI932X_POW_CTRL3 , 0x0000,
0213
ILI932X_POW_CTRL4 , 0x0000,
0214
TFTLCD_DELAY , 200,
0215
ILI932X_POW_CTRL1 , 0x1690,
0216
ILI932X_POW_CTRL2 , 0x0227,
0217
TFTLCD_DELAY , 50,
0218
ILI932X_POW_CTRL3 , 0x001A,
0219
TFTLCD_DELAY , 50,
0220
ILI932X_POW_CTRL4 , 0x1800,
0221
ILI932X_POW_CTRL7 , 0x002A,
0222
TFTLCD_DELAY , 50,
0223
ILI932X_GAMMA_CTRL1 , 0x0000,
0224
ILI932X_GAMMA_CTRL2 , 0x0000,
0225
ILI932X_GAMMA_CTRL3 , 0x0000,
0226
ILI932X_GAMMA_CTRL4 , 0x0206,
0227
ILI932X_GAMMA_CTRL5 , 0x0808,
0228
ILI932X_GAMMA_CTRL6 , 0x0007,
0229
ILI932X_GAMMA_CTRL7 , 0x0201,
0230
ILI932X_GAMMA_CTRL8 , 0x0000,
0231
ILI932X_GAMMA_CTRL9 , 0x0000,
0232
ILI932X_GAMMA_CTRL10 , 0x0000,
0233
ILI932X_GRAM_HOR_AD , 0x0000,
0234
ILI932X_GRAM_VER_AD , 0x0000,
0235
ILI932X_HOR_START_AD , 0x0000,
0236
ILI932X_HOR_END_AD , 0x00EF,
0237
ILI932X_VER_START_AD , 0X0000,
0238
ILI932X_VER_END_AD , 0x013F,
0239
ILI932X_GATE_SCAN_CTRL1 , 0xA700,
// Driver Output Control (R60h)
0240
ILI932X_GATE_SCAN_CTRL2 , 0x0003,
// Driver Output Control (R61h)
0241
ILI932X_GATE_SCAN_CTRL3 , 0x0000,
// Driver Output Control (R62h)
0242
ILI932X_PANEL_IF_CTRL1 , 0X0010,
// Panel Interface Control 1 (R90h)
0243
ILI932X_PANEL_IF_CTRL2 , 0X0000,
0244
ILI932X_PANEL_IF_CTRL3 , 0X0003,
0245
ILI932X_PANEL_IF_CTRL4 , 0X1100,
0246
ILI932X_PANEL_IF_CTRL5 , 0X0000,
0247
ILI932X_PANEL_IF_CTRL6 , 0X0000,
0248
ILI932X_DISP_CTRL1 , 0x0133,
// Main screen turn on
0249
};
0250
0251
void
Adafruit_TFTLCD::begin(uint16_t id ,uint8_t mflag ) {
0252
uint8_t i = 0;
0253
0254
reset();
0255
0256
delay(200);
0257
0258
if
((id == 0x9325) || (id == 0x9328)) {
0259
0260
uint16_t a, d;
0261
driver = ID_932X;
0262
CS_ACTIVE;
0263
while
(i <
sizeof
(ILI932x_regValues) /
sizeof
(uint16_t)) {
0264
a = pgm_read_word(&ILI932x_regValues[i++]);
0265
d = pgm_read_word(&ILI932x_regValues[i++]);
0266
if
(a == TFTLCD_DELAY) delay(d);
0267
else
writeRegister16(a, d);
0268
}
0269
setRotation(rotation);
0270
setAddrWindow(0, 0, TFTWIDTH-1, TFTHEIGHT-1);
0271
0272
}
else
if
(id == 0x9341) {
0273
0274
uint16_t a, d;
0275
driver = ID_9341;
0276
CS_ACTIVE;
0277
writeRegister8(ILI9341_SOFTRESET, 0);
0278
delay(50);
0279
if
(mflag==0)
0280
{
0281
//Serial.print("*************="); Serial.println(mflag);
0282
writeRegister8(ILI9341_DISPLAYOFF, 0);
0283
writeRegister8(ILI9341_POWERCONTROL1, 0x23);
0284
writeRegister8(ILI9341_POWERCONTROL2, 0x10);
0285
writeRegister16(ILI9341_VCOMCONTROL1, 0x2B2B);
0286
writeRegister8(ILI9341_VCOMCONTROL2, 0xC0);
0287
writeRegister8(ILI9341_MEMCONTROL, ILI9341_MADCTL_MY | ILI9341_MADCTL_BGR);
0288
writeRegister8(ILI9341_PIXELFORMAT, 0x55);
0289
writeRegister16(ILI9341_FRAMECONTROL, 0x001B);
0290
0291
writeRegister8(ILI9341_ENTRYMODE, 0x07);
0292
/* writeRegister32(ILI9341_DISPLAYFUNC, 0x0A822700);*/
0293
0294
writeRegister8(ILI9341_SLEEPOUT, 0);
0295
delay(150);
0296
writeRegister8(ILI9341_DISPLAYON, 0);
0297
delay(500);
0298
}
0299
else
if
(mflag==1)
0300
{
0301
//Serial.println("***********use minimal init************");
0302
// от ili9488
0303
writeRegister8(0x11, 0);
//Exit Sleep
0304
delay(150);
0305
writeRegister8(0x36, 0x48);
// очень важен, иначе перевернуто и цветопередача не та
0306
writeRegister8(0x3A, 0x05);
// очень важен, иначе черно-белые кракозябры
0307
writeRegister8(0x29, 0);
//display on
0308
writeRegister8(0x2c, 0);
//write end
0309
}
0310
else
0311
{
0312
Serial
.println(
"***********use minimal init 2************"
);
0313
// от ili9488
0314
writeRegister8(0x11, 0);
//Exit Sleep
0315
delay(150);
0316
writeRegister8(0x36, 0x10);
// ориентация
0317
writeRegister8(0x3A, 0x05);
// очень важен, иначе черно-белые кракозябры
0318
// writeRegister8(0x3B, mflag-2);// цвета
0319
writeRegister8(0x29, 0);
//display on
0320
writeRegister8(0x2c, 0);
//write end
0321
}
0322
0323
0324
0325
setAddrWindow(0, 0, TFTWIDTH-1, TFTHEIGHT-1);
0326
return
;
0327
0328
}
else
if
(id == 0x8357) {
0329
// HX8357D
0330
driver = ID_HX8357D;
0331
CS_ACTIVE;
0332
while
(i <
sizeof
(HX8357D_regValues)) {
0333
uint8_t r = pgm_read_byte(&HX8357D_regValues[i++]);
0334
uint8_t len = pgm_read_byte(&HX8357D_regValues[i++]);
0335
if
(r == TFTLCD_DELAY) {
0336
delay(len);
0337
}
else
{
0338
//Serial.print("Register $"); Serial.print(r, HEX);
0339
//Serial.print(" datalen "); Serial.println(len);
0340
0341
CS_ACTIVE;
0342
CD_COMMAND;
0343
write8(r);
0344
CD_DATA;
0345
for
(uint8_t d=0; d<len; d++) {
0346
uint8_t x = pgm_read_byte(&HX8357D_regValues[i++]);
0347
write8(x);
0348
}
0349
CS_IDLE;
0350
0351
}
0352
}
0353
return
;
0354
0355
}
else
if
(id == 0x7575) {
0356
0357
uint8_t a, d;
0358
driver = ID_7575;
0359
CS_ACTIVE;
0360
while
(i <
sizeof
(HX8347G_regValues)) {
0361
a = pgm_read_byte(&HX8347G_regValues[i++]);
0362
d = pgm_read_byte(&HX8347G_regValues[i++]);
0363
if
(a == TFTLCD_DELAY) delay(d);
0364
else
writeRegister8(a, d);
0365
}
0366
setRotation(rotation);
0367
setLR();
// Lower-right corner of address window
0368
0369
}
else
{
0370
driver = ID_UNKNOWN;
0371
return
;
0372
}
0373
}
0374
0375
void
Adafruit_TFTLCD::reset(
void
) {
0376
0377
CS_IDLE;
0378
// CD_DATA;
0379
WR_IDLE;
0380
RD_IDLE;
0381
0382
#ifdef USE_ADAFRUIT_SHIELD_PINOUT
0383
digitalWrite(5, LOW);
0384
delay(2);
0385
digitalWrite(5, HIGH);
0386
#else
0387
if
(_reset) {
0388
digitalWrite(_reset, LOW);
0389
delay(2);
0390
digitalWrite(_reset, HIGH);
0391
}
0392
#endif
0393
0394
// Data transfer sync
0395
CS_ACTIVE;
0396
CD_COMMAND;
0397
write8(0x00);
0398
for
(uint8_t i=0; i<3; i++) WR_STROBE;
// Three extra 0x00s
0399
CS_IDLE;
0400
}
0401
0402
// Sets the LCD address window (and address counter, on 932X).
0403
// Relevant to rect/screen fills and H/V lines. Input coordinates are
0404
// assumed pre-sorted (e.g. x2 >= x1).
0405
void
Adafruit_TFTLCD::setAddrWindow(
int
x1,
int
y1,
int
x2,
int
y2) {
0406
CS_ACTIVE;
0407
if
(driver == ID_932X) {
0408
0409
// Values passed are in current (possibly rotated) coordinate
0410
// system. 932X requires hardware-native coords regardless of
0411
// MADCTL, so rotate inputs as needed. The address counter is
0412
// set to the top-left corner -- although fill operations can be
0413
// done in any direction, the current screen rotation is applied
0414
// because some users find it disconcerting when a fill does not
0415
// occur top-to-bottom.
0416
int
x, y, t;
0417
switch
(rotation) {
0418
default
:
0419
x = x1;
0420
y = y1;
0421
break
;
0422
case
1:
0423
t = y1;
0424
y1 = x1;
0425
x1 = TFTWIDTH - 1 - y2;
0426
y2 = x2;
0427
x2 = TFTWIDTH - 1 - t;
0428
x = x2;
0429
y = y1;
0430
break
;
0431
case
2:
0432
t = x1;
0433
x1 = TFTWIDTH - 1 - x2;
0434
x2 = TFTWIDTH - 1 - t;
0435
t = y1;
0436
y1 = TFTHEIGHT - 1 - y2;
0437
y2 = TFTHEIGHT - 1 - t;
0438
x = x2;
0439
y = y2;
0440
break
;
0441
case
3:
0442
t = x1;
0443
x1 = y1;
0444
y1 = TFTHEIGHT - 1 - x2;
0445
x2 = y2;
0446
y2 = TFTHEIGHT - 1 - t;
0447
x = x1;
0448
y = y2;
0449
break
;
0450
}
0451
writeRegister16(0x0050, x1);
// Set address window
0452
writeRegister16(0x0051, x2);
0453
writeRegister16(0x0052, y1);
0454
writeRegister16(0x0053, y2);
0455
writeRegister16(0x0020, x );
// Set address counter to top left
0456
writeRegister16(0x0021, y );
0457
0458
}
else
if
(driver == ID_7575) {
0459
0460
writeRegisterPair(HX8347G_COLADDRSTART_HI, HX8347G_COLADDRSTART_LO, x1);
0461
writeRegisterPair(HX8347G_ROWADDRSTART_HI, HX8347G_ROWADDRSTART_LO, y1);
0462
writeRegisterPair(HX8347G_COLADDREND_HI , HX8347G_COLADDREND_LO , x2);
0463
writeRegisterPair(HX8347G_ROWADDREND_HI , HX8347G_ROWADDREND_LO , y2);
0464
0465
}
else
if
((driver == ID_9341) || (driver == ID_HX8357D)){
0466
uint32_t t;
0467
0468
t = x1;
0469
t <<= 16;
0470
t |= x2;
0471
writeRegister32(ILI9341_COLADDRSET, t);
// HX8357D uses same registers!
0472
t = y1;
0473
t <<= 16;
0474
t |= y2;
0475
writeRegister32(ILI9341_PAGEADDRSET, t);
// HX8357D uses same registers!
0476
0477
}
0478
CS_IDLE;
0479
}
0480
0481
// Unlike the 932X drivers that set the address window to the full screen
0482
// by default (using the address counter for drawPixel operations), the
0483
// 7575 needs the address window set on all graphics operations. In order
0484
// to save a few register writes on each pixel drawn, the lower-right
0485
// corner of the address window is reset after most fill operations, so
0486
// that drawPixel only needs to change the upper left each time.
0487
void
Adafruit_TFTLCD::setLR(
void
) {
0488
CS_ACTIVE;
0489
writeRegisterPair(HX8347G_COLADDREND_HI, HX8347G_COLADDREND_LO, _width - 1);
0490
writeRegisterPair(HX8347G_ROWADDREND_HI, HX8347G_ROWADDREND_LO, _height - 1);
0491
CS_IDLE;
0492
}
0493
0494
// Fast block fill operation for fillScreen, fillRect, H/V line, etc.
0495
// Requires setAddrWindow() has previously been called to set the fill
0496
// bounds. 'len' is inclusive, MUST be >= 1.
0497
void
Adafruit_TFTLCD::flood(uint16_t color, uint32_t len) {
0498
uint16_t blocks;
0499
uint8_t i, hi = color >> 8,
0500
lo = color;
0501
0502
CS_ACTIVE;
0503
CD_COMMAND;
0504
if
(driver == ID_9341) {
0505
write8(0x2C);
0506
}
else
if
(driver == ID_932X) {
0507
write8(0x00);
// High byte of GRAM register...
0508
write8(0x22);
// Write data to GRAM
0509
}
else
if
(driver == ID_HX8357D) {
0510
write8(HX8357_RAMWR);
0511
}
else
{
0512
write8(0x22);
// Write data to GRAM
0513
}
0514
0515
// Write first pixel normally, decrement counter by 1
0516
CD_DATA;
0517
write8(hi);
0518
write8(lo);
0519
len--;
0520
0521
blocks = (uint16_t)(len / 64);
// 64 pixels/block
0522
if
(hi == lo) {
0523
// High and low bytes are identical. Leave prior data
0524
// on the port(s) and just toggle the write strobe.
0525
while
(blocks--) {
0526
i = 16;
// 64 pixels/block / 4 pixels/pass
0527
do
{
0528
WR_STROBE; WR_STROBE; WR_STROBE; WR_STROBE;
// 2 bytes/pixel
0529
WR_STROBE; WR_STROBE; WR_STROBE; WR_STROBE;
// x 4 pixels
0530
}
while
(--i);
0531
}
0532
// Fill any remaining pixels (1 to 64)
0533
for
(i = (uint8_t)len & 63; i--; ) {
0534
WR_STROBE;
0535
WR_STROBE;
0536
}
0537
}
else
{
0538
while
(blocks--) {
0539
i = 16;
// 64 pixels/block / 4 pixels/pass
0540
do
{
0541
write8(hi); write8(lo); write8(hi); write8(lo);
0542
write8(hi); write8(lo); write8(hi); write8(lo);
0543
}
while
(--i);
0544
}
0545
for
(i = (uint8_t)len & 63; i--; ) {
0546
write8(hi);
0547
write8(lo);
0548
}
0549
}
0550
CS_IDLE;
0551
}
0552
0553
void
Adafruit_TFTLCD::drawFastHLine(int16_t x, int16_t y, int16_t length,
0554
uint16_t color)
0555
{
0556
int16_t x2;
0557
0558
// Initial off-screen clipping
0559
if
((length <= 0 ) ||
0560
(y < 0 ) || ( y >= _height) ||
0561
(x >= _width) || ((x2 = (x+length-1)) < 0 ))
return
;
0562
0563
if
(x < 0) {
// Clip left
0564
length += x;
0565
x = 0;
0566
}
0567
if
(x2 >= _width) {
// Clip right
0568
x2 = _width - 1;
0569
length = x2 - x + 1;
0570
}
0571
0572
setAddrWindow(x, y, x2, y);
0573
flood(color, length);
0574
if
(driver == ID_932X) setAddrWindow(0, 0, _width - 1, _height - 1);
0575
else
setLR();
0576
}
0577
0578
void
Adafruit_TFTLCD::drawFastVLine(int16_t x, int16_t y, int16_t length,
0579
uint16_t color)
0580
{
0581
int16_t y2;
0582
0583
// Initial off-screen clipping
0584
if
((length <= 0 ) ||
0585
(x < 0 ) || ( x >= _width) ||
0586
(y >= _height) || ((y2 = (y+length-1)) < 0 ))
return
;
0587
if
(y < 0) {
// Clip top
0588
length += y;
0589
y = 0;
0590
}
0591
if
(y2 >= _height) {
// Clip bottom
0592
y2 = _height - 1;
0593
length = y2 - y + 1;
0594
}
0595
0596
setAddrWindow(x, y, x, y2);
0597
flood(color, length);
0598
if
(driver == ID_932X) setAddrWindow(0, 0, _width - 1, _height - 1);
0599
else
setLR();
0600
}
0601
0602
void
Adafruit_TFTLCD::fillRect(int16_t x1, int16_t y1, int16_t w, int16_t h,
0603
uint16_t fillcolor) {
0604
int16_t x2, y2;
0605
0606
// Initial off-screen clipping
0607
if
( (w <= 0 ) || (h <= 0 ) ||
0608
(x1 >= _width) || (y1 >= _height) ||
0609
((x2 = x1+w-1) < 0 ) || ((y2 = y1+h-1) < 0 ))
return
;
0610
if
(x1 < 0) {
// Clip left
0611
w += x1;
0612
x1 = 0;
0613
}
0614
if
(y1 < 0) {
// Clip top
0615
h += y1;
0616
y1 = 0;
0617
}
0618
if
(x2 >= _width) {
// Clip right
0619
x2 = _width - 1;
0620
w = x2 - x1 + 1;
0621
}
0622
if
(y2 >= _height) {
// Clip bottom
0623
y2 = _height - 1;
0624
h = y2 - y1 + 1;
0625
}
0626
0627
setAddrWindow(x1, y1, x2, y2);
0628
flood(fillcolor, (uint32_t)w * (uint32_t)h);
0629
if
(driver == ID_932X) setAddrWindow(0, 0, _width - 1, _height - 1);
0630
else
setLR();
0631
}
0632
0633
void
Adafruit_TFTLCD::fillScreen(uint16_t color) {
0634
0635
if
(driver == ID_932X) {
0636
0637
// For the 932X, a full-screen address window is already the default
0638
// state, just need to set the address pointer to the top-left corner.
0639
// Although we could fill in any direction, the code uses the current
0640
// screen rotation because some users find it disconcerting when a
0641
// fill does not occur top-to-bottom.
0642
uint16_t x, y;
0643
switch
(rotation) {
0644
default
: x = 0 ; y = 0 ;
break
;
0645
case
1 : x = TFTWIDTH - 1; y = 0 ;
break
;
0646
case
2 : x = TFTWIDTH - 1; y = TFTHEIGHT - 1;
break
;
0647
case
3 : x = 0 ; y = TFTHEIGHT - 1;
break
;
0648
}
0649
CS_ACTIVE;
0650
writeRegister16(0x0020, x);
0651
writeRegister16(0x0021, y);
0652
0653
}
else
if
((driver == ID_9341) || (driver == ID_7575) || (driver == ID_HX8357D)) {
0654
// For these, there is no settable address pointer, instead the
0655
// address window must be set for each drawing operation. However,
0656
// this display takes rotation into account for the parameters, no
0657
// need to do extra rotation math here.
0658
setAddrWindow(0, 0, _width - 1, _height - 1);
0659
0660
}
0661
flood(color, (
long
)TFTWIDTH * (
long
)TFTHEIGHT);
0662
}
0663
0664
void
Adafruit_TFTLCD::drawPixel(int16_t x, int16_t y, uint16_t color) {
0665
0666
// Clip
0667
if
((x < 0) || (y < 0) || (x >= _width) || (y >= _height))
return
;
0668
0669
CS_ACTIVE;
0670
if
(driver == ID_932X) {
0671
int16_t t;
0672
switch
(rotation) {
0673
case
1:
0674
t = x;
0675
x = TFTWIDTH - 1 - y;
0676
y = t;
0677
break
;
0678
case
2:
0679
x = TFTWIDTH - 1 - x;
0680
y = TFTHEIGHT - 1 - y;
0681
break
;
0682
case
3:
0683
t = x;
0684
x = y;
0685
y = TFTHEIGHT - 1 - t;
0686
break
;
0687
}
0688
writeRegister16(0x0020, x);
0689
writeRegister16(0x0021, y);
0690
writeRegister16(0x0022, color);
0691
0692
}
else
if
(driver == ID_7575) {
0693
0694
uint8_t hi, lo;
0695
switch
(rotation) {
0696
default
: lo = 0 ;
break
;
0697
case
1 : lo = 0x60;
break
;
0698
case
2 : lo = 0xc0;
break
;
0699
case
3 : lo = 0xa0;
break
;
0700
}
0701
writeRegister8( HX8347G_MEMACCESS , lo);
0702
// Only upper-left is set -- bottom-right is full screen default
0703
writeRegisterPair(HX8347G_COLADDRSTART_HI, HX8347G_COLADDRSTART_LO, x);
0704
writeRegisterPair(HX8347G_ROWADDRSTART_HI, HX8347G_ROWADDRSTART_LO, y);
0705
hi = color >> 8; lo = color;
0706
CD_COMMAND; write8(0x22); CD_DATA; write8(hi); write8(lo);
0707
0708
}
else
if
((driver == ID_9341) || (driver == ID_HX8357D)) {
0709
setAddrWindow(x, y, _width-1, _height-1);
0710
CS_ACTIVE;
0711
CD_COMMAND;
0712
write8(0x2C);
0713
CD_DATA;
0714
write8(color >> 8); write8(color);
0715
}
0716
0717
CS_IDLE;
0718
}
0719
0720
// Issues 'raw' an array of 16-bit color values to the LCD; used
0721
// externally by BMP examples. Assumes that setWindowAddr() has
0722
// previously been set to define the bounds. Max 255 pixels at
0723
// a time (BMP examples read in small chunks due to limited RAM).
0724
void
Adafruit_TFTLCD::pushColors(uint16_t *data, uint8_t len, boolean first) {
0725
uint16_t color;
0726
uint8_t hi, lo;
0727
CS_ACTIVE;
0728
if
(first ==
true
) {
// Issue GRAM write command only on first call
0729
CD_COMMAND;
0730
if
(driver == ID_932X) write8(0x00);
0731
if
((driver == ID_9341) || (driver == ID_HX8357D)){
0732
write8(0x2C);
0733
}
else
{
0734
write8(0x22);
0735
}
0736
}
0737
CD_DATA;
0738
while
(len--) {
0739
color = *data++;
0740
hi = color >> 8;
// Don't simplify or merge these
0741
lo = color;
// lines, there's macro shenanigans
0742
write8(hi);
// going on.
0743
write8(lo);
0744
}
0745
CS_IDLE;
0746
}
0747
0748
void
Adafruit_TFTLCD::setRotation(uint8_t x) {
0749
0750
// Call parent rotation func first -- sets up rotation flags, etc.
0751
Adafruit_GFX::setRotation(x);
0752
// Then perform hardware-specific rotation operations...
0753
0754
CS_ACTIVE;
0755
if
(driver == ID_932X) {
0756
0757
uint16_t t;
0758
switch
(rotation) {
0759
default
: t = 0x1030;
break
;
0760
case
1 : t = 0x1028;
break
;
0761
case
2 : t = 0x1000;
break
;
0762
case
3 : t = 0x1018;
break
;
0763
}
0764
writeRegister16(0x0003, t );
// MADCTL
0765
// For 932X, init default full-screen address window:
0766
setAddrWindow(0, 0, _width - 1, _height - 1);
// CS_IDLE happens here
0767
0768
}
0769
if
(driver == ID_7575) {
0770
0771
uint8_t t;
0772
switch
(rotation) {
0773
default
: t = 0 ;
break
;
0774
case
1 : t = 0x60;
break
;
0775
case
2 : t = 0xc0;
break
;
0776
case
3 : t = 0xa0;
break
;
0777
}
0778
writeRegister8(HX8347G_MEMACCESS, t);
0779
// 7575 has to set the address window on most drawing operations.
0780
// drawPixel() cheats by setting only the top left...by default,
0781
// the lower right is always reset to the corner.
0782
setLR();
// CS_IDLE happens here
0783
}
0784
0785
if
(driver == ID_9341) {
0786
// MEME, HX8357D uses same registers as 9341 but different values
0787
uint16_t t;
0788
0789
switch
(rotation) {
0790
case
2:
0791
t = ILI9341_MADCTL_MX | ILI9341_MADCTL_BGR;
0792
break
;
0793
case
3:
0794
t = ILI9341_MADCTL_MV | ILI9341_MADCTL_BGR;
0795
break
;
0796
case
0:
0797
t = ILI9341_MADCTL_MY | ILI9341_MADCTL_BGR;
0798
break
;
0799
case
1:
0800
t = ILI9341_MADCTL_MX | ILI9341_MADCTL_MY | ILI9341_MADCTL_MV | ILI9341_MADCTL_BGR;
0801
break
;
0802
}
0803
writeRegister8(ILI9341_MADCTL, t );
// MADCTL
0804
// For 9341, init default full-screen address window:
0805
setAddrWindow(0, 0, _width - 1, _height - 1);
// CS_IDLE happens here
0806
}
0807
0808
if
(driver == ID_HX8357D) {
0809
// MEME, HX8357D uses same registers as 9341 but different values
0810
uint16_t t;
0811
0812
switch
(rotation) {
0813
case
2:
0814
t = HX8357B_MADCTL_RGB;
0815
break
;
0816
case
3:
0817
t = HX8357B_MADCTL_MX | HX8357B_MADCTL_MV | HX8357B_MADCTL_RGB;
0818
break
;
0819
case
0:
0820
t = HX8357B_MADCTL_MX | HX8357B_MADCTL_MY | HX8357B_MADCTL_RGB;
0821
break
;
0822
case
1:
0823
t = HX8357B_MADCTL_MY | HX8357B_MADCTL_MV | HX8357B_MADCTL_RGB;
0824
break
;
0825
}
0826
writeRegister8(ILI9341_MADCTL, t );
// MADCTL
0827
// For 8357, init default full-screen address window:
0828
setAddrWindow(0, 0, _width - 1, _height - 1);
// CS_IDLE happens here
0829
}}
0830
0831
#ifdef read8isFunctionalized
0832
#define read8(x) x=read8fn()
0833
#endif
0834
0835
// Because this function is used infrequently, it configures the ports for
0836
// the read operation, reads the data, then restores the ports to the write
0837
// configuration. Write operations happen a LOT, so it's advantageous to
0838
// leave the ports in that state as a default.
0839
uint16_t Adafruit_TFTLCD::readPixel(int16_t x, int16_t y) {
0840
0841
if
((x < 0) || (y < 0) || (x >= _width) || (y >= _height))
return
0;
0842
0843
CS_ACTIVE;
0844
if
(driver == ID_932X) {
0845
0846
uint8_t hi, lo;
0847
int16_t t;
0848
switch
(rotation) {
0849
case
1:
0850
t = x;
0851
x = TFTWIDTH - 1 - y;
0852
y = t;
0853
break
;
0854
case
2:
0855
x = TFTWIDTH - 1 - x;
0856
y = TFTHEIGHT - 1 - y;
0857
break
;
0858
case
3:
0859
t = x;
0860
x = y;
0861
y = TFTHEIGHT - 1 - t;
0862
break
;
0863
}
0864
writeRegister16(0x0020, x);
0865
writeRegister16(0x0021, y);
0866
// Inexplicable thing: sometimes pixel read has high/low bytes
0867
// reversed. A second read fixes this. Unsure of reason. Have
0868
// tried adjusting timing in read8() etc. to no avail.
0869
for
(uint8_t pass=0; pass<2; pass++) {
0870
CD_COMMAND; write8(0x00); write8(0x22);
// Read data from GRAM
0871
CD_DATA;
0872
setReadDir();
// Set up LCD data port(s) for READ operations
0873
read8(hi);
// First 2 bytes back are a dummy read
0874
read8(hi);
0875
read8(hi);
// Bytes 3, 4 are actual pixel value
0876
read8(lo);
0877
setWriteDir();
// Restore LCD data port(s) to WRITE configuration
0878
}
0879
CS_IDLE;
0880
return
((uint16_t)hi << 8) | lo;
0881
0882
}
else
if
(driver == ID_7575) {
0883
0884
uint8_t r, g, b;
0885
writeRegisterPair(HX8347G_COLADDRSTART_HI, HX8347G_COLADDRSTART_LO, x);
0886
writeRegisterPair(HX8347G_ROWADDRSTART_HI, HX8347G_ROWADDRSTART_LO, y);
0887
CD_COMMAND; write8(0x22);
// Read data from GRAM
0888
setReadDir();
// Set up LCD data port(s) for READ operations
0889
CD_DATA;
0890
read8(r);
// First byte back is a dummy read
0891
read8(r);
0892
read8(g);
0893
read8(b);
0894
setWriteDir();
// Restore LCD data port(s) to WRITE configuration
0895
CS_IDLE;
0896
return
(((uint16_t)r & B11111000) << 8) |
0897
(((uint16_t)g & B11111100) << 3) |
0898
( b >> 3);
0899
}
else
return
0;
0900
}
0901
0902
// Ditto with the read/write port directions, as above.
0903
uint16_t Adafruit_TFTLCD::readID(
void
) {
0904
uint8_t hi, lo ;
0905
0906
Serial
.println(F(
"v5.3 B0h <- 0xFFFFFF <- 0x040404 from Slider"
)) ;
0907
Serial
.println(F(
"www.arduino.ru/forum/apparatnye-voprosy/arduino-i-displei-ot-sotikov-mobilnykh-telefonov "
));
0908
Serial
.println(
" "
);
0909
Serial
.print(
"reg p1 p2 p3 p4 p5 p6 p7 p8 "
);
0910
//Serial.println(" ");
0911
for
(uint8_t i=0; i<255; i++) {
// i<128
0912
readRegPrint8param(i);
0913
}
0914
0915
0916
Serial
.println(
" "
);
0917
Serial
.println(
"o------------------------------------o"
);
0918
Serial
.print(
"| |"
);
0919
readRegPrint8param(0x00);
Serial
.print(
" |"
);
0920
readRegPrint8param(0x04);
Serial
.print(
" |"
);
0921
readRegPrint8param(0xB0);
Serial
.print(
" |"
);
0922
readRegPrint8param(0xBF);
Serial
.print(
" |"
);
0923
readRegPrint8param(0xD3);
Serial
.print(
" |"
);
0924
readRegPrint8param(0xDA);
Serial
.print(
" |"
);
0925
readRegPrint8param(0xDB);
Serial
.print(
" |"
);
0926
readRegPrint8param(0xDC);
Serial
.print(
" |"
);
0927
readRegPrint8param(0xEF);
Serial
.print(
" |"
);
0928
Serial
.println(
" "
);
0929
Serial
.println(
"| |"
);
0930
Serial
.println(
"o------------------------------------o"
);
0931
delay(1000);
Serial
.print(
" ."
);delay(1000);
Serial
.print(
" ."
);
0932
delay(1000);
Serial
.print(
" ."
); delay(1000);
Serial
.print(
" ."
);
0933
delay(1000);
Serial
.print(
" ."
);delay(1000);
Serial
.print(
" ."
);
0934
delay(1000);
Serial
.print(
" ."
); delay(1000);
Serial
.println(
" "
);
0935
0936
//Serial.println(" ");
0937
Serial
.print(
" writing in Manufacturer Command Access Protect (B0h) <- 0xFFFFFF "
);
0938
writeRegister24(0xb0, 0xffffff); delay(300);
0939
//Serial.println(" ");
0940
readRegPrint8param(0xB0);
0941
Serial
.println(
" "
);
0942
Serial
.print(
"Device Code Read (BFh) "
);
0943
readRegPrint8param(0xBF);
0944
Serial
.println(
" "
);
0945
0946
0947
//Serial.println(" look register 0xBF 0xD3 0xDA 0xDB 0xDC 0xEF");
0948
delay(1000);
Serial
.print(
" ."
);delay(1000);
Serial
.print(
" ."
);
0949
delay(1000);
Serial
.print(
" ."
);delay(1000);
Serial
.println(
" "
);
0950
0951
Serial
.println(
" "
);
0952
Serial
.print(
"reg p1 p2 p3 p4 p5 p6 p7 p8 "
);
0953
//Serial.println(" ");
0954
0955
for
(uint8_t i=176; i<255; i++) {
// i<128
0956
readRegPrint8param(i);
0957
}
0958
Serial
.println(
" "
);
0959
0960
// запись в B0h 0x04 и опрос последних
0961
Serial
.print(
" writing in Manufacturer Command Access Protect (B0h) <- 0x040404 "
);
0962
writeRegister24(0xb0, 0x040404);
0963
//Serial.println(" ");
0964
readRegPrint8param(0xB0);
0965
Serial
.println(
" "
);
0966
Serial
.print(
"Device Code Read (BFh) "
);
0967
readRegPrint8param(0xBF);
0968
Serial
.println(
" "
);
0969
0970
0971
//Serial.println(" look register 0xBF 0xD3 0xDA 0xDB 0xDC 0xEF");
0972
delay(1000);
Serial
.print(
" ."
);delay(1000);
Serial
.print(
" ."
);
0973
delay(1000);
Serial
.print(
" ."
);delay(1000);
Serial
.println(
" "
);
0974
0975
Serial
.println(
" "
);
0976
Serial
.print(
"reg p1 p2 p3 p4 p5 p6 p7 p8 "
);
0977
//Serial.println(" ");
0978
0979
for
(uint8_t i=176; i<255; i++) {
// i<128
0980
readRegPrint8param(i);
0981
}
0982
Serial
.println(
" "
);
0983
0984
0985
0986
0987
//************ стандартная процедура определения известных для запуска скетча на известных ему инитах
0988
0989
if
(readReg(0x04) == 0x8000) {
// eh close enough
0990
// setc!
0991
// Serial.println("! readReg(0x04) = 0x8000 ");
0992
/*
0993
for
(uint8_t i=0; i<254; i++) {
0994
Serial
.print(
"$"
);
Serial
.print(i, HEX);
0995
Serial
.print(
" = 0x"
);
Serial
.println(readReg(i), HEX);
0996
}
0997
*/
0998
writeRegister24(HX8357D_SETC, 0xFF8357);
0999
delay(300);
1000
//Serial.print("$D0 = 0x");
1001
//Serial.println(readReg(0xD0), HEX);
1002
if
(readReg(0xD0) == 0x990000) {
1003
return
0x8357;
1004
}
1005
}
1006
1007
uint16_t id = readReg(0xD3);
// испольование 16 бит , это значит что возьмутся последние 2 параметра из 4х (24бита)
1008
// иначе в сандарте бы получили ответ 02 00 93 41
1009
if
(id == 0x9341) {
1010
return
id;
1011
}
1012
1013
// чтоние с 0 адреса для других видов диспов
1014
CS_ACTIVE;
1015
CD_COMMAND;
1016
write8(0x00);
1017
WR_STROBE;
// Repeat prior byte (0x00)
1018
setReadDir();
// Set up LCD data port(s) for READ operations
1019
CD_DATA;
1020
read8(hi);
1021
read8(lo);
1022
setWriteDir();
// Restore LCD data port(s) to WRITE configuration
1023
CS_IDLE;
1024
1025
id = hi; id <<= 8; id |= lo;
1026
return
id;
1027
}
1028
1029
uint32_t Adafruit_TFTLCD::readReg(uint8_t r) {
1030
uint32_t id;
1031
uint8_t x;
1032
1033
// try reading register #4
1034
CS_ACTIVE;
1035
CD_COMMAND;
1036
write8(r);
1037
setReadDir();
// Set up LCD data port(s) for READ operations
1038
CD_DATA;
1039
delayMicroseconds(50);
1040
read8(x);
1041
id = x;
// Do not merge or otherwise simplify
1042
id <<= 8;
// these lines. It's an unfortunate
1043
read8(x);
1044
id |= x;
// shenanigans that are going on.
1045
id <<= 8;
// these lines. It's an unfortunate
1046
read8(x);
1047
id |= x;
// shenanigans that are going on.
1048
id <<= 8;
// these lines. It's an unfortunate
1049
read8(x);
1050
id |= x;
// shenanigans that are going on.
1051
CS_IDLE;
1052
setWriteDir();
// Restore LCD data port(s) to WRITE configuration
1053
1054
//Serial.print("Read $"); Serial.print(r, HEX);
1055
//Serial.print(":\t0x"); Serial.println(id, HEX);
1056
return
id;
1057
}
1058
1059
1060
uint32_t Adafruit_TFTLCD::readRegPrint8param(uint8_t r) {
1061
uint32_t id;
1062
uint32_t id2;
1063
uint8_t x;
1064
uint8_t x1, x2, x3, x4, x5, x6, x7, x8;
1065
1066
// try reading register #4
1067
CS_ACTIVE;
1068
CD_COMMAND;
1069
write8(r);
1070
setReadDir();
// Set up LCD data port(s) for READ operations
1071
CD_DATA;
1072
delayMicroseconds(50);
1073
1074
read8(x); x1=x;
1075
id = x;
// Do not merge or otherwise simplify
1076
id <<= 8;
// these lines. It's an unfortunate
1077
read8(x); x2=x;
1078
id |= x;
// shenanigans that are going on.
1079
id <<= 8;
// these lines. It's an unfortunate
1080
read8(x); x3=x;
1081
id |= x;
// shenanigans that are going on.
1082
id <<= 8;
// these lines. It's an unfortunate
1083
read8(x); x4=x;
1084
id |= x;
// shenanigans that are going on.
1085
1086
read8(x); x5=x;
1087
id2 = x;
// Do not merge or otherwise simplify
1088
id2 <<= 8;
// these lines. It's an unfortunate
1089
read8(x); x6=x;
1090
id2 |= x;
// shenanigans that are going on.
1091
id2 <<= 8;
// these lines. It's an unfortunate
1092
read8(x); x7=x;
1093
id2 |= x;
// shenanigans that are going on.
1094
id2 <<= 8;
// these lines. It's an unfortunate
1095
read8(x); x8=x;
1096
id2 |= x;
// shenanigans that are going on.
1097
CS_IDLE;
1098
setWriteDir();
// Restore LCD data port(s) to WRITE configuration
1099
1100
Serial
.println(
" "
);
1101
if
(r<0x10)
Serial
.print(
"0"
);
1102
Serial
.print(r,HEX);
Serial
.print(
" = "
);
1103
if
(id>0 && id2>0)
1104
{
1105
if
(x1<0x10)
Serial
.print(
"0"
);
Serial
.print(x1,HEX);
Serial
.print(
" "
);
1106
if
(x2<0x10)
Serial
.print(
"0"
);
Serial
.print(x2,HEX);
Serial
.print(
" "
);
1107
if
(x3<0x10)
Serial
.print(
"0"
);
Serial
.print(x3,HEX);
Serial
.print(
" "
);
1108
if
(x4<0x10)
Serial
.print(
"0"
);
Serial
.print(x4,HEX);
Serial
.print(
" "
);
1109
if
(x5<0x10)
Serial
.print(
"0"
);
Serial
.print(x5,HEX);
Serial
.print(
" "
);
1110
if
(x6<0x10)
Serial
.print(
"0"
);
Serial
.print(x6,HEX);
Serial
.print(
" "
);
1111
if
(x7<0x10)
Serial
.print(
"0"
);
Serial
.print(x7,HEX);
Serial
.print(
" "
);
1112
if
(x8<0x10)
Serial
.print(
"0"
);
Serial
.print(x8,HEX);
Serial
.print(
" "
);
1113
if
( r==0x00 || r==0x04 || r==0xBF || r==0xD3 || r==0xDA || r==0xDB || r==0xDC || r==0xEF )
Serial
.print(
"*****"
);
1114
}
1115
else
1116
{
Serial
.print(
"0"
);
1117
if
( r==0x00 || r==0x04 || r==0xBF || r==0xD3 || r==0xDA || r==0xDB || r==0xDC || r==0xEF )
Serial
.print(
" *"
);
1118
}
1119
1120
1121
1122
//Serial.print("Read $"); Serial.print(r, HEX);
1123
//Serial.print(":\t0x"); Serial.println(id, HEX);
1124
return
id;
1125
}
1126
1127
1128
1129
1130
1131
1132
1133
1134
// Pass 8-bit (each) R,G,B, get back 16-bit packed color
1135
uint16_t Adafruit_TFTLCD::color565(uint8_t r, uint8_t g, uint8_t b) {
1136
return
((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
1137
}
1138
1139
// For I/O macros that were left undefined, declare function
1140
// versions that reference the inline macros just once:
1141
1142
#ifndef write8
1143
void
Adafruit_TFTLCD::write8(uint8_t value) {
1144
write8inline(value);
1145
}
1146
#endif
1147
1148
#ifdef read8isFunctionalized
1149
uint8_t Adafruit_TFTLCD::read8fn(
void
) {
1150
uint8_t result;
1151
read8inline(result);
1152
return
result;
1153
}
1154
#endif
1155
1156
#ifndef setWriteDir
1157
void
Adafruit_TFTLCD::setWriteDir(
void
) {
1158
setWriteDirInline();
1159
}
1160
#endif
1161
1162
#ifndef setReadDir
1163
void
Adafruit_TFTLCD::setReadDir(
void
) {
1164
setReadDirInline();
1165
}
1166
#endif
1167
1168
#ifndef writeRegister8
1169
void
Adafruit_TFTLCD::writeRegister8(uint8_t a, uint8_t d) {
1170
writeRegister8inline(a, d);
1171
}
1172
#endif
1173
1174
#ifndef writeRegister16
1175
void
Adafruit_TFTLCD::writeRegister16(uint16_t a, uint16_t d) {
1176
writeRegister16inline(a, d);
1177
}
1178
#endif
1179
1180
#ifndef writeRegisterPair
1181
void
Adafruit_TFTLCD::writeRegisterPair(uint8_t aH, uint8_t aL, uint16_t d) {
1182
writeRegisterPairInline(aH, aL, d);
1183
}
1184
#endif
1185
1186
1187
void
Adafruit_TFTLCD::writeRegister24(uint8_t r, uint32_t d) {
1188
CS_ACTIVE;
1189
CD_COMMAND;
1190
write8(r);
1191
CD_DATA;
1192
delayMicroseconds(10);
1193
write8(d >> 16);
1194
delayMicroseconds(10);
1195
write8(d >> 8);
1196
delayMicroseconds(10);
1197
write8(d);
1198
CS_IDLE;
1199
1200
}
1201
1202
1203
void
Adafruit_TFTLCD::writeRegister32(uint8_t r, uint32_t d) {
1204
CS_ACTIVE;
1205
CD_COMMAND;
1206
write8(r);
1207
CD_DATA;
1208
delayMicroseconds(10);
1209
write8(d >> 24);
1210
delayMicroseconds(10);
1211
write8(d >> 16);
1212
delayMicroseconds(10);
1213
write8(d >> 8);
1214
delayMicroseconds(10);
1215
write8(d);
1216
CS_IDLE;
1217
1218
}
Adafruit_TFTLCD
как на 8бит переключить пока не разобрался
В ветке Слайдер писал как подсунуть нужный инит.
fps Очень навороченный шлейф. Попробую разобраться.
У тебя телефон с которого он снят есть?
Попался вот такой дисп 4" от китайца.
Поискал на просторах...ничего более-менее не нашел. Помогите с распиновкой.
Выложи хорошее фото, чтоб видно было.
Вот тут в архиве крупные
https://yadi.sk/d/n_kDgDQp3SAJ9j
Дисплей 800х480. Сейчас заточен под 24 бит. Шлейф слегка наворочен.
Придется помучаться. Ты уверен, что оно тебе надо. Плюс для ардуин библиотеки
думаю нет. Шрифт 8х8 будет очень маленьким. Для картинок памяти нужно будет немеряно.
Дисплей 800х480. Сейчас заточен под 24 бит. Шлейф слегка наворочен.
Придется помучаться. Ты уверен, что оно тебе надо. Плюс для ардуин библиотеки
думаю нет. Шрифт 8х8 будет очень маленьким. Для картинок памяти нужно будет немеряно.
Там не особо стандартный контроллер? Пока этот дисп первый у меня с нормальным паябельным шлейфом)
С двумя по SPI так толком и не разобрался, пока, один мешает второму инициализироваться...почему хз.