Lo que significa pantalla tft. También pantalla TFT en teléfonos inteligentes

Balcones y logias
26.08.2020

indicaciones:

Yuriy Oleksandrovich Peisakhovich:
Doctor, en mi opinión, un no humano. Más hermosa Los monitores EPT seguirán cuidando la imagen, pero no todos y solo si están correctamente ajustados. Y con los de cristal duro, en primer lugar, hay una molestia con el permiso de la pantalla, un poco de hedor normalmente se muestra solo con la tolerancia de 1152x1024 puntos, en los modos inferiores el brillo es visible, luego hay un poco menos El color, y lo mismo, por tener píxeles cuadrados, en la vista de los redondos del EPT, para producir ojos agudos, que están constantemente ocupados por la aproximación de curvas de laman, que se pliegan todas. Además de los monitores de cristal, en la vista de los monitores ELT, aunque hay una falta de gradación de contraste, es posible producir hasta una pérdida de elementos de imagen (por ejemplo, los botones de las ventanas no se pueden ver por los visibles). Por eso todos los que se ocupan profesionalmente de los gráficos no recurren a los monitores de cristal sólido. Permítanme contarles sobre el hecho de que los monitores EPT vipprominuyut, desde el punto de vista de la República de Kazajstán, eran más probables a mediados de los 90 y, al mismo tiempo, los estándares TCO 03 y 05 no permitían ningún tipo de frontal manchado. viprominuvannya. Es obvio, navegar por el medio de uno de los monitores virobnik para crear absolutamente riznі para yakіstu. Por ejemplo, LG es desde el nombre del LG775FT que no cumple con el LG F720P bastante decente. Eso, a mi modo de ver, siempre y cuando no existan alternativas a un buen monitor EPT, con el establecimiento de una permisividad que sea cómoda para la vista y la máxima frecuencia posible de actualización.

TU-154:
Los monitores TFT y LCD son lo mismo. Un poco de sentido les llega solo por una buena razón: tales monitores CRT se inyectan en la pantalla no más, no más que TFT, pero por la calidad y las características de la imagen, es posible usar TFT (poky) . Si desea un monitor que tenga 10 años, entonces es sensato, ...

Shurovik:
Aproximadamente, TFT y LCD son lo mismo. Ale LCD es un tipo de monitor (Liquid Crystal Display - pantalla de cristal líquido), y TFT es un tipo de matriz, que es una forma de imagen (Thin Film Transistor - transistor de película delgada). Los monitores con tipo de matriz TFT se denominan "monitores de matriz activa". Її especialidad: la imagen no implica ni mucho menos la gran mirada de kuti a su alrededor. Ale "monitor plano" no es necesariamente LCD. Monitores Vzhe є zvychaynі (CRT, Cathode Ray Tube - EPT, tubo de intercambio electrónico) con pantalla plana.

Hacia adelante:
TFT es el tipo más popular, más precisamente, la tecnología de monitores LCD.

Alexeyslav:
Dr. Breshe es más hermoso que el monitor TFT. Y no es posible sentar el monitor, pero la forma en que sale victorioso, cuando llega el momento, es práctico mirar un mismo punto desde la misma posición. Monitor TFT Puedes lucir más bella en el otoño como si pudieras crecer fuera de la distancia de tus ojos, entonces ni siquiera puedes poner un EPT voluminoso para llegar lejos de tus ojos, el eje e ir mientras te sientas. es prácticamente a quemarropa y te sientas. Recuerda, es óptimo ir a la superficie de la pantalla desde el punto de vista de la ergonomía - en el dorso de una mano nudosa, pero es una pena no hacerlo manualmente (es prácticamente imposible hacerlo manualmente). Primero, puede usar fácilmente una fuente grande para leerlo fácilmente sin forzar la vista.

Pumba:
TFT y LCD cuando se dan sinónimos. Y el eje de la legibilidad de la imagen y la visibilidad es excelente para el pase de monitores RK y no está conectado con el EPT. Así que hay algo de parecido en lo que puede ser madre.

Faja:
Todas las tecnologías de costo, TFT y LCD son aún más débiles y no ven las características silenciosas que pueden usar los monitores EPT. Además de TFT y LCD, ya que el hedor ahorra energía, ocupa poco tiempo y no demasiado tiempo para los ojos. En el hedor inshomu, se aceptan monitores EPT.

Antonio:
Si no usa monitores, entonces no quiere hablar de eso en absoluto, el LSD de TFT parece mirar a su alrededor, de modo que (para aquellos que están dotados) como si los monitores no piensen en eso. Image viglyad p_d BE-YAKY KUTOM.

SpectreLX:
No tengo LCD, puedo decir que es posible usarlo de tal manera que no es posible perder el ojo y sobre todo no perder la imagen en la imagen.

Nik:
Poniendo TFT - farbi vidminnі, voy al monitor zbіlshilasya, lo pongo más hermoso para los ojos.

Sasha .:
Skoda aquí fechas tontas ... La información de Bagato está obsoleta durante una hora. Los monitores LCD son fáciles de controlar.

Itfm:
La explicación muy objetiva dada por Shurovik, y me gustaría alimentar: ¿es más hermosa, TFT o LSD?

Yaroslav:
Creo que vale la pena leerlo al leer o escribir texto. Ojos en el mismo momento vtomlyuyutsya! Traté de usar pantallas TFT y EPT; sin embargo, me cansé. Pueden verse en TFT a través del contraste de monitores. ¡Likar no es muy adecuado para ser construido!

El precio de la comida del archivo. El suplemento de vistas está habilitado.

Hay muchos tipos de pantallas TFT LCD con Arduino, se pueden arreglar con comandos básicos y terminar con un diseño profesional.

Puede ver cómo la TFT LCD gana con las placas Arduino. Intentaremos santificar los equipos base, así como informar sobre el diseño profesional y la tecnología. Para los planes, el campo de la estadística se puede encontrar:

  • vivoditi textos, símbolos y números en la fuente requerida;
  • maluvati figuri, taki yak kolo, triciclo, cuadrado, etc.;
  • visualización de imágenes .bmp en pantallas;
  • cambiar los parámetros de la pantalla, como envolver e invertir el color;
  • Muestra la animación detrás del complemento Arduino.

de Vіkіpedії: Una pantalla de cristal sólido con una matriz activa (TFT LCD, transistor de película delgada en inglés - transistor de película delgada) es un tipo de pantalla de cristal sólido, en la que una matriz activa está activa, queerovada con película delgada. transistores.

En proyectos de electrónica, es aún más importante configurar la interfaz entre el sistema y el sistema. Toda la interfaz se puede abrir mostrando los tributos, los menús y la facilidad de acceso. diseño de guarnición no menos importante.

Para un conjunto completo de componentes. LED, módulos de 7 segmentos, pantallas gráficas y pantallas TFT a color. El componente adecuado para sus proyectos es establecer una serie de donaciones, que parecen ser un tipo de interacción con un procesador y una multiplicidad de procesadores.

