Kulaté displeje nejsou v bastlířských projektech tak běžné jako klasické obdélníkové LCD nebo OLED panely. Přitom se přímo nabízejí pro různé budíky, měřicí přístroje, hodiny nebo stavové ukazatele.
Tentokrát tu mám malý 1,28″ barevný IPS TFT displej s rozlišením 240 × 240 bodů a řadičem GC9A01. Navíc je osazený na kulaté desce, takže se celý modul dobře hodí právě pro zabudování do nějakého kruhového přístroje.
Pro první pokusy ho připojím k LOLIN D1 mini V4.0 s ESP8266, který jsem už použil například při pokusech se senzorem SGP41. Nejdřív vyzkouším základní grafiku a potom si na displeji vytvořím jednoduchý analogový budík.

Co je to za displej
Použitý modul obsahuje kulatý IPS TFT LCD panel. TFT displej je proti jednoduchým monochromatickým LCD nebo OLEDům schopný zobrazovat plnobarevnou grafiku. Každému bodu můžeme samostatně nastavit barvu a vytvořit tak text, obrázky, grafy nebo třeba ručičkové přístroje.
IPS technologie se stará hlavně o dobré pozorovací úhly. Obraz by tak měl být dobře viditelný i při pohledu ze strany, což se u malého displeje určeného například do měřicího přístroje docela hodí.
Samotný panel má rozlišení 240 × 240 pixelů. Z pohledu programu tedy stále pracujeme se čtvercovou plochou 240 × 240 bodů. Fyzický panel je ale kulatý, takže rohové části této pomyslné čtvercové plochy jednoduše nevidíme.
To je dobré mít na paměti při návrhu grafiky. Text nebo jiný důležitý údaj umístěný příliš blízko rohu souřadnicové plochy skončí mimo viditelnou část displeje.
Řízení má na starosti čip GC9A01 a komunikace s mikrokontrolérem probíhá přes SPI.

Parametry modulu
Použil jsem konkrétně variantu s kulatou PCB z LaskaKitu.
| Parametr | Hodnota |
|---|---|
| Typ | IPS TFT LCD |
| Tvar | Kulatý |
| Úhlopříčka | 1,28″ |
| Řadič | GC9A01 |
| Rozlišení | 240 × 240 px |
| Barevná hloubka | 65 536 barev |
| Formát barev | RGB565, 16 bit |
| Komunikace | 4vodičové SPI |
| Logické úrovně | 3,3 V |
| Typický jas | 400 cd/m² |
| Aktivní plocha | Ø 32,4 mm |
| Kulatá část PCB | Ø 38 mm |
| Dotyková vrstva | Ne |
Barevný formát RGB565 používá pro každý pixel 16 bitů. Pět bitů připadá na červenou, šest na zelenou a dalších pět na modrou složku. Výsledkem je maximálně 65 536 různých barev.
Na desce je také stabilizátor XC6206P332MR, takže napájecí vstup VCC podle dokumentace konkrétního modulu snese i 5 V. Samotné logické vstupy jsou ale stále pouze 3,3V, takže při použití například klasického 5V Arduina by byl potřeba převodník logických úrovní.
S ESP8266 tento problém nemám. D1 mini pracuje přímo s 3,3V logikou.
Pro jednoduchost budu celý displej napájet také z výstupu 3,3 V.
Podsvícení
Na rozdíl od některých jiných TFT modulů tu nenajdeme samostatný vývod BL pro řízení podsvícení. Dvě bílé LED podsvícení jsou na této desce připojené napevno, takže po přivedení napájení displej svítí stále.
To je jednoduché při prvních pokusech, ale pro zařízení napájené z baterie je to zároveň určité omezení. Pokud bych chtěl podsvícení řídit programově, musel bych zasáhnout do samotného modulu nebo vypínat napájení celého displeje.

