Conexión de una pantalla gráfica nokia 5110

Philips PCD8544.
Para conectar el módulo a otros dispositivos, la placa contiene un conector y orificios para soldar cables. También hay 4 orificios de montaje ubicados en las esquinas del tablero.
La pantalla monocromática del Nokia 5110 LCD (pantalla azul) está retroiluminada con LED azules. A lo largo de los años de producción, Nokia 5110 se ha utilizado y se utiliza en una amplia gama de aplicaciones. El módulo de visualización facilita la conexión e instalación de Nokia en el dispositivo. Gracias al módulo, se simplifica el primer contacto de un ingeniero electrónico o programador con la pantalla LCD del Nokia 5110. Inicialmente utilizada como indicador de teléfono móvil, la pantalla se ha extendido a otras categorías de dispositivos. Es conveniente utilizarlo en instrumentos de medida: voltímetros, amperímetros, óhmetros y otros. La pantalla también es útil para mostrar lecturas de dispositivos médicos móviles. Es interesante utilizarlo para la escala de un receptor de radio o un indicador de nivel de señal en equipos de reproducción de sonido. La pantalla con una resolución de 84x48 píxeles le permite mostrar información simbólica y gráfica.
Si tiene experiencia con el Nokia 3310 LCD, le resultará fácil dominar el Nokia 5110 LCD, ya que estos indicadores están integrados en el mismo controlador PCD8544.

Especificaciones del módulo LCD Nokia 5110

Nutrición
tensión 2,7…3,3 V
actual
retroiluminación apagada 5 mA
retroiluminación en 20 mA

Temperatura del aire durante el funcionamiento 0…50
Temperatura de almacenamiento -10…70

Indicador LCD Nokia 5110

Características principales

El componente principal del módulo LCD Nokia 5110 es el indicador LCD. Tiene generadores integrados de tensión de alimentación y polarización de elementos LCD y retroiluminación LED. Interfaz de entrada de información SPI. Nokia 5110 puede funcionar en cuatro modos: normal, inversión de imagen, pantalla en blanco y "todos los puntos encendidos". El usuario también puede controlar la temperatura, el voltaje de suministro y la polarización.

Nutrición
tensión 2,7…3,3 V
corriente hasta 320 µA
Frecuencia de reloj hasta 4 MHz
Tiempo de reinicio al menos 100 ns

Estructura de visualización

La pantalla es una matriz de elementos LCD y un microcircuito PCD8544 para su control, ubicado en una carcasa montada en la placa. También alberga cuatro LED de retroiluminación de pantalla. La información sobre el estado de los puntos de visualización se almacena en la RAM del controlador PCD8544; cada punto corresponde a un bit de memoria. También hay un contador de direcciones incorporado, que aumenta automáticamente cuando se escribe en la memoria el siguiente byte de información.

control de pantalla

Realizado a través de la interfaz SPI, la pantalla es un dispositivo esclavo. Sin embargo, en lugar de las cuatro líneas de control habituales, sólo hay tres. Estas son las líneas de reloj CLK, selección de chip SCE y datos de entrada MOSI. No hay línea de salida MISO. Esto lleva a la necesidad de utilizar métodos de gestión especiales, más sobre esto a continuación. La interfaz funciona en modos SPI-0 o SPI-3. El Nokia 5110 también tiene una línea de control de información/comando adicional: D/C̅. Cada byte enviado al display puede interpretarse como un comando o un byte de información, dependiendo del nivel en la línea D/C̅.
La transferencia de información es unidireccional y los datos no se pueden leer de la memoria ni de los registros de visualización. Por lo tanto, el programa debe proporcionar la capacidad de controlar los estados de visualización. Sin embargo, hay una característica más que complica la gestión. Esta característica está relacionada con la organización de la memoria.

La memoria consta de seis bancos, cada uno de los cuales contiene 84 celdas con una capacidad de 1 byte.

Abordar cada píxel indicador. En total tenemos 84x48 píxeles, organizados en 6 bancos horizontales (de cero a cinco) y 84 columnas.

Cada banco contiene 8 píxeles dispuestos verticalmente, que en la suma de seis bancos dan 48 líneas. La figura muestra cómo se mostrará un píxel determinado desde la RAM en la pantalla; cada línea de la figura representa un banco.
La información se escribe en la memoria byte a byte, no bit a bit, y no hay forma de controlar cada punto, sino solo grupos de ocho puntos. Esto, combinado con el hecho de que la información de la memoria LCD del Nokia 5110 no se puede leer, significa que antes de enviar es necesario recordar qué datos están almacenados en qué celular. De lo contrario, es posible que se pierda información cuando se envíen nuevos datos a la pantalla. Esta característica se ilustra con una imagen que muestra la sustitución de un símbolo. Al escribir un programa de control, es necesario prever la posibilidad de almacenar datos.

Reemplazando el símbolo L por el símbolo A.

La pantalla tiene un tamaño de 84x48 píxeles. La información se genera en bloques verticales de 8 píxeles de alto, cuyos valores están determinados por los valores de bits en el byte de salida. El bit menos significativo codifica el píxel superior.
Mirando hacia las descripciones de los comandos, digamos. Los comandos 1xxxxxxx y 01000yyy definen las coordenadas del cursor: la línea y la posición en la que se mostrarán los siguientes 8 bits de datos. Una vez generado el byte, el cursor se mueve automáticamente a la posición adyacente.
Si se selecciona el modo de direccionamiento horizontal V=0 con el comando 00100PDVH, el cursor se mueve hacia la derecha y el siguiente byte de datos se mostrará en la posición adyacente a la derecha. Cuando se llega al borde derecho de la pantalla, el cursor se mueve al principio de la siguiente línea. Si se selecciona el direccionamiento vertical V=1, entonces el cursor se mueve hacia abajo a la línea siguiente y, después de la última línea, el cursor se mueve una posición horizontal hacia la derecha y se coloca en la línea superior.
Como memoria intermedia, puede utilizar la memoria del controlador de control, que almacenará una copia de los datos en la pantalla. Antes de enviar, es necesario ajustar los datos, dependiendo de qué información esté almacenada en la memoria intermedia.

