namai > Grindys

Daugiafunkcis TFT ekranas. Skirtumas tarp TFT ir IPS ekrano. TFT ekranų tipai, jų privalumai ir trūkumai

Šioje pamokoje parodysime, kaip naudoti TFT LCD ekranus su Arduino – nuo ​​pagrindinių komandų iki profesionalaus dizaino.

Šiame straipsnyje sužinosite, kaip naudoti TFT LCD su Arduino plokštėmis. Bandysime aprėpti pagrindines komandas, taip pat kalbėsime apie profesionalius dizainus ir metodus. Pagal straipsnio lauko planus galite išmokti:

  • rodyti tekstus, simbolius ir skaičius norimu šriftu;
  • piešti tokias formas kaip apskritimas, trikampis, kvadratas ir kt.;
  • rodyti images.bmp ekrane;
  • keisti ekrano nustatymus, pvz., sukti ir apversti spalvas;
  • ekrano animacija naudojant Arduino.

Iš Vikipedijos: Aktyviosios matricos skystųjų kristalų ekranas (TFT LCD, angliškas plonasluoksnis tranzistorius) yra skystųjų kristalų ekrano tipas, kuriame naudojama aktyvioji matrica, valdoma plonasluoksniais tranzistoriais.

Elektronikos projektuose labai svarbu sukurti sąsają tarp vartotojo ir sistemos. Šią sąsają galima sukurti rodant naudingus duomenis, meniu ir lengvą prieigą. Gražus dizainas yra ne mažiau svarbus.

Tam yra keli komponentai. Šviesos diodai, 7 segmentų moduliai, grafiniai ekranai ir spalvoti TFT ekranai. Tinkamas komponentas jūsų projektams priklauso nuo rodomų duomenų kiekio, vartotojo sąveikos tipo ir procesoriaus talpos.

TFT LCD yra skystųjų kristalų ekrano (LCD) variantas, kuriame naudojama plonasluoksnio tranzistoriaus (TFT) technologija, siekiant pagerinti vaizdo kokybę, pvz., adresą ir kontrastą. TFT LCD yra aktyviosios matricos skystųjų kristalų ekranas, priešingai nei pasyviosios matricos LCD arba paprasti kelių segmentų tiesioginio valdymo LCD.

Arduino projektuose procesoriaus dažnis yra žemas. Todėl neįmanoma rodyti sudėtingų didelės raiškos vaizdų ir didelio greičio judesių. Todėl spalvoti TFT ekranai gali būti naudojami tik paprastiems duomenims ir komandoms rodyti.

Šiame straipsnyje mes naudojome bibliotekas ir pažangias technologijas duomenims, diagramoms, meniu ir kt. rodyti. su profesionaliu dizainu. Tokiu būdu bet kuris jūsų projektas atrodys neįtikėtinai šaunus.

Kokio dydžio? Koks valdiklis?

Ekranų dydis turi įtakos jūsų projekto parametrams. Didesnis ekranas ne visada yra geresnis. Jei norite rodyti didelės raiškos simbolius ir vaizdus, ​​turėtumėte pasirinkti didelį ekrano dydį ir didesnę skiriamąją gebą. Tačiau tai sumažina apdorojimo greitį, reikalauja daugiau vietos, taip pat reikia daugiau srovės veikti.

Taigi, pirmiausia, turėtumėte patikrinti vaizdų, tekstų ir skaičių skiriamąją gebą, judėjimo greitį, spalvą ir dydį. Mes siūlome populiarius Arduino ekrano dydžius, tokius kaip:

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

Kai pasirinksite tinkamą ekraną, laikas pasirinkti tinkamą valdiklį. Jei norite rodyti simbolius, tekstus, skaičius ir statinius vaizdus, ​​o rodymo greitis nėra svarbus, Atmega328 Arduino plokštės (pvz., ) yra tinkamas pasirinkimas.

Jei jūsų kodo dydis yra didelis, UNO gali nepakakti. Tu gali naudoti . O jei norite rodyti didelės raiškos vaizdus ir didelius judesius, turėtumėte naudoti „Arduino ARM“ modulius, tokius kaip „Arduino DUE“.

Vairuotojai ir bibliotekos

Elektronikoje / kompiuterio aparatinėje įrangoje ekrano tvarkyklė paprastai yra puslaidininkinis integrinis grandynas (tačiau gali būti ir būsenos mašina, sudaryta iš diskrečios logikos ir kitų komponentų), kuri užtikrina sąsajos funkciją tarp mikroprocesoriaus, mikrovaldiklio, ASIC arba bendrosios paskirties periferinės sąsajos ir konkretaus tipo rodymo įrenginys , pvz., LCD, LED, OLED, ePaper, CRT, Nixie ir kt.

Ekrano tvarkyklė paprastai priima komandas ir duomenis naudodama standartinę bendrosios paskirties nuosekliąją arba lygiagrečią sąsają, pvz., TTL, CMOS, RS232, SPI, I2C ir kt. ir generuoja signalus su tinkama įtampa, srove, laiku ir demultipleksavimu, kad būtų rodomas norimas tekstas arba vaizdas.

LCD gamintojai savo gaminiuose naudoja skirtingas tvarkykles. Kai kurie iš jų yra populiaresni, o kai kurie nežinomi. Norėdami lengvai paleisti ekraną, turėtumėte naudoti Arduino LCD bibliotekas ir pridėti jas prie savo kodo. Priešingu atveju gali būti labai sunku paleisti ekraną. Internete yra daug nemokamų bibliotekų, tačiau svarbu tai, kad jos yra suderinamos su LCD tvarkykle. Jūsų LCD tvarkyklė turi būti žinoma jūsų bibliotekai. Šiame straipsnyje naudojame Adafruit GFX biblioteką ir MCUFRIEND KBV biblioteką bei kodo pavyzdžius. Galite juos atsisiųsti iš pridedamų nuorodų.

Išpakuokite MCUFRIEND KBV ir atidarykite MCUFRIEND_kbv.CPP. Pamatysite tvarkyklių, kurias palaiko MCUFRIEND biblioteka, sąrašą.

Atidarykite aplanką su pavyzdžiais (anglų kalba - pavyzdys). Yra keli kodo pavyzdžiai, kuriuos galite paleisti „Arduino“. Prijunkite LCD ir patikrinkite keletą pavyzdžių.

Komponentų sąrašas

Norint įgyvendinti daugelį projektų, susijusių su TFT LCD, mums reikės kai kurių komponentų rinkinio, kurį jau aptarėme aukščiau:

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

Programinė įranga

Be to, norint dirbti su Arduino, mums paprastai reikia .