Vývody
Modul má pouze sedm pinů:
| Pin | Funkce |
|---|---|
| VCC | Napájení |
| GND | Zem |
| SCL | SPI hodinový signál |
| SDA | SPI data |
| DC | Volba data / příkaz |
| CS | Výběr displeje |
| RST | Reset displeje |
Označení SCL a SDA může na první pohled připomínat I²C, ale o I²C nejde.
SCL zde odpovídá hodinovému signálu SPI SCLK a SDA používám jako datový vstup MOSI. Pro tento displej nepotřebuji linku MISO, protože z něj při běžném použití žádná obrazová data zpět do ESP8266 nečtu.
Použitý hardware
Pro pokus budu potřebovat:
- 1,28″ TFT IPS GC9A01 240 × 240 px – zobrazovací modul
- LOLIN D1 mini V4.0 – řídicí deska s ESP8266
- propojovací vodiče
- USB-C kabel – napájení a programování D1 mini
LOLIN D1 mini V4.0 obsahuje ESP8266, 4 MB flash paměti a pracuje s logickými úrovněmi 3,3 V.

Zapojení
Pro přenos obrazových dat použiju hardwarové SPI ESP8266.
Standardní SPI piny ESP8266 jsou:
MOSI– GPIO13MISO– GPIO12SCLK– GPIO14
Zbývající řídicí signály můžeme připojit na další volné GPIO.
Zapojení jsem zvolil takto:
| GC9A01 | LOLIN D1 mini | GPIO | Význam |
|---|---|---|---|
| VCC | 3V3 | – | Napájení 3,3 V |
| GND | GND | – | Zem |
| SCL | 14 | GPIO14 | SPI SCLK |
| SDA | 13 | GPIO13 | SPI MOSI |
| DC | 4 | GPIO4 | Data / Command |
| CS | 16 | GPIO16 | Chip Select |
| RST | 5 | GPIO5 | Reset |
Pro CS jsem použil D0. Chip Select nemusí být přímo hardwarovým CS pinem SPI, protože knihovna si jej ovládá sama.
Vývod RST jsem připojil také přímo k ESP8266, takže může knihovna při inicializaci provést hardwarový reset řadiče.
MISO tentokrát nepotřebuji, protože v těchto příkladech posílám data pouze z ESP8266 do displeje.
Pozor: Přestože napájecí vstup tohoto konkrétního modulu snese podle výrobce desky i 5 V, jeho logické vstupy jsou pouze 3,3V. S D1 mini je tedy můžeme propojit přímo, ale při použití 5V mikrokontroléru by bylo potřeba použít převodník logických úrovní.