Comandos de control del Nokia 5110

La pantalla se controla enviando una palabra de comando a través de la interfaz SPI. El tamaño de la palabra es 1 byte. Los comandos de control se dividen en 3 categorías.

Funciones supremas de la dirección

Establecer tipo de función: indica con qué tipo de funciones funcionará el módulo, básicas o avanzadas.
Establecer modo de energía: enciende o apaga la alimentación.
Establecer modo de direccionamiento: determina el tipo de direccionamiento de la memoria: vertical u horizontal. En el primer caso, después de escribir un byte de datos, el contador de direcciones Y aumentará, es decir, la grabación se realizará en columnas. En el segundo, el contador de direcciones X, la grabación se realizará línea por línea.
Las funciones se transfieren al Nokia 5110 LCD cuando la línea D/C̅ está baja. Se definen mediante una única palabra de comando. Esta palabra debe enviarse al display al inicio de la operación. Formato:

0 0 1 0 0 PD V H

El bit PD determina el modo de energía; establecido en PD significa modo de apagado.
Modo de direccionamiento del bit V: 1 - vertical, 0 - horizontal.
El bit H es el tipo de funciones que se utilizarán para trabajos posteriores: 0 - normal, 1 - extendido.
Como puede ver, es necesario recordar el estado actual de la pantalla para que al configurar un nuevo valor de parámetro no pierda información sobre los valores de otros. El comando 00100PDVH está presente en ambos conjuntos de comandos.

Funciones básicas

Establezca el modo de visualización en 00001D0E. Define el modo de visualización: pantalla en blanco, todos los puntos encendidos, visualización normal, visualización inversa. E - signo de inversión de imagen, D - salida de imagen. Si D=0, entonces la pantalla está completamente clara E=0 o completamente negra E=1.
Establezca el comando de dirección X en 1xxxxxxx, o 0x80 + x, selección de una posición horizontal en la línea actual donde se mostrará la imagen. Donde x = 0 es la posición más a la izquierda, 83 es ​​la más a la derecha.
El comando SetY-address 01000yyy establece la dirección Y de la celda donde se escribirá el siguiente byte. Comando, o 0x40+y seleccione el número de línea (página) en la que se muestra la imagen. Y=0 es la línea superior, 5 es la línea inferior. La línea tiene 8 puntos de altura.

Funciones avanzadas

El conjunto de comandos extendido se selecciona después de enviar el comando 00100PDV1.
Configure el modo de temperatura. El comando 000001tt, o 0x04 + t selecciona uno de los cuatro modos de corrección de temperatura. Dependiendo del modo, el voltaje de la pantalla cambiará de manera diferente a medida que cambia la temperatura.
Establezca el voltaje de polarización de los elementos de la pantalla LCD. El comando 00010bbb, o 0x10 + b selecciona uno de los ocho modos para calcular las compensaciones de nivel para el control LCD. Para pantallas Nokia normales, el modo recomendado es 0001011 o 0x13.
Configure el voltaje de suministro para los elementos de la pantalla LCD. Comando 1vvvvvvv, o 0x80 + v selecciona el voltaje en el generador de voltaje de refuerzo para la pantalla LCD. Cuando v=0 el generador se apaga. El voltaje de salida se calcula mediante la fórmula VLCD = 3,06 V + v * 0,06 V. Dependiendo de la elección del método de corrección de voltaje, este valor cambia según la temperatura. Para evitar daños en la pantalla a bajas temperaturas, se recomienda que este valor sea inferior a 8,5 V, es decir v<=90. Для обычных дисплеев Nokia это нормальное рабочее значение этого параметра примерно равно 56, т. е. команда принимает вид 10111000, или 0xB8.
Es más fácil trabajar con las funciones básicas y avanzadas porque cada una tiene su propia palabra de comando.
Hay que recordar que para poder trabajar con un determinado tipo de función, es necesario configurar la pantalla para que funcione con estas funciones. De lo contrario, enviar la palabra de comando provocará una ejecución incorrecta de este comando. Se pueden encontrar más detalles sobre los comandos de control en la documentación de la página 11.

Inicializando la pantalla

Debe ejecutarse dentro de los 30 ms posteriores a la aparición de energía en la siguiente secuencia:
restablecer activando la entrada correspondiente a nivel bajo durante 100 ns o más,
encienda la pantalla y seleccione un conjunto extendido de comandos enviando 0x21,
enviar comando de compensación de voltaje 0x13,
configurar la corrección de temperatura con el comando 0x04,
encienda el generador de alto voltaje al nivel de 6,42 V usando el comando 0xB8,
volver al comando estándar establecido enviando 0x20,
habilite el modo de gráficos con el comando 0x0C.
Después de estos pasos, Nokia 5110 LCD está listo para usar.

Conexión del módulo LCD Nokia 5110

La salida de señales a los contactos del módulo se muestra en la imagen en la parte superior de la página. También puede haber una disposición diferente de los contactos que se muestra en la figura.

Una de las opciones para la ubicación de contactos.

Señales y líneas del módulo.