Kodas

Turite pridėti biblioteką ir įkelti kodą. Jei pirmą kartą naudojate „Arduino“ plokštę, nesijaudinkite. Tiesiog atlikite šiuos veiksmus:

  • Eikite į mūsų svetainę arba www.arduino.cc/en/Main/Software ir atsisiųskite savo OS programinę įrangą. Įdiekite programinę įrangą pagal instrukcijas.
  • Paleiskite Arduino IDE, išvalykite teksto rengyklę ir nukopijuokite kodą į teksto rengyklę.
  • Eikite į eskizą ir įgalinkite bibliotekas. Spustelėkite „Pridėti ZIP biblioteką“ ir pridėkite bibliotekas.
  • Skiltyje „Įrankiai ir lentos“ pasirinkite plokštę, pasirinkite savo „Arduino“ plokštę.
  • Prijunkite „Arduino“ prie kompiuterio ir nustatykite COM prievadą į „Įrankiai ir prievadas“.
  • Spustelėkite mygtuką Įkelti (rodyklė).
  • Dabar viskas nustatyta!

Atsisiuntę pavyzdinį kodą, laikas išmokti kurti vaizdus LCD ekrane.

biblioteka

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

Pirmoje eilutėje pridedama pagrindinė ekranų grafikos biblioteka (parašyta Adafruit).

Antrasis prideda biblioteką, kuri palaiko MCUFRIEND Arduino ekrano tvarkykles.

#include "TouchScreen.h" // tik jei norite naudoti jutiklinį ekraną #include "bitmap_mono.h" // kai norite rodyti bibliotekos taškinę schemą #include "bitmap_RGB.h" // kai norite rodyti bitų schemą iš bibliotekos #include "Fonts/FreeSans9pt7b.h" // kai reikia kitų šriftų #include "Fonts/FreeSans12pt7b.h" // kai reikia kitų šriftų #include "Fonts/FreeSerif12pt7b.h" // kada jums reikia kitų šriftų #include "FreeDefaultFonts.h" // kai reikia kitų šriftų #include "SPI.h" // naudokite sdcard, kad būtų rodoma taškinė schema #include "SD.h"

Šios bibliotekos dabar nereikalingos, 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 linija sukuria objektą pavadinimu TFT iš klasės MCUFRIEND_kbv ir užtikrina SPI ryšį tarp LCD ir Arduino.

LCD paleidimas

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

Funkcija tft.readID nuskaito ID iš ekrano ir įdeda jį į ID kintamąjį. Tada funkcija tft.begin gauna ID ir LCD ekranas yra paruoštas naudoti.

Ekrano skiriamoji geba

tft.width(); //int16_t width(void); tft.aukštis(); //int16_t height(void);

Iš šių dviejų funkcijų galite sužinoti ekrano skiriamąją gebą. Tiesiog pridėkite juos prie savo kodo ir įdėkite išvestį į kintamąjį uint16_t. Tada perskaitykite jį iš nuosekliojo prievado Serial.println();. Pirmiausia pridėkite Serial.begin(9600); V setup ().

Ekrano spalva

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

Funkcija užpildykite ekraną pakeičia ekrano spalvą į spalvą t. Tai turėtų būti 16 bitų kintamasis su spalvos kodu UTFT.

#define BLACK 0x0000 #define NAVY 0x000F #define DARKGREEN 0x03E0 #define DARKCYAN 0x03EF #define MAROON 0x7800 #define PURPLE 0x780F #define OLIVE 0x7BEGREYBx0define #define EF #define BLUE 0x001F #define GREEN 0x07E0 #define CYAN 0x07FF # apibrėžti RAUDONĄ 0xF800 #apibūdinti RAUDONĄ 0xF81F #apibūdinti GELTONĄ 0xFFE0 #define BALTA 0xFFFF #apibūdinti ORANŽINĖ 0xFD20 #apibūdinti GREENYELLOW 0xAFE5 #apibūdinti ROŽINĘ 0xF81F

Šias eilutes galite įtraukti į kodo pradžią ir tiesiog naudoti spalvos pavadinimą funkcijose.

Pikselių užpildymas

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į užpildo pikselį ties x ir y spalva t.

Funkcija skaitykite pikselius nuskaito pikselio spalvą x ir y vietose.

Brėžti linijas

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 nubrėžia vertikalią liniją, kuri prasideda nuo x, y vietos, jos ilgis yra h pikselių, o spalva yra t.

Funkcija pieštiFastHLine nubrėžia horizontalią liniją, kuri prasideda x ir y taškais, ilgis yra w pikselių, o spalva yra t.

Funkcija drawLine brėžia liniją, prasidedančią xi, yi ir baigiančią 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 brėžia linijas, panašias į ankstesnį kodą su 5 pikselių storiu.

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 brėžia užpildytą stačiakampį x ir y koordinatėmis, w – plotis, h – aukštis, t – stačiakampio spalva.

Funkcija pieštiRect nubrėžia stačiakampį x ir y koordinatėse, kurių plotis w, aukštis h ir spalva t.

Funkcija fillRoundRect nupiešia užpildytą stačiakampį, kurio kampo spindulys r, x ir y koordinatėmis, plotis w ir aukštis h, spalva t.

Funkcija drawRoundRect nubrėžia stačiakampį su r radialiniais užapvalintais kampais x ir y, kurių plotis w ir aukštis h ir spalva t.

Ratų piešimas

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ą nubrėžia apskritimą x ir y koordinatėmis, kurių spindulys r ir spalva t.

Funkcija užpildytiCircle nubrėžia užpildytą apskritimą x ir y koordinatėmis, kurių spindulys r ir spalva 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 nubrėžia lanką. Galite pakeisti reikšmę „for“ nuo 0 iki 4000.

Trikampių piešimas

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.fillTrikampis(x1,y21,x3,y); //fillTriangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3, // uint16_t t)

Funkcija nubrėžti trikampį nubrėžia trikampį su trimis kampinėmis koordinatėmis x, y ir z bei t spalva.

Funkcija užpildykite trikampį nubrėžia užpildytą trikampį, kurio spalvos yra trys kampinės koordinatės x, y, z ir t.

Teksto rodymas

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. Kitoje eilutėje nustatoma teksto ir jo fono spalva.

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

Šis kodas nustato teksto dydį s. Pats skaičius s svyruoja nuo 1 iki 5.

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

Šis kodas rodo simbolį.

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

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