TFT LCD es una variante de una pantalla de cristal sólido (LCD), un tipo de tecnología de transistor de película delgada (TFT) para mejorar la calidad de la imagen, como la direccionabilidad y el contraste. TFT LCD є pantallas LCD de matriz activa, en la vista de pantallas RK de matriz pasiva o pantallas RK simples con control directo desde los segmentos decilcom.

Los proyectos de Arduino tienen una frecuencia de procesador baja. En tal rango, es imposible imaginar una imagen plegable de alta disponibilidad y alto vuelo. Además, las pantallas TFT en color solo se pueden utilizar para mostrar comandos simples.

En el transcurso de la estadística se presentaron bibliotecas y tecnología avanzada para la visualización de datos, gráficos, menús, etc. con diseño profesional. Si su proyecto es de tal rango, será genial.

¿Qué tamaño? ¿Controlador de Yaky?

El tamaño de las pantallas inyectadas en los parámetros de su proyecto. Una gran pantalla nunca es más brillante. Si desea mostrar los símbolos e imágenes de una gran variedad de edificios, es culpable de hacer vibrar el gran tamaño de la pantalla con una gran variedad de edificios. Si cambia la velocidad de su procesamiento, puede obtener más dinero y también puede obtener más velocidad para el lanzamiento.

De la misma, en primer lugar, es culpa de la reconversión de la respuesta, la flexibilidad del ruch, los detalles del color y el tamaño de la imagen, el texto y los números. Los tamaños de pantalla de Arduino más populares, como:

  • 3,5 "pulgadas 480 × 320,
  • 2.8 "pulgadas 400 × 240,
  • 2,4 "pulgadas 320 × 240,
  • 1.8 "pulgadas 220 × 176.

Habiendo vibrado la pantalla correcta, ha llegado la hora de vibrar con el controlador correcto. Si desea mostrar símbolos, textos, números e imágenes estáticas y las imágenes no son importantes, pague por el Arduino Atmega328 (como) є con la selección correcta.

Siempre que su código sea excelente, UNO puede parecer un error. Puede sustituirlo victorioso. Si desea mostrar una imagen en un edificio de alta calidad y una arquitectura de alta calidad, es culpable de los módulos ARM de arduino, como el Arduino DUE.

Controladores y bibliotecas

En el controlador de pantalla electrónico / propiedad de la computadora, el controlador está diseñado para parecerse a un circuito integrado de microinterfaz (o, alternativamente, a un microcontrolador, para ser almacenado en lógica discreta y otros componentes), tipo específico de accesorio de pantalla, por ejemplo LCD, LED, OLED, ePaper, CRT, Nixie, etc.

El controlador de pantalla acepta el comando y los datos de la configuración de la señal serial universal estándar paralela a la interfaz, como TTL, CMOS, RS232, SPI, I2C, etc. y la generación de señales a partir de la fuerza de visualización, rasgueo, hora y demultiplexación, para realizar en la pantalla la imagen requerida para el texto o la imagen.

Wirobniki de pantallas LCD vicoristovuyt rіznі drivers en sus productos. Los de ellos son más populares, pero los de ellos no están disponibles. Es fácil iniciar su pantalla, asegúrese de usar las bibliotecas LCD de Arduino y agréguelas a su código. En algunos casos, el lanzamiento de la pantalla también se puede acelerar. En Internet, hay muchas bibliotecas independientes, pero un punto importante en las bibliotecas es la confusión con el controlador LCD. El controlador de su pantalla RK es culpable de ser su bіblіotetsі. Tenemos las estadísticas de la biblioteca Adafruit GFX y la biblioteca MCUFRIEND KBV y el código. Podrás asegurarlos según tus seguidores.

Descomprima MCUFRIEND KBV y abra MCUFRIEND_kbv.CPP. Descargue la lista de controladores que se pueden utilizar con la biblioteca MCUFRIEND.

Abra la carpeta con colillas (Inglés - Ejemplo). Si lo ha aplicado al código, puede ejecutarlo en Arduino. Encienda la pantalla RK e invierta los botones.

lista de accesorios

Para la implementación de los proyectos de equipajes conectados con el TFT LCD, conoceremos un conjunto de componentes que ya se han comentado:

  • Pantalla TFT a color de 3,5 pulgadas ElectroPeak × 1
  • Pantalla TFT LCD ElectroPeak de 2,4 pulgadas × 1
  • Arduino UNO R3 × 1
  • Arduino Mega 2560 × 1
  • Arduino DUE × 1

Programa seguro

También para robots con Arduino, lo necesitamos.

código

Asegúrese de agregar la biblioteca y luego agregue el código. Tan pronto como inicie la placa Arduino, no se sienta abrumado. Solo eventos desagradables vikonayte:

  • Vaya a nuestro sitio o al sitio www.arduino.cc/en/Main/Software y agregue programáticamente seguro para su sistema operativo. Instale el software según las instrucciones.
  • Inicie en el medio del cuadro de Arduino, borre el editor de texto y copie el código en el editor de texto.
  • Vaya a la lista e incluya bibliotecas. Regala una biblioteca ZIP y regala una biblioteca.
  • Haga vibrar la placa en "Herramientas y placas", haga vibrar su placa Arduino.
  • Conecte el Arduino a la computadora y coloque el puerto COM en "Herramientas y puerto".
  • Presione el botón "Registrarse" (flecha).
  • ¡Ahora todo está arreglado!

Escribiré el extremo del código durante una hora para aprender a mostrar la imagen en la pantalla RK.

Biblioteca

#incluir "Adafruit_GFX.h" #incluir "MCUFRIEND_kbv.h"

La primera fila tiene una biblioteca gráfica básica para pantallas (escrita por Adafruit).

Un amigo agregará a la biblioteca, agregaré los controladores de pantalla MCUFRIEND Arduino.

#include "TouchScreen.h" // solo si desea levantar la pantalla táctil #include "bitmap_mono.h" // si desea mostrar el mapa de bits de la biblioteca #include "bitmap_RGB.h" // si lo desea para mostrar la imagen #include "Fonts / FreeSans9pt7b.h" // si necesita algunas fuentes #include "Fonts / FreeSans12pt7b.h" // si necesita algunas fuentes #include "Fonts / FreeSerif12pt7b.h" // si necesita algunas fuentes "FreeDefaultFonts.h" // si necesita algunas fuentes #incluya "SPI.h" // visualización de tarjeta sd para visualización de mapa de bits #incluya "SD.h"

No se necesitan todas las bibliotecas a la vez, pero puede agregarlas.

Comandos principales

Klas i ob'єkt

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

Una serie de filas para robar los objetos TFT con la clase MCUFRIEND_kbv y evitará llamadas SPI desde la pantalla RC y Arduino.

Iniciar la pantalla LCD

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

función tft.readID Leer el ID de la pantalla y colocarlo en la ventana del identificador. función poti tft.begin Apagaremos el identificador y la pantalla LCD lista para robot.

Expansión a la pantalla

tft.width (); // int16_t ancho (vacío); tft.height (); // int16_t altura (vacío);

Para una variedad de dos funciones, puede consultar el marcador de pantalla. Simplemente agregue іх al código y coloque el contenido en zminnu uint16_t... Entonces léelo desde el último puerto. Serial.println ();... dame una pizca Serial.begin (9600); v configuración ().