Alimentación VCC 3,3 V.
Cable común GND
SCE habilitado, activo bajo
Restablecer Restablecer, activo bajo
D/C̅ Datos/comando: 0 - datos, 1 - comando
Entrada de interfaz SDIN
Señal de reloj SCLC
Retroiluminación LED. Para los módulos en la placa roja, conéctelo al común, para los módulos azules, conéctelo a la alimentación. Utilice una resistencia de 330 ohmios en el circuito de iluminación de fondo. Algunas modificaciones ya tienen una resistencia instalada, otras no. Para determinar la presencia de una resistencia y seleccionar el modo de retroiluminación óptimo, debe controlar la corriente del módulo y la corriente de retroiluminación. No debe exceder los 20 mA.

Si no hay otros dispositivos conectados a la interfaz SPI del microcontrolador, entonces para guardar los contactos del módulo de control principal del dispositivo y reducir la cantidad de líneas de comunicación, el pin de selección de dispositivo activo SCE debe conectarse al pin GND en el módulo. junta. Pero hay un inconveniente. Si el controlador Nokia ha perdido la sincronización con el MK, ahora es imposible detectarlo.
De esta manera se debería realizar una conexión más confiable. Lleve esta línea a un nivel alto con una resistencia de 100-500 kOhm para evitar que la interferencia afecte al controlador mientras el MK está en estado de reinicio.
Cuando se trabaja con microcontroladores AVR, es conveniente utilizar la interfaz USART en modo maestro SPI. Modo SPI-3 (CPHA=1, CPOL=1). Esto significa que mientras no hay intercambio, la línea SCLK está alta y el controlador lee datos de la línea SDIN en un flanco ascendente en la línea SCLK durante 100 ns. En este caso, deben ajustarse al menos 100 ns antes del flanco ascendente. La transmisión se realiza en 8 bits, el más significativo primero.
El nivel en la línea D/C̅ determina cómo interpretar los datos recibidos. Un nivel alto significa que se deben mostrar los datos transmitidos, un nivel bajo significa que se transmite un comando. El controlador lee el valor en esta línea junto con el último bit (el más bajo) de cada byte de datos transferido. Esto puede resultar complicado cuando se utiliza la transferencia de hardware asíncrona. Debe esperar a que el byte anterior complete la transmisión antes de configurar el nivel.

Conexión del módulo LCD Nokia 5110 y Arduino UNO.

Las señales de entrada del módulo deben corresponder a los niveles lógicos del circuito alimentado por un voltaje de 3,3 V. Cuando se trabaja con un microcontrolador alimentado con una fuente de alimentación de 5 V, se deben utilizar circuitos de adaptación de niveles.

Gráficos

Al comenzar a preparar una imagen gráfica, debe preparar una imagen en blanco y negro en formato *.bmp con una resolución de 84x48 píxeles en cualquier editor gráfico. Preparamos una imagen así en Paint, aquí está:

El nombre del archivo de imagen debe guardarse en letras latinas. Usando el programa

Para los usuarios inexpertos que quieran crear de forma independiente sistemas de control para dispositivos robóticos o herramientas de automatización, en el mercado de servicios de TI se ofrecen varios módulos de hardware y sus modificaciones. Como regla general, estos dispositivos tienen una arquitectura simple con derechos de copia y software que los acompaña en forma de utilidades simples. Estos productos se pueden utilizar de forma independiente o conectados a otros sistemas informáticos mediante interfaces cableadas o inalámbricas.

Ventajas de trabajar con pantallas gráficas

Anteriormente, las pantallas gráficas monocromáticas se utilizaban mucho en la producción de teléfonos móviles.

Nokia ha lanzado una gran cantidad de modelos diferentes equipados con dicha pantalla. Los días de aquellos teléfonos han quedado atrás, pero las pantallas no han desaparecido del mercado y siguen utilizándose activamente hasta el día de hoy. Resultaron ser dispositivos indispensables y, además, baratos para la salida de texto y pantallas que funcionan creando matrices de puntos en las pantallas, que resaltan la imagen. Ahorran recursos y tiempo, a la vez que muestran una gran cantidad de información y consumen una pequeña cantidad de energía. Hay una gran cantidad de áreas diferentes en las que se pueden utilizar los dispositivos Nokia 5110: fotografía, vídeo, equipos de televisión, medicina y muchas otras industrias.

Antes de describir cómo conectar una pantalla Nokia al módulo de hardware Arduino, es necesario brindar una breve introducción a estos dispositivos.

Beneficios de usar Arduino Uno

Se han creado muchas plataformas y microcontroladores que son análogos de la plataforma Arduino presentada en este artículo. Algunos de estos análogos son el BX-24 de Netmedia, el Parallax Basic Stamp y muchos otros. Sin embargo, nos centraremos en el Arduino Uno, ya que este diseñador tiene una serie de ventajas sobre otros controladores a las que debes prestar atención a la hora de elegir una plataforma. En primer lugar, lo principal es el bajo costo de estos dispositivos. Los modelos con este software cuestan menos de $45 y, si se desea, se pueden ensamblar manualmente, ya que tienen un diseño bastante simple. El segundo punto es que las plataformas Arduino pueden funcionar. con todos los sistemas operativos: Windows, Linux, así como Macintosh OSX, mientras que el resto se limita a trabajar exclusivamente con Windows.

Descripción de Arduino Uno

Arduino Uno es una plataforma para desarrollar y programar diversos dispositivos, que cuenta con 14 entradas y salidas digitales, 6 entradas analógicas, varios conectores (USB, ICSP, alimentación) y un botón que tiene función de reseteo del dispositivo. Esta plataforma tiene un fusible incorporado que evita cortocircuitos y garantiza un funcionamiento seguro con el cable USB. Se activa cuando más de 500 mA de corriente fluyen a través del puerto USB. En comparación con las computadoras centrales, Arduino Uno interactúa mucho más estrechamente con el entorno físico que lo rodea. La plataforma está construida sobre una placa de circuito impreso y está diseñada para funcionar con código abierto. Puede ser utilizado tanto por estudiantes como por aficionados, así como por profesionales que pueden ampliar y complementar los modelos a su propia discreción y trabajar libremente con código abierto. La plataforma está diseñada de tal manera que se le pueden agregar fácilmente nuevos componentes. El diseño requiere que el desarrollador opte por utilizar el dispositivo de forma independiente, por lo que no se coloca en una carcasa y no está estrictamente vinculado a la instalación;

