Aprender

Um display redondo GC9A01 em um Arduino: um mostrador de relógio

Intermediário

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: um mostrador de relógio em um GC9A01ao vivo0.000 s 0.00x
Clique para abrir no editor
Um GC9A01 redondo de 240x240 em SPI e um DS3231 em I2C, desenhando um relógio analógico em um ATmega328P simulado.

O GC9A01 é o controlador dos displays coloridos redondos de 1,28 polegada usados em relógios caseiros, medidores e olhos de robô. O vidro é um círculo de 240 pixels de diâmetro, ele se comunica por SPI, e as chamadas de desenho são as mesmas da Adafruit GFX que você talvez conheça de outras telas coloridas.

O circuito acima é um Uno desenhando um relógio analógico em um GC9A01, com a hora vinda de um módulo de relógio DS3231. Ele desenha o mostrador uma vez e depois move os ponteiros a cada segundo. Aperte Rodar: o mostrador leva alguns segundos para aparecer, porque um Uno tem muitos pixels para enviar, e então o ponteiro dos segundos começa a se mover.

O que você precisa

  • Um Arduino Uno
  • Um módulo display redondo GC9A01 de 1,28 polegada
  • Um módulo de relógio DS3231
  • Uma protoboard e jumpers

Ligação

Componente e pinoVai paraNota
GC9A01 VCC5 VO módulo tem seu próprio regulador
GC9A01 GNDGND
GC9A01 SCLPino 13Clock do SPI, mesmo dizendo SCL
GC9A01 SDAPino 11Dados do SPI (MOSI), mesmo dizendo SDA
GC9A01 CSPino 10Seleção de chip
GC9A01 DCPino 9Comando ou dado
GC9A01 RESNadaDeixado livre; a biblioteca o reinicia com um comando
DS3231 SDA, SCLA4, A5O relógio, em I2C

SCL e SDA, mas não I2C

Os rótulos na maioria dos módulos GC9A01 dizem SCL e SDA, o que faz todo mundo pensar em I2C. Eles são SPI. SCL é o clock do SPI e vai para o pino 13 de um Uno, e SDA é a entrada de dados e vai para o pino 11. CS seleciona o display e DC diz se um byte é um comando ou um pixel.

Isso deixa A4 e A5, os pinos I2C de verdade do Uno, livres para o DS3231. Os dois barramentos não atrapalham um ao outro.

A biblioteca Adafruit GC9A01A

Instale "Adafruit GC9A01A" no Gerenciador de Bibliotecas, e ela traz a Adafruit GFX junto. No Mokxi as duas já vêm incluídas. O construtor recebe CS e DC, aqui Adafruit_GC9A01A tft(10, 9), e um pino de reset opcional em terceiro. begin() envia a longa tabela de inicialização, acorda o painel e o liga.

Depois disso você desenha com a GFX: fillScreen(), drawLine(), drawCircle(), fillCircle(), setCursor() e print(). As cores são números de 16 bits, com nomes como GC9A01A_BLACK, GC9A01A_WHITE e GC9A01A_RED.

A memória é um quadrado de 240 por 240, e o vidro redondo fica em cima dela. O centro é (120, 120) e o raio é 120, então o que você desenhar nos cantos fica armazenado, mas ninguém vê.

Do sketch do mostrador de relógio redondo
#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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Desenhe o que se move, não a tela inteira

Uma tela inteira tem 240 vezes 240 pixels a dois bytes cada: 115.200 bytes. Isso é mais de cinquenta vezes a memória do Uno, então o Uno não consegue guardar uma cópia da tela. Ele envia os pixels direto para o display conforme os desenha. No circuito aqui, preencher a tela de preto e desenhar o mostrador leva cerca de três segundos, e é por isso que o mostrador aparece um pouco depois que você aperta Rodar.

Então o sketch nunca redesenha o mostrador. A cada segundo ele desenha os ponteiros antigos de novo em preto, o que os apaga, e depois desenha os novos. Três linhas finas levam um instante, enquanto um redesenho completo levaria segundos e piscaria.

Os ponteiros vêm de uma pequena tabela de senos em passos de 6 graus, um minuto do mostrador. O DS3231 começa em 10:08:30, então o ponteiro dos minutos aponta para a marca de 8 minutos e o das horas para a posição 50 do mostrador, que é (10 x 5) mais 8 / 12 arredondado para baixo.

A hora do DS3231

O sketch não usa uma biblioteca de RTC. Ele lê os três primeiros registradores do DS3231 com Wire: segundos, minutos e horas, começando no registrador 0. O chip guarda cada um como dois dígitos decimais empacotados em um byte, o chamado BCD, então fromBcd() transforma 0x38 em 38 antes de o sketch usar.

loop() lê o relógio a cada 20 milissegundos e só redesenha quando os segundos mudam. Assim os ponteiros se movem uma vez por segundo, e o display passa o resto do tempo ocioso. Se o relógio não responder, readClock() retorna false e o sketch tenta de novo 20 milissegundos depois.

Cores, rotação e texto

O vidro do GC9A01 é IPS, e ele mostra as cores invertidas até o driver mandar não fazer isso. A biblioteca faz isso em begin(), então você só vê esse efeito se escrever seu próprio driver: o preto sai branco. As cores têm 16 bits, cinco para o vermelho, seis para o verde e cinco para o azul, e é por isso que o vermelho puro é 0xF800.

setRotation() gira a imagem em passos de 90 graus, útil quando o módulo está montado de cabeça para baixo. O texto funciona com setCursor(), setTextColor() e print(), as mesmas chamadas GFX de outras telas coloridas; no Mokxi o texto usa uma fonte de 5x8.

Com um pino de reset ligado, passe-o como terceiro argumento: Adafruit_GC9A01A tft(10, 9, 8). Também existe uma forma de cinco pinos que recebe os pinos de dados e clock, para SPI por software em qualquer pino, ao custo de velocidade.

Erros comuns

Ligar SCL e SDA em A5 e A4 porque os rótulos parecem I2C. Em um Uno eles vão nos pinos 13 e 11.

Redesenhar a tela inteira em loop(). Funciona, mas devagar, e pisca. Apague e redesenhe apenas as partes que mudam.

Desenhar nos cantos da memória quadrada, fora do vidro redondo.

Deixar o módulo do relógio sem ligação e esperar uma hora. Desligue aqui o fio SDA do DS3231 e o mostrador continua sendo desenhado, mas os ponteiros nunca aparecem, porque o sketch espera por uma hora que nunca chega.

Abra este circuito no editor. Arduino Uno: um mostrador de relógio em um GC9A01, ligado como roda no topo desta página. Troque um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

Qual biblioteca uso para um GC9A01 no Arduino?

Adafruit GC9A01A (Adafruit_GC9A01A.h) com Adafruit GFX. A TFT_eSPI também suporta o GC9A01, principalmente em placas ESP32.

O GC9A01 é SPI ou I2C?

SPI. Os pinos rotulados SCL e SDA são o clock e o dado do SPI, então vão nos pinos 13 e 11 de um Uno.

Qual é a resolução do display redondo GC9A01?

240 por 240 pixels, com o vidro redondo centrado em (120, 120) e raio de 120.

Por que meu GC9A01 está lento em um Arduino Uno?

Uma tela cheia tem 115.200 bytes, e um Uno os envia um por um via SPI. Desenhe apenas o que muda, como o mostrador do relógio faz com os ponteiros.

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.