Technologijos tft tn. TFT ekrano technologija. Kas yra TFT technologija

Mes žinome, kaip naudoti TFT LCD ekranus su Arduino, pradedant pagrindinėmis komandomis ir baigiant profesionaliu dizainu.

Šiame straipsnyje sužinosite, kaip naudoti TFT LCD su Arduino plokštėmis. Mes apžvelgsime pagrindines komandas, taip pat sužinosime apie profesionalų dizainą ir technologijas. Už planų galima perskaityti statistikos lauką:

rodyti tekstus, simbolius ir skaičius reikiamu šriftu;
piešti figūras, tokias kaip kolo, trikutnik, kvadratas ir pan.;
rodyti images.bmp ekrane;
pakeisti ekrano parametrus, pvz., spalvų apvyniojimą ir apvertimą;
Rodyti animaciją naudojant Arduino.

Iš Vikipedijos: Retas kristalinis ekranas su aktyvia matrica (TFT LCD, angliškas plonasluoksnis tranzistorius) yra reto kristalo ekrano tipas, kuriame yra įdėta aktyvioji matrica, padengta plonasluoksniais tranzistoriais.

Elektronikos projektuose svarbu sukurti sąsają tarp techninės įrangos ir sistemos. Ši sąsaja gali būti sukurta taip, kad būtų rodomi svarbūs duomenys, meniu ir būtų lengva pasiekti. Garny dizainas yra ne mažiau svarbus.

Ir yra keletas komponentų. LED, 7 segmentų moduliai, grafiniai ekranai ir kelių spalvų TFT ekranai. Tinkamas komponentas jūsų projektams yra duomenų kiekis, pvz., sąveika su kompiuteriu ir procesoriaus talpa.

TFT LCD yra reto kristalinio ekrano (LCD) variantas, kuriame naudojama plono pluošto tranzistoriaus (TFT) technologija, siekiant pagerinti vaizdo aiškumą, pvz., fokusavimą ir kontrastą. TFT LCD yra aktyvios matricos PK ekranas, kurį galima pakeisti pasyviosios matricos PK ekranais arba paprastais PK ekranais su tiesioginėmis kelių segmentų plokštėmis.

Arduino projektai turi žemą procesoriaus dažnį. Tokiu būdu neįmanoma rodyti sudėtingų, labai aiškių ir aukštos kokybės grafikos vaizdų. Todėl paprastoms komandoms ir duomenims rodyti gali būti naudojami keli spalvoti TFT ekranai.

Šiame straipsnyje naudojamos bibliotekos ir pažangios technologijos duomenims, diagramoms, meniu ir kt. rodyti. su profesionaliu dizainu. Tokiu būdu jūsų projektas atrodys neįtikėtinai šaunus.

Kokio dydžio? Koks valdiklis?

Ekranų dydis turi įtakos projekto parametrams. Puikus ekranas neaplenkti savęs. Jei norite, kad simboliai ir vaizdai būtų rodomi aukštos kokybės, turite pasirinkti puikus dydis rodyti su daugiau aukštas atskiras pastatas. Tai pakeičia jūsų pašarų sklandumą, ištraukia daugiau vietos ir taip pat ištraukia daugiau skysčių paleidimui.

Taigi, visų pirma, reikia patikrinti plaštakos atskirumą, sklandumą, detales, paveikslėlių, tekstų ir skaičių spalvą ir dydį. Pristatome populiarius Arduino ekranų dydžius, tokius kaip:

3,5 colio 480 × 320,
2,8 colio 400 × 240,
2,4 colio 320 × 240,
1,8 colio 220 × 176.

Suvibravus teisingą ekraną, atėjo laikas vibruoti teisingą valdiklį. Jei norite rodyti simbolius, tekstus, skaičius ir statinius vaizdus, o rodymo greitis nėra svarbus, „Atmega328 Arduino“ yra tinkamas pasirinkimas.

Jei kodo dydis yra didelis, UNO gali nepakakti. Taip pat galite vikorist. O kaip norite parodyti vaizdus su dideliu atskyrimo ir krypties lygiu? didelis greitis Jūs esate atsakingi už ARM Arduino modulių, tokių kaip Arduino DUE, naudojimą.

Vairuotojai ir bibliotekos

Elektronikos / kompiuterio įrenginiuose ekrano tvarkyklė vadinama laikmena. integrinis grandynas(arba galite įdėti galinį įrenginį, susidedantį iš diskrečios logikos ir kitų komponentų), kuri užtikrina sąsajos funkciją tarp mikroprocesoriaus, mikrovaldiklio, ASIC arba periferinės sąsajos zagalnogo reikšmė ir konkretaus tipo rodymo įtaisas, pvz., LCD, LED, OLED, ePaper, CRT, Nixie ir kt.

Ekrano tvarkyklė paprastai priima komandas ir duomenis iš standartinių universalių nuosekliųjų arba lygiagrečių sąsajų, tokių kaip TTL, CMOS, RS232, SPI, I2C ir kt. Jis generuoja signalus su laidžia įtampa, srove ir demultipleksavimu, kad ekrane būtų rodomas reikiamas tekstas ar vaizdas.

PK ekranų kūrėjai savo gaminiams naudoja skirtingas tvarkykles. Kai kurie iš jų yra populiarūs, tačiau kai kurie nežinomi. Norėdami lengvai paleisti ekraną, turite naudoti LCD Arduino bibliotekas ir pridėti jas prie savo kodo. Priešingu atveju gali būti sunkiau paleisti ekraną. Internete yra daug nemokamų bibliotekų, tačiau svarbus dalykas bibliotekose yra jų supainiojimas su PK ekrano tvarkykle. Jūsų PK ekrano tvarkyklė yra kaltas dėl jūsų bibliotekos. Šiame straipsnyje naudojama Adafruit GFX biblioteka ir MCUFRIEND KBV biblioteka bei programos kodas. Galite privilioti juos tolesniems pasiuntiniams.

Išpakuokite MCUFRIEND KBV ir atidarykite MCUFRIEND_kbv.CPP. Pamatysite MCUFRIEND bibliotekos palaikomų tvarkyklių sąrašą.