pantalla a color

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

función fillScreen cambiar el color a la pantalla en color t... El precio es correcto, pero es de 16 bits. UTFT.

#define NEGRO 0x0000 #define NAVY 0x000F #define verde oscuro 0x03E0 #define Darkcyan 0x03EF #define MARRÓN 0x7800 #define PURPLE 0x780F #define OLIVA 0x7BE0 #define lightgrey 0xC618 #define darkgrey 0x7BEF #define BLUE 0x001F #define GREEN 0x07E0 #define CYAN 0x07FF #define ROJO 0xF800 #define MAGENTA 0xF81F #define AMARILLO 0xFFE0 #define WHITE 0xFFFF #define NARANJA 0xFD20 #define GREENYELLOW 0xAFE5 #define ROSA 0xF81F

Puede agregar varias filas a la oreja con su código y simplemente elegir el color en las funciones.

Zapovnennya Pikel

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)

función drawPixel Almacenaré un píxel en x і y detrás del color t.

función readPixel Leyendo el color del píxel en el movimiento de roseta x і y.

pintando la linea

tft.drawFastVLine (x, y, h, t); // dibujarFastVLine (int16_t x, int16_t y, int16_t h, uint16_t t) tft.drawFastHLine (x, y, w, t); // dibujarFastHLine (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)

función drawFastVLine una pequeña línea vertical, para el arrepentimiento por rosetting x, y, її dovzhina - h pikselіv, y color - t.

función drawFastHLine una pequeña línea horizontal, ya que debe repararse de la roseta xey, mientras que el color es t.

función Dibujar linea fila pequeña, cómo obedecer de xi, yi і a xj, yj, color - t.

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

Hay tres bloques en el código de la línea de color, hasta el código frontal con una línea de 5 píxeles.

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)

función fillRect pequeña reclinación en las coordenadas x і y, w - ancho, h - altura, t - tamaño del rectángulo.

función drawRect rectángulo pequeño en coordenadas xey con ancho w, alto h y color t.

función fillRoundRect Rectángulo de espacio de almacenamiento pequeño con radio r, en coordenadas x і y, ancho w і altura h, color t.

función drawRoundRect pequeño rectángulo con r kutas radiales redondeadas a lo largo de xey, con ancho w y alto h y color t.

poco de 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)

función dibujarCirculo pequeño para las coordenadas xey, con radio r y color t.

función fillCircle una pequeña cantidad de almacenamiento por coordenadas x і y, radio r і color t.

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

Arco pequeño del código Tsei. Puede cambiar el valor en "para" entre 0 y 4000.

pintura de trikutnikiv

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

función drawTriangle pequeño triciclo con tres coordenadas de corte x, y en color.

función fillTriangle pequeño triciclo de almacenamiento con tres coordenadas de corte de color x, y, zy t.

mostrando texto

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

Todo el código establecerá la posición del cursor en xey.

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

La primera fila establece el color del texto. La fila de pasos establece el color del texto y el fondo.

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

El código establecerá el tamaño del texto por el tamaño s... el número en sí s cambio en el rango de 1 a 5.

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

Este código muestra un símbolo.

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

La primera función mostrará la fila y moverá el cursor a la siguiente fila.

Otras funciones simplemente muestran una fila.

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

Qia funkts_ya zmіnyu fuente al texto. Somos responsables de proporcionar la función y la biblioteca de fuentes.

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

La función se puede utilizar para leer el texto. Por favor revise su código.

envoltura de pantalla

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

Cambie el código para girar la pantalla. 0 = 0 °, 1 = 90 °, 2 = 180 °, 3 = 270 °.

Invertuvannya kolorіv ekranu

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

Verifique el código de la pantalla a color.

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

El código Tsey transmitirá el código RGB y rechazará el código de color UTFT.

desplazarse por la pantalla

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

El código se desplazará por su pantalla. Maxroll: altura máxima de desplazamiento.

Skidannya

tft.reset ();

Verifique la pantalla del código de derrape.

Imágenes monocromáticas

