Technologie tft tn. Technologie displeje TFT. Co je technologie TFT

Víme, jak používat TFT LCD displeje s Arduinem, počínaje základními příkazy a konče profesionálním designem.

V tomto článku se dozvíte, jak používat TFT LCD s deskami Arduino. Probereme základní příkazy a také se seznámíme s profesionálním designem a technologií. Za plány lze číst pole statistiky:

zobrazovat texty, symboly a čísla v požadovaném písmu;
kreslit postavy jako kolo, trikutnik, čtverec a tak dále;
zobrazení obrázků.bmp na obrazovce;
změnit parametry obrazovky, jako je zalomení a převrácení barev;
Zobrazte animaci pomocí Arduina.

Z Wikipedie: Vzácný krystalový displej s aktivní matricí (TFT LCD, anglicky thin-film tranzistor) je typ displeje ze vzácných krystalů, ve kterém je zapuštěna aktivní matrice, potažená tenkovrstvými tranzistory.

V projektech elektroniky je důležité vytvořit rozhraní mezi hardwarem a systémem. Toto rozhraní lze vytvořit způsoby, jak zobrazovat relevantní data, nabídky a snadný přístup. Neméně důležitý je design Garny.

A komponentů je celá řada. LED, 7segmentové moduly, grafické displeje a vícebarevné TFT displeje. Správná součást pro vaše projekty spočívá v množství dat, jako je interakce s počítačem a kapacita procesoru.

TFT LCD je varianta displeje se vzácnými krystaly (LCD), který využívá technologii tenkých vláken tranzistoru (TFT) ke zlepšení čistoty obrazu, jako je zaostření a kontrast. TFT LCD je aktivní maticový PK displej, který může nahradit pasivní maticové PK displeje nebo jednoduché PK displeje s přímými vícesegmentovými panely.

Projekty Arduino mají nízkou frekvenci procesoru. Tímto způsobem není možné zobrazovat složité obrázky s vysokou čistotou a vysoce kvalitní grafikou. Proto lze pro zobrazení jednoduchých příkazů a dat použít vícebarevné TFT displeje.

Tento článek využívá knihovny a pokročilé technologie pro zobrazování dat, grafů, nabídek atd. s profesionálním designem. Tímto způsobem bude váš projekt vypadat neuvěřitelně cool.

Jaké velikosti? Jaký typ ovladače?

Velikost obrazovek ovlivňuje parametry projektu. Skvělý displej nepředbíhej se. Pokud chcete zobrazovat symboly a obrázky ve vysoké kvalitě, musíte vybrat skvělá velikost zobrazit s více vysoká samostatná budova. To změní tekutost vašeho krmiva, vytěží více prostoru a také odebere více tekutiny pro spouštění.

Nejprve tedy musíte zkontrolovat samostatnost, plynulost ruky, detaily, barvu a velikost obrázků, textů a čísel. Představujeme oblíbené velikosti displejů Arduino, jako jsou:

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

Po zavibrování správného displeje nastal čas zavibrovat správný ovladač. Pokud chcete zobrazovat symboly, texty, čísla a statické obrázky a na rychlosti zobrazení nezáleží, je Atmega328 Arduino tou správnou volbou.

Pokud je velikost kódu velká, UNO nemusí stačit. Můžete také vikorist. A jak chcete zobrazovat obrázky s vysokou úrovní oddělení a směru? vysoká rychlost Jste odpovědní za používání modulů ARM Arduino, jako je Arduino DUE.

Ovladače a knihovny

V elektronických/počítačových instalacích je ovladač displeje označován jako nosič. integrovaný obvod(nebo můžete alternativně umístit koncový stroj, který se skládá z diskrétní logiky a dalších komponent), který poskytuje funkci rozhraní mezi mikroprocesorem, mikrokontrolérem, ASIC nebo periferním rozhraním zagalnogo význam a konkrétní typ zobrazovacího zařízení, například LCD, LED, OLED, ePaper, CRT, Nixie atd.

Ovladač displeje obvykle přijímá příkazy a data ze standardních univerzálních sériových nebo paralelních rozhraní, jako jsou TTL, CMOS, RS232, SPI, I2C atd. Generuje signály s vodivým napětím, proudem a demultiplexováním za účelem zobrazení požadovaného textu nebo obrázku na displeji.

Vývojáři displejů PK používají pro své produkty různé ovladače. Některé z nich jsou populární, ale některé z nich jsou neznámé. Pro snadné spuštění obrazovky musíte použít knihovny LCD Arduino a přidat je do svého kódu. Jinak může být spuštění displeje obtížnější. Na internetu je spousta bezplatných knihoven, ale důležitým bodem v knihovnách je jejich záměna s ovladačem zobrazení PK. Ovladač zobrazení PK je na vině kvůli vaší knihovně. Tento článek používá knihovnu Adafruit GFX a knihovnu a kód aplikace MCUFRIEND KBV. Můžete je nalákat na další vyslance.

Rozbalte MCUFRIEND KBV a otevřete MCUFRIEND_kbv.CPP. Zobrazí se seznam ovladačů podporovaných knihovnou MCUFRIEND.

Otevřete složku s nedopalky (angličtina – příklad). Zde je seznam kódových aplikací, které lze na Arduinu spustit. Připojte displej PK a otočte zadky.

Seznam příslušenství

K realizaci mnoha projektů souvisejících s TFT LCD potřebujeme sadu komponent, jak jsme již diskutovali:

3,5" ElectroPeak TFT barevný displej × 1
2,4" TFT displej LCD ElectroPeak × 1
Arduino UNO R3 × 1
Arduino Mega 2560×1
Arduino DUE × 1

Softwarová bezpečnost

Pro roboty potřebujeme také Arduino.

Kód

Musíte přidat knihovnu a poté získat kód. Co spustíte jako první? Deska Arduino, nechlub se. Stačí zadat následující:

Přejděte na naši webovou stránku nebo na webovou stránku www.arduino.cc/en/Main/Software a užívejte si bezpečnostní software pro váš OS. Před vložením nainstalujte bezpečnostní software.
Spouštěcí prostředí Arduino obvody, Průhledná textový editor Poté zkopírujte kód do textového editoru.
Přejděte na miniaturu a rozbalte knihovny. Klikněte na "Přidat knihovnu ZIP" a přidejte knihovny.
Vyberte desku v "Nástroje a desky", vyberte desku Arduino.
Připojte Arduino k počítači a nastavte COM port na "Nástroje a port".
Klikněte na tlačítko "Enter" (šipka).
Nyní je vše vyřešeno!

Po získání kódu zadku přišel čas přijít na to, jak vytvářet obrázky na displeji PK.

Knihovna

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

První řada dostala hlavní grafická knihovna pro displeje (napsal Adafruit).

Další poskytuje knihovnu, která podporuje ovladače obrazovky MCUFRIEND Arduino.

#include "TouchScreen.h" // pokud chcete zobrazit dotykovou obrazovku #include "bitmap_mono.h" // pokud chcete zobrazit obrazový rastr z knihovny #include "bitmap_RGB.h" // pokud chcete zobrazit rastrové obrázky z knihovny #include "Fonts/FreeSans9pt7b.h" // pokud potřebujete další písma #include "Fonts/FreeSans12pt7b.h" // pokud potřebujete další písma #include "Fonts/FreeSerif12pt7b.h" // pokud potřebujete další písma #include "FreeDefaultFonts.h" // pokud potřebujete další písma #include "SPI.h" // zdroj sdcard pro zobrazení bitmapových obrázků # obsahovat "SD .h"

Tyto knihovny nejsou vyžadovány okamžitě, ale můžete je přidat.

Základní příkazy

Třída a objekt

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

Tato řada vytvoří objekt s TFT třídou MCUFRIEND_kbv a poskytne SPI spojení mezi displejem PK a Arduinem.

Spuštění obrazovky RK

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

Funkce tft.readID přečte ID z displeje a umístí vaše vyměnitelné ID. Pak funkce tft.begin Odebere identifikátor a displej PK je připraven k provozu.

Oddělený prostor na obrazovce

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

Za těmito dvěma funkcemi můžete rozpoznat oddělený charakter displeje. Stačí je přidat do kódu a umístit výstupní data do změny uint16_t. Poté načtěte ze sériového portu Serial.println();. Přidejte další Serial.begin(9600); PROTI založit().

Vybarvěte obrazovku

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

Funkce fillScreen změní barvu obrazovky na t. Je zde 16bitová změna pro změnu barvy kódu UTFT.

#definovat ČERNOU 0x0000 #definovat NAVY 0x000F #definovat DARKGREEN 0x03E0 #definovat DARKCYAN 0x03EF #definovat Kaštanovou 0x7800 #definovat FIALOVOU 0x780F #definovat jemnou DARKGREY #definovat 00x7REBEN1 0 #definovat AZUROVÁ 0x07FF #definovat ČERVENOU 0xF800 #definovat MAGENTA 0xF81F # definovat ŽLUTOU 0xFFE0 #definovat BÍLOU 0xFFFF #definovat ORANŽOVOU 0xFD20 #definovat ZELENOŽLUTÍ 0xAFE5 #definovat RŮŽOVOU 0xF81F

Tyto řádky můžete přidat do kódu a jednoduše změnit barvu názvu ve funkcích.

Rezervace pikeliv

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)

Funkce drawPixel přiřadí pixel x a y barvě t.

Funkce čístPixelčte barvu pixelů v krocích x a y.

Malování linek

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)

Funkce drawFastVLine barvy svislá čára, Co začíná stínováním x, y, її dovzhin - h pixelů a barvou - t.

Funkce drawFastHLline barvy vodorovná čára, která začíná stínováním x a y, většinou w pixelů a barvou - t.

Funkce drawLine nakreslí řadu, která začíná od xi, yi do xj, yj, barva - t.

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

Tyto tři bloky kódu jsou nakresleny čarami podobnými předchozímu kódu o šířce 5 pixelů.

Tft.fillRect(x,y,š,v,t); //fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t t) tft.drawRect(x, y, š, 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_th, 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_th, uint8_t R , uint16_t t)

Funkce fillRect Nakreslí výplně Orthocutanea v souřadnicích x a y, w – šířka, h – výška, t – barva Orthocutanea.

Funkce drawRect namaluje ortokutánní strom v souřadnicích x a y o šířce w, výšce h a barvě t.

Funkce fillRoundRect natírá výplně rekta o poloměru r, souřadnice x a y, šířku š a výšku h, barvu t.

Funkce drawRoundRect maluje ortokutánní s r radiálně zaoblenými hranami x a y, se šířkou w a výškou h a barvou t.

Malířská cola

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)