Descripción de la pantalla Nokia 5110

La pantalla gráfica del Nokia 5110 es una pantalla monocromática económica con una diagonal de 1,6", que permite mostrar no sólo información de texto sino también imágenes. Su resolución es de 48x84 px y el voltaje al que puede funcionar es de 2,7-5 V. La información en la pantalla se muestra en bloques verticales. Su altura es de ocho píxeles, el ancho de la pantalla es de seis líneas. En el panel posterior hay símbolos para cada contacto, lo que no permitirá a los usuarios cometer errores en su ubicación.

Al ensamblar dispositivos en Arduino, a menudo nos enfrentamos a la necesidad de una salida de información autónoma. Y, como siempre, quiero que la solución sea económica. Y aquí resulta que la elección de dispositivos económicos no es muy rica.

Si se muestra poca información, es conveniente utilizar indicadores de siete segmentos. Son muy brillantes y contrastantes. Estas reglas de 4 dígitos y 0,36 pulgadas de alto en el TM1637 se venden por 70 centavos y están controladas por sólo 2 pines. Como puede imaginar, están diseñados principalmente para mostrar la hora, aunque pueden mostrar fácilmente, por ejemplo, la temperatura, la presión y otros parámetros, para los cuales 4 dígitos son suficientes.

Pero si hay mucha información de salida, no funcionarán. En tales casos, las más utilizadas son las pantallas LCD 1602 "populares", que tienen la capacidad de mostrar 2 líneas de 16 caracteres por un precio de dólar y medio. De esta manera podrás mostrar muchas veces más información.

Su hermano más avanzado de 4 líneas mostrará aún más información, pero ya es notablemente más caro, unos 5 dólares, y su tamaño ya es bastante grande.

Todos estos dispositivos tienen sus pros y sus contras. Las principales desventajas incluyen la falta de soporte para el idioma ruso, ya que la tabla de códigos está estrechamente conectada al chip y la imposibilidad de mostrar gráficos. Estrictamente hablando, es posible tener firmware cirílico en estos dispositivos, pero se venden principalmente en Rusia y a precios excesivos.
Si estas desventajas son decisivas para su uso en el dispositivo que está creando y le conviene la resolución de 84x48 píxeles en gráficos en blanco y negro, entonces debe prestar atención a la pantalla del Nokia 5110. Érase una vez una, pero estaba muy incompleta. y en lugares obsoletos. En particular, se afirmó allí que era imposible mostrar el alfabeto cirílico. Hoy no existe tal problema.

El héroe de nuestra revisión, con un precio de menos de un par de dólares, vino a mí en una caja de cartón duradera con una película protectora en la pantalla, por lo que muchas gracias al vendedor. El dispositivo tiene una placa de circuito impreso de 45x45 mm de PCB rojo y una pantalla LCD con una resolución de 84x48 píxeles y un tamaño de 40x25 mm. El dispositivo pesa 15 g. Tiene una luz de fondo azul que se puede apagar. Para Arduino, esta pantalla arrancará 5 pines digitales, sin contar la fuente de alimentación. El tablero tiene 2 filas de pines paralelos, por lo que puedes usar solo una fila. De ellos, 5 son para control, 2 para encendido y uno para encender la luz de fondo. Para encender la luz de fondo, debe conectar el pin LIGHT a tierra (hay otra versión de esta pantalla, como dicen, en la placa azul, donde este pin está conectado a la fuente de alimentación). La placa se entrega sin soldar y en el kit se incluyen dos peines.
Entonces, conectamos los pines SCLK, DIN, DC, CE y RTS a los pines Arduino, por ejemplo, 3, 4, 5, 6, 7. El pin VCC a 3.3V (¡Exactamente 3.3, no 5!), conectamos el tierra y descargar la biblioteca.
Las funciones de esta biblioteca le permiten mostrar primitivas gráficas (línea, círculo, rectángulo, etc.), imágenes rasterizadas y texto. La biblioteca contiene un ejemplo que muestra sus capacidades, le aconsejo que lo mire. Pero para que el texto se muestre en ruso, tendrás que modificar la fuente. Pero, afortunadamente, buenas personas ya han hecho todo por nosotros y ya podemos descargar el archivo de sustitución.
Daré un ejemplo del boceto a continuación y el resultado del texto en ruso se puede ver arriba. Es fácil calcular que con el tamaño de fuente más pequeño (No. 1) se pueden mostrar 84 caracteres (14 en 6 líneas), lo que es suficiente para mostrar, por ejemplo, mensajes de diagnóstico extensos. La fuente n.° 2 es el doble de grande.
La resolución de la pantalla le permite mostrar imágenes rasterizadas de dos colores bastante buenas, que pueden usarse como íconos en el programa.

Crear estos iconos es muy sencillo. Debajo del spoiler te mostraré cómo se hace esto.

Cómo crear rápidamente una imagen rasterizada usando el ejemplo del logotipo del sitio web MYSKU

Primero, tomemos una captura de pantalla de la pantalla del logotipo (tecla Imprimir pantalla).
Inicie Paint desde programas estándar y presione Ctrl+V. Toda la pantalla con el logo está a nuestra disposición.


Seleccione el fragmento deseado y presione el botón RECORTAR. Consigamos nuestro fragmento.

Ahora necesitamos convertir este fragmento en dos colores. La pintura misma puede manejar esto. Haga clic en "Guardar como" y seleccione el tipo "Imagen monocromática (*.bmp)". Ignoramos la advertencia del editor, hacemos clic en Aceptar y vemos la siguiente imagen:

Ahora necesitamos convertir este conjunto de píxeles en una serie de códigos para Arduino. Encontré uno que hace frente a esta tarea.
Necesita enviar un archivo bmp como entrada, ¡pero debe tener 256 colores! Así que haremos clic en "Guardar como" nuevamente y seleccionaremos el tipo "Arte bmp de 256 colores". Ahora recordemos las dimensiones de los lados del archivo resultante, deberá indicarlas en el boceto (busque en Paint en la parte inferior de la barra de estado o abriendo Propiedades del archivo -> pestaña Detalles) y vaya al convertidor en línea. .


Seleccionemos nuestro archivo, marquemos la casilla de números hexadecimales y hagamos clic en CONVERTIR.
Consigamos la matriz que necesitamos:


Copiamos esta matriz en el boceto, la compilamos y vemos qué sucede.


Ahora apaguemos la luz de fondo y veamos cómo se verán las imágenes sin ella.


Como puede ver, tanto el texto como los iconos son legibles. Además, cuanto más brillante sea la luz, mejor será la legibilidad (oh, recuerdo lo agradable que era usar el Nokia 1100 en un día soleado, mientras la gente escondía sus teléfonos con matrices de colores en la sombra para marcar un número). En general, puede utilizar la pantalla en este modo si hay suficiente iluminación o si la luz de fondo interfiere, o para ahorrar energía de la batería. Si la pantalla de alguien es difícil de ver, juega con el contraste en el boceto. El mejor contraste con y sin retroiluminación se obtiene con diferentes valores, esto hay que tenerlo en cuenta.

Un boceto de ejemplo para mostrar texto e imágenes.

#incluir #incluir // pin 3 - Salida de reloj serie (SCLK) // pin 4 - Salida de datos serie (DIN) // pin 5 - Selección de datos/comandos (D/C) // pin 6 - Selección de chip LCD (CS) // pin 7 - Reinicio de LCD (RST) Pantalla Adafruit_PCD8544 = Adafruit_PCD8544(3, 4, 5, 6, 7); const static unsigned char PROGMEM ku59x39 = ( 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xc0, 0x7f, 0xff, xff, 0xff, 0xff, 0xff, 0xf0, 0xe0, 0x1f, 0xff, 0xff, 0xe0, 0x0, 0x3, 0xf0, 0xfc, 0xf, 0xff, 0xfc, 0x0, 0x0, 0x0, 0x0, 0xff, 0x87, 0xff 0xc0, , 0x0, 0x0, 0x7f, 0xc0, 0xff, 0xe3, 0xff, 0x0, 0x0, 0x7f, 0xff, 0x90, 0xff, 0xf1, 0xfc, 0x0, 0x7, 0xff, 0xff, 0x30, 0xff, 0xf8, 0xf0, 0x0, , 0xff, 0xfe, 0x30, 0xff, 0xfc, 0x40, 0x3, 0xff, 0xff, 0xfc, 0x70, 0xff, 0xfe, 0x0, 0xf, 0xff, 0xff, 0xf8, 0xf0, 0xff, 0xff, 0x0, 0x7f, 0xf0, , 0xf0, 0xff, 0xff, 0x81, 0xff, 0xff, 0xff, 0xe1, 0xf0, 0xff, 0xff, 0xc7, 0xff, 0xff, 0xff, 0xe3, 0xf0, 0xff, 0xff, 0xc3, 0xff, 0xff, 0xff, 0xf0, 0xff, 0xe3, 0xff, 0xff, 0xff, 0x83, 0xf0, 0xff, 0xff, 0xe1, 0xff, 0xff, 0xff, 0x87, 0xf0, 0xff, 0xff, 0xf0, 0xff, 0xff, 0xff, 0x87, , 0xff, 0xff, 0, 0xff, 0xff , 0xff, 0x87, 0xf0, 0xff, 0xff, 0xf8, 0x7f, 0xff, 0x1f, 0x87, 0xf0, 0xff, 0xff, 0xf8, 0x7f, 0x0, 0x0, 0x7, 0xf0, 0xff, 0xfc, 0x38, 0x0, 0x0, 0x1, 0xf0, 0xff, 0xff, 0xfc, 0x20, 0x0, 0x0, 0xbf, 0xf0, 0xff, 0xff, 0xfe, 0x0, 0x3, 0xff, 0xff, 0xf0, 0xff, 0xff, 0xfe, 0x0, x3f, 0xe1, 0xff, 0xf0, 0xff, 0xff, 0xfe, 0x3, 0xf0, 0x0, 0x1, 0xf0, 0xff, 0xff, 0xfe, 0xf, 0x80, 0x0, 0x0, 0xf0, 0xff, 0xff, 0xff, 0xe, 0x0, 3f, 0xff, 0xf0, 0xff, 0xff, 0xff, 0xc, 0x3, 0xff, 0xe1, 0xf0, 0xff, 0xff, 0xff, 0x0, 0x1f, 0xff, 0xc0, 0xf0, 0xff, 0xff, 0xff, 0x7f, 0x88, 0xf0, 0xff, 0xff, 0xff, 0x80, 0xff, 0xff, 0x9c, 0xf0, 0xff, 0xff, 0xff, 0x83, 0xff, 0xff, 0x38, 0xf0, 0xff, 0xff, 0xff, 0xc3, , 0xff, 0x19, 0xf0, xff, 0xff, 0xff , 0xf0, 0xff, 0xff, 0x3, 0xf0, 0xff, 0xff, 0xff, 0xe0, 0x7f, 0xff, 0x87, 0xf0, 0xff, 0xff, 0xff, 0xce, 0x7f, 0xdf, 0xf0, 0xff, 0xff, xff, 0xce, 0x7f , 0xff, 0xff, 0xf0, 0xff, 0xff, 0xff, 0x9e, 0x7f, 0xff, 0xff, 0xf0, 0xff, 0xff, 0xff, 0x8c, 0xff, 0xff, 0xff 0, xf0, 0xff, 0xff, 0x80, , 0xff, 0xff, 0xff, 0xf0, 0xff, 0xff, 0xff, 0xc1, 0xff, 0xff, 0xff, 0xf0, 0xff, 0xff, 0xff, 0xe3, 0xff, 0xff, 0xff, 0xf0); void setup() ( display.begin(); display.setContrast(50); display.setTextSize(1); display.setTextColor(BLACK); // establece el color del texto ) void loop() ( display.clearDisplay(); display .drawBitmap(10, 5, ku59x39, 59, 39, BLACK); display.display(); display.clearDisplay(); display.setCursor(0,0); ; mostrar.display(); retraso(2000);