static const uint8_t name PROGMEM = (// Proporcione el código de la imagen aquí.) tft.drawBitmap (x, y, name, sx, sy, 0x0000);

La lista de culpabilidad debe convertirse en un código de dieciséis dígitos. Zavanazhte programa zabezpechennya de acuerdo con el orden a continuación. Si no desea cambiar la seguridad del software, por la falla de invertir el color de la imagen, muestre la imagen horizontalmente (espejo) y gírela 90 grados contra la línea anterior.

Ahora agréguelo al software para asegurarlo y reescribirlo. Abra el archivo de exportación y copie el código hexadecimal al IDE de Arduino. Xі y- imagen de rostashuvannya. sxі sy- tamaño de la imagen. Puedes cambiar el color de la imagen al resto aporte.

Visualización de imagen en color RGB

const uint16_t name PROGMEM = (// Agregar código de imagen aquí.) tft.drawRGBBitmap (x, y, name, sx, sy);

Reconstruye tu imagen en código. Vikoristovyte qiu opts_yu para recrear la imagen:

Agregue la imagen y descargue el archivo de conversión, que se puede usar para copiar la biblioteca UTFT. Ahora copie el código de 16 bits al IDE de Arduino. x і y - retoque de imágenes. sx і sy - tamaño de la imagen.

Puede descargar el programa de conversión de código de imagen a dieciséis a continuación:

Elementos de la hoja frontal

Para varias plantillas, simplemente seleccionaron una fila de 8 teclas memorizadas, que cambiarían sus colores en orden. Schob namaluvati cola cerca de un punto estático, puede vikoristovuvati sin (); і cos (); funciones. Establezca el valor de PI. Schob cambia de color, puedes función vikoristovuvati color565 (); y reemplace su código RGB.

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

texto clásico

En muchas plantillas, eligieron la fuente clásica y utilizaron la función para atenuar el texto.

#include "Adafruit_GFX.h" // Biblioteca de gráficos principal #include "MCUFRIEND_kbv.h" // Biblioteca específica de 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 sz, const GFXfont * f , const char * msg) (int16_t x1, y1; uint16_t wid, ht; tft.setFont (f); tft.setCursor (x, y); tft.setTextSize (sz); tft.println (msg);) uint8_t r = 255, g = 255, b = 255; uint16_t color; configuración vacía () (Serial.begin (9600); uint16_t ID = tft.readID (); tft.begin (ID); tft.invertDisplay (verdadero); tft.setRotation (1);) bucle vacío (void) (tft .invertDisplay (true); tft.fillScreen (WHITE); color = tft.color565 (40, 40, 40); tft.setTextColor (color); showmsgXY (50, 40, 1, & FreeSerif12pt7b, "Me encantan los que pueden sonríe en problemas, "); demora (40); tft.println (" quién puede recuperar fuerzas de la angustia "); demora (40); tft.println (" y hazte valiente por reflexión "); demora (40) ; tft.println ("" Es asunto de las mentes pequeñas encogerse "); retrasar (40); tft.println (" pero aquellos cuyo corazón es firme "); retrasar (40); tft.println (" y cuya conciencia aprueba su conducta, "); demora (40); tft.println (" perseguirá sus principios hasta la muerte. "); demora (40); tft.println (" "); demora (700); para (int j = 0; j< 20; j++) { tft.setCursor(145, 290); color = tft.color565(r -= 12, g -= 12, b -= 12); tft.setTextColor(color); tft.print(" ---- Da Vinci ----"); delay(30); } while (1); }

Sumisión / presentación al logo

El archivo se modificó para varias plantillas. a.jpg archivar .C Lo agregué al código, escribí una fila y vikoristovuvalid mostrando el código de desvanecimiento. Luego jugamos el código de desplazamiento, luego movimos la pantalla a su izquierda. alterar el archivo .h agréguelo a su carpeta Arduino eskiz.

#include "Adafruit_GFX.h" // Biblioteca de gráficos principal #include "MCUFRIEND_kbv.h" // Biblioteca específica de hardware MCUFRIEND_kbv tft; #incluir "Ard_Logo.h" #define BLACK 0x0000 #define RED 0xF800 #define GREEN 0x07E0 #define WHITE 0xFFFF #define GREY 0x8410 #include "Fonts / FreeSans9pt7b.h" #include "Fonts" / FreeSbans "/ 12pt7bans" #include "FreeDefaultFonts.h" void showmsgXY (int x, int y, int sz, const GFXfont * f, const char * msg) (int16_t x1, y1; uint16_t wid, ht; tft.setFont (f); tft.setCursor (x, y); tft.setTextSize (sz); tft.println (msg);) uint8_t r = 255, g = 255, b = 255; uint16_t color; configuración vacía () (Serial.begin (9600); uint16_t ID = tft.readID (); tft.begin (ID); tft.invertDisplay (verdadero); tft.setRotation (1);) bucle vacío (void) (tft .invertDisplay (verdadero); tft.fillScreen (BLANCO); tft.drawRGBBitmap (100, 50, Logo, 350, 200); delay (1000); tft.setTextSize (2); for (int j = 0; j< 20; j++) { color = tft.color565(r -= 12, g -= 12, b -= 12); tft.setTextColor(color); showmsgXY(95, 280, 1, &FreeSans12pt7b, "ELECTROPEAK PRESENTS"); delay(20); } delay(1000); for (int i = 0; i < 480; i++) { tft.vertScroll(0, 480, i); tft.drawFastVLine(i, 0, 320, 0xffff); // vertical line delay(5);} while (1); }

diagrama de puntos

En varias plantillas, se utilizaron las líneas de pintura, la memorización de cola y las funciones de mostrar filas.

#incluya "Adafruit_GFX.h" #incluya "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; para (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; signo = 1;) de lo contrario signo = 0; para (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); }

temperatura

Al mismo tiempo, salieron victoriosos pecado ();і cos (); funciones para dibujar arcos desde la base y mostrar un número para la función adicional de un amigo de texto. Luego convertimos la imagen en un código de dieciséis dígitos y lo agregamos al código y renderizamos la imagen para la función adicional de una imagen rasterizada. Luego tenemos la función vikoristovuvali de pintar líneas, para cambiar el estilo de la imagen. Agregue el archivo .h y agréguelo a la carpeta eskizu de Arduino.

#incluir "Adafruit_GFX.h" #incluir "MCUFRIEND_kbv.h" #incluir "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); configuración vacía () (tft.reset (); Serial.begin (9600); uint16_t ID = tft.readID (); tft.begin (ID); tft.invertDisplay (verdadero); tft.setTextSize (2);) void loop () (// ponga su código principal aquí, para que se ejecute repetidamente: tft.fillScreen (0xffff); tft.setRotation (1); tft.drawBitmap (350, 70, Temp, 70, 180, 0x0000); tft.fillCircle (385,213,25, tft.color565 (255, 0, 0)); para (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) (mientras (a Diagrama circular

En varias plantillas, se configuró una función, ya que se tomó la cantidad de datos de entrada y la imagen de un diagrama circular. Somos solo un arco vicioso de pintar y memorizar la función de la estaca.

#incluir "Adafruit_GFX.h" #incluir "MCUFRIEND_kbv.h" #incluir "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); configuración vacía () (tft.reset (); Serial.begin (9600); uint16_t ID = tft.readID (); tft.begin (ID); tft.invertDisplay (verdadero); tft.setTextSize (2);) void loop () (// ponga su código principal aquí, para que se ejecute repetidamente: 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); }

música

#incluya "Adafruit_GFX.h" #incluya "MCUFRIEND_kbv.h" MCUFRIEND_kbv tft; #incluye "Volume.h" #define BLACK 0x0000 int a = 0, b = 4000, c = 1000, d = 3000; int s = 2000; int j, j2; int i, i2; int White; configuración vacía () (Serial.begin (9600); uint16_t ID = tft.readID (); tft.begin (ID); tft.invertDisplay (verdadero); tft.setRotation (1);) bucle vacío (void) (tft .invertDisplay (verdadero); tft.fillScreen (NEGRO); tft.drawRGBBitmap (0, 0, prueba, 480, 320); Blanco = tft.color565 (255, 255, 255); while (1) (si (a< s) { j = 14 * (sin(PI * a / 2000)); i = 14 * (cos(PI * a / 2000)); j2 = 1 * (sin(PI * a / 2000)); i2 = 1 * (cos(PI * a / 2000)); tft.drawLine(i2 + 62, j2 + 240, i + 62, j + 240, White); j = 14 * (sin(PI * (a-300) / 2000)); i = 14 * (cos(PI * (a-300) / 2000)); j2 = 1 * (sin(PI * (a-300) / 2000)); i2 = 1 * (cos(PI * (a-300) / 2000)); tft.drawLine(i2 + 62, j2 + 240, i + 62, j + 240, 0x0000); tft.fillRect(50, 285, 30, 30, 0x0000); tft.setTextSize(2); tft.setTextColor(0xffff); tft.setCursor(50, 285); tft.print(a / 40); tft.print("%"); a++; } if (b < s) { j = 14 * (sin(PI * b / 2000)); i = 14 * (cos(PI * b / 2000)); j2 = 1 * (sin(PI * b / 2000)); i2 = 1 * (cos(PI * b / 2000)); tft.drawLine(i2 + 180, j2 + 240, i + 180, j + 240, White); j = 14 * (sin(PI * (b-300) / 2000)); i = 14 * (cos(PI * (b-300) / 2000)); j2 = 1 * (sin(PI * (b-300) / 2000)); i2 = 1 * (cos(PI * (b-300) / 2000)); tft.drawLine(i2 + 180, j2 + 240, i + 180, j + 240, 0x0000); tft.fillRect(168, 285, 30, 30, 0x0000); tft.setTextSize(2); tft.setTextColor(0xffff); tft.setCursor(168, 285); tft.print(b / 40); tft.print("%"); b++;} if (c < s) { j = 14 * (sin(PI * c / 2000)); i = 14 * (cos(PI * c / 2000)); j2 = 1 * (sin(PI * c / 2000)); i2 = 1 * (cos(PI * c / 2000)); tft.drawLine(i2 + 297, j2 + 240, i + 297, j + 240, White); j = 14 * (sin(PI * (c-300) / 2000)); i = 14 * (cos(PI * (c-300) / 2000)); j2 = 1 * (sin(PI * (c-300) / 2000)); i2 = 1 * (cos(PI * (c-300) / 2000)); tft.drawLine(i2 + 297, j2 + 240, i + 297, j + 240, 0x0000); tft.fillRect(286, 285, 30, 30, 0x0000); tft.setTextSize(2); tft.setTextColor(0xffff); tft.setCursor(286, 285); tft.print(c / 40); tft.print("%"); c++;} if (d < s) { j = 14 * (sin(PI * d / 2000)); i = 14 * (cos(PI * d / 2000)); j2 = 1 * (sin(PI * d / 2000)); i2 = 1 * (cos(PI * d / 2000)); tft.drawLine(i2 + 414, j2 + 240, i + 414, j + 240, White); j = 14 * (sin(PI * (d-300) / 2000)); i = 14 * (cos(PI * (d-300) / 2000)); j2 = 1 * (sin(PI * (d-300) / 2000)); i2 = 1 * (cos(PI * (d-300) / 2000)); tft.drawLine(i2 + 414, j2 + 240, i + 414, j + 240, 0x0000); tft.fillRect(402, 285, 30, 30, 0x0000); tft.setTextSize(2); tft.setTextColor(0xffff); tft.setCursor(402, 285); tft.print(d / 40); tft.print("%"); d++;} if (a >s) (j = 14 * (sin (PI * a / 2000)); i = 14 * (cos (PI * a / 2000)); j2 = 1 * (sin (PI * a / 2000)); i2 = 1 * (cos (PI * a / 2000)); tft.drawLine (i2 + 62, j2 + 240, i + 62, j + 240, Blanco); 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, Blanco); 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--;) si (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, Blanco); 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--;) si (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, Blanco); 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.f illRect (402, 285, 30, 30, 0x0000); tft.setTextSize (2); tft.setTextColor (0xffff); tft.setCursor (402, 285); tft.print (d / 40); tft.print ("%"); D--;)))

velocímetro

#include "Adafruit_GFX.h" // Biblioteca de gráficos principal #include "MCUFRIEND_kbv.h" MCUFRIEND_kbv tft; #define BLACK 0x0000 #include "Gauge.h" #include "Fonts / FreeSans9pt7b.h" #include "Fonts / FreeSans12pt7b.h" #include "Fonts / FreeSerif12pt7b.h" #include "FreeDefaultFonts.h" int a = 1000; int b = 4000; int j, j2; int i, i2; vacío showmsgXY (int x, int y, int sz, const GFXfont * f, const char * msg) (int16_t x1, y1; uint16_t wid, ht; tft.setFont (f); tft.setCursor (x, y); tft .setTextSize (sz); tft.println (msg);) void setup () (Serial.begin (9600); uint16_t ID = tft.readID (); tft.begin (ID); tft.invertDisplay (verdadero); tft .setRotation (1);) bucle vacío (vacío) (tft.invertDisplay (verdadero); tft.fillScreen (NEGRO); tft.drawRGBBitmap (0, 0, prueba, 480, 320); si (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; ) ///////////////////////////////////////////////// // /////////////// mientras (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--; ) Mientras (1); )

feliz cholov_chok

En varias plantillas, una imagen simple se muestra una tras otra, más claramente detrás de la función adicional de una imagen rasterizada. Con tal rango, puede crear su animación con un truco. Agregue el archivo .h y agréguelo a la carpeta eskizu de Arduino.

#incluya "Adafruit_GFX.h" #incluya "MCUFRIEND_kbv.h" MCUFRIEND_kbv tft; #include "image.h" #include "Fonts / FreeSans9pt7b.h" #include "Fonts / FreeSans12pt7b.h" #include "Fonts / FreeSerif12pt7b.h" #include "FreeDefaultFonts.h" #define BLACK 0x0000 #define BLUE 0x001F # definir ROJO 0xF800 #define VERDE 0x07E0 #define CYAN 0x07FF #define MAGENTA 0xF81F #define AMARILLO 0xFFE0 #define BLANCO 0xFFFF #define GRIS 0x8410 #define ORANGE 0xE880 int yFont, int yFont *, int yFont msg) (int16_t x1, y1; uint16_t wid, ht; tft.setFont (f); tft.setCursor (x, y); tft.setTextColor (BLANCO); tft.setTextSize (sz); tft.print (msg); ) void setup () (Serial.begin (9600); uint16_t ID = tft.readID (); tft.begin (ID); tft.setRotation (1); tft.invertDisplay (verdadero); tft.fillScreen (tft. color565 (0,20,0)); showmsgXY (20, 40, 2, & FreeSans9pt7b, "La Linea"); tft.setRotation (0);) void loop () (while (1) (tft.drawBitmap (20, 180, Line1, 258, 128, WHITE); delay (60); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Línea2,258,128, WH ITE); retraso (40); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line3, 258, 128, BLANCO); retraso (60); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line4, 258, 128, BLANCO); retraso (40); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line5, 258, 128, BLANCO); retraso (60); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line6, 258, 128, BLANCO); retraso (40); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line7, 258, 128, BLANCO); retraso (60); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line8, 258, 128, BLANCO); retraso (40); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line9, 258, 128, BLANCO); retraso (60); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line10, 258, 128, BLANCO); retraso (40); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line11, 258, 128, BLANCO); retraso (60); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line12, 258, 128, BLANCO); retraso (40); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line13, 258, 128, BLANCO); retraso (60); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line14, 258, 128, BLANCO); retraso (40); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line15, 258, 128, BLANCO); retraso (60); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line16, 258, 128, BLANCO); retraso (40); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line17, 258, 128, BLANCO); retraso (60); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line18, 258, 128, BLANCO); retraso (40); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line19, 258, 128, BLANCO); retraso (60); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line20, 258, 128, BLANCO); retraso (40); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line21, 258, 128, BLANCO); retraso (60); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line22, 258, 128, BLANCO); retraso (40); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line23, 258, 128, BLANCO); retraso (60); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line24, 258, 128, BLANCO); retraso (40); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line25, 258, 128, BLANCO); retraso (60); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line26, 258, 128, BLANCO); retraso (40); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); tft.drawBitmap (20, 180, Line27, 258, 128, BLANCO); retraso (60); tft.fillRect (20, 180, 258, 128, tft.color565 (0,20,0)); ))

fotografía

Para muchas plantillas, es fácil mostrar las acciones de la imagen detrás de las funciones adicionales. Mapa de bits RGBі mapa de bits... Simplemente voltee el código de la pantalla táctil y elija la plantilla. Agregue el archivo .h y agréguelo a la carpeta eskizu de Arduino.

#include "Adafruit_GFX.h" // Biblioteca de gráficos principal #include "MCUFRIEND_kbv.h" // Biblioteca específica de hardware MCUFRIEND_kbv tft; #define BLACK 0x0000 #define RED 0xF800 #define GREEN 0x07E0 #define WHITE 0xFFFF #define GREY 0x8410 #include "images.h" #include "Fonts / FreeSans9pt7b.h" #include "Fonts / FreeSans12pt7bde.h" FreeSans12pt7b.h "#include FreeSerif12pt7b.h" #include "FreeDefaultFonts.h" int a = 3000; int b = 4000; int j, j2; int i, i2; void showmsgXY (int x, int y, int sz, const GFXfont * f, const char * msg) (int16_t x1, y1; uint16_t wid, ht; // tft.drawFastHLine (0, y, tft.width (), 0xffff ); tft.setFont (f); tft.setCursor (x, y); tft.setTextColor (BLANCO); tft.setTextSize (sz); tft.print (msg); delay (1000);) configuración vacía () ( Serial.begin (9600); uint16_t ID = tft.readID (); tft.begin (ID); tft.invertDisplay (verdadero); tft.setRotation (1);) bucle vacío (void) (tft.invertDisplay (verdadero) ; tft.fillScreen (NEGRO); tft.drawRGBBitmap (0, 0, prueba, 480, 320); tft.drawBitmap (20, 20, Line1, 45, 45, 0xffff); // batería tft.drawBitmap (65, 20 , Line2, 45, 45, 0xffff); // wifi tft.drawBitmap (125, 25, Line3, 45, 45, 0xffff); // mail tft.drawBitmap (185, 25, Line4, 45, 45, 0xffff); // instagram tft.drawBitmap (245, 25, Line6, 45, 45, 0xffff); // poder tft.drawBitmap (20, 260, Line5, 45, 45, 0xffff); // twitter tft.drawBitmap (410, 140 , Line7, 45, 45, 0xffff); // lluvia tft.setTextSize (6); tft.setTextColor (0xffff); tft.setCurso r (280, 210); tft.print ("20:45"); tft.setTextSize (2); tft.setTextColor (0xffff); showmsgXY (330, 280, 1 y FreeSans12pt7b, "sábado"); showmsgXY (300, 305, 1 y FreeSans12pt7b, "6 de octubre de 2018"); mientras (1); )

bolsa pid

Descargar archivo con archivos .h más bajo:

  • Se ha editado la velocidad de producción de todos los archivos GIF, el hedor de la destrucción es más rápido o más para una mente más corta. La cantidad de dinero se puede almacenar en forma de su procesador o el tipo de código, así como el tamaño y tipo de elementos en el código.
  • Puede agregar el código de la imagen al lado de la cabecera, pero puede recordar el lado completo. Con este rango, puede editar el archivo a.h y agréguelo a la carpeta eskizu.
  • Con las mismas estadísticas, solo recogieron la visualización de elementos en la pantalla RK. Siga las lecciones ofensivas, aprenda a tocar la pantalla táctil y las imágenes SD.
  • Si tiene problemas con la biblioteca incluida, cambie el signo de la pata "" a<>.

Déjalo todo. Comparta una pantalla LCD TFT para Arduino con sus amigos y colegas.

Un monitor vibrante, un monitor de televisión o un teléfono, el comprador a menudo se para frente a un tipo de pantalla vibrante. Yakom podrá verlos: ¿IPS o TFT? La razón de tal malentendido fue el conocimiento continuo y profundo de las tecnologías utilizadas en la producción de pantallas.

Todos los monitores con tecnología TFT se pueden dividir en tres tipos principales:

  1. Película TN +.
  2. PVA / MVA.

Tobto, tecnología TFT є pantalla de cristal sólido de matriz activa Y IPS es el uno de los tipos de matriz... La primera clase de dos categorías no es posible, ya que es prácticamente la misma. Si todo es más detallado en el hecho de que se trata de una pantalla con matriz TFT, entonces es posible realizar el procedimiento, o no con las pantallas, sino con las tecnologías de su preparación: IPS y TFT-TN.

Espacio para la cabeza TFT

TFT (transistor de película fina) transistor de flujo fino... En el corazón de la pantalla LCD con tecnología TFT se encuentra una matriz activa. Dicha tecnología se basa en el crecimiento espinal de los cristales, como en la mente de una fuerza fuerte para estimular un giro en un rango tal que la pantalla es vieja. Y cuando hay una tensión de gran esfuerzo, Bachimo Biliy Ekran. La pantalla con dicha tecnología en la entrada muestra un color gris oscuro en lugar del ideal negro. Para eso, las pantallas TFT son populares entre los modelos más baratos.

Descripción IPS

La tecnología de la matriz RK a la pantalla IPS (In-Plane Switching) paralelo al crecimiento de cristales en toda el área del monitor... Las espirales están por todos lados aquí. Y para eso eran cristal en la mente de un pico fuerte, no se puede dar la vuelta. En otras palabras, la tecnología IPS es cara, como pulimento TFT. Vaughn es un color negro más bellamente transmitido, al mismo tiempo, los pasos de contraste y claridad de la imagen son más brillantes. El hecho mismo se le da a la tecnología costosa, no TFT, y vikoristovuyutsya en modelos más caros.

Información básica TN-TFT e IPS

Bazhayuchi realizuvati yakomog más productos, gerentes de ventas para presentar a la gente a Omán sobre aquellos que tienen TFT e IPS: tipos de pantallas absolutamente diferentes. Fakhivtsi en el ámbito del marketing no da más información sobre la tecnología e incluso les permite ver la caja por ahora.

Viendo IPS y TFT, mi bacimo, scho no es práctico pero también... La ganancia es menor en el hecho de que el monitor está equipado con tecnología IPS y tiene un diseño más generoso, en el caso de TN-TFT. No tiene importancia por el precio, de todos modos puedes ver una serie de indicaciones entre los significados de las categorías:

  1. mayor contraste... Aquellos que parecen ser de color negro, sin infundir predominantemente en el contraste de la imagen. Si hay una buena pantalla con tecnología TFT sin IPS, entonces será prácticamente imposible leerla. Y todo eso en que la pantalla se oscurece cuando nahila. Si observa la matriz IPS, entonces, de acuerdo con el hecho de que la transferencia del color negro se realiza mediante cristales, idealmente, la imagen es clara.
  2. Transferencia de color y número de imágenes... La matriz TN-TFT no es redundante por el rango de la transferencia. Y todo a través de aquellos que pueden crear un píxel delgado para crear un color. La pantalla con tecnología IPS se puede utilizar para transferir la imagen.
  3. poniéndose al día con vidguk... Con una transferencia de pantallas TN-TFT sobre IPS є pantalla de alta velocidad. Y todo eso, es mucho tiempo para girar los cristales IPS paralelos sin bisel. Parece un diseño robusto, pero ahí, la maldad de la producción es de un gran valor, más hermosa que la pantalla victoriosa con la matriz TN. La pantalla con tecnología IPS es mejor, pero en toda la vida no es agradable. Y el viyaviti dado a conocer puede ser privado de las marcas especialmente escondidas para toda la prueba tecnológica. Como regla general, es más hermoso que la pantalla con la matriz IPS.
  4. Focha mira a tu alrededor... El personal del corte ancho mirará alrededor de la pantalla con la tecnología IPS, yo no miro la imagen, solo puedo asombrarme con un nuevo corte a 178 grados. Además, el significado del kuta se puede ver vertical u horizontalmente.
  5. energía... La pantalla con tecnología IPS, a la vista de TN-TFT, aporta más energía. Tim puso el precio, pero para convertir cristales paralelos, se necesita una gran cantidad de esfuerzo. En el caso de la batería, hay más navantazhennya, más bajo con la matriz TFT vicoriana. Si necesita ajustarse con poca energía, la tecnología TFT será una opción ideal.
  6. Política de Tsinova... Una gran cantidad de modelos económicos de electrónica tienen pantallas de alta calidad basadas en la tecnología TN-TFT, un tipo especial de matriz, la más económica. Debe hacerse paso a paso hasta que la matriz IPS esté prácticamente equipada con tecnología TN-TFT.

pidbags

Tan pronto como sepa lo que se ha dicho, puede traer el inicio de la bolsa.

Abreviatura para quedarse estancada para características específicas o especificidad. En este tipo particular de pantallas IPS y TFT, hay mucha plutanina, por lo que la tecnología (matriz) IPS es un tipo de matrices TFT y única. Desgarra groseramente entre tú y 2 tecnologías.

¡CERVEZA INGLESA! Є Tecnología TN-TFT: el eje entre este y el IPS puede vibrar y romperse. A eso, si hablamos de esos, qué pantalla es más bonita: IPS o TFT, podemos usar pantallas TFT de cualquier tipo, pero están hechas sobre la base de nuevas tecnologías: TN e IPS.

Brevemente sobre TN-TFT e IPS

TN-TFT es una tecnología basada en una matriz de viconano de una pantalla de cristal sólido. Aquí los cristales, si no hay necesidad de alimentarse de їkh a mitad de camino, se "maravillan" uno por uno a 90 grados. Huele roztashovuyutsya en espiral, y si se sirven con licores, entonces el hedor se vuelve de tal rango, para que pueda fijar el color requerido.

IPS es una tecnología para adaptarla al hecho de que aquí los cristales crecen en paralelo, uno a uno en la misma zona de la pantalla (en primer lugar, en espiral). Todo está ordenado ... en la practicidad de mostrar pantallas basadas en matrices TN e IPS en el hecho de que IPS muestra idealmente un color negro, como resultado de lo cual la imagen es más clara y fuerte.

Sin embargo, TN-TFT, la transmisión del color de esta matriz no inspira confianza. Aquí, el píxel delgado se puede hacer a partir de la madre, del color del color. Las matrices IPS muestran la imagen de manera más hermosa y también se convierten más rápidamente en cuadrados. Además, IPS te permite patrocinar a un equipo para que se vea en la pantalla antes del gran kut. Si le sorprende la pantalla TN-TFT con el mismo corte, la pantalla creará los colores y podrá crear la imagen sin problemas.

reversiones TN

Sin embargo, las matrices TN-TFT son poco comunes. Más importante aún, son más de baja velocidad en respuesta a las imágenes. IPS tardará más de una hora en convertir todo el conjunto de cristales paralelos en el corte requerido. A eso, me gustaría hablarles sobre la vibración del monitor para igor o para la visualización de escenas dinámicas, si la velocidad de la producción es aún más importante, entonces es más hermoso hacer vibrar la pantalla en base a TN-TFT. tecnología.

Por otro lado, cuando hay un robot extraordinario con una PC, no es prudente notar la diferencia en las horas de visualización de los píxeles. Solo puedes verlo cuando miras escenas dinámicas, lo que a menudo se ve en luchadores y videojuegos.

Otra ventaja es el bajo consumo energético. Las matrices IPS están energizadas, por lo que se necesita mucho esfuerzo para rotar la matriz de cristales. Otzhe, las pantallas basadas en TFT son más hermosas para dispositivos móviles;

Además, las matrices TN-TFT son económicas. No conozco el monitor actual (no utilizo modelos de segunda mano sino modelos EPT), que es más económico que un modelo basado en tecnología TN. Ya sea electrónica prist_y presupuestaria con una pantalla, será matriz vikoristovuvati TN-TFT.

Otzhe, qué pantalla es más hermosa:TFT aboIPS:

  1. IPS mensh chuiny durante una gran hora para verlo (mierda para igor y escenas de acción);
  2. IPS garantiza una transmisión de contraste y color ideal y práctica;
  3. IPS volodin bolsh con un corte ancho alrededor;
  4. IPS energía y más electricidad;
  5. El olor también es más caro, a esa hora el TN-TFT sale más barato.

El eje, en principio, y toda la diferencia entre estas matrices. Mientras todos los pasajes y deficiencias estén en curso, entonces, por supuesto, es fácil llegar a un momento específico: las pantallas IPS son más hermosas.


Sea una caricia, evalúe el artículo:

Tecnología de matriz LCD TFT para la transmisión de pantallas microcristalinas en transistores especiales de flujo fino. El nombre TFT en sí es un transistor de película delgada de tipo de movimiento rápido, pero en la sección transversal significa un transistor de filamento delgado. Este tipo de matriz se instala en los anexos más flexibles, desde calculadoras, hasta pantallas en smartphones.

Melodiosamente, el sentimiento delgado de TFT y LCD, pero un poco se perdió, pero también, a través del camino de los no iniciados, ¿quién puede ver el TFT desde la pantalla LCD? Mire la cadena alimentaria del campo en el hecho de que hay dos discursos diferentes, que no son variados. Más inteligencia, en la que la diferencia en tecnología, varto rozibrati, también LCD y también TFT.

1. También LCD

LCD: la tecnología para hacer pantallas para televisores, monitores y otros anexos, se basa en moléculas especiales, que se denominan pequeños cristales. Las moléculas pueden tener un poder único, el hedor abruma constantemente la tierra nativa y aumenta su posición cuando se vierte un campo electromagnético sobre ellas. Además, las moléculas pueden tener un poder óptico, similar al poder de los cristales, a través del cual las moléculas han dado su nombre.

Existen muchos tipos diferentes de matrices que se pueden utilizar en las pantallas LCD, ya que en el agotamiento de la tecnología se preparan para el desarrollo de potencia e indicadores.

2. Sho también TFT

Como ya se dijo, TFT es una tecnología para la producción de pantallas LCD, ya que se puede utilizar para la producción de transistores de flujo fino. Por tanto, se puede decir que TFT es un tipo de monitores LCD. Por supuesto, todos los televisores LCD, monitores y pantallas de teléfonos modernos se denominan TFT. La fuente de alimentación es más hermosa que la TFT o la pantalla LCD no es correcta. Además, veo FTF como una polaridad LCD en que LCD es la tecnología para generar pantallas de cristal sólido, y TFT es una serie de pantallas LCD, antes de que se muestren todos los tipos de matrices activas.

Puedo nombrar la mitad de las matrices TFT: activa. Tales matrices pueden ser de bastante alta calidad, desde el punto de vista de las matrices LCD pasivas. Además, se está desarrollando el tipo de pantalla LCD TFT para mejorar la claridad, el contraste de la imagen y la gran apariencia. Otro momento importante de la polaridad es que hay menos movimiento en las matrices activas durante el día, lo que significa que para tales monitores es mejor tomar pratsyuvati, porque es menos probable que se canse.

Las matrices TFT de píxeles de piel están equipadas con tres transistores con transistores de tres núcleos, la frecuencia de la pantalla actualizada se puede alcanzar fácilmente, en el caso de matrices pasivas. En tal rango, antes del almacén del píxel de la piel, hay tres colores en el medio, que están controlados por un transistor externo. Por ejemplo, si la pantalla está configurada para convertirse en 1920 x 1080 píxeles, entonces la cantidad de transistores en dicho monitor es 5760 x 3240. El estancamiento de una cantidad tan grande de transistores se ha convertido en una estructura superfina y clara: 0,1 0,01 micrones.

3. Ver la matriz de pantallas TFT

En un día actual, hay toda una serie de pantallas TFT perevag en las dependencias más populares.

Todos los tipos de televisores LCD que se encuentran en el mercado ruso están equipados con pantallas TFT. El hedor se puede atribuir a sus parámetros en la deposición de la matriz vicorista.

Por el momento, las matrices más extendidas de pantallas TFT є:

Kozhen de las representaciones de los tipos de matrices de sus propios pasajes.

3.1. Tipo de matriz LCD TFT TN

TN es el tipo más común de pantalla LCD TFT. Tal es la popularidad del tipo de matriz danesa, que presenta características únicas. Con su baja variabilidad, el hedor puede llegar a indicadores altos, y en algunos momentos, tales pantallas TN para pasar la sobretensión frente a los otros tipos de matrices.

La principal especialidad es el mensaje invaluable. Este es un parámetro, que se establece para una hora, para el cual se construye un píxel con el cambio de un campo eléctrico. Tobto, la hora, que es necesaria para el cambio principal de color (del blanco al negro). Este es un indicador aún más importante para cualquier televisor y monitor, especialmente para los amantes de las montañas y el cine, lleno de todo tipo de características especiales.

Se da poco de la tecnología: el intercambio de kuti mirando a su alrededor. Sin embargo, las tecnologías modernas permitieron correcciones a corto plazo. La infección de matrices de película TN + puede ser una gran cantidad de personas mirando a su alrededor, por ejemplo, estas pantallas están compitiendo con nuevas matrices IPS.

3.2. Matrices IPS

La visión danesa de la matriz tiene las mejores perspectivas. La peculiaridad de esta tecnología del campo radica en el hecho de que tales matrices pueden ser las más hermosas al mirar a su alrededor, así como la transferencia de color más natural y natural. Sin embargo, la escasez de tecnología hasta la actualidad buv trivialy vidguk. Todos los zavdyaki con tecnologías modernas, el parámetro aumentó la velocidad a un rendimiento aceptable. Además, los últimos monitores con matrices IPS pueden tardar una hora en devolver 5 ms, por lo que no tiene que ir a las matrices TN + Film.

Con la idea de una gran cantidad de monitores y pantallas de televisión, es posible esconderse detrás de las matrices IPS, porque TN + Film ha estado haciendo un movimiento para el hedor.

Por lo demás, los teléfonos móviles, smartphones, tablets y laptops cada vez eligen más módulos TFT LCD con matrices IPS, respeto la transmisión visual del color, son buenos para divertirse, además de ser económicamente importantes para el ahorro de energía.

3.3. MVA / PVA

El tipo danés de matrices es un compromiso de cadena entre matrices TN e IPS. La peculiaridad de la polaridad es que en el estado de reposo las moléculas de los cristales raros crecen perpendiculares al área de la pantalla. El vyrobniki zavdyaky logró alcanzar el máximo en color negro puro. La tecnología está dada, permitiendo el alcance de las grandes cuevas alrededor, en el contexto de matrices TN. Alcanza el precio con la ayuda de viseras especiales en las cuentas. Este proceso comienza directamente con las moléculas de los cristales raros. Al mismo tiempo, tales matrices pueden aparecer hace menos de una hora, pantallas IPS más bajas y más, en el caso de matrices TN.

No es maravilloso, pero la tecnología no conocía el almacenamiento generalizado en la producción masiva de monitores y televisores.

4. Más hermoso que Super LCD o TFT

Para una mazorca de varto rosibrati, también Super LCD.

Super LCD es una tecnología para la producción de pantallas, que se ha expandido ampliamente entre la gama más amplia de teléfonos inteligentes y tabletas modernas. Por cierto, Super LCD es una combinación de matrices IPS, a las que se les ha dado un nuevo nombre comercial y una nueva política.

La razón principal de tales matrices es que el hedor no parece ocultar el espacio entre la pendiente visible y la imagen (imágenes). El personal del tsom fue lejos para llegar al cambio de opiniones. El tamaño de la imagen visual en tales pantallas se construye más cerca del aspecto. Si habla de pantallas táctiles en teléfonos inteligentes y tabletas, las pantallas Super LCD responden mejor al punto y responden mejor a los bloqueos.

5. Monitor TFT / LCD: Video

Más de un cambio de un tipo dado de matrices en un suministro de energía reducido, pero nuevamente, es importante organizar una computadora portátil, un teléfono inteligente o una tableta. Tal economía se puede alcanzar debido al hecho de que en la estación de spoky del cristal se levantó para que se salte la luz, lo que reduce el consumo de energía al mostrar imágenes claras. Al mismo tiempo, es importante que haya muchas imágenes de fondo en todos los sitios de Internet, protectores de pantalla en complementos y hasta ahora, como si fueran livianos.

El área principal para el almacenamiento de pantallas de CD SL es la tecnología muy móvil, debido al bajo consumo de energía, la alta calidad de imagen, para navegar con cambios directos de sueño, y también la baja tasa, por ejemplo, en AMED.

Sus pantallas LCD TFT incluyen un tipo de matriz SLCD. Por lo tanto, Super LCD es un tipo de pantalla TFT de matriz activa. En la propia oreja de esta publicación, ya se habló de los que no tienen diferencias TFT y LCD, pero en principio son lo mismo.

6. Mostrar vibración

Yak ya habla vishche, tipos de piel de matrices de sus propios pasajes. También se discutieron todos los hedores. En primer lugar, cuando vibre la pantalla, varto vrahovuvati su vimogi. Varto puso su propia comida, - ¿Qué se necesita de la pantalla, cómo saldrá victorioso y en qué mentes?

Vidshtovuyuchis vid vimog y varto vibrate display. Es una pena que en este momento no exista una pantalla universal, por lo que se puede decir que realmente es más bonita para todos. A través del precio, si la transferencia de color es importante para usted y al mirar las imágenes, definitivamente su vibración es el precio de la matriz IPS. Si eres fanático de lo último en tecnología y de los yaskravikh igors, es más hermoso ir a TN + Film.

Todas las matrices modernas pueden alcanzar altos indicadores, por eso es fácil ver una diferencia, incluso las matrices IPS prácticamente no se ven comprometidas por TN durante una hora para ver, y TN puede alcanzar un gran kuti a la vuelta de la esquina. Hasta entonces, como regla, koristuvach roztashovutsya contra la pantalla, y no desde un lado o desde arriba, por lo que, en principio, no se necesita un gran kuti. Ale vibir es todo tuyo.