Antroji funkcija tiesiog rodo 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) ( uint16_t x1, y1; uint16_t wid;

Ši funkcija pakeičia teksto šriftą. Turėtumėte pridėti šią funkciją ir šriftų bibliotekas.

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

Dėl šios funkcijos tekstas gali išnykti. Turėtumėte pridėti jį prie savo kodo.

Ekrano pasukimas

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ą.

Ekrano slinkimas

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

Šis kodas slenka ekrane. Maxroll – maksimalus slinkties aukštis.

Nustatyti iš naujo

tft.reset();

Šis kodas iš naujo nustato ekraną.

Vienspalvių vaizdų rodymas

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

Pirmiausia turite konvertuoti vaizdą į šešioliktainį kodą. Atsisiųskite programinę įrangą iš toliau pateiktos nuorodos. Jei nenorite keisti programinės įrangos nustatymų, turite apversti vaizdo spalvą, apversti vaizdą horizontaliai (veidrodinis) ir pasukti 90 laipsnių prieš laikrodžio rodyklę.

Dabar pridėkite jį prie programinės įrangos ir konvertuokite. Atidarykite eksportuotą failą ir nukopijuokite šešioliktainį kodą į Arduino IDE. x Ir y- vaizdo vieta. sx Ir sy- vaizdo matmenys. Galite pakeisti paskutinio vaizdo spalvą įvestis.

RGB spalvoto vaizdo ekranas

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

Pirmiausia turite konvertuoti vaizdą į kodą. Norėdami konvertuoti vaizdą, naudokite šią nuorodą:

Įkelkite vaizdą ir atsisiųskite konvertuotą failą, su kuriuo gali dirbti UTFT bibliotekos. Dabar nukopijuokite šešioliktainį kodą į Arduino IDE. x ir y yra vaizdo vietos. sx ir sy – vaizdo dydis.

Galite atsisiųsti paveikslėlį į šešiakampio keitiklio programą žemiau:

Iš anksto pastatyti elementai

Šiame šablone mes tiesiog panaudojome liniją ir 8 užpildytus apskritimus, kurie eilės tvarka keičia spalvas. Norėdami nubrėžti apskritimus aplink statinį tašką, galite naudoti sin(); ir cos(); funkcijas. Turite nustatyti PI reikšmę. Norėdami pakeisti spalvas, galite naudoti funkciją spalva565(); ir pakeiskite savo 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); void setup(); (ID); tft.fillScreen(0xffff), „Įkeliama...“ , 80); col = tft.color565(255, 210, 240) ( for (int i = 8; i > 0; i--) ( tft.fillCircle(240 + 40 * (cos(-i * PI); / 4)), 120 + 40 * (sin(-i * PI / 4)), 10, col.(15 + 40 * (cos(-(i + 1)*PI); / 4)), 120 + 40 * (sin(-(i + 1)*PI / 4)), 10, col.(15 + 40 * (cos(-(i +). 2)*PI / 4)), 120 + 40 * (sin (-(i + 2)*PI / 4)), 10, col.); 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

Šiame šablone pasirinkome klasikinį šriftą ir panaudojome teksto blukimo 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(ystx infont, infont , const char *msg) ( int16_t x1, y1; uint16_t wid, ht; tft.setFont(f); tft.setCursor(x, y); tft.setTextSize(sz); tft.println(msg); ) uint8_t r = 255, g = 255, b = 255; uint16_t 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); tft.fillScreen(WHITE) bėdoje"); delay(40); tft.println("kas gali sukaupti jėgų iš nelaimės,"); delay(40); tft.println("ir būk drąsus apmąstydamas."); delay(40); tft.println(" "Šis mažų protų reikalas susitraukti,"); delsti(40); tft.println(" bet tie, kurių širdis tvirta,"); delay(40); tft.println(" ir kieno sąžinė patvirtina jų elgesį,"); delay(40); tft.println(" laikysis savo principų iki mirties."); delay(40); tft.println(" "); delay(700); for (int j = 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); }

Logotipo pristatymas/pristatymas

Šiame šablone mes konvertavome failą a.jpgį failą .c ir pridėjo jį prie kodo, parašė eilutę ir panaudojo rodomą išnykimo kodą. Tada naudojome slinkties kodą, norėdami perkelti ekraną į kairę. Įkelti 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.hnclude #include"fres. Šriftai/ FreeSerif12pt7b.h" #include "FreeDefaultFonts.h" void showmsgXY(int x, int y, int sz, const GFXfont *f, const char *msg) ( int16_t x1, y1; uint16_t wid, ht(f)setF; tftf. tft.setCursor(x, y); tft.setTextSize(sz) uint8_t r = 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); 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); }

Sklaidos sklypas