Funkce drawCircle maluje v souřadnicích x a y, s poloměrem r a barvou t.

Funkce fillCircle vykreslí celý kruh o souřadnicích x a y, poloměru r a barvě t.

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

Tento kód je zlatým obloukem. Hodnotu „pro“ můžete změnit mezi 0 a 4000.

Malování tricutniků

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

Funkce kreslení trojúhelníku vybarví tricutnik třemi rohovými souřadnicemi x, yaz a t barvami.

Funkce fillTriangle vybarví tři části trikutikuly souřadnicemi x, y, z a t barvou.

Reprezentace textu

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

Tento kód nastaví pozici kurzoru na x a y.

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

První řádek nastavuje barvu textu. První řádek nastavuje barvu textu a pozadí.

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

Tento kód nastavuje velikost textu titulku s. Samotné číslo s Změny v rozsahu od 1 do 5.

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

Tento kód představuje symbol.

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

První funkce zobrazí řádek a přesune kurzor na další řádek.

Další funkce jednoduše zobrazí řádek.

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

Tato funkce změní text na font. Tuto funkci a knihovnu písem musíte přidat.

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

Tato funkce dokáže rozmazat text, který znáte. Toto musíte přidat do svého kódu.

Obal obrazovky

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

Tento kód otočí obrazovku. 0 = 0°, 1 = 90°, 2 = 180°, 3 = 270°.

Inverze barev obrazovky

tft.invertDisplay(i); //invertDisplay(booleovské i)

Tento kód invertuje barvy obrazovky.

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

Tento kód vysílá kód RGB a přijímá barevný kód UTFT.

Posouvejte obrazovku

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

Tento kód bude posouvat obrazovku. Maxroll – maximální výška rolování.

Skidannya

tft.reset();

Tento kód odstraní obrazovku.

Pohled na monochromatické obrázky