Atidarykite aplanką su užpakaliais (anglų kalba – pavyzdys). Čia yra kodo programų, kurias galima paleisti „Arduino“, sąrašas. Prijunkite PK ekraną ir apverskite užpakalius.

Aksesuarų sąrašas

Norint įgyvendinti daugelį projektų, susijusių su TFT LCD, mums reikia komponentų rinkinio, kaip jau aptarėme:

3,5 colio ElectroPeak TFT spalvotas ekranas × 1
2,4 colio TFT ekranas LCD ElectroPeak × 1
Arduino UNO R3 × 1
Arduino Mega 2560×1
Arduino DUE × 1

Programinės įrangos saugumas

Mums taip pat reikia Arduino robotams.

Kodas

Turite pridėti biblioteką, tada įsigyti kodą. Ką pirmiausia paleidžiate? Arduino lenta, nesigirkite. Tiesiog įveskite šiuos dalykus:

Apsilankykite mūsų svetainėje arba svetainėje www.arduino.cc/en/Main/Software ir mėgaukitės saugos programinė įranga jūsų OS. Prieš įdėdami įdiekite saugos programinę įrangą.
Paleidimo aplinka Arduino grandinės, aišku teksto redaktorius Tada nukopijuokite kodą į teksto rengyklę.
Eikite į miniatiūrą ir išplėskite bibliotekas. Spustelėkite „Pridėti ZIP biblioteką“ ir pridėkite bibliotekas.
Pasirinkite plokštę „Tools and Boards“, pasirinkite „Arduino“ plokštę.
Prijunkite „Arduino“ prie kompiuterio ir nustatykite COM prievadą į „Įrankiai ir prievadas“.
Spustelėkite mygtuką „Enter“ (rodyklė).
Dabar viskas sutvarkyta!

Įsigijus užpakalio kodą, atėjo laikas sugalvoti, kaip sukurti vaizdus PK ekrane.

biblioteka

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

Pirmoji eilutė gavo pagrindinį grafikos biblioteka ekranams (parašė Adafruit).

Kitas yra biblioteka, palaikanti MCUFRIEND Arduino ekrano tvarkykles.

#include "TouchScreen.h" // jei norite rodyti jutiklinį ekraną #include "bitmap_mono.h" // jei norite rodyti vaizdo rastras iš bibliotekos #include "bitmap_RGB.h" // jei norite rodyti rastrinius vaizdus iš bibliotekos #include "Fonts/FreeSans9pt7b.h" // jei reikia kitų šriftų #include "Fonts/FreeSans12pt7b.h" // jei jums reikia kitų šriftų #include "Fonts/FreeSerif12pt7b.h" // jei reikia kitų šriftų #include "FreeDefaultFonts.h" // jei reikia kitų šriftų #include "SPI.h" // sdcard šaltinis taškinių vaizdų rodymui # įtraukti "SD .h"

Šios bibliotekos nebūtinos iš karto, bet galite jas pridėti.

Pagrindinės komandos

Klasė ir objektas

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

Ši serija sukurs objektą su TFT klase MCUFRIEND_kbv ir užtikrins SPI ryšius tarp PK ekrano ir Arduino.

RK ekrano paleidimas

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

Funkcija tft.readID nuskaito ID iš ekrano ir įdeda jūsų keičiamą ID. Tada funkcija tft.begin Pašalina identifikatorių ir PK ekranas paruoštas darbui.

Atskira ekrano vieta

tft.width(); // int16_t plotis (tuščia); tft.aukštis(); //int16_t height(void);

Galite atpažinti atskirą ekrano pobūdį už šių dviejų funkcijų. Tiesiog pridėkite juos prie kodo ir įdėkite išvesties duomenis į pakeitimą uint16_t. Tada skaitykite iš nuosekliojo prievado Serial.println();. Pridėkite dar šiek tiek Serial.begin(9600); V setup ().

Nuspalvinkite ekraną

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

Funkcija fillScreen pakeičia ekrano spalvą į t. Yra 16 bitų pakeitimas, norint pakeisti kodo spalvą UTFT.

#define BLACK 0x0000 #define NAVY 0x000F #define DARKGREEN 0x03E0 #define DARKCYAN 0x03EF #define MAROON 0x7800 #define PURPLE 0x780F #define fine DARKGREEN #define DARKGREEN # 0x7x1F0 0 #define CYAN 0x07FF #define RED 0xF800 #define MAGENTA 0xF81F # apibrėžti GELTONA 0xFFE0 # apibrėžti BALTA 0xFFFF # apibrėžti ORANŽINĖ 0xFD20 # apibrėžti GREENYELLOW 0xAFE5 # apibrėžti ROŽINĖ 0xF81F

Šias eilutes galite pridėti prie kodo ir tiesiog pakeisti pavadinimo spalvą funkcijose.

Pikeliv rezervacija

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)

Funkcija piešti pikselį priskiria pikselius x ir y spalvai t.

Funkcija skaitykite pikselius nuskaito pikselių spalvą x ir y žingsniais.

Dažymo linijos

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)

Funkcija drawFastVLine dažai vertikali linija, Kas prasideda nuo x, y, її dovzhin šešėliavimo - h pikselių, o spalvos - t.

Funkcija pieštiFastHLine dažai horizontali linija, Kuris prasideda nuo x ir y atspalvio, daugumos w pikselių, o spalva - t.

Funkcija drawLine brėžia eilutę, kuri prasideda nuo xi, yi iki xj, yj, spalva - 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);}

Šie trys kodo blokai nupiešti linijomis, panašiomis į ankstesnį kodą, kurio plotis yra 5 pikseliai.

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)

Funkcija užpildytiRect Braižo Orthocutaneum užpildus x ir y koordinatėmis, w – plotis, h – aukštis, t – Orthocutaneum spalva.

Funkcija pieštiRect nudažo ortokutaninį medį x ir y koordinatėmis, kurių plotis w, aukštis h ir spalva t.

Funkcija fillRoundRect dažo tiesiosios žarnos užpildus spinduliu r, koordinatės x ir y, plotis w ir aukštis h, spalva t.

Funkcija drawRoundRect nudažo ortokutaną su r radialiai suapvalintais kraštais x ir y, kurių plotis w ir aukštis h ir spalva t.

Tapyba kola

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)