Bueno, y dado que Arduino (Procesador+RAM+Bootloader-BIOS)+unidad (EEPROM) + sistema de entrada/salida (IRDA Remote y Nokia 5110) es, de hecho, una computadora completa, entonces ¿por qué no escribir una completa? juego para ello? Por supuesto, nuestra computadora Arduino no podrá manejar un juego como GTA, ¡pero puede manejar fácilmente un simple juguete casual! Escribamos un juego de todos los tiempos: el Tetris.
Para cualquier programador, esto es como un ejercicio matutino, un ejercicio fácil para el cerebro, ¡así que adelante! Y es como si esto nunca hubiera sucedido antes en Muska. Y el juego revelará el potencial del tema.
Como sistema de entrada, decidí utilizar el control remoto IRDA desde CUALQUIER dispositivo. Con esta solución, sólo necesitamos uno, a un coste de 4 rublos cada uno. Y se puede encontrar un mando a distancia por infrarrojos en cualquier apartamento. Para la actuación de voz, también usaremos un tweeter piezoeléctrico de una placa base antigua; este será nuestro análogo económico de multimedia)). Ahora me llegará uno más genial, ¡pero esto ya está elevando el precio de nuestra supercomputadora en un dólar entero! Nos las arreglaremos por ahora. Ya estará con él.
En la placa conectamos dispositivos de entrada y salida y nuestro “multimedia”. Resultó así:


Yo usé Arduino Uno, ya que ya tiene los 3.3V que necesitamos, pero si usas el Mini, tendrás que sacar los 3.3 requeridos de los 5 voltios para la pantalla. La forma más sencilla desde internet es poner dos diodos de silicio en serie (seleccionar).
Para no dibujar un diagrama eléctrico, simplemente indicaré los pines de Arduino que utilicé.
Conexión de la pantalla Nokia 5110:
pin 3 - Reloj de salida en serie (SCLK)
pin 4 - Salida de datos serie (DIN)
pin 5 - Selección de datos/comando (D/C)
pin 6 - Selección de chip LCD (CS)
pin 7 - reinicio de LCD (RST)
Para iluminar el pin LIGHT del display lo tiramos al GND del Arduino. (¡Sólo para tablero rojo!). Más fuente de alimentación a 3,3V. Tierra a GND.
Conexión del receptor de infrarrojos:
pin 8 - IR (control). Alimentación a +5V y GND respectivamente.
Conexión del tweeter piezoeléctrico:
pin 9 - altavoz, Tierra a GND.
Después de la instalación, cargue el boceto.

Bosquejo del juego Tetris