Instalace knihovny
Pro první pokus jsem zvolil knihovnu Adafruit GC9A01A. Ta je postavená na známé knihovně Adafruit GFX, přes kterou se kreslí text, čáry, kruhy a další grafické prvky. Knihovna Adafriut GC9A01A přímo podporuje hardwarové SPI a jako závislost používá Adafruit GFX.
V Arduino IDE otevřeme Manažéra knihoven, vyhledáme Adafruit GC9A01A a knihovnu nainstalujeme. Pokud si Arduino IDE vyžádá instalaci dalších závislostí Adafruit, necháme je také nainstalovat.
První program
Nejdřív nechci dělat nic složitého. První program pouze inicializuje displej, postupně vyplní celou plochu několika základními barvami a nakonec vykreslí kružnice, čáry a text.
Tím můžu jedním pokusem ověřit:
- komunikaci s displejem
- základní barvy
- orientaci obrazu
- text
- kreslení grafických objektů
- skutečnou viditelnou oblast kulatého displeje
///////////////////////GC9A01 TEST fw v.0.1 //////////////////////////////
///////////////////////31.8.2026 /////////////////////////////////////////
///////////////////////www.michaluvbrloh.cz////////////////////////////////
#include <SPI.h> //hardwarové SPI
#include <Adafruit_GFX.h> //základní grafické funkce
#include <Adafruit_GC9A01A.h> //ovládání displeje GC9A01A
const byte TFT_CS = D0; //Chip Select displeje - GPIO16
const byte TFT_DC = D2; //Data / Command - GPIO4
const byte TFT_RST = D1; //Reset displeje - GPIO5
Adafruit_GC9A01A displej(TFT_CS, TFT_DC, TFT_RST);
/////////////////////////////po spuštění///////////////////////////////////////////////////////////////////////////////////////
void setup()
{
Serial.begin(115200); //start sériové linky
displej.begin(); //inicializace displeje
displej.setRotation(0); //orientace obrazu
testBarev(); //otestuj základní barvy
testGrafiky(); //zobraz testovací obrazec
}
/////////////////////////////hlavní smyčka/////////////////////////////////////////////////////////////////////////////////////
void loop()
{
//testovací obraz zůstává zobrazený
}
/////////////////////////////test barev////////////////////////////////////////////////////////////////////////////////////////
void testBarev()
{
displej.fillScreen(GC9A01A_RED); //červená
delay(800);
displej.fillScreen(GC9A01A_GREEN); //zelená
delay(800);
displej.fillScreen(GC9A01A_BLUE); //modrá
delay(800);
displej.fillScreen(GC9A01A_WHITE); //bílá
delay(800);
displej.fillScreen(GC9A01A_BLACK); //černá
delay(800);
}
/////////////////////////////test grafiky//////////////////////////////////////////////////////////////////////////////////////
void testGrafiky()
{
displej.fillScreen(GC9A01A_BLACK); //černé pozadí
displej.drawCircle(120, 120, 115, GC9A01A_WHITE); //vnější kružnice
displej.drawCircle(120, 120, 100, GC9A01A_BLUE); //modrá kružnice
displej.drawCircle(120, 120, 80, GC9A01A_GREEN); //zelená kružnice
displej.drawLine(120, 5, 120, 235, GC9A01A_RED); //svislá osa
displej.drawLine(5, 120, 235, 120, GC9A01A_RED); //vodorovná osa
displej.setTextColor(GC9A01A_YELLOW); //žlutý text
displej.setTextSize(2); //velikost textu
displej.setCursor(78, 108); //pozice textu
displej.print(F("GC9A01")); //vypiš text
}
Knihovna při použití tohoto konstruktoru využívá výchozí hardwarové SPI. U ESP8266 má aktuální knihovna (v.1.1.1) nastavenou výchozí SPI frekvenci 40 MHz.
Po zapnutí by měl displej postupně přejít přes červenou, zelenou, modrou, bílou a černou plochu. Nakonec se zobrazí testovací obrazec.