Funkcija piešti apskritimą piešia koordinatėmis x ir y, spinduliu r ir spalva t.

Funkcija užpildytiCircle nudažo visą apskritimą koordinačių x ir y, spindulio r ir spalvos t.

Už (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]); }

Šis kodas yra aukso lankas. Galite pakeisti reikšmę „for“ nuo 0 iki 4000.

Trikutnikų tapyba

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,x1,tle 16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3, // uint16_t t)

Funkcija nubrėžti trikampį piešia trikutniką su trimis kampų koordinatėmis x, y ir z bei t spalvomis.

Funkcija užpildykite trikampį nudažo tris trikūnės atkarpas koordinatėmis x, y, z ir t spalva.

Teksto vaizdavimas

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

Šis kodas nustato žymeklio padėtį į x ir y.

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

Pirmoje eilutėje nustatoma teksto spalva. Pirmoje eilutėje nustatoma teksto ir fono spalva.

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

Šis kodas nustato antraštės teksto dydį s. Pats skaičius s Pakeitimai diapazone nuo 1 iki 5.

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

Šis kodas reiškia simbolį.

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

Pirmoji funkcija rodo eilutę ir perkelia žymeklį į kitą eilutę.

Kita funkcija tiesiog parodo eilutę.

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) y1, uint16_t wid ,ht; tft.set

Ši funkcija pakeičia tekstą į šriftą. Turite pridėti šią funkciją ir šriftų biblioteką.

Už (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); }

Ši funkcija gali sulieti žinomą tekstą. Turite tai pridėti prie savo kodo.

Ekrano apvalkalas

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

Šis kodas pasuka ekraną. 0 = 0°, 1 = 90°, 2 = 180°, 3 = 270°.

Ekrano spalvų invertavimas

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

Šis kodas apverčia ekrano spalvas.

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

Šis kodas perduoda RGB kodą ir gauna UTFT spalvų kodą.

Slinkite ekranu

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

Šis kodas slinks ekranu. Maxroll – maksimalus slinkimo aukštis.

Skidannya

tft.reset();

Šis kodas pašalina ekraną.

Vienspalvių vaizdų vaizdas