//// © Klop 2017 #incluir #incluir #incluir #incluir #definir rk 4 // ancho del cuadrado #definir rz 5 // ancho del asiento #definir smeX 1 #definir smeY 1 #definir MaxX 10 // vidrio número de asientos horizontalmente #definir altavoz 9 #definir RECV_PIN 8 // pie en el receptor IRDA // pin 3 - Salida de reloj serie (SCLK) // pin 4 - Salida de datos serie (DIN) // pin 5 - Selección de datos/comandos (D/C) // pin 6 - Selección de chip LCD (CS) // pin 7 - reinicio de LCD (RST) Pantalla Adafruit_PCD8544 = Adafruit_PCD8544(3, 4, 5, 6, 7); IRrecv irrecv(RECV_PIN); resultados decode_results; byte mstacan; byte Lst,SmeH, centro, NumNext; byte MaxY; // número de lugares del vaso verticalmente int dxx, dyy, FigX, FigY, Victory, myspeed,tempspeed; sin firmar largo ok, izquierda, pravo, vniz, myrecord; flfirst largo sin firmar = 1234; // primer byte de etiqueta de lanzamiento fig= (((0,0,0,0), (0,0,0,0), (0,0,0,0), (0,0,0,0)) , ((0,1,0,0), (0,1,0,0), (0,1,0,0), (0,1,0,0)), ((0,0,0 ,0), (0,1,1,0), (0,1,1,0), (0,0,0,0)), ((0,1,0,0), (0,1 ,1,0), (0,0,1,0), (0,0,0,0)), ((0,1,0,0), (0,1,0,0), (0 ,1,1,0), (0,0,0,0)), ((0,1,0,0), (0,1,1,0), (0,1,0,0), (0,0,0,0)), ((0,0,1,0), (0,1,1,0), (0,1,0,0), (0,0,0,0 )), ((0,0,1,0), (0,0,1,0), (0,1,1,0), (0,0,0,0)), ((0,0 ,0,0), //8 (0,0,0,0), (0,0,0,0), (0,0,0,0)) ); //================================================== ============= void mybeep () // sonido (analogWrite(altavoz, 100); retardo(100); analogWrite(altavoz, 0); ) //======= =============== ========================= void figmove(byte a, byte b) (para (byte i=0;i<4;i++) for (byte j=0;j<4;j++) fig[a][i][j]=fig[b][i][j]; } //============================================== void figinit(byte a) { for (byte i=0;i<4;i++) for (byte j=0;j<4;j++) { fig[i][j]=fig[i][j]; if (fig[a][j][i]==1) // покажем след фигуру display.fillRect(i*rz+60, 20+(j)*rz, rk , rk, BLACK); else display.fillRect(i*rz+60, 20+(j)*rz, rk , rk, WHITE); } display.display(); NumNext=a; tempspeed=myspeed-(Victory/30)*50; // через каждые 30 линий увеличим скорость падения; dxx=0; for (byte i=0;i0) display.fillRect(i*rz+1, SmeH+(j-4)*rz, rk, rk, NEGRO); else display.fillRect(i*rz+1, SmeH+(j-4)*rz, rk, rk, BLANCO);<4;i++) for (j=0;j<4;j++) if (fig[j][i]==1) if (i+FigX+dx<0 || i+FigX+dx>ds(Victoria,1);<4;i++) for (j=0;j<4;j++) if (fig[j][i]==1) {mstacan=1; dxx=0; } } // переместили фигуру на новые координаты else { if (pov) figmove(0,8); for (i=0;i<4;i++) // восстановили фигуру for (j=0;j<4;j++) if (fig[j][i]==1) mstacan=1; } return(flag); } //================================================ void clearstacan() { for (byte i=0;imostrar.display(); ) //================================================ =============== = void ds(int aa, int b) ( display.fillRect(55, 10, 29, 10, BLANCO); display.setCursor(55,b*10 ); ========================== bool iffig(int dx, int dy) (int i,j; bool flag=true; bool pov=false; para (i=0;yo
Y puedes luchar. El juego admite la vinculación a cualquier control remoto. Para ello, al inicio del juego, cuando se te solicite “Presiona OK”, presiona el botón del control remoto que se encargará de rotar la figura. Si el control remoto del juego ya le resulta familiar, el juego comenzará inmediatamente. Si el control remoto es nuevo, entonces el código del botón OK no coincidirá con el memorizado y el juego requerirá que presiones los botones "Izquierda", "Derecha" y "Abajo" en secuencia. Estos botones se grabarán en la memoria no volátil del Arduino y posteriormente este control remoto en particular será reconocido inmediatamente al presionar el botón "OK".


Cuando "fallas" en la línea recopilada, se reproducirá un chirrido. Se implementa sobre la base de varios pines Arduino (en nuestro caso 9) para producir PWM a una frecuencia determinada.
El juego admite todos los atributos de un juego normal. También hay una pista para la siguiente cifra y la puntuación actual. El juego realiza un seguimiento de los registros. Este valor se almacena en la memoria no volátil de Arduino. Para restablecer el registro, simplemente cambie el valor flfirst=1234 en el boceto a cualquier otro valor. El juego también aumenta automáticamente la velocidad de caída cada 30 líneas canceladas, por lo que no podrás jugar indefinidamente). El boceto no fue optimizado ni ejecutado cuidadosamente, sino que fue escrito en tiempo libre por diversión. Si alguien encuentra algún error que escriba. Acerca de ©. Puedes editar el boceto como desees. Solo cuando publique sus opciones en algún lugar, indique un enlace a la fuente original).
Por qué lo hice - fines de semana largos + “por amor al arte”. Si mi hija fuera pequeña, probablemente le haría una mini máquina tragamonedas para su cuarto de muñecas para el 8 de marzo, justo a tiempo. Agregaría algunos juegos como Snake y Arkanoid, y probablemente cortaría el cuerpo de la PCB. Solo mi hija ya está defendiendo su doctorado este año, así que es un error, pero tal vez esta idea le resulte útil a alguien más).

Resumamos la pantalla del Nokia 5110:
Ventajas
+Posibilidad de mostrar gráficos;
+No hay problemas con el alfabeto cirílico;
+Bajo peso;
+Excelente relación dimensiones/cantidad de información mostrada;
+Las ventajas de la tecnología LCD utilizada son el bajo consumo de energía y la buena legibilidad con luz brillante;
+ Luz de fondo conmutable;
+Precio.

Contras
-La luz de fondo es desigual;
-La imagen es en blanco y negro (sin sombras);
-La necesidad de cuidar 3.3V, no todos los Arduino tienen ese voltaje.

Veredicto: Por su dinero, en base a la totalidad de sus características, ocupa con confianza su nicho, no en vano es un hígado tan largo entre los dispositivos de visualización para Arduino;

Estoy pensando en comprar +102 Añadir a favoritos Me gustó la reseña +148 +269

Nuevos artículos

● Proyecto 16: Indicador gráfico. Conexión de la pantalla Nokia 5110

En este experimento, veremos la pantalla gráfica Nokia 5110, que se puede utilizar en proyectos Arduino para mostrar información gráfica.

Componentes necesarios:

La pantalla de cristal líquido del Nokia 5110 es una pantalla monocromática con una resolución de 84×48 en un controlador PCD8544, diseñada para mostrar información gráfica y de texto. La fuente de alimentación de la pantalla debe estar entre 2,7 y 3,3 V (máximo 3,3 V; si se suministran 5 V al pin VCC, la pantalla puede dañarse). Pero los pines del controlador toleran +5 V, por lo que se pueden conectar directamente a las entradas de Arduino. Un punto importante es el bajo consumo, que permite alimentar la pantalla desde la placa Arduino sin una fuente de alimentación externa.
El diagrama de conexión del Nokia 5110 a Arduino se muestra en la Fig. 16.1.

Arroz. 16.1. Diagrama de conexión de Nokia 5110 a Arduino