Šiame šablone naudojome piešimo linijas, užpildytus apskritimus ir linijų 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 už (int i=0; i<24; i++){ for (uint16_t a=0; a<3; a++){ tft.drawLine(avet+a, z, avet+a, z+10, 0xFB21);} // thick for (uint16_t a=0; a<2; a++){ tft.drawLine(avet-a, z, avet-a, z+10, 0xFB21);} delay(100); z=z+20; } } ////////////////////////////////////////////////////////////////// void dchart_10x10(uint16_t nx,uint16_t ny) { ave+=nx; avec++; nx=nx*32; ny=ny*48; tft.drawCircle(nx, ny, 10, 0x0517); tft.drawCircle(nx, ny, 9, 0x0517); tft.fillCircle(nx, ny, 7, 0x0517); delay (100); ox=nx; oy=ny; } /////////////////////////////////////////////////////////////////////// void dotchart_10x10(uint16_t nx,uint16_t ny) { ave+=nx; avec++; nx=nx*32; ny=ny*48; int plus=0; float fplus=0; int sign=0; int y=0,x=0; y=oy; x=ox; float xmines, ymines; xmines=nx-ox; ymines=ny-oy; if (ox>nx) (xmines=ox-nx; ž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

Šiame šablone mes naudojome nuodėmė (); Ir cos(); funkcijos, leidžiančios nubrėžti norimo storio ir skaičiaus lankus, rodomus naudojant teksto spausdinimo funkciją. Tada konvertavome vaizdą į šešioliktainį kodą ir pridėjome jį prie kodo ir parodėme vaizdą naudodami bitmap funkciją. Tada naudojome linijos piešimo funkciją, kad pakeistume vaizdo stilių. Atsisiųskite .h failą ir pridėkite jį prie Arduino eskizo 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.fillCircle (385,213,25,tft.color565(255, 0, 0)) (int p = 0; p< 4000; p++) { j = 120 * (sin(PI * p / 2000)); i = 120 * (cos(PI * p / 2000)); j2 = 110 * (sin(PI * p / 2000)); i2 = 110 * (cos(PI * p / 2000)); tft.drawLine(i2 + 160, j2 + 160, i + 160, j + 160, tft.color565(100, 100, 100)); } ///////////////////////////////////////////////////////////////////// if (b>a)(o(a Skritulinė diagrama

Šiame šablone sukūrėme funkciją, kuri paima skaičius kaip įvestį ir rodo juos kaip skritulinę diagramą. Mes tiesiog naudojame piešimo lanko ir užpildyto apskritimo 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(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)); / 2000)); / 2000)); 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)); / 2000)); / 2000)); tft.drawLine(i2 + 180, j2 + 240, i + 180, j + 240, 0x0000); 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)); PI * (c+300) / 2000)); tft.drawLine(i2 + 297, j2 + 240, i + 297, j + 240, 0x0000); tft.setTextColor(28 t 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)); sin(PI * (d+300) / 2000)); 2000)); 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" #include.0"include int b = 4000; int j, j2; int i, i2; void showmsgXY(int x, int y, int sz, const GFXfont *f, const char *msg) ( int16_t x1, y1; uint16_t wid, ht; tft.setFont(f); tft.setCursor(x, y); tft .setTextSize(sz); tft.println(msg) ( Serial.begin(9600); uint16_t ID = tft.readID(); tft.begin(ID); tft.invertDisplay(true); setRotation(1 ) void loop(void) ( tft.invertDisplay(true); tft.fillScreen(BLACK); tft.drawRGBBitmap(0, 0, test, 480, 320); if (a< b) { while (a < b) { Serial.println(a); j = 80 * (sin(PI * a / 2000)); i = 80 * (cos(PI * a / 2000)); j2 = 50 * (sin(PI * a / 2000)); i2 = 50 * (cos(PI * a / 2000)); tft.drawLine(i2 + 235, j2 + 169, i + 235, j + 169, tft.color565(0, 255, 255)); tft.fillRect(200, 153, 75, 33, 0x0000); tft.setTextSize(3); tft.setTextColor(0xffff); if ((a/20)>99) tft.setCursor(208, 160); else tft.setCursor(217, 160); tft.print(a / 20); a++; ) b = 1000; ) ///////////////////////////////////////////////// //////////////// 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 vyras

Šiame šablone paprastus vaizdus po vieną labai greitai atvaizduojame naudodami bitmap funkciją. Taigi galite sukurti savo animaciją naudodami šį triuką. Atsisiųskite .h failą ir pridėkite jį prie Arduino eskizo 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" #0x0Fonts.h #0x0BLACK #0x0BLACK define RED 0xF800 #define GREEN 0x07E0 #define CYAN 0x07FF #define MAGENTA 0xF81F #define YELLOW 0xFFE0 #define WHITE 0xFFFF #define GRAY 0x8410 #define ORANGE 0x8410 #define ORANGE 0x8410 X šriftas *f, konst char *msg) ( int16_t x1, y1; uint16_t wid, ht; tft.setFont(f); tft.setCursor(x, y); tft.setTextColor(WHITE); tft.setTextSize(sz); tft.print(msg) ) ; ) void setup() ( Serial.begin(9600); uint16_t ID = tft.readID(); tft.begin(ID); tft.setRotation(1); tft.invertDisplay(true); tft.fillScreen(tft spalva565(0,20,0)); , 180, Line1, 258, 128, WHITE);delay(60); tft.fillRect(20, 180, 258, 128, tft.color565(0,20,0)); , 258, 128, BALTAS);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, 24 eilutė, 258, 128, BALTAS);delsa (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

Šiame šablone mes tiesiog rodome kai kuriuos vaizdus naudodami funkcijas RGB bitų žemėlapis Ir bitmap. Tiesiog sukurkite jutiklinio ekrano kodą ir naudokite šį šabloną. Atsisiųskite .h failą 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; #define BLACK 0x0000 #define RED 0xF800 #define GREEN 0x07E0 #define WHITE 0xFFFF #define GRAY 0x8410 #include "images.h" #include "Fonts/FreeSans9pt7b.h" #sh1nclude s/ FreeSerif12pt7b.h" #include "FreeDefaultFonts.h" int a = 3000; int b = 4000; int j, j2; int i, i2; void showmsgXY(int x, int y, int sz, const GFXfont *f, const char *msg) ( int16_t x1, y1; uint16_t wid, ht; // tft.drawFastHLine(0, y, tft.width(), 0xffff tft.setFont(FHITE); tft.setRotation(1) void loop(void) tft.drawRGBBitmap(0, 0, test, 480, 320, Line1, 40xff, ); );//baterija tft.drawBitmap(65, 20 , Line2, 45, 45, 0xffff);//wifi tft.drawBitmap(125, 25, Line3, 45, 45, 0xffff);//mail tft.drawBitmap(1 , 25, Line4, 45, 45, 0xffff); //instagram tft.drawBitmap(245, 25, Line6, 45, 45, 0xffff);//power tft.drawBitmap(20, 260, Line5, 40x, 45 );//twitter tft.drawBitmap(410, 140 , Line7, 45, 45, 0xffff);//rain tft.setTextSize(6); tft.setTextColor(0xffff); tft.setTextSize(2); tft.setTextColor(0xffff); showmsgXY(330, 280, 1, &FreeSans12pt7b, "šeštadienis"); showmsgXY(300, 305, 1, &FreeSans12pt7b, "2018 m. spalio 6 d."); o (1); )

Apatinė eilutė

Atsisiųskite archyvą su failais .hžemiau:

  • Visų GIF failų atkūrimo greitis buvo redaguotas, kad jie būtų greitesni arba lėtesni, kad būtų lengviau suprasti. Judesių greitis priklauso nuo jūsų procesoriaus greičio arba kodo tipo, taip pat nuo kode esančių elementų dydžio ir storio.
  • Vaizdo kodą galite pridėti pagrindiniame puslapyje, tačiau jis užpildo visą puslapį. Taigi galite sukurti failą a.h ir pridėkite jį prie eskizo aplanko.
  • Šiame straipsnyje mes tiesiog pažvelgėme į elementų rodymą LCD ekrane. Stebėkite kitą mokymo programą, kad sužinotumėte, kaip naudojami jutikliniai ekranai ir SD kortelės.
  • Jei kyla problemų, įskaitant bibliotekas, pakeiskite citatos ženklą "" į<>.

Tai kol kas viskas. Pasidalykite šia Arduino TFT LCD mokymo programa su draugais ir kolegomis.

Šiuolaikiniuose įrenginiuose yra įvairių konfigūracijų ekranai. Pagrindiniai šiuo metu yra pagrįsti ekranais, tačiau jiems gali būti naudojamos skirtingos technologijos, ypač kalbame apie TFT ir IPS, kurie skiriasi daugybe parametrų, nors yra to paties išradimo palikuonys.

Šiais laikais yra daugybė terminų, žyminčių tam tikras technologijas, paslėptas po santrumpos. Pavyzdžiui, daugelis galbūt girdėjo ar skaitė apie IPS ar TFT, tačiau tik nedaugelis supranta, koks jų skirtumas. Taip yra dėl informacijos trūkumo elektronikos kataloguose. Štai kodėl verta suprasti šias sąvokas ir nuspręsti, ar TFT ar IPS yra geresni?

Terminija

Norint nustatyti, kas bus geriau ar blogiau kiekvienu konkrečiu atveju, reikia išsiaiškinti, už kokias funkcijas ir užduotis atsakingas kiekvienas IPS. Tiesą sakant, tai yra TFT, o tiksliau, jo įvairovė buvo naudojama tam tikra technologija – TN-TFT. Šias technologijas reikėtų apsvarstyti išsamiau.

Skirtumai

TFT (TN) yra vienas iš matricų, tai yra plonasluoksnių tranzistorių ekranų, gamybos būdų, kai elementai yra išdėstyti spirale tarp plokščių poros. Jei nėra įtampos, jie bus pasukti vienas į kitą stačiu kampu horizontalioje plokštumoje. Didžiausia įtampa priverčia kristalus suktis taip, kad pro juos sklindanti šviesa susidaro juodi pikseliai, o nesant įtampos – balti.

Jei atsižvelgsime į IPS arba TFT, skirtumas tarp pirmojo ir antrojo yra tas, kad matrica yra pagaminta remiantis anksčiau aprašytu pagrindu, tačiau joje esantys kristalai nėra išdėstyti spirale, o lygiagrečiai vienai plokštumai. ekrane ir vienas kitam. Skirtingai nei TFT, kristalai šiuo atveju nesisuka esant be įtampos.

Kaip mes tai matome?

Pažvelgus į IPS ar vizualiai, skirtumas tarp jų yra kontrastas, kurį užtikrina beveik tobulas juodos spalvos atkūrimas. Pirmame ekrane vaizdas bus aiškesnis. Tačiau spalvų perteikimo kokybė naudojant TN-TFT matricą negali būti vadinama gera. Šiuo atveju kiekvienas pikselis turi savo atspalvį, kuris skiriasi nuo kitų. Dėl to spalvos labai iškraipomos. Tačiau tokia matrica turi ir privalumą: ji pasižymi didžiausiu atsako greičiu tarp visų šiuo metu esamų. IPS ekranas reikalauja tam tikro laiko, per kurį visi lygiagrečiai kristalai visiškai apsisuks. Tačiau žmogaus akis vargu ar aptinka reakcijos laiko skirtumą.

Svarbios savybės

Jei kalbėsime apie tai, kas veikia geriau: IPS ar TFT, verta paminėti, kad pirmieji sunaudoja daugiau energijos. Taip yra dėl to, kad kristalams sukti reikia nemažai energijos. Štai kodėl, jei gamintojas susiduria su užduotimi, kad jų prietaisas būtų efektyvus, jis dažniausiai naudoja TN-TFT matricą.

Pasirinkus TFT arba IPS ekraną, verta atkreipti dėmesį į platesnius antrojo žiūrėjimo kampus, būtent 178 laipsnių abiejose plokštumose, tai labai patogu vartotojui. Kiti įrodė, kad negali pateikti to paties. Ir dar vienas reikšmingas skirtumas tarp šių dviejų technologijų – jomis pagrįstų gaminių kaina. TFT matricos šiuo metu yra pigiausias sprendimas, kuris naudojamas daugumoje biudžetinių modelių, o IPS priklauso aukštesniam lygiui, tačiau tai taip pat nėra aukščiausios klasės.

Rinktis IPS arba TFT ekraną?

Pirmoji technologija leidžia gauti aukščiausios kokybės, ryškiausią vaizdą, tačiau reikia daugiau laiko sukti naudojamus kristalus. Tai turi įtakos reakcijos laikui ir kitiems parametrams, ypač akumuliatoriaus išsikrovimo greičiui. TN matricų spalvų perteikimo lygis yra daug žemesnis, tačiau jų reakcijos laikas yra minimalus. Kristalai čia išsidėstę spirale.

Tiesą sakant, galima nesunkiai pastebėti neįtikėtiną šių dviejų technologijų pagrindu sukurtų ekranų kokybės atotrūkį. Tai taip pat taikoma sąnaudoms. TN technologija išlieka rinkoje tik dėl kainos, tačiau ji negali pateikti sodraus ir ryškaus vaizdo.

IPS yra labai sėkmingas TFT ekranų kūrimo tęsinys. Didelis kontrasto lygis ir gana dideli žiūrėjimo kampai yra papildomi šios technologijos pranašumai. Pavyzdžiui, TN pagrindu veikiančiuose monitoriuose kartais pati juoda spalva pakeičia savo atspalvį. Tačiau didelės IPS pagrįstų įrenginių energijos sąnaudos verčia daugelį gamintojų griebtis alternatyvių technologijų arba sumažinti šį skaičių. Dažniausiai tokio tipo matricos randamos laidiniuose monitoriuose, kurie neveikia iš baterijos, o tai leidžia įrenginiui nebūti tiek priklausomam nuo energijos. Tačiau pokyčiai šioje srityje nuolat vyksta.

Santrumpos dažniausiai naudojamos charakteristikoms ar specifikai nurodyti. Šiuo atveju kyla baisi painiava dėl IPS ir TFT ekranų palyginimo, nes IPS technologija (matrica) yra TFT matricos tipas ir nieko daugiau. Neįmanoma palyginti šių 2 technologijų viena su kita.

BET! Yra TN-TFT technologija - galite pasirinkti ir palyginti ją su IPS. Todėl kalbėdami apie tai, kuris ekranas geresnis: IPS ar TFT, turime omenyje bet kokiu atveju TFT ekranus, tačiau pagamintus skirtingų technologijų pagrindu: TN ir IPS.

Trumpai apie TN-TFT ir IPS

TN-TFT yra technologija, pagal kurią gaminama LCD ekrano matrica. Čia kristalai, kai į jų ląsteles neduodama jokios įtampos, „žiūri“ vienas į kitą 90 laipsnių kampu. Jie išsidėstę spirale, o įjungus įtampą, sukasi taip, kad susidarytų norima spalva.

IPS – ši technologija skiriasi tuo, kad čia kristalai išsidėstę lygiagrečiai vienas kitam vienoje ekrano plokštumoje (pirmuoju atveju spirale). Visa tai sudėtinga... praktiškai TN ir IPS ekranai skiriasi tuo, kad IPS puikiai atvaizduoja juodą spalvą, todėl vaizdai yra ryškesni ir sodresni.

Kalbant apie TN-TFT, šios matricos spalvų perteikimo kokybė nekelia pasitikėjimo. Čia kiekvienas pikselis gali turėti savo atspalvį, todėl spalvos yra iškraipytos. IPS matricos daug geriau parodo vaizdą ir atidžiau elgiasi su spalvomis. IPS taip pat leidžia dideliu kampu stebėti, kas vyksta ekrane. Jei žiūrėsite į TN-TFT ekraną tuo pačiu kampu, spalvos bus taip iškraipytos, kad bus sunku atskirti vaizdą.

TN privalumai

Tačiau TN-TFT matricos turi savų privalumų. Pagrindinis yra mažesnis pikselių atsako greitis. IPS reikia daugiau laiko pasukti visą lygiagrečių kristalų masyvą norimu kampu. Todėl jei kalbame apie monitoriaus pasirinkimą žaidimams ar dinamiškoms scenoms rodyti, kai piešimo greitis yra labai svarbus, tuomet geriausia rinktis ekranus pagal TN-TFT technologiją.

Kita vertus, normaliai dirbant su kompiuteriu neįmanoma pastebėti pikselių reakcijos laiko skirtumo. Tai matoma tik žiūrint dinamines scenas, kas dažnai nutinka veiksmo filmuose ir vaizdo žaidimuose.

Kitas pliusas yra mažas energijos suvartojimas. IPS matricos sunaudoja daug energijos, nes Norint pasukti kristalų masyvą, jiems reikia daug įtampos. Todėl TFT pagrįsti ekranai geriau tinka mobiliesiems įtaisams, kur akumuliatoriaus energijos taupymo klausimas yra neatidėliotinas.

Ir dar vienas dalykas – TN-TFT matricos pigios. Šiandien negalite rasti monitoriaus (neskaičiuojant naudotų ar CRT modelių), kuris būtų pigesnis nei modelis, pagrįstas TN technologija. Bet koks biudžetinis elektronikos įrenginys su ekranu tikrai naudos TN-TFT matricą.

Taigi, kuris ekranas yra geresnis:TFT arbaIPS:

  1. IPS mažiau reaguoja dėl ilgesnio atsako laiko (blogai žaidžiant žaidimus ir veiksmo scenas);
  2. IPS garantuoja beveik tobulą spalvų atkūrimą ir kontrastą;
  3. IPS turi platesnį žiūrėjimo kampą;
  4. IPS yra alkani energijos ir sunaudoja daugiau elektros energijos;
  5. Jie taip pat yra brangesni, o TN-TFT yra pigūs.

Iš principo tai ir 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 geresni.


Įvertinkite straipsnį:

Technologijos nestovi vietoje, o skystųjų kristalų ekranų gamyba nėra išimtis. Tačiau dėl nuolatinio tobulėjimo ir naujų technologijų išleidimo ekranų gamyboje, taip pat dėl ​​specialių rinkodaros požiūrių į reklamą daugeliui pirkėjų renkantis monitorių ar televizorių gali kilti klausimas, kuris yra geresnis IPS ar TFT ekranas?

Norėdami atsakyti į pateiktą klausimą, turite suprasti, kas yra IPS technologija ir kas yra TFT ekranas. Tik tai žinodami galėsite suprasti šių technologijų skirtumą. Tai savo ruožtu padės teisingai pasirinkti ekraną, kuris visiškai atitiks jūsų reikalavimus.

1. Taigi, kas yra TFT ekranas?

Kaip jau spėjote, TFT yra sutrumpintas technologijos pavadinimas. Tai visiškai atrodo taip - Thin Film Transistor, kuris išvertus į rusų kalbą reiškia plonasluoksnį tranzistorių. Iš esmės TFT ekranas yra skystųjų kristalų ekrano tipas, pagrįstas aktyvia matrica. Kitaip tariant, tai įprastas aktyviosios matricos LCD ekranas. Tai yra, skystųjų kristalų molekulės valdomos naudojant specialius plonasluoksnius tranzistorius.

2. Kas yra IPS technologija

IPS taip pat yra „In-Plane Switching“ trumpinys. Tai aktyvios matricos LCD ekrano tipas. Tai reiškia, kad klausimas, kuris yra geresnis TFT ar IPS, yra klaidingas, nes jie iš esmės yra tas pats dalykas. Tiksliau, IPS yra FTF ekrano matricos tipas.

IPS technologija gavo savo pavadinimą dėl unikalaus elektrodų išdėstymo, kurie yra vienoje plokštumoje su skystųjų kristalų molekulėmis. Savo ruožtu skystieji kristalai yra lygiagrečiai ekrano plokštumai. Šis sprendimas leido žymiai padidinti žiūrėjimo kampus, taip pat padidinti vaizdo ryškumą ir kontrastą.

Šiandien yra trys labiausiai paplitę aktyviosios matricos TFT ekranų tipai:

  • TN+Plėvelė;
  • PVA/MVA.

Taigi tampa akivaizdu, kad skirtumas tarp TFT ir IPS yra tik tas, kad TFT yra skystųjų kristalų ekrano tipas su aktyvia matrica, o IPS yra ta pati aktyvioji matrica TFT ekrane, tiksliau vienas iš matricos tipų. Verta paminėti, kad ši matrica yra labiausiai paplitusi tarp vartotojų visame pasaulyje.

3. Kuo skiriasi TFT ir IPS ekranai: Vaizdo įrašas

Paplitusi klaidinga nuomonė, kad tarp TFT ir IPS yra koks nors skirtumas, atsirado dėl pardavimų vadybininkų rinkodaros triukų. Siekdami pritraukti naujų klientų, rinkodaros specialistai neskleidžia pilnos informacijos apie technologijas, o tai leidžia sukurti iliuziją, kad į pasaulį ateina visiškai nauja plėtra. Žinoma, IPS yra naujesnė plėtra nei TN, bet jūs negalite pasirinkti, kuris TFT ar IPS ekranas yra geresnis dėl aukščiau nurodytų priežasčių.

Renkantis monitorių, daugelis vartotojų susiduria su klausimu: kas geriau PLS ar IPS.

Šios dvi technologijos egzistuoja gana ilgą laiką ir abi puikiai pasirodo.

Pažvelgus į įvairius straipsnius internete, jie arba rašo, kad kiekvienas turi pats nuspręsti, kas geriau, arba iš viso neatsako į užduotą klausimą.

Tiesą sakant, šie straipsniai neturi prasmės. Juk jie niekaip nepadeda vartotojams.

Todėl išanalizuosime, kokiais atvejais geriau rinktis PLS ar IPS ir duosime patarimų, kurie padės teisingai pasirinkti. Pradėkime nuo teorijos.

Kas yra IPS

Iš karto verta pasakyti, kad šiuo metu technologijų rinkoje pirmauja dvi svarstomos galimybės.

Ir ne kiekvienas specialistas galės pasakyti, kuri technologija yra geresnė ir kokių privalumų turi kiekviena iš jų.

Taigi pats žodis IPS reiškia „In-Plane-Switching“ (pažodžiui „perjungimas vietoje“).

Ši santrumpa taip pat reiškia Super Fine TFT ("super plonas TFT"). TFT, savo ruožtu, reiškia Thin Film Transistor.

Paprasčiau tariant, TFT yra vaizdų rodymo kompiuteryje technologija, pagrįsta aktyvia matrica.

Pakankamai sunku.

Nieko. Išsiaiškinkime tai dabar!

Taigi TFT technologijoje skystųjų kristalų molekulės valdomos naudojant plonasluoksnius tranzistorius, tai reiškia „aktyviąją matricą“.

IPS lygiai toks pat, tik monitoriuose su šia technologija elektrodai yra toje pačioje plokštumoje su skystųjų kristalų molekulėmis, kurios yra lygiagrečios plokštumai.

Visa tai aiškiai matyti 1 paveiksle. Tiesą sakant, ten rodomi abiejų technologijų ekranai.

Pirmiausia yra vertikalus filtras, tada skaidrūs elektrodai, po jų skystųjų kristalų molekulės (mėlynos lazdelės, jos mus labiausiai domina), tada horizontalus filtras, spalvų filtras ir pats ekranas.

Ryžiai. Nr. 1. TFT ir IPS ekranai

Vienintelis skirtumas tarp šių technologijų yra tas, kad LC molekulės TFT yra ne lygiagrečiai, o IPS jos yra lygiagrečiai.

Dėl to jie gali greitai pakeisti žiūrėjimo kampą (konkrečiai, čia jis yra 178 laipsniai) ir pateikti geresnį vaizdą (IPS).

O taip pat dėl ​​šio sprendimo gerokai padidėjo vaizdo ekrane ryškumas ir kontrastas.

Dabar aišku?

Jei ne, rašykite savo klausimus komentaruose. Į juos tikrai atsakysime.

IPS technologija buvo sukurta 1996 m. Tarp jo privalumų verta paminėti vadinamojo „jaudulio“ nebuvimą, tai yra, neteisingą reakciją į prisilietimą.

Jis taip pat pasižymi puikiu spalvų perteikimu. Gana daug kompanijų gamina monitorius naudodami šią technologiją, įskaitant NEC, Dell, Chimei ir net.

Kas yra PLS

Labai ilgą laiką gamintojas nieko nesakė apie savo intelektą, o daugelis ekspertų pateikė įvairių prielaidų dėl PLS savybių.

Tiesą sakant, net ir dabar ši technologija yra apgaubta daugybe paslapčių. Bet mes vis tiek rasime tiesą!

PLS buvo išleistas 2010 m. kaip alternatyva anksčiau minėtam IPS.

Ši santrumpa reiškia „Plane To Line Switching“ (tai yra „perjungimas tarp eilučių“).

Prisiminkime, kad IPS yra perjungimas plokštumoje, tai yra „perjungimas tarp linijų“. Tai reiškia perjungimą plokštumoje.

Ir aukščiau sakėme, kad naudojant šią technologiją skystųjų kristalų molekulės greitai tampa plokščios ir dėl to pasiekiamas geresnis žiūrėjimo kampas ir kitos charakteristikos.

Taigi, PLS viskas vyksta lygiai taip pat, bet greičiau. 2 paveiksle visa tai aiškiai parodyta.

Ryžiai. Nr. 2. Veikia PLS ir IPS

Šiame paveikslėlyje viršuje yra pats ekranas, tada kristalai, tai yra tos pačios skystųjų kristalų molekulės, kurios buvo pažymėtos mėlynomis lazdelėmis paveikslėlyje Nr.

Elektrodas parodytas žemiau. Abiem atvejais jų vieta rodoma kairėje išjungtoje būsenoje (kai kristalai nejuda), o dešinėje - kai jie įjungti.

Veikimo principas yra tas pats - kai kristalai pradeda veikti, jie pradeda judėti, o iš pradžių yra lygiagrečiai vienas kitam.

Bet, kaip matome paveikslėlyje Nr.2, šie kristalai greitai įgauna norimą formą – tokią, kuri reikalinga maksimaliai.

Per tam tikrą laiką IPS monitoriaus molekulės netampa statmenos, o PLS – statmenos.

Tai yra, abiejose technologijose viskas yra taip pat, bet PLS viskas vyksta greičiau.

Taigi tarpinė išvada – PLS veikia greičiau ir teoriškai ši konkreti technologija galėtų būti laikoma geriausia mūsų palyginime.

Tačiau dar anksti daryti galutines išvadas.

Tai įdomu: „Samsung“ prieš keletą metų pateikė ieškinį LG. Ji teigė, kad LG naudojama AH-IPS technologija yra PLS technologijos modifikacija. Iš to galime daryti išvadą, kad PLS yra IPS tipas, ir pats kūrėjas tai pripažino. Tiesą sakant, tai pasitvirtino ir esame šiek tiek aukščiau.

Kuris geresnis PLS ar IPS? Kaip išsirinkti gerą ekraną – vadovas

O jei aš nieko nesuprantu?

Tokiu atveju jums padės šio straipsnio pabaigoje esantis vaizdo įrašas. Tai aiškiai rodo TFT ir IPS monitorių skerspjūvį.

Galėsite pamatyti kaip viskas veikia ir suprasti, kad PLS viskas vyksta lygiai taip pat, bet greičiau nei IPS.

Dabar galime pereiti prie tolesnio technologijų palyginimo.

Ekspertų nuomonės

Kai kuriose svetainėse galite rasti informacijos apie nepriklausomą PLS ir IPS tyrimą.

Ekspertai šias technologijas palygino po mikroskopu. Rašoma, kad galų gale jie nerado jokių skirtumų.

Kiti ekspertai rašo, kad visgi geriau pirkti PLS, bet nelabai paaiškina kodėl.

Tarp visų ekspertų teiginių yra keletas pagrindinių dalykų, kuriuos galima pastebėti beveik visose nuomonėse.

Šie punktai yra tokie:

  • Monitoriai su PLS matricomis yra brangiausi rinkoje. Pigiausias variantas yra TN, tačiau tokie monitoriai visais atžvilgiais nusileidžia tiek IPS, tiek PLS. Taigi, dauguma ekspertų sutinka, kad tai labai pateisinama, nes vaizdas geriau atvaizduojamas PLS;
  • Monitoriai su PLS matrica geriausiai tinka įvairioms projektavimo ir inžinerinėms užduotims atlikti. Ši technika puikiai susidoros ir su profesionalių fotografų darbu. Vėlgi, iš to galime daryti išvadą, kad PLS geriau perteikia spalvas ir užtikrina pakankamą vaizdo aiškumą;
  • Pasak ekspertų, PLS monitoriai praktiškai neturi problemų, tokių kaip akinimas ir mirgėjimas. Jie padarė tokią išvadą testuodami;
  • Oftalmologai teigia, kad PLS daug geriau suvoks akys. Be to, jūsų akims bus daug lengviau visą dieną žiūrėti į PLS nei į IPS.

Apskritai iš viso to vėl darome tą pačią išvadą, kurią jau padarėme anksčiau. PLS yra šiek tiek geresnis nei IPS. Ir šią nuomonę patvirtina dauguma ekspertų.

Kuris geresnis PLS ar IPS? Kaip išsirinkti gerą ekraną – vadovas

Kuris geresnis PLS ar IPS? Kaip išsirinkti gerą ekraną – vadovas

Mūsų palyginimas

Dabar pereikime prie galutinio palyginimo, kuris atsakys į pačioje pradžioje užduotą klausimą.

Tie patys ekspertai nustato daugybę savybių, pagal kurias reikia palyginti skirtingas.

Kalbame apie tokius rodiklius kaip jautrumas šviesai, reakcijos greitis (tai reiškia perėjimą iš pilkos į pilką), kokybę (pikselių tankį neprarandant kitų savybių) ir sodrumą.

Jas naudosime vertindami dvi technologijas.

1 lentelė. IPS ir PLS palyginimas pagal kai kurias charakteristikas

Kitos savybės, įskaitant turtingumą ir kokybę, yra subjektyvios ir skiriasi nuo žmogaus iki žmogaus.

Tačiau iš aukščiau pateiktų rodiklių aišku, kad PLS charakteristikos yra šiek tiek aukštesnės.

Taigi dar kartą patvirtiname išvadą, kad ši technologija veikia geriau nei IPS.

Ryžiai. Nr. 3. Pirmasis monitorių palyginimas su IPS ir PLS matricomis.

Yra vienas "populiarus" kriterijus, leidžiantis tiksliai nustatyti, kuris yra geresnis - PLS ar IPS.

Šis kriterijus vadinamas „iš akies“. Praktiškai tai reiškia, kad tereikia pažvelgti į du gretimus monitorius ir vizualiai nustatyti, kur vaizdas yra geresnis.

Todėl pateiksime kelis panašius vaizdus, ​​ir kiekvienas galės pats įsitikinti, kur vaizdas vizualiai atrodo geriau.

Ryžiai. Nr. 4. Antrasis monitorių palyginimas su IPS ir PLS matricomis.

Ryžiai. Nr. 5. Trečiasis monitorių su IPS ir PLS matricomis palyginimas.

Ryžiai. Nr. 6. Ketvirtasis monitorių su IPS ir PLS matricomis palyginimas.

Ryžiai. Nr.7. Penktas monitorių palyginimas su IPS (kairėje) ir PLS (dešinėje) matricomis.

Vizualiai aišku, kad visuose PLS pavyzdžiuose vaizdas atrodo daug geriau, sodresnis, ryškesnis ir pan.

Aukščiau minėjome, kad TN šiandien yra pati nebrangiausia technologija, todėl ją naudojantys monitoriai taip pat kainuoja pigiau nei kiti.

Po jų į kainą ateina IPS, o paskui PLS. Tačiau, kaip matome, visa tai nieko nestebina, nes vaizdas tikrai atrodo daug geriau.

Kitos charakteristikos šiuo atveju taip pat yra aukštesnės. Daugelis ekspertų pataria pirkti su PLS matricomis ir Full HD raiška.

Tada vaizdas tikrai atrodys tiesiog puikus!

Neįmanoma tiksliai pasakyti, ar šis derinys yra geriausias šiandieninėje rinkoje, tačiau jis tikrai vienas geriausių.

Beje, palyginimui galite pamatyti, kaip IPS ir TN atrodo aštriu žiūrėjimo kampu.

Ryžiai. Nr. 8. Monitorių su IPS (kairėje) ir TN (dešinėje) matricomis palyginimas.

Verta pasakyti, kad „Samsung“ iš karto sukūrė dvi technologijas, kurios yra naudojamos monitoriuose ir / ir sugebėjo žymiai pranokti IPS.

Kalbame apie Super AMOLED ekranus, kurie yra šios įmonės mobiliuosiuose įrenginiuose.

Įdomu tai, kad Super AMOLED skiriamoji geba paprastai yra mažesnė nei IPS, tačiau vaizdas yra sodresnis ir ryškesnis.

Tačiau PLS atveju tai yra beveik viskas, kas gali būti, įskaitant skiriamąją gebą.

Galima daryti bendrą išvadą, kad PLS yra geresnis už IPS.

Be kitų dalykų, PLS turi šiuos privalumus:

  • galimybė perteikti labai platų atspalvių spektrą (be pagrindinių spalvų);
  • galimybė palaikyti visą sRGB diapazoną;
  • mažesnės energijos sąnaudos;
  • matymo kampai leidžia keliems žmonėms patogiai matyti vaizdą vienu metu;
  • visi iškraipymai yra visiškai atmesti.

Apskritai IPS monitoriai puikiai tinka įprastoms namų užduotims spręsti, pavyzdžiui, žiūrėti filmus ir dirbti su biuro programomis.

Bet jei norite pamatyti tikrai sodrų ir kokybišką vaizdą, pirkite įrangą su PLS.

Tai ypač aktualu, kai reikia dirbti su projektavimo/projektavimo programomis.

Žinoma, jų kaina bus didesnė, bet verta!

Kuris geresnis PLS ar IPS? Kaip išsirinkti gerą ekraną – vadovas

Kas yra amoled, super amoled, LCD, Tft, Tft ips? Tu nežinai? Žiūrėk!

Taip pat rekomenduojame

Įkeliama...Įkeliama...