static const uint8_t název PROGMEM = ( // Sem přidejte kód obrázku. ) tft.drawBitmap(x, y, název, sx, sy, 0x0000);

Od této chvíle jste odpovědní za převod obrázku do hexadecimálního kódu. Zavantazhte program nezabechennya posilannya nižší. Pokud nechcete měnit nastavení softwaru, musíte invertovat barvu obrázku, zobrazit obrázek vodorovně (zrcadlově) a otočit ho o 90 stupňů proti šipce roku.

Nyní jej přidejte do softwaru a změňte jej. Otevřete exportovaný soubor a zkopírujte hexadecimální kód z Arduino IDE. Xі y- Obrázek Roztashuvannya. sxі sy- Velikost obrázku. Barvu obrázku můžete změnit na zbývající vstup.

RGB barevný obrazový displej

const uint16_t jméno PROGMEM = ( // Sem přidejte kód obrázku. ) tft.drawRGBBitmap(x, y, jméno, sx, sy);

Je vaší odpovědností převést svůj obrázek na kód. Vikorista tse poslannya za přetvoření obrazu:

Zadejte obrázek a stáhněte si transformační soubor, který mohou používat knihovny UTFT. Nyní zkopírujte hexadecimální kód do Arduino IDE. x a y - vykreslení obrázku. sx a sy - velikost obrázku.

K zobrazení hexadecimálního kódu můžete použít níže uvedený převodní program:

Přední skládací prvky

V této šabloně jsme jednoduše přidali řadu 8 náhradních barev, abychom změnili jejich barvy v pořadí. Chcete-li nakreslit kolík kolem statického bodu, můžete použít sin(); ta cos(); funkcí. Musíte nastavit hodnotu PI. Chcete-li změnit barvy, můžete změnit funkci barva565(); Poté vyměňte kód RGB.

#include "Adafruit_GFX.h" #include "MCUFRIEND_kbv.h" MCUFRIEND_kbv tft; #include "Fonts/FreeSans9pt7b.h" #include "Fonts/FreeSans12pt7b.h" #include "Fonts/FreeSerif12pt7b.h" #include "FreeDefaultFonts.h" #define PI 3.141592653578946293; 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); barva565(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, sloupec); zpoždění (15) * PI / 4)), 10, sloupec); zpoždění(15); (-(i + 2)*PI/4)), 10, col); zpoždění(15); tft.fillCircle(240 + 40 * (cos(-(i + 3)*PI / 4)), 120 + 40 * (sin(-(i + 3)*PI / 4)), 10, col); zpoždění(15); tft.fillCircle(240 + 40 * (cos(-(i + 4)*PI / 4)), 120 + 40 * (sin(-(i + 4)*PI / 4)), 10, col); zpoždění(15); tft.fillCircle(240 + 40 * (cos(-(i + 5)*PI / 4)), 120 + 40 * (sin(-(i + 5)*PI / 4)), 10, col); zpoždění(15); tft.fillCircle(240 + 40 * (cos(-(i + 6)*PI / 4)), 120 + 40 * (sin(-(i + 6)*PI / 4)), 10, col); zpoždění(15); tft.fillCircle(240 + 40 * (cos(-(i + 7)*PI / 4)), 120 + 40 * (sin(-(i + 7)*PI / 4)), 10, col); zpoždění(15); )

Klasický text

Pro tuto šablonu jsme zvolili klasické písmo a přidali funkci zeslabení textu.

#include "Adafruit_GFX.h" // Knihovna základní grafiky #include "MCUFRIEND_kbv.h" // Knihovna specifická pro hardware MCUFRIEND_kbv tft; #include "Fonts/FreeSans9pt7b.h" #include "Fonts/FreeSans12pt7b.h" #include "Fonts/FreeSerif12pt7b.h" #include "FreeDefaultFonts.h" void showmsgXY(int x, int y, int *ms const ) ( 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 barva; 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(BÍLÁ v potížích,"); delay(40); tft.println(" kdo může nabrat sílu z nouze,"); delay(40); delay(40); svědomí; schvaluje jejich chování,"); zpoždění(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); }

pocta/prezentace logu

Čí šablonu jsme předělali soubor a.jpg y souboru .C A přidal to do kódu, napsal řádek a vikorizoval kód. Potom jsme vikorizovali rolovací kód, abychom posunuli obrazovku doleva. Předstírejte soubor .h A přidejte jej do složky Arduino skic.

#include "Adafruit_GFX.h" // Knihovna základní grafiky #include "MCUFRIEND_kbv.h" // Knihovna specifická pro hardware 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" "Serif12Fonts"/Fonts oid 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); }

Bodový diagram

V této šabloně jsme použili linie malby, plnění sázky a funkce zobrazení řádků.

#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; znaménko = 1;) jinak znaménko = 0; pro (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); }

Teplota

Kterou šablonu jsme vikorizovali? hřích();і cos(); funkce pro kreslení oblouků s velkým číslem a číslem, které se zobrazuje za doplňkovou funkcí textového přítele. Poté jsme obrázky převedli do hexadecimálního kódu a přidali jej do kódu a zobrazili obrázky pomocí doplňkové funkce rastrového obrázku. Poté jsme pomocí funkce Line Painting změnili styl obrázku. Vyberte soubor.h a přidejte jej do složky Arduino.

#include "Adafruit_GFX.h" #include "MCUFRIEND_kbv.h" #include "Math.h" MCUFRIEND_kbv tft; #include "Teplota.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() ( // sem vložte svůj hlavní kód, aby se spouštěl opakovaně: 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) (zatímco (a Výsečový graf

V této šabloně jsme vytvořili funkci, která přijímá čísla jako vstup a zobrazuje je jako koláčový graf. Jsme prostě vikoristovuyu obloukové malování a obnovování funkcí kůlu.

#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() ( // sem vložte svůj hlavní kód, aby se spouštěl opakovaně: 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); }

Hudba

#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 bílá; void setup() ( Serial.begin(9600); uint16_t ID = tft.readID(); tft.begin(ID); tft.invertDisplay(true); tft.setRotation(1); ) void loop(void) ( tft .invertDisplay(true), tft.fillScreen(BLACK);< 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) i = 14* (cos (PI* (b + 300) / 2000)); PI* (b + 300) / 2000)); tft.setTextSize(2); tft.setTextColor(0xffff); tft.setCursor(168, 285); tft.print(b/40); tft.print("%"); b--;) jestliže (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 / 2 000)); 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 / 2 000)); 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--;)))

Rychloměr

#include "Adafruit_GFX.h" // Základní grafická knihovna #include "MCUFRIEND_kbv.h" MCUFRIEND_kbv tft; #define BLACK 0x0000 #include "Gauge.h" #include "Fonts/FreeSans9pt7b.h" #include "Fonts/FreeSans12pt7b.h" #include "Fonts/FreeSerif12pt7b.h" #include "FreeDefault4000 int b; 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.setCurs (x, y); tft.println(msg); tft. invertDisplay(true); .setRotation(1); void loop(void) ( tft.invertDisplay(true); tft.fillScreen(BLACK); tft.drawRGBBitmap(0, 0, test, 480, 320);< 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; ) //////////////////////////////////////////////// / ////////////////// zatímco (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--; ) zatímco (1); )

Veselý mužíček

V této šabloně lze zobrazit jednoduché obrázky i s doplňkovou funkcí rastrového obrázku. Tímto způsobem můžete vylepšit svou animaci pomocí tohoto triku. Vyberte soubor.ha přidejte jej do složky Arduino.

#include "Adafruit_GFX.h" #include "MCUFRIEND_kbv.h" MCUFRIEND_kbv tft; #include "image.h" #include "Fonts/FreeSans9pt7b.h" #include "Fonts/FreeSans12pt7b.h" #include "Fonts/FreeSerif12pt7b.h" #include "FreeDefaultFonts.h" #define BLUE 0x0eedefinujte ČERVENÁ 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 *ms16t_t nastavitFont (f); tft.setCursor(x, y); tft.print(msg) ; setRotation(1) tft.fillScreen(tft. barva565(0,20,0));zpoždění(60); 258, 128, BÍLÁ); zpoždění(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Řádek3, 258, 128, BÍLÁ);zpoždění(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Řádek4, 258, 128, BÍLÁ);zpoždění(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line5, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line6, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Řádek7, 258, 128, BÍLÁ);zpoždění(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line8, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Řádek9, 258, 128, BÍLÁ);zpoždění(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line10, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line11, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line12, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line13, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Řádek14, 258, 128, BÍLÁ);zpoždění(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line15, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Řádek16, 258, 128, BÍLÁ);zpoždění(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line17, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128,tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line18, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Řádek19, 258, 128, BÍLÁ);zpoždění(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line20, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line21, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line22, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line23, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line24, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line25, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128,tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line26, 258, 128, WHITE);delay(40); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); tft.drawBitmap(20, 180, Line27, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); )

obraz

Ve které šabloně jednoduše ukážeme akce obrázku pro další funkci RGB bitmapaі bitmapa. Stačí vytvořit kód pro dotykovou obrazovku a vikorizovat šablonu. Vyberte soubor.h a přidejte jej do složky Arduino.

#include "Adafruit_GFX.h" // Knihovna základní grafiky #include "MCUFRIEND_kbv.h" // Knihovna specifická pro hardware 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" #2Serifh.Free./Fnts " int a = 3000; int b = 4000; int j, j2; int i, i2; void showmsgXY(int x, int y, int sz, const GFXfont *f, const char *msg) ( int16_t x1, y1; uint16_t wid, ht // tft.drawFastHLline(0, y, tft.width()); tft.setCursor(x, y); .drawRGBBitmap(0, 0, test, 480, 320) // wifi tft.drawBitmap (125, 25, Řádek3, 45, 45, 0xffff); , 0xffff);//power tft.drawBitmap(20, 260, Line5, 45, 45, 0xffff);//twitter tft.drawBitmap(4 , Line7, 45, 0xffff);//rain tft.setTextSize(6); tft.setTextColor(0xffff, 280, 1, FreeSans12pt7b, "sobota"); while(1); )

Vak

Zachyťte archivy se soubory .h dolní:

Rychlost vytváření všech souborů GIF byla redigována a byly více či více kompilovány pro rychlé pochopení. Tekutost kapaliny závisí na plynulosti vašeho procesoru a typu kódu, stejně jako na velikosti a počtu prvků v kódu.
Kód obrázku můžete přidat na úvodní stránku, jinak vyplní celou stránku. Tímto způsobem můžete vytvořit soubor a.h A přidejte do složky skicu.
V tomto článku jsme pečlivě rozebrali zobrazení prvků na obrazovce RK. V následujících lekcích se dozvíte, jak používat dotykové obrazovky a karty SD.
Pokud máte problémy se zahrnutými knihovnami, změňte znak nohy "" na<>.

Tak to je prozatím vše. Sdílejte tento TFT LCD pro Arduino se svými přáteli a kolegy.

Současná zařízení jsou vybavena obrazovkami různých konfigurací. Hlavní jsou v tuto chvíli displeje na základně, ale lze pro ně použít různé technologie, zejména TFT a IPS, které se liší od celé řady nízkých parametrů, přestože jsou založeny na jediném vstupním vstupu.

Neexistují žádné termíny, které by označovaly technologie spadající pod tyto zkratky. Třebaže mnoho lidí něco málo četlo o IPS a TFT, málokdo chápe, jaký je mezi nimi skutečný rozdíl. Důvodem je nedostatek informací v katalozích elektroniky. Je důležité porozumět těmto konceptům a také se rozhodnout mezi TFT a IPS – co je lepší?

Terminologie

Pro určení toho, co bude kratší nebo silnější v textuře pokožky, je nutné při přípravě každého vikoristu zjistit, jaké funkce má kůže IPS ve vztahu k faktu TFT, přesněji řečeno různé typy. aktualizováno - TN-TFT. Následuje pohled na zprávy a technologie.

Vidminnosti

TFT (TN) je jednou z metod vytváření matice obrazovek na tenkovláknových tranzistorech, ve kterých jsou prvky spirálovitě uspořádány mezi dvojicí desek. Jakmile je přivedeno napětí, rohy se otočí jedna k jedné pod přímkou vodorovné roviny. Maximální napětí způsobí rotaci krystalů tak, že světlo procházející jimi způsobí vznik černých pixelů, a pokud není napětí, objeví se bílé pixely.

Pokud se podíváte na IPS nebo TFT, rozdíl mezi prvním a druhým spočívá ve skutečnosti, že matrice je připravena na základě popsaném dříve, protože krystaly v ní nejsou uspořádány spirálovitě, ale rovnoběžně se stejným povrchem obrazovky. . V režimu TFT se krystaly nikdy neotáčejí vlivem napětí.

Jak mi tse bachimo?

Pokud se podíváte na IPS nebo vizuálně, rozdíl mezi nimi spočívá v kontrastu, který zajišťuje dokonalé podání černé barvy. Na první obrazovce budou obrázky jasnější. A osu přenosu barev v jiné matici TN-TFT nelze nazvat harmonickou. Tento typ pleti má vlhký odstín, odlišný od ostatních. Tato barva způsobuje spoustu zmatků. Tato matrice má však výhodu: vyznačuje se v současnosti nejvyšší tekutostí ze všech ostatních materiálů. U obrazovky IPS to trvá dlouhou dobu, během níž jsou všechny paralelní krystaly vytaženy, aby se znovu otočily. Rozdíl v hodinách pití však lidské oko prakticky nepostřehne.

Důležité detaily

Mluvíme o těch, které se používají snadněji: IPS nebo TFT, což znamená, že první jmenované jsou energeticky náročnější. To znamená, že otáčení krystalů vyžadovalo energii. Navíc, protože vysílač stojí před úkolem učinit jeho zařízení energeticky úsporným, je nutné použít matici TN-TFT.

Ať už si vyberete TFT nebo IPS obrazovku, znamená to širší výhled na druhou a 178 stupňů v obou velikostech, což je praktické i pro uživatele fotoaparátu. Jiné se ukázaly jako nedostupné, aby to zajistily. A další výhodou rozdílu mezi těmito dvěma technologiemi je schopnost virů na nich založených. TFT matice jsou v současné době nejlevnějším řešením, které se nachází ve většině levných modelů, a IPS je poslán na vyšší úroveň, ale není špičkový.

Vibruje IPS Chi TFT displej?

Prvotřídní technologie vám umožňuje získat nejčistší a nejostřejší obraz, ale otočení krystalů k vytvrzení trvá déle než hodinu. To přidává výkon a další parametry na hodinu a zároveň zvyšuje plynulost vybíjené baterie. Barva TN-matice je velmi nízká a během této doby je minimální. Krystaly jsou zde uspořádány do spirály.

Ve skutečnosti je možné snadno detekovat neustálé vyrušování obrazovek, které fungují na základě dvou technologií. Je kolem toho velký povyk. Technologie TN je pro trh ztracena, včetně ceny, a nelze ji chránit před poskytnutím jasného obrazu.

IPS je další vývoj TFT displejů. Vysoká úroveň kontrastu a skvělý vizuální dopad jsou dalšími výhodami této technologie. Například na monitorech na bázi TN černá barva sama o sobě mění svůj odstín. Vysoká energetická náročnost zařízení, která fungují na bázi IPS, však mnohé výrobce odrazuje od alternativních technologií nebo snižování jejich výkonu. Nejčastěji se matice tohoto typu používají v kabelových monitorech, které jsou napájeny baterií, což zabraňuje kolísání pracovní plochy. Vývoj v tomto galusu však neustále probíhá.

Matice TFT a IPS: vlastnosti, výhody a nevýhody

V dnešním světě se pravidelně dostáváme do styku s displeji telefonů, tabletů, PC monitorů a televizorů. Technologie pro výrobu vzácných krystalových matric nestojí, kvůli čemuž má mnoho lidí problémy s jídlem, co je lepší zvolit TFT nebo IPS?

Abychom získali úplný obrázek o napájecím zdroji, je nutné pečlivě zvážit funkce obou matic, prohlédnout si jejich vlastnosti, výhody a nevýhody. Se znalostí všech jemností si můžete snadno vybrat zařízení, jehož displej je plně kompatibilní s vašimi potřebami. Jak vám může pomoci náš článek?

TFT matrice

Thin Film Transistor (TFT) je systém pro generování vzácných krystalových displejů, který je založen na aktivní matrici tranzistorů z tenkých vláken. Když je na takovou matrici přivedeno napětí, krystaly rotují jedna ku jedné, což vede k vytvoření černé barvy. Připojení elektřiny dává stejný výsledek - krystaly vytvářejí bílou barvu. Změna dodávaného napětí umožňuje vytvořit libovolnou barvu na kůži vybraného pixelu.

Hlavní výhodou TFT displejů je pozoruhodně nízká výrobní cena, která je srovnatelná se současnými analogy. Navíc takové matrice uvolňují výjimečný jas a občasnou sílu. Z nějakého důvodu není nedostatek času na sledování dynamických scén. Displeje vyrobené pomocí technologie TFT se nejčastěji používají na levných televizorech a monitorech.

Málo TFT displejů:

- nízký přenos barev. Technologie má 6 bitů na kanál;
- Spirálové uspořádání krystalů má negativní dopad na kontrast obrazu;
- Jas obrazu znatelně klesá, když se na něj díváte;
- vysoký výskyt „rozbitých“ pixelů;
- nízká spotřeba energie.

Nejpozoruhodnější je, že krátké části matice TFT jsou při práci zobrazeny černě. Můžete jít až do šedé, jinak je potřeba, aby byla kontrastní.

IPS matrice

Matrice IPS je vysoce pokročilý displej založený na technologii TFT. Hlavní rozdíl mezi těmito matricemi je v tom, že TFT krystaly jsou zřídka uspořádány do spirály, zatímco v IPS krystaly leží ve stejné rovině, vzájemně rovnoběžné. Navíc se díky absenci elektřiny neotáčí vůně, což se pozitivně projevuje na černém barevném provedení.

Výhody IPS matice:

Rozhlédnu se, ale jas obrazu neklesá, je zvýšen na 178 stupňů;
přenos barev byl natřen. Množství dat přenášených přes kanál skinu bylo zvýšeno na 8 bitů;
Kontrast byl vylepšen;
snížená spotřeba energie;
nízká pravděpodobnost výskytu „rozbitých“ nebo vypálených pixelů.

Obrazy na matici IPS vypadají živěji a živěji, ale to neznamená, že tato technologie byla trochu omezena. V případě IPS s předním panelem je jas obrazu výrazně snížen. Také po výměně elektrod, které jsou ovládány, utrpěl takový účinek, protože je čas oživit matrici. Poslední, ale neméně významnou nevýhodou je poměrně vysoká cena za zařízení využívající IPS displeje. Zpravidla jsou o 10-20% dražší než podobné s TFT maticí.

Co je to vibrace: TFT chi IPS?

Je jasné, že matice TFT a IPS, bez ohledu na vlastní důležitost obrázků, mají velmi podobné technologie. Vůně jsou vytvářeny na bázi aktivních matric a vikoristických struktur vzácných krystalů. Mnoho současných výrobců dává přednost IPS matricím. Skvělou zprávou je, že smrady mohou vést k větší konkurenci s plazmovými matricemi a mohou mít v budoucnu mnoho vyhlídek. Matrice Prote TFT se také vyvíjejí. Na trh lze uvést jak TFT-TN, tak TFT-HD displeje. Obrazy prakticky neobětují IPS maticím, ale to umožňuje vyšší kvalitu obrazu. Zařízení s takovými monitory však není tolik.

Pokud je pro vás důležitá kvalita obrazu a jste ochotni si trochu připlatit, pak je zařízení s IPS displejem tou nejlepší volbou.

K definování charakteristik a specifik je nutné používat zkratky. Kdykoli dojde k poškození obrazovek IPS a TFT, výsledkem je, že technologie IPS (matice) je odlišný typ matice a panelů TFT. Není možné tyto dvě technologie vzájemně porovnávat.

ALE! Technologie TN-TFT – osu mezi ní a IPS lze vybrat a upravit. Pokud tedy mluvíme o tom, která obrazovka je lepší: IPS nebo TFT, v každém případě bereme v úvahu obrazovky TFT, ale vyrobené na základě různých technologií: TN a IPS.

Stručně o TN-TFT a IPS

TN-TFT je technologie založená na vzácné krystalové matrici obrazovky. Zde krystaly, pokud není do jejich komisí přivedeno žádné napětí, stojí samostatně v 90 stupních. Pachy se pohybují po spirále a když je na ně přivedeno napětí, pachy rotují tak, aby vytvořily požadovanou barvu.

IPS - tato technologie je pozoruhodná tím, že krystaly jsou uspořádány paralelně k sobě ve stejné ploše obrazovky (v prvním případě spirálovitě). Je to všechno složité... v praxi spočívá rozdíl mezi obrazovkami založenými na TN a IPS matici v tom, že IPS ideálně zobrazuje černou barvu, díky čemuž je obraz jasnější a živější.

I když neexistuje TN-TFT, schopnost přenosu barev této matrice nevzbuzuje důvěru. Zde může mít kožní pixel svůj vlastní chlupatý odstín, takže barvy jsou zmatené. IPS matrice zobrazují obraz mnohem krásněji a také se s nimi snadněji manipuluje. IPS také umožňuje sledovat, co se zobrazuje na obrazovce, pod velkým vlivem. Pokud se pod stejným rámem podíváte na obrazovku TN-TFT, budou barvy na panelech, což znesnadní sledování obrazu.

Výhody TN

Matice TN-TFT však mají své výhody. Hlavním důvodem je nižší plynulost pixelů. IPS vyžaduje více než hodinu, než se celé pole paralelních krystalů otočí v požadovaném úhlu. Pokud tedy jde o výběr monitoru pro hraní her nebo pro zobrazování dynamických scén, pokud je důležitá čistota stínování, pak je nejlepší zvolit samotnou obrazovku založenou na technologii TN-TFT.

Na druhou stranu, při počáteční práci z PC není možné zaznamenat rozdíl v pixelhodinách. Vidíte to až po hodině sledování dynamických scén, což se v akčních filmech a videohrách často stává.

Dalším plusem je nízká spotřeba energie. IPS matrice jsou energeticky účinné, protože K otočení pole krystalů vyžadují velké napětí. Obrazovky založené na TFT jsou také nejvhodnější pro mobilní zařízení, která vyžadují vysokou spotřebu energie a šetří energii baterie.

A také – matice TN-TFT jsou levnější. Dnes nenajdete žádné monitory (ať už levně používané nebo modely EPT), které by byly levnější než model založený na technologii TN. Jakékoli levné elektronické zařízení s obrazovkou vyžaduje matici TN-TFT.

No, která obrazovka je krásnější:TFT neboIPS:

IPS méně smyslu pro více hodin úprav (špatné pro hry a akční scény);
IPS zaručuje téměř dokonalou reprodukci barev a kontrast;
IPS je nejdůležitější věc, na kterou je třeba se dívat;
IPS spotřebovává více energie než elektřina;
Jsou také dražší, zatímco TN-TFT je levnější.

Osa je v principu celý rozdíl mezi těmito maticemi. Pokud vezmete v úvahu všechny výhody a nevýhody, pak je samozřejmě snadné dojít ke konkrétnímu závěru: obrazovky IPS jsou mnohem krásnější.

Buďte laskaví, ohodnoťte článek:

Jas monitoru (obrazovky) je velmi důležitý pro záchranu očí uživatelů osobních počítačů. O to větší nároky na váš zrak má intenzivní dlouhá léta práce za monitorem. Jasnost obrazu závisí do značné míry na velikosti fosforových bodů na obrazovce. Střední vzdálenost mezi body se nazývá zrno. U ostatních monitorů se tento parametr pohybuje v rozmezí 0,21 až 0,31. Důležitými parametry jsou frekvence snímkového (vertikálního) spouštění a malého (horizontálního) spouštění a množství přenosu video signálu. Čím vyšší je snímková frekvence, tím je obraz stabilnější a zobrazení zabere méně času (u čistých monitorů je snímková frekvence 70-80 Hz). Frekvence řádků v kilohertzech je určena vynásobením počtu řádků, které jsou zobrazeny v jednom snímku, snímkovou frekvencí. Rozsah přenosových frekvencí pro video signál (upravený MHz) je určen jako součet počtu bodů v řadě a frekvence malého vzorku. Níže jsou uvedeny hlavní charakteristiky TFT LCD displejů:

1. Větrací otvor.

Aktualizace clony (horní otvor) є plochý obraz nebo efektivní oblast clony, do podzemní matrice RC displej. Čím vyšší cena, tím jasnější displej , plocha obsazená barvami se zvětší. Také se zvýší kontrast . Přední otvor je důležitým ukazatelem PK displeje, který slouží k vyhodnocení jeho jasu.

2. Dovolte mi, abych se rozhlédl kolem sebe.

Kontrast obrazu PK monitoru se mění v závislosti na umístění, na které je dbáno. Kut zoru charakterizuje tuto změnu. Může dojít k projevům změnou kontrastu při řazení nahoru/dolů a pravák/levák. Kapacita vzácného krystalu spočívá ve velkém světě pod okrajem dopadajícího světla. . Změny kontrastu jsou tedy určeny koeficientem přenosu na vstupu a výstupu.

Nezapomeňte uvést význam omezení, například 170/170°. Rychle se rozhlédnu kolemє Úsporný kontrastní poměr není nižší než 10:1. V tomto případě je bezpodmínečně nutné přenést barvy v této poloze, takže barvy budou inverzní (barvy jsou zobrazeny ve středu matice a na barvách jsou samozřejmě pod barvou vidět).

3. Rušení.

Objeví se rušení negativní Propojení pixelů , pokud aktivací napjatě pixel proudí do pasivu plavidla . To je charakteristické pro jednoduché panely typu STN v panelech s aktivními matricemi však dochází k mírnému přílivu rušení.
4. Yaskravist.

Pro nastavení jasu PK displejů se používají následující hodnoty: NIT, noha Lambert kandela na metr čtvereční – cd/m (cd/m).

Jas displeje objeví se Jsem upřímný zadní osvětleníі Řízení přístupu panely.

Propustnost vzácného krystalu nízkýže pro zvýšení jasu obrazu vítězství clonové dveře z velkých vzdušných dveří , polarizační panely a barevné filtry s vysokou průchodností nebo hranolem.

5. Změna měřítka obrazu během operace ve více režimech.

Pro TFT monitory se doporučují samostatné formáty XGA (1024x768) a SXGA (1280x1024), navíc tyto monitory budou podporovat režimy celoobrazovkového rozšíření SVGA a VGA. U samostatných obrázků, jako je SVGA a menší režimy, se však mohou znaky na obrázku jevit jako hrubé a nestabilní. Důvodem je, že základní počet pixelů pro 14" a 15" TFT panely Bulo vibrano pro režim XGA. Proto pro vytvoření obrazu v režimech SVGA nebo VGA bude viník obrácen.

Hlavní problém spočívá v oblasti konkurenceschopnosti společnosti v této tržní situaci. Firmy neplatí speciální návštěvy před zajištěním čistého obrazu s robotem v režimu bagator monitor. Dodáno a realizováno funkce pokročilého škálování obrazu (Image Enhancement Function), jaka, vikorista metoda nelineární interpolace Pro vylepšení obrazu umožňuje přehledné zobrazení výtvoru v samostatném vydání, odděleném od toho základního.

6. Je čas zpívat.

Tento indikátor označuje minimální hodinu, během které panel vzácných krystalů změní barvu. Existují dva způsoby, jak upravit tekutost matrice: Černý k Černému (černo-bílá-černá),і šedá až šedá(mezi stupni šedi), Kromě toho se význam těchto metod hodnocení velmi liší. Při změně polohy mezi krajními polohami (černá a bílá) je do krystalu přiváděno maximální napětí a kolík se otáčí maximální rychlostí (tato charakteristika by měla být uvedena v charakteristikách současných monitorů). : 8, 6, inody a 4 ms. S přemístěnými krystaly mezi stupni šedi předloženy do reklamy výrazně méně Napětí, protože je třeba je přesně umístit, aby odstranily požadovaný závit, a za což se vynakládá mnohem více (od 14 ms do 28 ms). Nedávno se nám podařilo najít příjemný způsob, jak tento problém vyřešit. Do spínače je přivedeno maximální napětí (nebo sníženo na nulu) a v požadovaném okamžiku je poloha krystalu okamžitě nastavena do potřebné polohy. Kromě všech výhod této metody se výrazně zvyšuje složitost přesné regulace napětí. s frekvencí, která přesahuje frekvenci klaksonu. Kromě toho musí být jádrový impuls vyrovnán se zarovnáním polohy žeber krystalů (Samsung již představil modely s technologií digitální kompenzace kapacity, který skutečně poskytne výkon za 8-6 ms pro PVA matici).

7. Kontrast obrazu.

Hodnota kontrastu je určena na základě jasu matice ve fázi „černá“ a „bílá“ (černá barva je méně exponovaná a čím jasnější je bílá, tím vyšší je kontrast). Toto zobrazení je důležité pro jasné zobrazení obrazu videa a pro dobrý obrázek jakýkoli obrázek(například pro S-IPS průměrná hodnota - 400:1 , a pro PVA – až 1000:1). V charakteristikách monitoru je uvedeno: měřeno pro matrice, ne pro monitor, a na speciálním stojanu, pokud je na matrici přiváděno velmi standardní napětí, je osvětlení napájeno přísně standardním napětím atd.).

8. Přenos barev.

Nezapomeňte na tuto ukázku správnosti. Matrix Belshist, panny stojící za kolapsem technologie, na přenos 24-Bitnu do Koloro (vicicacituces є Adetori Montory PVA VID Samsung-Niyako systémy v instalaci 18-abed PVA samsung nebudou zvýrazněny).

Windows 7