Para trabajar con la pantalla Nokia 5110, usaremos la biblioteca Adafruit_GFX, que tiene amplias capacidades para mostrar gráficos y texto. En nuestro experimento, recibiremos datos de iluminación de un fotorresistor conectado a la entrada analógica de Arduino A0 y generaremos los datos de iluminación en representación numérica y gráfica. El diagrama de conexión se muestra en la Fig. 16.2.

Arroz. 16.2. Diagrama de conexión de Nokia 5110 y fotorresistor a Arduino

El código para nuestro boceto experimental se muestra en el Listado 16.1. Leemos los datos del fotorresistor y mostramos el valor numérico, así como gráficamente (barra de progreso), el valor de iluminancia como porcentaje del valor máximo. Tomamos los valores de iluminación mínima y máxima del experimento 13.

// Conectando la biblioteca #incluir #incluir // PIN 7 - RST Pin 1 en LCD // PIN 6 - CE Pin 2 en LCD // PIN 5 - DC Pin 3 en LCD // PIN 4 - DIN Pin 4 en LCD // PIN 3 - CLK Pin 5 en LCD Pantalla Adafruit_PCD8544 = Adafruit_PCD8544(3, 4, 5, 6, 7); const int LUZ=A0; // Pin A0 para entrada del fotorresistor constint MIN_LIGHT=200; // Umbral de iluminación inferior constanteint MAX_LIGHT=900; // Umbral de iluminación superior // Variable para almacenar datos del fotorresistor int valor1,val2 = 0; configuración nula()( mostrar.begin(); // establecer el contraste del fondo de la pantalla // parámetro muy importante! display.setContrast(60); display.clearDisplay(); // borrar pantalla retraso(2000); ) bucle vacío()( val1 = lectura analógica(LUZ); // Leer las lecturas del fotorresistor dibujarTexto(val1,1); // mostrar texto // escalando el valor del potenciómetro a 0-75 val2= mapa (val1, MIN_LIGHT, MAX_LIGHT, 0, 75); // salida del rectángulo negro en % display.fillRect(5, 25, val2, 10, 1); // genera la parte blanca del rectángulo display.fillRect(5 +val2,25, 75 -val2, 10, 0); mostrar.display(); retraso(1000); // pausa antes de nueva medición dibujarTexto(val1,2); //borrar texto) // procedimiento de salida de texto texto de dibujo vacío ( número largo sin firmar, color int)( display.setTextSize(2); // tamaño de fuente display.setCursor(20,5); // posición del cursor if (color==1) display.setTextColor(NEGRO); //imprime el valor de lo contrario display.setTextColor(BLANCO); // borrar (blanco sobre blanco) mostrar.imprimir(núm); )
Orden de conexión:

1. Conecte el sensor de pantalla y el fotorresistor del Nokia 5110 según el diagrama de la Fig. 16.2.
2. Cargue el boceto del Listado 16.1 en la placa Arduino.
3. Bloqueando el flujo de luz con la mano, observe el cambio en las lecturas de iluminación en la pantalla.

Listados de programas

Probablemente, como todos los constructores de Arduino, tenía alguna idea loca en mi cabeza. Pedí todas las piezas necesarias a China. Tuvimos que esperar mucho tiempo, pero luego nos entregaron antes de lo previsto un clon de la placa Arduino Uno y una pantalla LCD Nokia 5110. Como antes no estaba familiarizado con la electrónica y la programación, decidí no perder el tiempo y comencé a aprender cómo mostrar información en este módulo.

Lo primero que hice fue buscar en Google y encontré la publicación “Arduino, módulo LCD Nokia 5110 y alfabeto cirílico” del autor. Y luego me di cuenta de que todo lo que había planeado previamente no sería tan fácil de realizar.

Descubrí el alfabeto cirílico, todo es simple, no copiaré y pegaré la última publicación, pero hay un problema real con las imágenes. La tarea es la siguiente: necesitas hacer un dibujo y subirlo a la pantalla. Encontré el primer problema, entré al entorno de programación Arduino y vi que no existe "Insertar - Imágenes", pero es necesario escribir la imagen con un código determinado en el sistema de cálculo hexadecimal. Encontré varios editores, pero ese no fue el caso. La imagen no se muestra adecuadamente. Empecé a buscar problemas que pudieran ser.

A través de una serie de experimentos, intentos y pruebas, se me ocurrió un algoritmo que compartiré con ustedes:

1) Necesita obtener la imagen en sí, en formato .bmp en blanco y negro con una extensión de 84 x 48 píxeles.
Esto se puede hacer de varias maneras. Casi todos los editores gráficos tienen una función "Guardar como" donde especificamos los parámetros necesarios.
Lo hice en corelDRAW. Obtenemos algo similar. Es necesario aclarar que el nombre de la imagen debe guardarse con la distribución del teclado latino, ya que el siguiente programa no podrá abrirla.

2) Si es necesario, puedes editar la imagen en Paint; por extraño que parezca, existen varias herramientas sencillas e interesantes.

3) Usando esto obtenemos el código hexadecimal de la imagen.

4) Pegue este código en el código del programa Arduino y cárguelo en la placa:

// SCK - Pin 8 // MOSI - Pin 9 // DC - Pin 10 // RST - Pin 11 // CS - Pin 12 // #include LCD5110 miGLCD(8,9,10,11,12); uint8_t externo OKO; flotar y; uint8_t* bm; espacio interno; configuración vacía() ( myGLCD.InitLCD(); ) bucle vacío() ( myGLCD.clrScr(); myGLCD.drawBitmap(0, 0, OKO, 84, 48); myGLCD.update(); retraso(2000); )

#incluir const uint8_t OKO PROGMEM=( //Herramientas GLCD de código hexadecimal copiadas );




Arriba