Una pantalla redonda GC9A01 en un Arduino: una esfera de reloj
Intermedio
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
La GC9A01 es el controlador detrás de las pantallas de color redondas de 1.28 pulgadas que se usan en relojes caseros, indicadores y ojos de robots. El vidrio es un círculo de 240 píxeles de diámetro, se comunica por SPI, y las funciones de dibujo son las mismas de Adafruit GFX que quizá conozcas de otras pantallas a color.
El circuito de arriba es un Uno dibujando un reloj analógico en una GC9A01, con la hora de un módulo de reloj DS3231. Dibuja el disco una vez y luego mueve las manecillas cada segundo. Presiona Ejecutar: el disco tarda unos segundos en aparecer, porque un Uno tiene muchos píxeles que enviar, y luego la manecilla de segundos empieza a moverse.
Lo que necesitas
- Un Arduino Uno
- Un módulo de pantalla redonda GC9A01 de 1.28 pulgadas
- Un módulo de reloj DS3231
- Una protoboard y cables jumper
Cableado
| Componente y pin | Va a | Nota |
|---|---|---|
| GC9A01 VCC | 5 V | El módulo tiene su propio regulador |
| GC9A01 GND | GND | |
| GC9A01 SCL | Pin 13 | Reloj SPI, aunque diga SCL |
| GC9A01 SDA | Pin 11 | Datos SPI (MOSI), aunque diga SDA |
| GC9A01 CS | Pin 10 | Selección de chip |
| GC9A01 DC | Pin 9 | Comando o datos |
| GC9A01 RES | Nada | Se deja libre; la biblioteca lo reinicia con un comando |
| DS3231 SDA, SCL | A4, A5 | El reloj, por I2C |
SCL y SDA, pero no I2C
Las etiquetas de la mayoría de los módulos GC9A01 dicen SCL y SDA, lo que hace que todos piensen en I2C. Son SPI. SCL es el reloj SPI y va al pin 13 de un Uno, y SDA es la entrada de datos y va al pin 11. CS selecciona la pantalla y DC le indica si un byte es un comando o un píxel.
Eso deja libres A4 y A5, los pines I2C reales del Uno, para la DS3231. Los dos buses no se estorban entre sí.
La biblioteca Adafruit GC9A01A
Instala "Adafruit GC9A01A" desde el Gestor de bibliotecas, y con ella viene Adafruit GFX. En Mokxi ambas están integradas. El constructor recibe CS y DC, aquí Adafruit_GC9A01A tft(10, 9), y opcionalmente un pin de reinicio como tercero. begin() envía la larga tabla de arranque, despierta el panel y lo enciende.
Después de eso dibujas con GFX: fillScreen(), drawLine(), drawCircle(), fillCircle(), setCursor() y print(). Los colores son números de 16 bits, con nombres como GC9A01A_BLACK, GC9A01A_WHITE y GC9A01A_RED.
La memoria es un cuadrado de 240 por 240, y el vidrio redondo está montado encima. El centro es (120, 120) y el radio es 120, así que lo que dibujes en las esquinas se guarda, pero nadie lo ve.
#include <SPI.h>
#include <Wire.h>
#include "Adafruit_GFX.h"
#include "Adafruit_GC9A01A.h"
Adafruit_GC9A01A tft(10, 9); // CS, DC; no reset pin
const int16_t CX = 120;
const int16_t CY = 120;
const uint16_t FACE = GC9A01A_BLACK;
void hand(uint8_t i, int16_t radius, uint16_t color) {
tft.drawLine(CX, CY, dialX(i, radius), dialY(i, radius), color);
}
void setup() {
tft.begin();
drawFace();
Wire.begin();
}
void loop() {
// Rub out the old hands, then draw the new ones, longest last.
if (!first) {
hand(secondPos, 95, FACE);
hand(minutePos, 85, FACE);
hand(hourPos, 55, FACE);
}
hourPos = (now[2] % 12) * 5 + now[1] / 12;
minutePos = now[1];
secondPos = now[0];
hand(hourPos, 55, GC9A01A_WHITE);
hand(minutePos, 85, GC9A01A_WHITE);
hand(secondPos, 95, GC9A01A_RED);
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Dibuja lo que se mueve, no toda la pantalla
Una pantalla completa son 240 por 240 píxeles a dos bytes cada uno: 115,200 bytes. Eso es más de cincuenta veces la memoria del Uno, así que el Uno no puede guardar una copia de la pantalla. Envía los píxeles directo a la pantalla mientras los dibuja. En este circuito, llenar la pantalla de negro y dibujar el disco toma unos tres segundos, y por eso la esfera aparece un poco después de presionar Ejecutar.
Así que el sketch nunca vuelve a dibujar la esfera completa. Cada segundo dibuja otra vez las manecillas viejas en negro, lo que las borra, y luego dibuja las nuevas. Tres líneas delgadas tardan un instante, mientras que redibujar todo tardaría segundos y parpadearía.
Las manecillas salen de una tabla pequeña de senos en pasos de 6 grados, un minuto del disco. La DS3231 arranca a las 10:08:30, así que la manecilla de minutos apunta a la marca de 8 minutos y la de horas a la posición 50 del disco, que es (10 x 5) más 8 / 12 redondeado hacia abajo.
La hora desde la DS3231
El sketch no usa una biblioteca de RTC. Lee los primeros tres registros de la DS3231 con Wire: segundos, minutos y horas, empezando en el registro 0. El chip guarda cada uno como dos dígitos decimales empaquetados en un byte, lo que se llama BCD, así que fromBcd() convierte 0x38 en 38 antes de que el sketch lo use.
loop() lee el reloj cada 20 milisegundos y solo vuelve a dibujar cuando los segundos han cambiado. Así las manecillas se mueven una vez por segundo, y la pantalla pasa el resto del tiempo inactiva. Si el reloj no responde, readClock() devuelve false y el sketch lo intenta de nuevo 20 milisegundos después.
Colores, rotación y texto
El vidrio de la GC9A01 es IPS, y muestra los colores invertidos hasta que el controlador le indica lo contrario. La biblioteca lo hace en begin(), así que solo lo verás si escribes tu propio controlador: el negro sale blanco. Los colores son de 16 bits, cinco para el rojo, seis para el verde y cinco para el azul, y por eso el rojo puro es 0xF800.
setRotation() gira la imagen en pasos de 90 grados, útil cuando el módulo está montado al revés. El texto funciona con setCursor(), setTextColor() y print(), las mismas funciones de GFX que en otras pantallas a color; en Mokxi el texto es una fuente de 5x8.
Si conectas un pin de reinicio, pásalo como tercer argumento: Adafruit_GC9A01A tft(10, 9, 8). También hay una forma de cinco pines que recibe los pines de datos y reloj, para SPI por software en cualquier pin, a costa de velocidad.
Errores comunes
Conectar SCL y SDA a A5 y A4 porque las etiquetas parecen I2C. En un Uno van a los pines 13 y 11.
Redibujar toda la pantalla en loop(). Funciona, pero lentamente, y parpadea. Borra y redibuja solo las partes que cambian.
Dibujar en las esquinas de la memoria cuadrada, fuera del vidrio redondo.
Dejar el módulo de reloj sin conectar y esperar una hora. Mueve aquí el cable SDA del DS3231 y el marcador sigue dibujándose, pero las manecillas nunca aparecen, porque el sketch espera una hora que nunca llega.
Abre este circuito en el editor. Arduino Uno: una esfera de reloj en un GC9A01, conectado como se ejecuta al inicio de esta página. Cambia un componente o un valor y ejecútalo de nuevo.
Abrir el circuitoPreguntas
¿Qué biblioteca uso para un GC9A01 en Arduino?
Adafruit GC9A01A (Adafruit_GC9A01A.h) con Adafruit GFX. TFT_eSPI también admite el GC9A01, sobre todo en placas ESP32.
¿El GC9A01 es SPI o I2C?
SPI. Los pines etiquetados SCL y SDA son el reloj y los datos del SPI, así que van a los pines 13 y 11 de un Uno.
¿Qué resolución tiene la pantalla redonda GC9A01?
240 por 240 píxeles, con el vidrio redondo centrado en (120, 120) y un radio de 120.
¿Por qué mi GC9A01 es lento en un Arduino Uno?
Una pantalla completa son 115,200 bytes, y un Uno los envía uno por uno por SPI. Dibuja solo lo que cambia, como hace la esfera del reloj con sus manecillas.
Sigue así
De dónde vienen los datos de esta página
Ármalo en la vida real
Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.