static const uint8_t name PROGMEM = ( // Čia pridėkite vaizdo kodą. ) tft.drawBitmap(x, y, name, sx, sy, 0x0000);

Nuo šiol jūs esate atsakingi už vaizdo konvertavimą į šešioliktainį kodą. Zavantazhte programa nezabechennya posilannya mažesnis. Jei nenorite keisti programinės įrangos nustatymų, turite apversti vaizdo spalvą, rodyti vaizdą horizontaliai (veidrodinis) ir pasukti 90 laipsnių kampu metų rodyklės atžvilgiu.

Dabar pridėkite jį prie programinės įrangos ir pakeiskite. Atidarykite eksportuotą failą ir nukopijuokite šešioliktainį kodą iš Arduino IDE. xі y- Roztashuvannya vaizdas. sxі sy- Padidinkite vaizdą. Galite pakeisti vaizdo spalvą į likusią įvestis.

RGB spalvoto vaizdo ekranas

const uint16_t name PROGMEM = ( // Čia pridėkite vaizdo kodą. ) tft.drawRGBBitmap(x, y, vardas, sx, sy);

Jūs esate atsakingi už vaizdo konvertavimą į kodą. Vikorista tse poslannya, kad pakeistumėte vaizdą:

Įveskite vaizdą ir atsisiųskite transformacijos failą, kurį gali naudoti UTFT bibliotekos. Dabar nukopijuokite šešioliktainį kodą į Arduino IDE. x ir y – vaizdo atvaizdavimas. sx ir sy – vaizdo dydis.

Norėdami parodyti šešioliktainį kodą, galite naudoti toliau pateiktą keitiklio programą:

Priekiniai sulankstomi elementai

Šiame šablone tiesiog įtraukėme 8 pakaitinių spalvų eilutę, kad pakeistume jų spalvas eilės tvarka. Norėdami nupiešti kuolą aplink statinį tašką, galite naudoti sin(); ta cos(); funkcijas. Turite nustatyti PI reikšmę. Norėdami pakeisti spalvas, galite pakeisti funkciją spalva565(); Tada pakeiskite RGB kodą.

#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.1563598 5 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); begin(ID);tft.setRotation(1) tft.invertDisplay(true) 155, 0, 50);col = tft.color565(170, 30, 80); spalva565(230, 120, 170); loop() ( for (int i = 8; i > 0; i--) ( tft.fillCircle(240 + 40 * (cos(-i * PI / 4))), 120 + 40 * (sin(-i * PI / 4)), 10, col.); vėlavimas (15) * PI / 4)), 10, col.); delsimas(15); (-(i + 2)*PI / 4)), 10, stulp.); delsimas(15); tft.fillCircle(240 + 40 * (cos(-(i + 3)*PI / 4)), 120 + 40 * (sin(-(i + 3)*PI / 4)), 10, col.); delsimas(15); tft.fillCircle(240 + 40 * (cos(-(i + 4)*PI / 4)), 120 + 40 * (sin(-(i + 4)*PI / 4)), 10, col.); delsimas(15); tft.fillCircle(240 + 40 * (cos(-(i + 5)*PI / 4)), 120 + 40 * (sin(-(i + 5)*PI / 4)), 10, col.); delsimas(15); tft.fillCircle(240 + 40 * (cos(-(i + 6)*PI / 4)), 120 + 40 * (sin(-(i + 6)*PI / 4)), 10, col.); delsimas(15); tft.fillCircle(240 + 40 * (cos(-(i + 7)*PI / 4)), 120 + 40 * (sin(-(i + 7)*PI / 4)), 10, col.); delsimas(15); )

Klasikinis tekstas

Šiam šablonui pasirinkome klasikinį šriftą ir pridėjome teksto išblukinimo funkciją.

#include "Adafruit_GFX.h" // Pagrindinė grafikos biblioteka #include "MCUFRIEND_kbv.h" // Konkrečios aparatinės įrangos biblioteka MCUFRIEND_kbv tft; #include "Fonts/FreeSans9pt7b.h" #include "Fonts/FreeSans12pt7b.h" #include "Fonts/FreeSerif12pt7b.h" #include "FreeDefaultFonts.h" void showmsgXY(y, ms instcharts ) ( 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 spalva; 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) pritaria jų elgesiui“); delsimas(40); = 0;< 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); }

pagerbimas/pristatymas logotipui

Kieno šabloną perdarėme failą a.jpg y failą .c Ir pridėjo prie kodo, parašė eilutę ir kodą sutvarkė. Tada pakeitėme slinkimo kodą, kad ekraną judintume kaire ranka. Apsimesk failą .h Ir pridėkite jį prie „Arduino“ eskizo aplanko.

#include "Adafruit_GFX.h" // Pagrindinė grafikos biblioteka #include "MCUFRIEND_kbv.h" // Konkrečios aparatinės įrangos biblioteka MCUFRIEND_kbv tft; #include "Ard_Logo.h" #define BLACK 0x0000 #define RED 0xF800 #define GREEN 0x07E0 #define WHITE 0xFFFF #define GRAY 0x8410 #include "Fonts/FreeSans9pt7b/FreeFreffe" #Freeffreff onts.h“ negalioja showmsgXY (int x, int y, int sz, const GFXfont *f, const char *msg) ( int16_t x1, y1; uint16_t wid, ht; tft. ; tft.setCursor(x, y); tft.setTextSize(sz); 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);< 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); }

Taškų diagrama

Šiame šablone naudojome piešimo linijas, kuolų užpildymą ir eilučių rodymo funkcijas.

#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;<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; ženklas = 1;) kitaip ženklas = 0; už (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); }

Temperatūra

Kurį šabloną vikorizavome? nuodėmė ();і cos(); funkcijos, skirtos piešti lankus su dideliu skaičiumi ir skaičiumi, kuris rodomas už papildomos teksto draugo funkcijos. Tada konvertavome vaizdus į šešioliktainį kodą ir pridėjome jį prie kodo ir atvaizdavome vaizdus naudodami papildomą rastrinio vaizdo funkciją. Tada mes panaudojome Line Painting funkciją, kad pakeistume vaizdo stilių. Pasirinkite failą.h ir pridėkite jį prie Arduino aplanko.

#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() ( // čia įdėkite savo pagrindinį kodą, kad jis būtų paleistas pakartotinai: tft.fillScreen(0xffff); tft.setRotation(1); tft.drawBitmap(350, 70, Temp, 70, 180, 0x0000); tft.fillCir (385,213,25,tft.color565(255, 0, 0));< 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) (o (a Skritulinė diagrama

Šiame šablone sukūrėme funkciją, kuri priima skaičius kaip įvestį ir rodo juos kaip skritulinę diagramą. Mes tiesiog vikoristovuyu lanko dažymas ir atnaujinti kuolo funkcijas.

#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() ( // įdėkite savo pagrindinį kodą, kad jis būtų paleistas pakartotinai: 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); }

Muzika

#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 Balta; 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(JUODAS);< 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));i = 14 * (cos (PI * (a + 300) / 2000)); PI * (a+300) / 2000)); tft.setTextSize(2); tft.setTextColor(0xffff); 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)); PI * (b + 300) / 2000)); tft.setTextSize(2); tft.setTextColor(0xffff); tft.setCursor(168, 285); tft.print(b/40); tft.print("%"); b--;) jei (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)); i=14* (cos(PI*(c+300)/2000)); ), i2 = 1 * (cos (PI * (c + 300) / 2000)); 285, 30, 30, 0x0000); tft.setTextSize(2); 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)); i = 14* );i2 = 1 * (cos (PI * (d +300) / 2000)); 285, 30, 30, 0x0000); tft.setTextSize(2); tft.setTextColor(0xffff); tft.setCursor(402, 285); tft.print(d/40); tft.print("%"); d--;)))

Spidometras

#include "Adafruit_GFX.h" // Pagrindinė grafikos biblioteka #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" #įtraukti 4 in 0,0 include 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.set (x, y); tft.setTextSize(sz); invertDisplay (true); .setRotation (1);< 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; ) ///////////////////////////////////////////////// ////////////////// o (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--; ) o (1); )

Linksmas žmogelis

Šiame šablone paprasti vaizdai gali būti rodomi net naudojant rastrinio vaizdo funkciją. Tokiu būdu galite patobulinti savo animaciją naudodami šį triuką. Pasirinkite failą.h ir pridėkite jį prie Arduino aplanko.

#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" #defineF #defineF #0xe0 GREEN 0x07E0 #define CYAN 0x07FF #define MAGENTA 0xF81F #define YELLOW 0xFFE0 #define WHITE 0xFFFF #define GRAY 0x8410 #define OX z, const GFXfont *f, const char, 16htd; . (f); tft.setCursor(x, y); tft.setText(msg) setRotation(1); tft.fillScreen(tft. color565(0,20,0)); 258, 128, BALTA); delsimas(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, 3 eilutė, 258, 128, BALTAS);delay (60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line4, 258, 128, BALTAS);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line5, 258, 128, BALTAS);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line6, 258, 128, BALTAS);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, 7 eilutė, 258, 128, BALTAS);delay (60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, 8 eilutė, 258, 128, BALTAS);delay (40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, 9 eilutė, 258, 128, BALTAS);delay (60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, 10 eilutė, 258, 128, BALTAS);delay (40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, 11 eilutė, 258, 128, BALTAS);delsimas (60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, 12 eilutė, 258, 128, BALTAS);delay (40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, 13 eilutė, 258, 128, BALTAS);delay (60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, 14 eilutė, 258, 128, BALTAS);delay (40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, 15 eilutė, 258, 128, BALTAS);delay (60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, 16 eilutė, 258, 128, BALTAS);delsa (40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, 17 eilutė, 258, 128, BALTAS);delay (60); tft.fillRect(20, 180, 258, 128,tft.color565(0,20,0)); tft.drawBitmap(20, 180, 18 eilutė, 258, 128, BALTAS);delay (40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, 19 eilutė, 258, 128, BALTAS);delay (60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, 20 eilutė, 258, 128, BALTAS);delay (40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, 21 eilutė, 258, 128, BALTAS);delay (60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line22, 258, 128, BALTAS);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line23, 258, 128, BALTAS);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line24, 258, 128, BALTAS);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line25, 258, 128, BALTAS);delay(60); tft.fillRect(20, 180, 258, 128,tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line26, 258, 128, BALTAS);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, 27 eilutė, 258, 128, BALTAS);delsa (60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); )

Vaizdas

Kuriame šablone tiesiog parodome vaizdo veiksmus papildomai funkcijai RGB bitų žemėlapisі bitmap. Tiesiog sukurkite jutiklinio ekrano kodą ir pakeiskite šabloną. Pasirinkite failą.h ir pridėkite jį prie Arduino aplanko.

#include "Adafruit_GFX.h" // Pagrindinė grafikos biblioteka #include "MCUFRIEND_kbv.h" // Konkrečios aparatinės įrangos biblioteka MCUFRIEND_kbv tft; #define BLACK 0x0000 #define RED 0xF800 #define GREEN 0x07E0 #define WHITE 0xFFFF #define GRAY 0x8410 #include "images.h" #include "Fonts/FreeSans9pt7b.h/pt onFreent" #7bterifrent ts.h " int a = 3000; int b = 4000; int j, j2; int i, i2; negalioja rodomsgXY(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());tft.setCursor(x, y .readID(tft); " , 0xffff);//power tft.drawBitmap(20, 260, Line5, 45, 45, 0xffff);//twitter tft.drawBitmap(4 , Line7, 45, 0xffff);//lietus tft.setTextSize(6); tft.setTextColor(0xffff); tft.setTextColor(0xffff, „Saturday“); o (1); )

Maišelis

Archyvų apsauga failais .hžemesnė:

Visų GIF failų kūrimo greitis buvo sumažintas ir jie buvo sudaryti daugiau ar daugiau, kad būtų galima greitai suprasti. Skysčio sklandumas priklauso nuo jūsų procesoriaus sklandumo ir kodo tipo, taip pat nuo kode esančių elementų dydžio ir skaičiaus.
Vaizdo kodą galite pridėti prie pagrindinio puslapio, kitaip jis užpildys visą puslapį. Tokiu būdu galite sukurti failą a.h Ir pridėkite eskizą į aplanką.
Šiame straipsnyje mes atidžiai išanalizavome elementų rodymą RK ekrane. Vykdykite būsimas pamokas, kad sužinotumėte, kaip naudoti jutiklinius ekranus ir SD korteles.
Jei kyla problemų dėl įtrauktų bibliotekų, pakeiskite pėdos ženklą "" į<>.

Taigi kol kas tiek. Pasidalykite šiuo TFT LCD, skirtu Arduino, su draugais ir kolegomis.

Dabartiniuose įrenginiuose yra įvairių konfigūracijų ekranai. Pagrindiniai šiuo metu yra ekranai ant pagrindo, tačiau jiems gali būti naudojamos įvairios technologijos, ypač TFT ir IPS, kurios skiriasi nuo daugybės žemų parametrų, nors yra pagrįstos vienu įvesties įėjimu.

Nėra jokių terminų, žyminčių technologijas, kurios patenka į santrumpas. Pavyzdžiui, nors daugelis žmonių šiek tiek skaitė apie IPS ir TFT, tik nedaugelis supranta, koks jų skirtumas. Taip yra dėl informacijos trūkumo elektronikos kataloguose. Svarbu suprasti šias sąvokas ir nuspręsti tarp TFT ir IPS – kas geriau?

Terminija

Norint nustatyti, kas bus trumpesnė ar storesnė odos tekstūroje, būtina išsiaiškinti, kokias funkcijas atlieka IPS oda, susijusi su TFT faktu, o tiksliau, skirtingų tipų, ruošiant kiekvieną vikoristą. atnaujinta - TN-TFT. Toliau apžvelgiamos ataskaitos ir technologijos.

Vidminnosti

TFT (TN) yra vienas iš būdų sukurti plono pluošto tranzistorių ekranų matricą, kurioje elementai yra išdėstyti spirale tarp plokščių poros. Kai tik tiekiama įtampa, ragai bus pasukti vienas prieš vieną po tiesia horizontalios plokštumos linija. Esant maksimaliai įtampai, kristalai sukasi taip, kad pro juos prasiskverbianti šviesa sukelia juodų pikselių atsiradimą, o jei įtampos nėra, atsiranda balti pikseliai.

Jei pažvelgsite į IPS ar TFT, skirtumas tarp pirmojo ir kito slypi tame, kad matrica paruošta remiantis anksčiau aprašytu pagrindu, nes joje esantys kristalai nėra išdėstyti spirale, o lygiagrečiai tam pačiam ekrano paviršiui. . TFT režimu kristalai niekada nesisuka dėl įtampos.

Yak mi tse bachimo?

Jei žiūrite į IPS ar vizualiai, skirtumas tarp jų yra kontrastas, kuris užtikrina tobulą juodos spalvos perteikimą. Pirmajame ekrane vaizdai bus aiškesni. Ir spalvų perdavimo ašis kitoje TN-TFT matricoje negali būti vadinama harmonine. Šio tipo oda turi drėgną atspalvį, skiriasi nuo kitų. Ši spalva sukelia daug painiavos. Tačiau ši matrica turi pranašumą: šiuo metu ji pasižymi didžiausiu sklandumu tarp visų kitų medžiagų. IPS ekranui tai užtrunka daug laiko, per kurį visi lygiagretūs kristalai ištraukiami, kad padarytų naują posūkį. Tačiau žmogaus akis praktiškai nepastebi gėrimo valandų skirtumo.

Svarbios detalės

Kalbame apie tuos, kuriuos naudoti lengviau: IPS arba TFT, o tai reiškia, kad pirmieji sunaudoja daugiau energijos. Tai reiškia, kad kristalams sukti reikėjo energijos. Be to, kadangi siųstuvas susiduria su užduotimi, kad jo įrenginys būtų efektyvus, būtina naudoti TN-TFT matricą.

Nesvarbu, ar pasirinksite TFT ar IPS ekraną, tai reiškia platesnį kito vaizdą ir 178 laipsnių abiejų dydžių kampą, o tai netgi patogu fotoaparato naudotojui. Paaiškėjo, kad kiti negalėjo to užtikrinti. Ir dar vienas šių dviejų technologijų skirtumo privalumas – jomis pagrįstų virusų galimybė. TFT matricos šiuo metu yra pigiausi sprendimai, kurie yra daugumoje biudžetinių modelių, o IPS yra pakeltas į aukštesnį lygį, bet nėra aukščiausios klasės.

IPS Chi TFT ekranas vibruoja?

Pirmos klasės technologija leidžia gauti kuo aiškiausius ir ryškiausius vaizdus, tačiau kristalams sukti reikia daugiau nei valandos. Tai padidina galią ir kitus parametrus valandai, o kartu padidina akumuliatoriaus išsikrovimo sklandumą. TN matricos spalva yra labai žema, o per tą laiką ji yra minimali. Kristalai čia išsidėstę spirale.

Tiesą sakant, galima nesunkiai aptikti nuolatinį dviejų technologijų pagrindu veikiančių ekranų pertrūkį. Dėl to kyla daug šurmulio. TN technologija prarandama rinkoje, įskaitant kainą, ir negali būti apsaugota nuo aiškaus vaizdo.

IPS yra tolesnė TFT ekranų plėtra. Didelis kontrasto lygis ir puikus vizualinis įspūdis yra papildomi šios technologijos pranašumai. Pavyzdžiui, TN pagrindu veikiančiuose monitoriuose pati juoda spalva keičia savo atspalvį. Tačiau didelės IPS pagrindu veikiančių įrenginių energijos sąnaudos atgraso daugelį gamintojų nuo alternatyvių technologijų ar mažinti jų našumą. Dažniausiai tokio tipo matricos naudojamos laidiniuose monitoriuose, kurie maitinami iš baterijos, o tai neleidžia darbalaukiui nepastovėti. Tačiau pokyčiai šioje galutėje nuolat vyksta.

TFT ir IPS matricos: savybės, privalumai ir trūkumai

Šiuolaikiniame pasaulyje nuolat susiduriame su telefonų, planšetinių kompiuterių, kompiuterių monitorių ir televizorių ekranais. Retų kristalų matricų gamybos technologijos nestovi vietoje, dėl ko daugelis turi problemų su maistu, ką geriau rinktis TFT ar IPS?

Norint susidaryti pilną vaizdą apie maitinimo šaltinį, būtina gerai apgalvoti abiejų matricų funkcijas, pamatyti jų ypatybes, privalumus ir trūkumus. Žinodami visas subtilybes, galite lengvai pasirinkti įrenginį, kurio ekranas visiškai atitinka jūsų poreikius. Kaip mūsų straipsnis gali jums padėti?

TFT matricos

Thin Film Transistor (TFT) yra retų kristalų ekranų generavimo sistema, pagrįsta aktyvia plono pluošto tranzistorių matrica. Kai tokiai matricai įjungiama įtampa, kristalai sukasi vienas prieš vieną, todėl susidaro juoda spalva. Prijungus elektrą gaunamas toks pat rezultatas – kristalai išgauna baltą spalvą. Pakeitus tiekiamą įtampą, pasirinkto pikselio paviršiuje galima suformuoti bet kokią spalvą.

Pagrindinis TFT ekranų pranašumas yra nepaprastai maža gamybos kaina, kuri prilygsta dabartiniams analogams. Be to, tokios matricos išskiria išskirtinį ryškumą ir retkarčiais energingumą. Dinamiškoms scenoms stebėti kažkodėl laiko netrūksta. Ekranai, pagaminti naudojant TFT technologiją, dažniausiai naudojami nebrangiuose televizoriuose ir monitoriuose.

Keletas TFT ekranų:

- mažas spalvų perdavimas. Technologija turi 6 bitus kanale;
- Spiralinis kristalų išdėstymas neigiamai veikia vaizdo kontrastą;
- Vaizdo ryškumas pastebimai sumažėja, kai apsižvalgote;
- didelis "sulaužytų" pikselių dažnis;
- mažas energijos suvartojimas.

Labiausiai pastebima, kad trumpos TFT matricos dalys darbo metu rodomos juoda spalva. Galite pereiti iki pilkos spalvos, kitaip ji turi būti kontrastinga.

IPS matricos

IPS matrica yra labai pažangus ekranas, pagrįstas TFT technologija. Pagrindinis skirtumas tarp šių matricų yra tas, kad TFT kristalai retai būna išsidėstę spirale, tuo tarpu IPS kristalai guli toje pačioje plokštumoje, lygiagrečiai vienas kitam. Be to, dėl to, kad nėra elektros, kvapas nesisuka, o tai teigiamai atsispindi juodos spalvos schemoje.

IPS matricos pranašumai:

Apsižvalgysiu, bet vaizdo ryškumas nesumažėja, padidinamas iki 178 laipsnių;
spalvos perkėlimas buvo nudažytas. Per odos kanalą perduodamų duomenų kiekis padidintas iki 8 bitų;
Patobulintas kontrastas;
sumažintas energijos suvartojimas;
maža „sugedusių“ ar išdegusių pikselių atsiradimo tikimybė.

Vaizdai IPS matricoje atrodo ryškesni ir ryškesni, tačiau tai nereiškia, kad ši technologija buvo šiek tiek sumažinta. IPS su priekine skydeliu atveju vaizdo ryškumas gerokai sumažėja. Taip pat pakeitus valdomus elektrodus, patyrus tokį poveikį, nes laikas atgaivinti matricą. Paskutinis, bet ne mažiau svarbus trūkumas yra palyginti didelė įrenginių, kuriuose naudojami IPS ekranai, kaina. Paprastai jie yra 10-20% brangesni nei panašūs su TFT matrica.

Kas yra vibracija: TFT chi IPS?

Akivaizdu, kad TFT ir IPS matricos, nepaisant būdingos vaizdų svarbos, turi labai panašias technologijas. Kvapai sukurti retų kristalų aktyvių matricų ir vikoristinių struktūrų pagrindu. Daugelis dabartinių gamintojų suteikia savo pranašumą IPS matricoms. Puikios naujienos yra tai, kad smarvės gali sukelti didesnę konkurenciją su plazmos matricomis ir gali turėti daug perspektyvų ateityje. Prote TFT matricos taip pat vystosi. Tiek TFT-TN, tiek TFT-HD ekranai gali būti pateikti rinkai. Jie praktiškai neaukoja vaizdų IPS matricoms, tačiau tai leidžia pasiekti geresnę vaizdo kokybę. Tačiau įrenginių su tokiais monitoriais nėra tiek daug.

Jei jums svarbi vaizdo kokybė ir esate pasiruošę šiek tiek mokėti papildomai, tuomet įrenginys su IPS ekranu yra geriausias pasirinkimas.

Charakteristikos ir specifikai apibrėžti turi būti naudojamos santrumpos. Kai pažeidžiami IPS ir TFT ekranai, IPS technologija (matrica) yra kitokio tipo TFT matrica ir plokštės. Neįmanoma palyginti šių dviejų technologijų.

ALE! TN-TFT technologija – galima pasirinkti ir reguliuoti ašį tarp jos ir IPS. Todėl jei kalbame apie tai, kuris ekranas geresnis: IPS ar TFT, bet kokiu atveju atsižvelgiame į TFT ekranus, tačiau gaminamus skirtingų technologijų pagrindu: TN ir IPS.

Trumpai apie TN-TFT ir IPS

TN-TFT yra technologija, pagrįsta reta kristalinio ekrano matrica. Čia kristalai, jei jų komitetams nėra tiekiama įtampa, stovi atskirai 90 laipsnių kampu. Kvapai juda spirale, o pajungus jiems įtampą, kvapai sukasi taip, kad susidarytų reikiama spalva.

IPS – ši technologija išsiskiria tuo, kad kristalai yra išsidėstę lygiagrečiai vienas kitam toje pačioje ekrano srityje (pirmuoju atveju – spirale). Viskas sudėtinga... praktiškai TN ir IPS matricos pagrindu veikiančių ekranų skirtumas slypi tame, kad IPS idealiai rodo juodą spalvą, dėl ko vaizdas atrodo aiškesnis ir gyvesnis.

Nors nėra TN-TFT, šios matricos spalvų perdavimo galimybė nekelia pasitikėjimo. Čia odos pikselis gali dėvėti savo plaukuotą atspalvį, todėl spalvos yra supainiotos. IPS matricos daug gražiau rodo vaizdą, be to, jas lengviau valdyti. IPS taip pat leidžia stebėti tai, kas rodoma ekrane, turint didelę įtaką. Jei žiūrėsite į TN-TFT ekraną po tuo pačiu rėmeliu, spalvos bus ant skydelių, todėl bus sunku peržiūrėti vaizdą.

Privalumai TN

Tačiau TN-TFT matricos turi savo privalumų. Pagrindinė to priežastis – mažesnis pikselių sklandumas. IPS reikia daugiau nei valandos, kad visas lygiagrečių kristalų masyvas būtų pasuktas reikiamu kampu. Todėl renkantis monitorių žaidimams ar dinamiškoms scenoms rodyti, jei svarbus šešėlių aiškumas, geriausia rinktis patį ekraną remiantis TN-TFT technologija.

Kita vertus, atliekant pradinį darbą iš kompiuterio, neįmanoma pastebėti pikselių valandų skirtumo. Tai pamatysite tik po valandos žiūrėdami dinamiškas scenas, kurios dažnai nutinka veiksmo filmuose ir vaizdo žaidimuose.

Kitas pliusas yra mažas energijos suvartojimas. IPS matricos yra energiją taupančios, nes Norint paversti daugybę kristalų, jiems reikia daug įtampos. Taip pat TFT pagrindu veikiantys ekranai labiausiai tinka mobiliosioms programėlėms, kurios reikalauja didelių energijos sąnaudų ir taupo baterijos energiją.

Ir dar – TN-TFT matricos pigesnės. Šiandien nerandate pigesnių monitorių (pigiai naudojamų ar EPT modelių), kurie būtų pigesni nei TN technologija paremtas modelis. Bet kuriam biudžetiniam elektronikos įrenginiui su ekranu reikia TN-TFT matricos.

Na, kuris ekranas gražesnis:TFT arbaIPS:

IPS mažiau prasmės daugiau valandų redaguoti (netinka žaidimų ir veiksmo scenoms);
IPS garantuoja beveik tobulą spalvų atkūrimą ir kontrastą;
IPS yra svarbiausias dalykas, į kurį reikia atkreipti dėmesį;
IPS sunaudoja daugiau energijos nei elektros;
Jie taip pat yra brangesni, o TN-TFT yra pigesni.

Ašis iš esmės yra visas skirtumas tarp šių matricų. Jei atsižvelgsite į visus privalumus ir trūkumus, tada, žinoma, lengva padaryti konkrečią išvadą: IPS ekranai yra daug gražesni.

Būkite malonūs, įvertinkite straipsnį:

Monitoriaus (ekrano) ryškumas labai svarbus tausojant asmeninio kompiuterio naudotojų akis. Ilgus metus intensyviai dirbant prie monitoriaus regėjimui keliami dar didesni reikalavimai. Vaizdo aiškumas labai priklauso nuo fosforo taškų ekrane dydžio. Vidutinis atstumas tarp taškų vadinamas grūdeliu. Kitų monitorių atveju šis parametras svyruoja nuo 0,21 iki 0,31. Svarbūs parametrai yra kadro (vertikalaus) šaudymo dažnis ir mažas (horizontalus) šaudymas bei vaizdo signalo perdavimo kiekis. Kuo didesnis kadrų dažnis, tuo stabilesnis vaizdas ir tuo mažiau laiko reikia peržiūrėti (aiškiems monitoriams kadrų dažnis yra 70-80 Hz). Eilučių dažnis kilohercais nustatomas padauginus viename kadre rodomų eilučių skaičių iš kadrų dažnio. Vaizdo signalo perdavimo dažnių diapazonas (modifikuotas MHz) nustatomas sudėjus taškų skaičių iš eilės ir mažos imties dažnį. Toliau pateikiamos pagrindinės TFT LCD ekranų charakteristikos:

1. Vėdinimo anga.

Diafragmos atnaujinimas (viršutinė skylė) є plokščias vaizdas arba efektyviąją diafragmos sritį, į požeminę matricą RC ekranas. Kuo didesnė kaina, tuo ryškesnis ekranas , padidės spalvų užimamas plotas. Taip pat padidės kontrastas . Priekinė anga yra svarbus PK ekrano indikatorius, naudojamas jo ryškumui įvertinti.

2. Leiskite man apsižvalgyti.

PK monitoriaus vaizdo kontrastas keičiasi priklausomai nuo vietos, kuria rūpinamasi. Kut zoru apibūdina šį pokytį. Pasikeitus kontrastui aukštyn/žemyn ir dešiniarankiams/kairiarankiams gali atsirasti išraiškų. Reto kristalo talpa slypi dideliame pasaulyje, esančiame po krintančios šviesos kraštu. . Taigi kontrasto pokyčius lemia perdavimo koeficientas įėjime ir išėjime.

Būtinai nurodykite ribos reikšmę, pavyzdžiui, 170/170°. Greitai apsižvalgysiuє Išsaugomas kontrasto santykis ne mažesnis kaip 10:1. Šiuo atveju būtinai būtina perkelti spalvas šioje pozicijoje, todėl spalvos bus apverstos (spalvos rodomos matricos centre, o ant spalvų, natūralu, jos matomos po spalva).

3. Trikdžiai.

Trikdžiai atsiranda neigiamas Pikselių sujungimas , jei aktyvacijosįsitempęs pikselių teka į laivo pasyvųjį . Tai būdinga paprastoms plokštėms tipo STN, tačiau plokštėse su aktyviomis matricomis yra nedidelis trukdžių antplūdis.
4. Jaskravistas.

Norint reguliuoti PK ekranų ryškumą, naudojamos šios reikšmės: NIT, Foot Lambert kandela kvadratiniam metrui – cd/m (cd/m).

Ekrano ryškumas pasirodo Aš esu sąžiningas galinis apšvietimasі prieigos kontrolė plokštės.

Reto kristalo pralaidumas žemas kad norėdami padidinti vaizdo ryškumą pergalė angos durys nuo didžiųjų oro durų , poliarizuojančios plokštės ir spalvų filtrai su dideliu pralaidumu arba prizme.

5. Vaizdo mastelio keitimas kelių režimų operacijos metu.

TFT monitoriams rekomenduojami atskiri XGA (1024x768) ir SXGA (1280x1024) formatai, be to, šie monitoriai palaikys viso ekrano išplėtimo režimus SVGA ir VGA. Tačiau naudojant atskirus vaizdus, pvz., SVGA ir mažesnius režimus, vaizdo simboliai gali atrodyti šiurkštūs ir nestabilūs. Priežastis ta, kad pagrindinis pikselių skaičius 14" ir 15" TFT plokštės Bulo vibrano režimui XGA. Todėl įvaizdžio kūrimui SVGA arba VGA režimuose kaltininkas bus pakeistas.

Pagrindinė problema yra įmonės konkurencingumo srityje šioje rinkos situacijoje. Įmonės nemoka specialūs vizitai prieš užtikrindami aiškų vaizdą su bagatoriaus režimo robotu stebėti. Pristatytas ir įgyvendintas išplėstinio vaizdo mastelio keitimo funkcija (vaizdo pagerinimo funkcija), jaka, vikorista metodas netiesinė interpoliacija Norėdami pagerinti vaizdą, galite aiškiai matyti kūrinį atskirame leidime, atskirai nuo pagrindinio.

6. Atėjo laikas dainuoti.

Šis indikatorius rodo mažiausią valandą, per kurią retas kristalų skydelis keičia spalvą. Yra du būdai, kaip reguliuoti matricos sklandumą: juoda juoda (juoda-balta-juoda),і nuo pilkos iki pilkos(tarp pilkos spalvos gradacijų), Be to, šių vertinimo metodų reikšmė labai skiriasi. Keičiant padėtį tarp kraštutinių padėčių (juodos ir baltos), į kristalą tiekiama maksimali įtampa, o kaištis sukasi maksimaliu greičiu (ši charakteristika turėtų būti nurodyta srovės monitorių charakteristikose). : 8, 6, inodai ir 4 ms. Su išstumtais kristalais tarp pilkos spalvos gradacijų pateikta reklamai žymiai mažiau Įtampa, nes juos reikia tiksliai išdėstyti, kad nuimtų reikiamą siūlą, ir tam išleidžiama kur kas daugiau (nuo 14 ms iki 28 ms). Neseniai mums pavyko rasti malonų būdą šiai problemai išspręsti. Į jungiklį tiekiama maksimali įtampa (arba sumažinama iki nulio), o reikiamu momentu kristalo padėtis iš karto nustatoma į reikiamą padėtį. Be visų šio metodo privalumų, labai padidėja tikslaus įtampos valdymo sudėtingumas. kurių dažnis viršija rago dažnį. Be to, pagrindinis impulsas turi būti suderintas su kristalų šonkaulių padėtimi (Samsung jau pristatė modelius su skaitmeninės talpos kompensavimo technologija, kuris iš tikrųjų užtikrins PVA matricos veikimą per 8–6 ms).

7. Vaizdo kontrastas.

Kontrastas nustatomas pagal matricos ryškumą „juodoje“ ir „baltoje“ stadijose (juoda spalva yra mažiau eksponuojama ir kuo ryškesnė balta, tuo didesnis kontrastas). Šis ekranas yra svarbus norint aiškiai matyti vaizdo vaizdą ir geras vaizdas bet koks vaizdas(pavyzdžiui, už S-IPS Vidutinė vertė - 400:1 , ir už PVA – iki 1000:1). Monitoriaus charakteristikose nurodyta: matuojamas matricos, ne monitoriui, o ant specialaus stovo, jei į matricą tiekiama labai standartinė įtampa, apšvietimas tiekiamas griežtai standartine įtampa ir pan.).

8. Spalvų perkėlimas.

Nepamirškite šio teisingumo parodymo. Belshist's matrica, mergelės už technologijų žlugimo, iki 24 bitų perdavimo į Koloro (vicicacituces є Adetori Montory PVA VID Samsung- Niyako sistemos 18 lovų PVA samsung instaliacijoje nebus paryškintos).

Windows 7