Pokud by byl výsledný obraz otočený, stačí změnit:
displej.setRotation(0);
na hodnotu 1, 2 nebo 3. Knihovna podporuje všechny čtyři orientace.
Jednoduchý analogový budík
Kulatý displej si přímo říká o nějaký ručičkový ukazatel. Pro další pokus proto vytvořím jednoduchý analogový budík s rozsahem 0 až 100.
Nejde zatím o skutečné měření. Hodnota se bude automaticky měnit a ručička bude jezdit přes stupnici. Cílem je vyzkoušet, jak se na kulatém panelu pracuje s čárami, výpočtem souřadnic a překreslováním obrazu.
///////////////////////GC9A01 BUDIK fw v.0.1 /////////////////////////////
///////////////////////31.8.2026 /////////////////////////////////////////
///////////////////////www.michaluvbrloh.cz////////////////////////////////
#include <SPI.h> //hardwarové SPI
#include <Adafruit_GFX.h> //grafické funkce
#include <Adafruit_GC9A01A.h> //ovládání displeje
const byte TFT_CS = D0; //Chip Select displeje - GPIO16
const byte TFT_DC = D2; //Data / Command - GPIO4
const byte TFT_RST = D1; //Reset displeje - GPIO5
Adafruit_GC9A01A displej(TFT_CS, TFT_DC, TFT_RST);
int hodnota = 0; //aktuální hodnota budíku
int smer = 1; //směr pohybu ručičky
/////////////////////////////po spuštění///////////////////////////////////////////////////////////////////////////////////////
void setup()
{
displej.begin(); //start displeje
displej.setRotation(0); //orientace
}
/////////////////////////////hlavní smyčka/////////////////////////////////////////////////////////////////////////////////////
void loop()
{
nakresliBudik(hodnota); //nakresli aktuální hodnotu
hodnota = hodnota + smer; //posuň ručičku
if(hodnota >= 100) //pokud jsme na konci stupnice
{
hodnota = 100;
smer = -1; //změň směr
}
if(hodnota <= 0) //pokud jsme na začátku stupnice
{
hodnota = 0;
smer = 1; //změň směr
}
delay(60); //rychlost pohybu ručičky
}
/////////////////////////////vykreslení budíku////////////////////////////////////////////////////////////////////////////////
void nakresliBudik(int data)
{
const int stredX = 120; //střed displeje X
const int stredY = 120; //střed displeje Y
displej.fillScreen(GC9A01A_BLACK); //smaž displej
displej.drawCircle(stredX, stredY, 115,
GC9A01A_WHITE); //okraj budíku
//nakreslení dílků stupnice
for(int i = 0; i <= 10; i++)
{
float uhel = 135.0 + (i * 27.0); //úhel dílku
float rad = uhel * PI / 180.0; //převod na radiány
int x1 = stredX + cos(rad) * 95;
int y1 = stredY + sin(rad) * 95;
int x2 = stredX + cos(rad) * 108;
int y2 = stredY + sin(rad) * 108;
displej.drawLine(x1, y1, x2, y2,
GC9A01A_WHITE); //dílek stupnice
}
//výpočet polohy ručičky
float uhel = 135.0 + (data * 2.7);
float rad = uhel * PI / 180.0;
int konecX = stredX + cos(rad) * 82;
int konecY = stredY + sin(rad) * 82;
displej.drawLine(stredX, stredY,
konecX, konecY,
GC9A01A_RED); //ručička
displej.fillCircle(stredX, stredY, 6,
GC9A01A_RED); //střed ručičky
//číselná hodnota
displej.fillRect(90, 155, 60, 30,
GC9A01A_BLACK); //místo pro hodnotu
displej.setTextColor(GC9A01A_YELLOW);
displej.setTextSize(2);
displej.setCursor(100, 160);
displej.print(data);
}
Ručička se pohybuje po 270° oblouku. Hodnota 0 začíná vlevo dole, 50 je nahoře a 100 končí vpravo dole.
Pro skutečný projekt by už stačilo místo proměnné hodnota dosadit například teplotu, tlak, stav baterie, otáčky motoru nebo jiný údaj.
Při první verzi programu jsem při každém pohybu ručičky celý displej vymazal pomocí fillScreen() a následně znovu vykreslil ciferník. Výsledkem bylo výrazné blikání. Mnohem lepší je statickou část ciferníku nakreslit pouze jednou a při změně hodnoty překreslovat jen měněné části – původní ručičku, její novou polohu a malou oblast s číselnou hodnotou. Množství dat posílaných do displeje se tím výrazně zmenší a pohyb je podstatně plynulejší.
///////////////////////GC9A01 BUDIK fw v.0.2 /////////////////////////////
///////////////////////www.michaluvbrloh.cz////////////////////////////////
#include <SPI.h> //hardwarové SPI
#include <Adafruit_GFX.h> //grafické funkce
#include <Adafruit_GC9A01A.h> //ovládání displeje
const byte TFT_CS = D0; //Chip Select displeje - GPIO16
const byte TFT_DC = D2; //Data / Command - GPIO4
const byte TFT_RST = D1; //Reset displeje - GPIO5
Adafruit_GC9A01A displej(TFT_CS, TFT_DC, TFT_RST);
const int stredX = 120; //střed displeje X
const int stredY = 120; //střed displeje Y
int hodnota = 0; //aktuální hodnota
int staraHodnota = -1; //předchozí hodnota
int smer = 1; //směr pohybu ručičky
/////////////////////////////po spuštění///////////////////////////////////////////////////////////////////////////////////////
void setup()
{
displej.begin(); //start displeje
displej.setRotation(0); //orientace displeje
displej.fillScreen(GC9A01A_BLACK); //smaž displej pouze jednou
nakresliStupnici(); //nakresli pevnou část budíku
}
/////////////////////////////hlavní smyčka/////////////////////////////////////////////////////////////////////////////////////
void loop()
{
nakresliRucicku(hodnota); //aktualizuj pouze ručičku
staraHodnota = hodnota; //ulož aktuální hodnotu
hodnota = hodnota + smer; //změň hodnotu
if(hodnota >= 100)
{
hodnota = 100;
smer = -1;
}
if(hodnota <= 0)
{
hodnota = 0;
smer = 1;
}
delay(60);
}
/////////////////////////////vykreslení stupnice//////////////////////////////////////////////////////////////////////////////
void nakresliStupnici()
{
displej.drawCircle(stredX, stredY, 115,
GC9A01A_WHITE); //okraj budíku
//hlavní dílky stupnice
for(int i = 0; i <= 10; i++)
{
float uhel = 135.0 + (i * 27.0);
float rad = uhel * PI / 180.0;
int x1 = stredX + cos(rad) * 95;
int y1 = stredY + sin(rad) * 95;
int x2 = stredX + cos(rad) * 108;
int y2 = stredY + sin(rad) * 108;
displej.drawLine(x1, y1, x2, y2,
GC9A01A_WHITE);
}
}
/////////////////////////////aktualizace ručičky//////////////////////////////////////////////////////////////////////////////
void nakresliRucicku(int data)
{
//nejdřív smaž starou ručičku
if(staraHodnota >= 0)
{
float staryUhel = 135.0 + (staraHodnota * 2.7);
float staryRad = staryUhel * PI / 180.0;
int staryX = stredX + cos(staryRad) * 82;
int staryY = stredY + sin(staryRad) * 82;
displej.drawLine(stredX, stredY,
staryX, staryY,
GC9A01A_BLACK);
}
//nakresli novou ručičku
float uhel = 135.0 + (data * 2.7);
float rad = uhel * PI / 180.0;
int konecX = stredX + cos(rad) * 82;
int konecY = stredY + sin(rad) * 82;
displej.drawLine(stredX, stredY,
konecX, konecY,
GC9A01A_RED);
//obnov střed ručičky
displej.fillCircle(stredX, stredY, 6,
GC9A01A_RED);
//aktualizuj pouze malou oblast s číslem
displej.fillRect(90, 155, 65, 25,
GC9A01A_BLACK);
displej.setTextColor(GC9A01A_YELLOW);
displej.setTextSize(2);
displej.setCursor(100, 160);
displej.print(data);
}
Proč je kulatý displej trochu jiný
Při programování není GC9A01 nijak zásadně složitější než běžný obdélníkový TFT. Rozdíl je hlavně v návrhu samotné grafiky.
Souřadnice stále používají rozsah:
X = 0 až 239
Y = 0 až 239
Střed displeje je tedy přibližně:
X = 120
Y = 120
Jenže bod (0,0) leží v levém horním rohu pomyslného čtverce a na fyzickém kulatém panelu ho vůbec neuvidíme.
U kulaté grafiky se proto vyplatí většinu důležitých prvků umisťovat vzhledem ke středu displeje. Právě kružnice, oblouky, ručičky a radiální ukazatele jsou pro tento panel přirozenější než klasické menu plné obdélníkových políček.
Další možnosti – obrázky a bitmapy
Barevný TFT se hodí také pro zobrazování obrázků. Rozlišení 240 × 240 px je už dostatečné například pro ikony, loga, ciferníky nebo jednoduché fotografie.
Použitá knihovna Adafruit GFX/GC9A01A neumí běžný JPG soubor sama přímo zobrazit. Jednou z možností je převést grafiku do pole pixelů v RGB565 a uložit ji přímo do programu.
U většího množství obrázků už ale začíná být zajímavější použít například SD kartu nebo souborový systém ve flash paměti ESP8266.
To by se mohlo hodit pro některý další pokus.
Kam se takový displej hodí
Kulatý tvar samozřejmě není vhodný úplně všude. Pro výpis dlouhého textu nebo klasické menu bude většinou praktičtější obdélníkový panel.
GC9A01 ale dává smysl hlavně tam, kde chceme vytvořit něco připomínajícího skutečný přístroj:
- analogový voltmetr
- ampérmetr
- teploměr
- otáčkoměr
- rychloměr
- ukazatel stavu baterie
- hodiny
- kompas
- stavový indikátor
- malé ovládací panely
- retro nebo steampunkové přístroje
Zajímavá je také kombinace kulatého displeje s mechanickým rámečkem. Při správném zabudování nemusí být na hotovém zařízení téměř poznat, že se pod ciferníkem skrývá plnobarevný LCD panel.
Praktické zkušenosti
Čitelnost displeje je velmi dobrá i při pohledu z ostrých úhlů. Obraz zůstává dobře viditelný a nezaznamenal jsem ani výraznou změnu barev, což odpovídá použití IPS panelu.
SPI komunikace fungovala během testování bez problémů a neobjevily se žádné chyby při přenosu dat nebo vykreslování. Výchozí orientace při nastavení setRotation(0) má spodní část obrazu na straně vývodů displeje.
Jas je pro běžné vnitřní osvětlení dostatečný. Na přímém slunci jsem displej zatím neměl možnost vyzkoušet, takže čitelnost v těchto podmínkách nedokážu posoudit.
Velmi příjemně mě překvapilo podání barev. Naživo jsou barvy pěkně syté a displej působí výrazně lépe než na fotografiích nebo videu, kde vypadají znatelně vybledleji.
Jedna vlastnost je ale jasná už z konstrukce modulu: podsvícení nejde samostatným pinem vypnout. Pro stolní nebo USB napájený přístroj to nemusí ničemu vadit, ale u bateriového zařízení s tím bude potřeba počítat.
Závěr
Kulatý GC9A01 je proti klasickým displejům zajímavý hlavně svým tvarem. Přestože má fyzicky kruhovou zobrazovací plochu, z pohledu programu stále pracujeme s běžným rastrem 240 × 240 bodů.
Při animované grafice se navíc ukázalo, že je mnohem lepší překreslovat pouze měněné prvky než při každém kroku mazat celý displej.
Připojení k LOLIN D1 mini je díky SPI jednoduché. Pro samotná obrazová data stačí hardwarové piny D5 a D7 a další tři GPIO použijeme pro CS, DC a reset. Obě zařízení zároveň pracují s 3,3V logikou, takže není potřeba žádný převodník úrovní.
Nejzajímavější mi na tomto displeji přijdou právě různé digitální náhrady klasických ručičkových přístrojů. Na 240 × 240 bodech už se dá vytvořit poměrně detailní ciferník a přitom celý displej zabere jen několik centimetrů.
Pro další pokus by stálo za to připravit vlastní grafický ciferník a vyzkoušet také zobrazování barevných bitmap.
Tento modul zakoupíte na Laskakit.cz, přímý odkaz je ZDE.
Další díly ze začátečnické série o modulech najdete ZDE.
