Componenten · 15 min leestijd

ILI9341 Arduino-gids: TFT-display aansluiten, touch en afbeeldingen van SD

Een ILI9341 TFT-display aansluiten op Arduino: 3,3 V-niveauconversie op de Uno, Adafruit GFX, XPT2046-touch, BMP van SD, ESP32 TFT_eSPI en witte scherm oplossen.

Een ILI9341 Arduino-opstelling is de goedkoopste en populairste manier om een display van 240×320 pixels met 65 duizend kleuren aan je project toe te voegen. Deze TFT-modules van 2,4 en 2,8 inch op een rode printplaat sluit je met een paar draden aan via SPI. De touchversies hebben ook een XPT2046-touchcontroller en een microSD-kaartsleuf. Met één module toon je kleurengraphics, touchknoppen en afbeeldingen van een kaart. Ideaal voor menu's, dashboards, games en fotolijsten waarvoor een OLED of een tekst-LCD niet meer genoeg is.

In deze gids leer je stap voor stap hoe de module werkt, hoe je de 5 V-uitgangen van de Arduino Uno veilig aansluit op de 3,3 V-ingangen van het display, hoe je tekst, vormen en kleuren tekent met de bibliotheken Adafruit_ILI9341 en Adafruit GFX, hoe je het touchscreen uitleest en hoe je BMP-afbeeldingen van een SD-kaart toont. Daarna behandelen we veel sneller tekenen op de ESP32 met TFT_eSPI, MicroPython op de Raspberry Pi Pico en alle oorzaken van het probleem met het "witte scherm" waar bijna iedereen minstens één keer tegenaan loopt.

ILI9341 TFT-kleurendisplaymodule
ILI9341 TFT-kleurendisplaymodule: 240×320 pixels, SPI-interface en 65 duizend kleuren. Touchversies hebben ook een XPT2046-chip en een microSD-sleuf op de print.

Wat is het ILI9341 TFT-display en hoe werkt het?

De ILI9341 is de driverchip achter het glas. Hij bevat ongeveer 172 KB beeldgeheugen (GRAM) voor alle 240×320 pixels. De Arduino stuurt commando's en kleurdata via SPI naar dit geheugen en de chip ververst het beeld zelf tientallen keren per seconde. Het beeld hoeft dus niet in het RAM van de Arduino te staan: zelfs een Uno met 2 KB RAM kan een groot kleurenscherm aansturen. Om iets te tekenen selecteer je eerst een venster (x, y, breedte, hoogte) en stuur je daarna de pixels van dat venster een voor een. De DC-pin geeft aan of de verstuurde byte een commando (LOW) of data (HIGH) is. Kleuren worden meestal verstuurd in RGB565-formaat: 16 bits per pixel, 5 bits rood, 6 bits groen en 5 bits blauw. Hoe de SPI-bus precies werkt, lees je in Wat is SPI.

EigenschapWaarde
DriverchipILI9341
Resolutie240×320 pixels (320×240 in landschap)
Kleur65.536 kleuren met RGB565 (de chip ondersteunt 262K)
Schermformaten2,2", 2,4", 2,8" en 3,2" (allemaal 240×320)
Interface4-draads SPI: CS, DC, SCK, MOSI (MISO om te lezen)
Voeding (VCC)3,3–5 V (er zit een 3,3 V-regelaar op de print)
Logisch niveau3,3 V (niet 5 V-tolerant)
StroomverbruikOngeveer 0,3–0,6 W, vooral de achtergrondverlichting
TouchResistief, XPT2046-controller (op touchmodellen)
Extra hardwaremicroSD-kaartsleuf (aparte SPI-pins)

2,4 of 2,8 inch? SPI-module of Uno-shield

Eigenschap2,4" SPI-module2,8" SPI-module2,4" Uno-shield
Resolutie240×320240×320240×320
AansluitingSPI, met jumperdradenSPI, met jumperdraden8-bits parallel, past bovenop de Uno
Gebruikte pins5 voor het display, 8–9 met touch en SD5 voor het display, 8–9 met touch en SDBijna alle (D2–D9, A0–A4, D10–D13 voor SD)
DriverILI9341ILI9341Wisselt: ILI9341, ILI9325, ST7789 en andere
BibliotheekAdafruit_ILI9341, TFT_eSPIAdafruit_ILI9341, TFT_eSPIMCUFRIEND_kbv
TouchXPT2046 (SPI)XPT2046 (SPI)4-draads analoog (TouchScreen-bibliotheek)
ESP32 en PicoGeschiktGeschiktOntworpen voor de Uno en Mega

Dit artikel behandelt de SPI-module, omdat die ook werkt met de ESP32 en Pico en de meeste pins van de Uno vrijlaat. De twee SPI-modules hebben precies dezelfde pins en code; het scherm van 2,8 inch heeft iets grotere pixels, dus touchknoppen raak je makkelijker. Als je display als shield direct op de Uno past, kunnen de SPI-bibliotheken het niet aansturen en is het resultaat meestal een wit scherm. Installeer voor zo'n shield de bibliotheek MCUFRIEND_kbv, lees de driver-ID uit met tft.readID() (0x9341 voor de ILI9341) en start hem met tft.begin(ID). Voor een kleiner maar scherper alternatief zie je ST7789 TFT-display, en om alle opties te vergelijken lees je Arduino-displaytypes.

ILI9341-pinout en bedradingstabel

Aan één rand van de module zit de hoofdheader van 14 pins: de eerste 9 pins zijn voor het display en de laatste 5, die met T_ beginnen, voor touch. De 4 pins aan de tegenoverliggende rand (SD_CS, SD_MOSI, SD_MISO, SD_SCK) gaan naar de kaartsleuf. Alle drie de apparaten kunnen dezelfde SPI-bus delen (SCK, MOSI, MISO); alleen hun CS-pins moeten apart zijn. De onderstaande tabel past bij elke sketch in dit artikel; op de Pico is touch vanwege het snelheidsverschil op een aparte SPI-bus aangesloten.

ModulepinArduino Uno (via niveauconverter)ESP32Raspberry Pi Pico
VCC5V3V33V3(OUT)
GNDGNDGNDGND
CSD10GPIO 15GP17
RESETD8GPIO 4GP21
DCD9GPIO 2GP20
SDI (MOSI)D11GPIO 23GP19
SCKD13GPIO 18GP18
LED3.3V3V33V3(OUT)
SDO (MISO)D12 (direct)GPIO 19GP16
T_CLKD13GPIO 18GP10
T_CSD7GPIO 21GP13
T_DIND11GPIO 23GP11
T_DOD12 (direct)GPIO 19GP12
T_IRQD2 (direct)Niet aangeslotenNiet aangesloten
SD_CSD4GPIO 5Niet aangesloten
SD_MOSI / SD_MISO / SD_SCKD11 / D12 / D13GPIO 23 / 19 / 18Niet aangesloten
De VCC-pin van ILI9341-modules accepteert 5 V, maar de signaalpins zijn alleen 3,3 V. De regelaar op de print verlaagt alleen de voedingsspanning; op de lijnen CS, DC, RESET, SCK en MOSI vindt geen niveauconversie plaats. Als je de 5 V-uitgangen van de Uno direct aansluit, krijg je vaak een wit scherm en soms raakt de chip blijvend beschadigd. De J1-jumper aan de achterkant omzeilt de regelaar: soldeer hem alleen dicht als je VCC voedt met 3,3 V. Zet je 5 V op VCC terwijl J1 dicht is, dan brandt het display door.

3,3 V-niveauconversie op de Arduino Uno

De ESP32 en Raspberry Pi Pico werken al op 3,3 V, dus je sluit het display direct aan. Op 5 V-boards zoals de Uno, Nano en Mega moet elke lijn van de Arduino naar het display worden teruggebracht naar 3,3 V: CS, DC, RESET, SCK, MOSI en, als je touch en SD gebruikt, T_CLK, T_DIN, T_CS, SD_CS, SD_MOSI en SD_SCK. De lijnen SDO, T_DO, SD_MISO en T_IRQ die van het display naar de Arduino lopen hebben geen converter nodig: de Uno leest alles boven 3 V als HIGH en een 3,3 V-uitgang voldoet daaraan. In de praktijk zijn er vier manieren:

  • 74HC4050-bufferchip (de schoonste oplossing): hij werkt op 3,3 V, accepteert 5 V op zijn ingangen en zet 6 lijnen om in één chip. Hij is snel en werkt zonder problemen met SPI op 8 MHz. De oudere CD4050 werkt ook maar is traag; raakt het beeld verstoord, dan moet je de SPI-snelheid verlagen. Het display alleen heeft 5 lijnen nodig; met touch en SD komen T_CS en SD_CS erbij voor 7 lijnen, gebruik dus voor de zevende een tweede chip of een spanningsdeler.
  • Spanningsdelers met weerstanden: plaats per lijn 1 kΩ tussen de Arduino-pin en de displaypin en 2 kΩ tussen de displaypin en GND; dat geeft 5 V × 2 / 3 ≈ 3,3 V. Andere weerstandsparen bereken je met de spanningsdelercalculator. Het is goedkoop, maar 10 weerstanden voor 5 lijnen maken het breadboard druk.
  • Kant-en-klare niveauconvertermodule: modules met 4 of 8 kanalen met BSS138-MOSFET's zijn makkelijk te bedraden, maar hun pull-upweerstanden maken de signaalflanken bij hoge snelheden zachter. Raakt het beeld verstoord, verlaag SPI dan naar 4 MHz met tft.begin(4000000). De methoden worden vergeleken in logische niveauconverter.
  • De methode die je beter vermijdt: de populaire truc met "een serieweerstand van 10 kΩ op elke lijn" voert de overtollige spanning af naar de interne beveiligingsdiodes van de chip. Het kan een tijdje werken, maar het is onbetrouwbaar en kan het display op de lange termijn beschadigen.

Stap voor stap: eerst testen met Adafruit_ILI9341

  1. Open de Library Manager in de Arduino IDE, zoek naar Adafruit ILI9341 en installeer hem. Kies bij de vraag over afhankelijkheden voor Install all, zodat ook Adafruit GFX en Adafruit BusIO worden geïnstalleerd. Is dit je eerste bibliotheek, dan helpt Een Arduino-bibliotheek toevoegen je verder.
  2. Installeer voor touch ook de bibliotheek XPT2046_Touchscreen van Paul Stoffregen. De SD-bibliotheek wordt met de Arduino IDE meegeleverd.
  3. Bedraad het display volgens de tabel hierboven, op de Uno via een niveauconverter. Voor de eerste test kun je de touch- en SD-pins onaangesloten laten.
  4. Upload de onderstaande sketch en open de Serial Monitor op 9600 baud. Je zou tekst en vormen op het display moeten zien en de diagnostische codes van het display in de Serial Monitor.
  5. Probeer ook de meegeleverde voorbeelden: File > Examples > Adafruit ILI9341 > graphicstest meet hoeveel microseconden elke tekenbewerking duurt.
C++ (Arduino IDE)
1#include <SPI.h>
2#include <Adafruit_GFX.h>
3#include <Adafruit_ILI9341.h>
4
5#define TFT_CS  10   // ekran seçme / chip select
6#define TFT_DC  9    // komut/veri seçimi / command/data select
7#define TFT_RST 8    // donanım reset / hardware reset
8
9Adafruit_ILI9341 tft(TFT_CS, TFT_DC, TFT_RST);   // donanım SPI: D11 MOSI, D13 SCK / hardware SPI
10uint16_t orange;                                  // kendi rengimiz / our own colour
11
12void setup() {
13  Serial.begin(9600);
14  tft.begin();                                    // Uno'da 8 MHz SPI / 8 MHz SPI on Uno
15
16  // Teşhis: çalışan ekranda 0x94 ve 0xC0 beklenir / Diagnostics: a working display reports 0x94 and 0xC0
17  Serial.print(F("Power Mode: 0x"));
18  Serial.println(tft.readcommand8(ILI9341_RDMODE), HEX);
19  Serial.print(F("Self Diagnostic: 0x"));
20  Serial.println(tft.readcommand8(ILI9341_RDSELFDIAG), HEX);
21
22  tft.setRotation(1);                             // yatay, 320x240 / landscape, 320x240
23  tft.fillScreen(ILI9341_BLACK);
24  orange = tft.color565(255, 128, 0);             // RGB'den RGB565'e / RGB to RGB565
25
26  tft.setTextColor(ILI9341_WHITE);
27  tft.setTextSize(3);                             // 18x24 piksel karakter / 18x24 px characters
28  tft.setCursor(10, 10);
29  tft.print(F("BlueGrays"));
30  tft.setTextColor(ILI9341_CYAN);
31  tft.setTextSize(2);
32  tft.setCursor(10, 45);
33  tft.print(F("ILI9341 320x240"));
34
35  tft.fillRect(10, 75, 90, 60, ILI9341_RED);                  // dolu dikdörtgen / filled rectangle
36  tft.drawRect(115, 75, 90, 60, ILI9341_GREEN);               // çerçeve / outline
37  tft.fillCircle(265, 105, 30, ILI9341_BLUE);                 // dolu daire / filled circle
38  tft.fillRoundRect(10, 150, 140, 50, 10, orange);            // yuvarlak köşeli düğme / rounded button
39  tft.drawTriangle(180, 200, 240, 150, 300, 200, ILI9341_YELLOW);
40  tft.drawFastHLine(0, 220, 320, ILI9341_MAGENTA);            // yatay çizgi / horizontal line
41}
42
43void loop() {
44  // Arka plan rengiyle yazınca eski rakam silinir, ekran titremez / writing with a background colour erases the old digits, no flicker
45  tft.setTextColor(ILI9341_WHITE, orange);
46  tft.setTextSize(2);
47  tft.setCursor(22, 167);
48  tft.print(millis() / 1000);
49  tft.print(F(" s"));
50  delay(200);
51}
FunctieWat het doet
tft.begin(frequency)Start het display; zonder frequentie gebruikt het 8 MHz SPI op de Uno en 40 MHz op de ESP32
tft.setRotation(0–3)Kiest de oriëntatie: 0 en 2 staand (240×320), 1 en 3 liggend (320×240)
tft.fillScreen(colour)Vult het hele scherm met één kleur
tft.setTextColor(text, background)Stelt de tekstkleur in; met een achtergrondkleur overschrijft het de oude tekst netjes
tft.setTextSize(n)Schaalt de tekst n keer; formaat 1 = tekens van 6×8 pixels
tft.drawRect / fillRect(x, y, width, height, colour)Omtrek van een rechthoek of gevulde rechthoek
tft.fillRoundRect(x, y, width, height, r, colour)Gevulde rechthoek met afgeronde hoeken; ideaal voor knoppen
tft.drawCircle / fillCircle(x, y, r, colour)Cirkel of gevulde cirkel
tft.color565(r, g, b)Zet RGB-waarden van 0–255 om in een 16-bits kleur
tft.readcommand8(command)Leest een register van het display (MISO moet aangesloten zijn); voor het oplossen van problemen

Kant-en-klare kleurconstanten (19 stuks, zoals ILI9341_RED, ILI9341_NAVY en ILI9341_ORANGE) horen bij de bibliotheek; gebruik voor je eigen kleur color565(). Die plaatst de bovenste 5 bits van rood, de bovenste 6 bits van groen en de bovenste 5 bits van blauw naast elkaar: kleur = (R >> 3) << 11 | (G >> 2) << 5 | (B >> 3). Voor oranje (255, 165, 0) bijvoorbeeld worden 31 << 11 = 0xF800 en 41 << 5 = 0x0520 samengevoegd tot 0xFD20, precies de waarde van ILI9341_ORANGE in de bibliotheek. Groen krijgt één extra bit omdat het menselijk oog gevoeliger is voor groen.

Als je veranderende getallen wist met fillScreen() en elke keer opnieuw tekent, gaat het scherm flikkeren; op de Uno duurt het vullen van het hele scherm bij 8 MHz SPI minstens 0,15 seconde. Gebruik in plaats daarvan setTextColor(text, background) zoals in de sketch, of wis met fillRect() alleen het kleine gebied dat verandert. Vaste teksten in F("...") schrijven bespaart ook de 2 KB RAM van de Uno; bij geheugenproblemen zie je Arduino te weinig geheugen.

Het XPT2046-touchscreen uitlezen

Op touchmodules zit een dunne resistieve laag boven op het glas. Waar je vinger of een stylus drukt, raken twee geleidende lagen elkaar; de XPT2046-chip meet de X- en Y-positie van dat punt met een 12-bits ADC als ruwe waarden van 0 tot 4095 en geeft ook een drukwaarde (Z). De bibliotheek beschouwt een Z-waarde onder 400 als geen aanraking. De chip zit op dezelfde SPI-bus als het display maar praat op een lagere snelheid, rond 2 MHz; de bibliotheek stelt de snelheid bij elke leesactie zelf in. De T_IRQ-pin gaat LOW als het scherm wordt aangeraakt, zodat de processor niet nutteloos hoeft te lezen. De onderstaande sketch verandert het scherm in een klein tekenbord: je kiest een kleur uit de vakjes bovenaan en wist het scherm met de knop "SIL" (wissen).

C++ (Arduino IDE)
1#include <SPI.h>
2#include <Adafruit_GFX.h>
3#include <Adafruit_ILI9341.h>
4#include <XPT2046_Touchscreen.h>
5
6#define TFT_CS  10
7#define TFT_DC  9
8#define TFT_RST 8
9#define T_CS    7    // dokunmatik seçme / touch chip select
10#define T_IRQ   2    // dokununca LOW olur / goes LOW on touch
11#define SD_CS   4    // SD kullanılmıyor, HIGH tutulur / SD unused, kept HIGH
12
13// Kalibrasyon: Seri Monitör'deki ham değerlerle değiştir / Calibration: replace with the raw values from Serial Monitor
14#define TS_MINX 300
15#define TS_MAXX 3800
16#define TS_MINY 300
17#define TS_MAXY 3800
18
19Adafruit_ILI9341 tft(TFT_CS, TFT_DC, TFT_RST);
20XPT2046_Touchscreen ts(T_CS, T_IRQ);
21
22uint16_t brush = ILI9341_YELLOW;                  // fırça rengi / brush colour
23
24void drawPalette() {
25  tft.fillRect(0, 0, 40, 40, ILI9341_RED);
26  tft.fillRect(40, 0, 40, 40, ILI9341_GREEN);
27  tft.fillRect(80, 0, 40, 40, ILI9341_BLUE);
28  tft.fillRect(120, 0, 40, 40, ILI9341_YELLOW);
29  tft.drawRect(260, 0, 60, 40, ILI9341_WHITE);    // silme düğmesi / clear button
30  tft.setTextColor(ILI9341_WHITE);
31  tft.setTextSize(2);
32  tft.setCursor(273, 13);
33  tft.print(F("SIL"));
34}
35
36void setup() {
37  Serial.begin(9600);
38  pinMode(SD_CS, OUTPUT);
39  digitalWrite(SD_CS, HIGH);                      // SD kart hattı meşgul etmesin / keep the SD card off the bus
40  tft.begin();
41  tft.setRotation(1);                             // ekran yatay / display landscape
42  ts.begin();
43  ts.setRotation(1);                              // dokunmatik de aynı yönde / touch in the same orientation
44  tft.fillScreen(ILI9341_BLACK);
45  drawPalette();
46}
47
48void loop() {
49  if (!ts.touched()) return;                      // dokunma yok / no touch
50  TS_Point p = ts.getPoint();                     // ham x, y (0-4095) ve basınç z / raw x, y and pressure z
51  Serial.print(p.x); Serial.print(',');
52  Serial.print(p.y); Serial.print(',');
53  Serial.println(p.z);
54
55  int16_t x = constrain(map(p.x, TS_MINX, TS_MAXX, 0, 319), 0, 319);   // ekran koordinatı / screen coordinate
56  int16_t y = constrain(map(p.y, TS_MINY, TS_MAXY, 0, 239), 0, 239);
57
58  if (y < 40) {                                   // üst şerit: palet ve düğme / top strip: palette and button
59    if (x < 40)        brush = ILI9341_RED;
60    else if (x < 80)   brush = ILI9341_GREEN;
61    else if (x < 120)  brush = ILI9341_BLUE;
62    else if (x < 160)  brush = ILI9341_YELLOW;
63    else if (x >= 260) { tft.fillScreen(ILI9341_BLACK); drawPalette(); }
64  } else {
65    tft.fillCircle(x, y, 3, brush);               // parmağın altına nokta / dot under the finger
66  }
67}

De ruwe waarden zijn niet precies 0 en 4095 in de uiterste hoeken; op de meeste modules liggen de randen ongeveer tussen 200–400 en 3700–3900. Om te kalibreren open je de Serial Monitor, raak je met een stylus de linkerbovenhoek en rechteronderhoek aan en vul je de x- en y-waarden die je ziet in bij de constanten TS_MINX, TS_MAXX, TS_MINY en TS_MAXY. Verschijnt de stip gespiegeld ten opzichte van je vinger, wissel dan de min- en maxwaarden van die as in map(); zijn X en Y helemaal verwisseld, probeer dan ts.setRotation()-waarden van 0 tot 3. Een echt menu werkt op dezelfde manier: je tekent knoppen en controleert in welke rechthoek het aangeraakte punt valt. De resistieve laag werkt ook met een vinger, maar een stylusachtige punt is nauwkeuriger voor kleine knoppen.

BMP-afbeeldingen van de SD-kaart tonen

Met de microSD-sleuf aan de achterkant van de module bewaar je logo's, achtergronden en foto's op een kaart en toon je ze op het scherm. Om een afbeelding voor te bereiden verklein je een foto tot 320×240 pixels en sla je hem in Paint op als 24-bits Bitmap (.bmp). Omdat de Arduino SD-bibliotheek met korte bestandsnamen werkt, gebruik je een naam van maximaal 8 tekens zoals RESIM.BMP en formatteer je de kaart als FAT32. Details over de kaart zelf en de oplossing voor de foutmelding initialization failed staan in Arduino SD-kaartmodule. Houd er rekening mee dat deze sleuf ook 3,3 V is: op de Uno moeten ook de lijnen SD_CS, SD_MOSI en SD_SCK door de niveauconverter.

C++ (Arduino IDE)
1#include <SPI.h>
2#include <SD.h>
3#include <Adafruit_GFX.h>
4#include <Adafruit_ILI9341.h>
5
6#define TFT_CS  10
7#define TFT_DC  9
8#define TFT_RST 8
9#define SD_CS   4
10#define T_CS    7
11#define CHUNK   20   // tek okumada 20 piksel (60 bayt) / 20 pixels (60 bytes) per read
12
13Adafruit_ILI9341 tft(TFT_CS, TFT_DC, TFT_RST);
14
15uint16_t read16(File &f) {                        // BMP sayıları küçük uçlu / BMP numbers are little-endian
16  uint16_t lo = f.read();
17  uint16_t hi = f.read();
18  return lo | (hi << 8);
19}
20
21uint32_t read32(File &f) {
22  uint32_t lo = read16(f);
23  uint32_t hi = read16(f);
24  return lo | (hi << 16);
25}
26
27bool drawBmp(const char *name, int16_t x, int16_t y) {
28  File f = SD.open(name);
29  if (!f) return false;                                   // dosya yok / file not found
30  if (read16(f) != 0x4D42) { f.close(); return false; }  // "BM" imzası / "BM" signature
31  read32(f);                                              // dosya boyutu / file size
32  read32(f);                                              // ayrılmış alan / reserved
33  uint32_t offset = read32(f);                            // piksel verisinin başı / start of pixel data
34  read32(f);                                              // başlık boyutu / header size
35  int32_t w = (int32_t)read32(f);
36  int32_t h = (int32_t)read32(f);
37  read16(f);                                              // düzlem sayısı / colour planes
38  uint16_t depth = read16(f);
39  uint32_t comp = read32(f);
40  if (depth != 24 || comp != 0) { f.close(); return false; }   // yalnız 24 bit, sıkıştırmasız / 24-bit uncompressed only
41
42  bool bottomUp = true;                                   // BMP satırları alttan üste / rows are stored bottom-up
43  if (h < 0) { h = -h; bottomUp = false; }
44  uint32_t rowSize = (w * 3 + 3) & ~3UL;                  // satırlar 4 baytın katı / rows padded to 4 bytes
45  int32_t drawW = w, drawH = h;
46  if (x + drawW > tft.width())  drawW = tft.width() - x;   // ekrana sığmayanı kırp / clip to the screen
47  if (y + drawH > tft.height()) drawH = tft.height() - y;
48
49  uint8_t sdBuf[CHUNK * 3];
50  uint16_t line[CHUNK];
51  for (int32_t row = 0; row < drawH; row++) {
52    uint32_t pos = offset + (bottomUp ? (h - 1 - row) : row) * rowSize;
53    f.seek(pos);                                          // satırın başına git / jump to the start of the row
54    for (int32_t col = 0; col < drawW; col += CHUNK) {
55      int16_t n = drawW - col;
56      if (n > CHUNK) n = CHUNK;
57      f.read(sdBuf, n * 3);
58      for (int16_t i = 0; i < n; i++) {                   // BGR'den RGB565'e / BGR to RGB565
59        line[i] = tft.color565(sdBuf[i * 3 + 2], sdBuf[i * 3 + 1], sdBuf[i * 3]);
60      }
61      tft.drawRGBBitmap(x + col, y + row, line, n, 1);    // parçayı ekrana bas / push the chunk to the screen
62    }
63  }
64  f.close();
65  return true;
66}
67
68void setup() {
69  Serial.begin(9600);
70  pinMode(T_CS, OUTPUT);
71  digitalWrite(T_CS, HIGH);                       // dokunmatik hattı meşgul etmesin / keep touch off the bus
72  tft.begin();
73  tft.setRotation(1);                             // 320x240 yatay / landscape
74  tft.fillScreen(ILI9341_BLACK);
75  tft.setTextSize(2);
76
77  if (!SD.begin(SD_CS)) {                         // kart başlatılamadı / card init failed
78    tft.setTextColor(ILI9341_RED);
79    tft.setCursor(10, 10);
80    tft.print(F("SD kart bulunamadi"));
81    return;
82  }
83  uint32_t t = millis();
84  if (!drawBmp("RESIM.BMP", 0, 0)) {
85    tft.setTextColor(ILI9341_YELLOW);
86    tft.setCursor(10, 10);
87    tft.print(F("RESIM.BMP okunamadi"));
88  }
89  Serial.print(F("Cizim suresi / Draw time (ms): "));
90  Serial.println(millis() - t);
91}
92
93void loop() {
94}

De eerste 54 bytes van een BMP-bestand vormen de header: daarin staan de handtekening "BM", waar de pixeldata begint, de breedte, de hoogte en de kleurdiepte. Pixels worden opgeslagen in de volgorde blauw, groen, rood (BGR) en normaal van onder naar boven, en elke rij wordt aangevuld tot een veelvoud van 4 bytes. Daarom springt de sketch voor elke schermrij naar de juiste positie in het bestand, leest telkens 20 pixels (60 bytes), zet ze om naar RGB565 en stuurt ze door met drawRGBBitmap(). Werken in kleine stukken houdt alles binnen het RAM van de Uno en laat de SD-kaart en het display om de beurt dezelfde SPI-bus gebruiken. De tekentijd wordt naar de Serial Monitor geprint; op de Uno verschijnt een afbeelding over het hele scherm in een paar seconden rij voor rij. Wil je PNG- of JPEG-bestanden tonen en veel sneller tekenen, stap dan over op een ESP32 met de bibliotheken TFT_eSPI en TJpg_Decoder.

Snel tekenen op de ESP32 met TFT_eSPI

ESP32-ontwikkelboard
Dankzij de 3,3 V-logica sluit de ESP32 direct aan op de ILI9341 en stuurt hij SPI aan op 40 MHz, waardoor hij vele malen sneller tekent dan de Uno.

De ESP32 werkt op 3,3 V en kan SPI tot 40 MHz aansturen, dus je hebt geen niveauconverter nodig en het vullen van het hele scherm duurt in theorie nog maar ongeveer 31 milliseconden. Om die snelheid echt te benutten is de bibliotheek TFT_eSPI van Bodmer de gebruikelijke keuze. Die spreekt de SPI-hardware van de ESP32 direct aan en ondersteunt anti-aliased (gladde) lettertypen en vooral buffers buiten beeld, sprites genoemd. Je tekent zoveel je wilt in een sprite in het RAM en stuurt het resultaat in één keer naar het scherm, zodat zelfs snel veranderende graphics niet flikkeren. Wat TFT_eSPI anders maakt, is dat de pins niet in je sketch worden ingesteld maar in het bestand User_Setup.h in de bibliotheekmap. Open het, zet de standaard actieve pinregels voor de ESP8266 (NodeMCU) in commentaar en activeer deze:

C++ (Arduino IDE)
1// TFT_eSPI/User_Setup.h içinde yalnız bu satırlar açık kalsın / keep only these lines active in TFT_eSPI/User_Setup.h
2#define ILI9341_DRIVER
3
4#define TFT_MISO 19
5#define TFT_MOSI 23
6#define TFT_SCLK 18
7#define TFT_CS   15   // ekran seçme / chip select
8#define TFT_DC    2   // komut/veri / data/command
9#define TFT_RST   4   // sıfırlama / reset
10#define TOUCH_CS 21   // dokunmatik seçme (T_CS) / touch chip select (T_CS)
11
12#define LOAD_GLCD     // 1: 8 piksel yazı tipi / 8 px font
13#define LOAD_FONT2    // 2: 16 piksel / 16 px
14#define LOAD_FONT4    // 4: 26 piksel / 26 px
15#define LOAD_FONT7    // 7: 7 segment rakamlar / 7-segment digits
16#define LOAD_GFXFF    // Adafruit FreeFont'lar / Adafruit FreeFonts
17#define SMOOTH_FONT
18
19#define SPI_FREQUENCY       40000000   // kablolar uzunsa 27000000 / 27 MHz with long wires
20#define SPI_READ_FREQUENCY  20000000
21#define SPI_TOUCH_FREQUENCY  2500000
C++ (Arduino IDE)
1#include <SPI.h>
2#include <TFT_eSPI.h>                     // pinler User_Setup.h içinde / pins are set in User_Setup.h
3
4TFT_eSPI tft = TFT_eSPI();
5TFT_eSprite graph = TFT_eSprite(&tft);    // ekran dışı çizim alanı / off-screen canvas
6
7// Touch_calibrate örneğinin verdiği 5 sayıyla değiştir / replace with the 5 numbers from the Touch_calibrate example
8uint16_t calData[5] = {286, 3534, 283, 3600, 6};
9
10const int GW = 300, GH = 100;             // grafik boyutu / graph size
11uint8_t samples[GW];                      // son 300 ölçüm / last 300 readings
12uint32_t frames = 0, fps = 0, lastFps = 0;
13
14void setup() {
15  tft.init();
16  tft.setRotation(1);                     // yatay, 320x240 / landscape, 320x240
17  tft.setTouch(calData);
18  tft.fillScreen(TFT_BLACK);
19  tft.setTextColor(TFT_WHITE, TFT_BLACK);
20  tft.drawString("ESP32 + TFT_eSPI", 10, 8, 4);   // 4 numaralı yazı tipi, 26 px / font 4, 26 px
21  graph.createSprite(GW, GH);             // 300x100x2 bayt = 60 KB RAM / 60 KB of RAM
22}
23
24void loop() {
25  memmove(samples, samples + 1, GW - 1);                          // grafiği sola kaydır / scroll the graph left
26  samples[GW - 1] = map(analogRead(34), 0, 4095, 0, GH - 1);       // GPIO 34'teki potansiyometre / pot on GPIO 34
27
28  graph.fillSprite(TFT_BLACK);
29  for (int y = 0; y < GH; y += 25) graph.drawFastHLine(0, y, GW, TFT_DARKGREY);   // ızgara / grid
30  for (int x = 1; x < GW; x++) {
31    graph.drawLine(x - 1, GH - 1 - samples[x - 1], x, GH - 1 - samples[x], TFT_GREEN);
32  }
33  graph.setTextColor(TFT_YELLOW);
34  graph.drawString(String(fps) + " FPS", 4, 4, 2);
35  graph.pushSprite(10, 50);               // tek seferde ekrana gönder, titreme yok / push in one go, no flicker
36
37  uint16_t tx, ty;
38  if (tft.getTouch(&tx, &ty)) {           // dokunulduysa / if touched
39    tft.fillRect(10, 170, 300, 30, TFT_BLACK);
40    tft.setTextColor(TFT_CYAN, TFT_BLACK);
41    tft.drawString("Dokunma / Touch: " + String(tx) + ", " + String(ty), 10, 175, 2);
42  }
43
44  frames++;
45  if (millis() - lastFps >= 1000) {       // saniyede bir FPS hesapla / compute FPS once per second
46    fps = frames;
47    frames = 0;
48    lastFps = millis();
49  }
50}

De sketch tekent de waarde van een potmeter op GPIO 34 als een scrollende grafiek en toont de frames per seconde (FPS) in de hoek van de sprite. Een sprite van 300×100 pixels in 16-bits kleur neemt 60 KB RAM in beslag; dat is ongeveer 30 keer het hele geheugen van de Uno, maar geen probleem voor de ESP32. Voor touch sluiten de pins T_CLK, T_DIN en T_DO aan op de lijnen SCK, MOSI en MISO van het display en blijft alleen T_CS (GPIO 21) apart. Voor je eigen kalibratiewaarden voer je het voorbeeld Generic > Touch_calibrate van TFT_eSPI één keer uit, raak je de pijlen in de hoeken aan en kopieer je de 5 getallen uit de Serial Monitor naar de array calData. De kant-en-klare regel Setup42_ILI9341_ESP32.h in User_Setup_Select.h kiest dezelfde displaypins, maar de regel TOUCH_CS moet je zelf toevoegen. Ben je nieuw met de ESP32, lees dan eerst Wat is de ESP32.

Als je TFT_eSPI bijwerkt vanuit de Arduino IDE, wordt de bibliotheekmap herschreven en gaan je instellingen in User_Setup.h verloren; blijft een display dat gisteren werkte vandaag wit, kijk dan eerst hier en bewaar dus een back-up van je setupbestand. Zijn rood en blauw verwisseld, activeer dan TFT_RGB_ORDER TFT_BGR; lijken de kleuren op een negatief, activeer dan TFT_INVERSION_ON; sommige panelen werken beter met ILI9341_2_DRIVER. TFT_eSPI 2.5.43 kan op sommige boards met de 3.x-versies van het esp32-boardpakket crashen en herstarten bij het opstarten; gebeurt dat, ga dan in de Boards Manager terug naar een 2.0.x-versie van het esp32-pakket.

ILI9341 met de Raspberry Pi Pico en MicroPython

De Pico is ook een 3,3 V-board, dus het display sluit direct aan. De meest gebruikte MicroPython-driver is het paar ili9341.py en xpt2046.py uit de repository micropython-ili9341 van rdagger; kopieer beide bestanden met Thonny naar de Pico. In de onderstaande code zit het display op SPI0 met 40 MHz en de touchcontroller op een aparte SPI1-bus met 1 MHz, zodat het snelheidsverschil tussen de twee chips geen probleem is. De code tekent tekst en vormen en zet daarna gele stippen waar je aanraakt, zodat je een eenvoudig tekenbord hebt. Gebruik je de Pico en Thonny voor het eerst, begin dan met Wat is de Raspberry Pi Pico.

MicroPython
1from machine import Pin, SPI
2from time import sleep_ms
3from ili9341 import Display, color565      # ili9341.py Pico'da olmalı / must be on the Pico
4from xpt2046 import Touch                  # xpt2046.py Pico'da olmalı / must be on the Pico
5
6# Ekran: SPI0, 40 MHz / Display: SPI0, 40 MHz
7spi_tft = SPI(0, baudrate=40000000, sck=Pin(18), mosi=Pin(19), miso=Pin(16))
8tft = Display(spi_tft, cs=Pin(17), dc=Pin(20), rst=Pin(21), width=240, height=320, rotation=0)
9
10# Dokunmatik: ayrı SPI1, 1 MHz / Touch: separate SPI1, 1 MHz
11spi_touch = SPI(1, baudrate=1000000, sck=Pin(10), mosi=Pin(11), miso=Pin(12))
12touch = Touch(spi_touch, cs=Pin(13), width=240, height=320)
13
14WHITE = color565(255, 255, 255)
15YELLOW = color565(255, 255, 0)
16
17tft.clear(color565(0, 0, 0))                                   # ekranı temizle / clear the screen
18tft.draw_text8x8(10, 10, "BlueGrays + Pico", WHITE)
19tft.fill_rectangle(10, 30, 100, 50, color565(255, 0, 0))       # dolu dikdörtgen / filled rectangle
20tft.draw_rectangle(130, 30, 100, 50, color565(0, 255, 0))      # çerçeve / outline
21tft.fill_circle(60, 130, 30, color565(0, 128, 255))            # dolu daire / filled circle
22tft.draw_line(0, 175, 239, 175, color565(255, 0, 255))         # çizgi / line
23tft.draw_text8x8(10, 185, "Ekrana dokun / Touch me", YELLOW)
24
25while True:
26    raw = touch.raw_touch()                # dokunma yoksa None / None when not touched
27    if raw is not None:
28        x, y = touch.normalize(*raw)       # ham değeri piksele çevir / raw value to pixels
29        y = 319 - y                        # eksen ters ise / if the axis is inverted
30        x = min(max(x, 3), 236)            # ekran dışına taşma / keep inside the screen
31        y = min(max(y, 3), 316)
32        tft.fill_circle(x, y, 3, YELLOW)
33    sleep_ms(20)

In staande stand (rotation=0) is de breedte 240 en de hoogte 320; om het scherm liggend te gebruiken geef je width=320 en height=240 mee samen met rotation=90. De standaardkalibratie van de touchdriver (x_min=100, x_max=1962) past niet op elke module; zit de stip ernaast, print dan de waarden van raw_touch() en geef je eigen x_min, x_max, y_min en y_max mee aan Touch(). Om afbeeldingen te tonen leest de functie draw_image() van de driver .raw-bestanden die zijn omgezet naar RGB565; het script utils/img2rgb565.py uit de repository doet die omzetting op je computer.

Het probleem met het witte scherm en hoe je het oplost

Het bekendste ILI9341-probleem is een scherm dat helemaal wit blijft terwijl de achtergrondverlichting aan is. Een wit scherm is eigenlijk een aanwijzing: voeding en achtergrondverlichting werken, maar de driverchip is nooit geïnitialiseerd. Als het paneel geen commando's ontvangt, laten de pixels het licht door en ziet het scherm er wit uit. Het probleem zit dus bijna altijd in de communicatie. Loop de onderstaande tabel van boven naar beneden door:

SymptoomWaarschijnlijke oorzaakOplossing
Wit scherm, direct op de Uno aangesloten5 V-signalen, geen niveauconverterGebruik een 74HC4050 of spanningsdelers; vervang de module als de chip beschadigd is
Wit scherm, draden aangeslotenCS en DC verwisseld, of de pinnummers in de code komen niet overeen met de bedradingVergelijk de definities van TFT_CS, TFT_DC en TFT_RST één voor één met de tabel
Wit scherm, RESET zweeftRESET niet aangesloten of op de verkeerde pinSluit RESET aan op de pin in de code of op 3,3 V; laat hem nooit zweven
Wit scherm op de ESP32 (TFT_eSPI)User_Setup.h niet aangepast of door een update gewistSchakel de ESP8266-regels uit en schrijf de ESP32-pins en ILI9341_DRIVER opnieuw
Af en toe een wit scherm, verschoven of vervormd beeldLange jumperdraden, SPI te snel, slecht contact op het breadboardHoud draden korter dan 10–15 cm; verlaag SPI naar 20–27 MHz, of naar 4 MHz op de Uno
Wit scherm alleen met touch of SD aangeslotenDe CS-pin van het andere apparaat zweeft en blokkeert de busZet elke ongebruikte CS-pin als OUTPUT en schrijf hem in je code HIGH
Werkt met geen enkele codeHet display is geen ILI9341 (ST7789, ILI9488) of het is een parallel shieldLees het label op de achterkant; een scherm van 3,5 inch en 320×480 is een ILI9488, een shield heeft MCUFRIEND_kbv nodig
Wit scherm, flikkerende achtergrondverlichtingOnvoldoende stroomVoed VCC met 5 V en probeer een andere USB-kabel en voeding
Om de fout te beperken gebruik je de diagnoseregels in de eerste sketch. Toont de Serial Monitor Power Mode: 0x94 en Self Diagnostic: 0xC0, dan ontvangt het display commando's en zit het probleem in de software (rotatie, kleuren of tekencode). Zijn de waarden 0x0 of 0xFF, dan kan de Arduino niet met het display praten: controleer de draden, de niveauconverter en de CS/DC-pins. Deze leesactie werkt alleen als de SDO-lijn (MISO) is aangesloten.

Andere veelgemaakte fouten

  • Verkeerde kleuren: als rood als blauw verschijnt, gebruikt het paneel BGR-volgorde; wijzig de instelling TFT_RGB_ORDER in TFT_eSPI. Lijken de kleuren op een negatief, probeer dan tft.invertDisplay(true).
  • Beeld op zijn kop of gespiegeld: wijzig de waarde van setRotation() tussen 0 en 3 en pas de touchassen daarop aan.
  • Het display werkt maar touch of SD niet: controleer of T_CS en SD_CS overeenkomen met de pins in je code. Op sommige modules geeft de SDO-uitgang van het display de bus niet vrij; probeer in dat geval de SDO-pin van het display los te koppelen, waarna alleen de diagnoseleesactie niet meer werkt.
  • De BMP verschijnt niet: de kaart is niet FAT32, de bestandsnaam is langer dan 8 tekens of de afbeelding is niet 24-bits. Vergeet niet in Paint 24-bits te kiezen; BMP's van 16 en 32 bits worden door deze sketch niet getekend.
  • Speciale tekens ontbreken: het standaard GFX-lettertype heeft geen letters met accenten zoals ş, ğ of é. In TFT_eSPI kun je een eigen gladde font maken of een GFX-font gebruiken met de tekens die je nodig hebt.
  • Het display is traag: een volledige schermverversing op de Uno duurt minstens 0,15 seconde. Stap voor animaties en games over op een ESP32 of Pico en teken alleen het gebied opnieuw dat verandert.
  • De module wordt heet: mogelijk staat er 5 V op VCC terwijl de J1-jumper dicht is, of zijn VCC en GND omgedraaid; haal direct de voeding eraf.

Projectideeën met de ILI9341

  • Touchpaneel voor je slimme huis: bedien lampen en relais met grote knoppen op het scherm; voor ideeën zie je Arduino-project voor een slim huis.
  • Weerdisplay in kleur: toon het weer dat je met een ESP32 van internet haalt met pictogrammen en grote cijfers (ESP32-weerstation).
  • Sensordashboard: teken temperatuur, luchtvochtigheid en luchtdruk van een BME280 als meters met een grafiek van de laatste 24 uur.
  • Retrogameconsole: speel Snake, Pong of Tetris in kleur; voeg een joystickmodule toe voor de besturing en bekijk Arduino-gameprojecten voor ideeën.
  • Digitale fotolijst: blader om de paar seconden door de BMP-afbeeldingen op de SD-kaart.
  • Mini-oscilloscoop: teken analogRead-waarden als een vloeiende golfvorm met een sprite op de ESP32.
  • Touch-codeslot: teken een cijferblok op het scherm en open een relais of servo wanneer de juiste code wordt ingevoerd.

De ILI9341 is de voordeligste manier om je projecten een kleurrijke touchinterface te geven: begin met de Uno om de basis-tekenfuncties te leren en stap daarna over op de ESP32 met TFT_eSPI als je snelheid en vloeiende animatie nodig hebt. Begin je liever met een kleiner scherm, dan is een OLED-display (SSD1306) een goed beginpunt. In de BlueGrays-app vind je de projecten ESP32-weerdisplay, temperatuurlogger, parkeersensor en games op een display, met schakelschema's en code stap voor stap.

Veelgestelde vragen

Werkt het ILI9341-display met 5 V?

De VCC-pin van de module accepteert 3,3–5 V omdat er een 3,3 V-regelaar op de print zit. De signaalpins zoals CS, DC, SCK en MOSI zijn echter alleen 3,3 V. Gebruik je hem met een Arduino Uno, plaats dan een niveauconverter zoals een 74HC4050 of spanningsdelers op die lijnen.

Waarom toont mijn ILI9341 alleen een wit scherm?

Een wit scherm betekent dat de achtergrondverlichting aan is maar de driverchip nooit is geïnitialiseerd. De meest voorkomende oorzaken zijn verkeerde bedrading van CS, DC of RESET, geen niveauconverter op de Uno, een niet aangepaste User_Setup.h in TFT_eSPI en een display dat eigenlijk geen ILI9341 is.

Welke bibliotheek moet ik voor de ILI9341 gebruiken?

Voor de Arduino Uno, Nano en Mega is Adafruit_ILI9341 met Adafruit GFX de makkelijkste keuze. Op ESP32-, ESP8266- en RP2040-boards verdient het veel snellere TFT_eSPI de voorkeur. Parallelle shields van 2,4 inch die op de Uno worden gestoken hebben in plaats daarvan MCUFRIEND_kbv nodig.

Hoe kalibreer ik het ILI9341-touchscreen?

De XPT2046-touchcontroller geeft ruwe waarden van 0 tot 4095. Noteer de kleinste en grootste waarden die je in de Serial Monitor ziet als je de hoeken aanraakt en reken ze met map() om naar schermcoördinaten. Gebruik je TFT_eSPI, dan doet het voorbeeld Touch_calibrate dit voor je en print het een kant-en-klare kalibratiearray.

Wat is het verschil tussen de ILI9341 van 2,4 en 2,8 inch?

Beide hebben een resolutie van 240×320 pixels en gebruiken dezelfde pins en code. Het scherm van 2,8 inch heeft iets grotere pixels, waardoor tekst makkelijker te lezen is en touchknoppen makkelijker in te drukken zijn. De module van 2,4 inch past in kleinere behuizingen.

Kan ik de ILI9341 gebruiken met een Arduino Nano?

Ja. De SPI-pins van de Nano zijn dezelfde als die van de Uno: D13 SCK, D11 MOSI en D12 MISO. De Nano gebruikt ook 5 V-logica, dus je hebt een niveauconverter nodig. Zijn 2 KB RAM is genoeg om het display aan te sturen, maar niet om grote afbeeldingen vast te houden, dus je moet afbeeldingen in kleine stukken van de SD-kaart lezen.

Alle projecten bekijken
ESP32 HTTPClient + weer-API (met SSD1306 OLED-display)
ES-32Gevorderd
Premium

ESP32 HTTPClient + weer-API (met SSD1306 OLED-display)

In dit project doet de ESP32 via internet een REST API-aanroep naar een weer-API (wttr.in) met HTTPClient.h. Anders dan bij de I2C-LCD-versie gebruiken we hier een SSD1306 OLED-display (128×64), met grote tekst en vectoricoontjes voor een rijkere weergave. Zeven weericonen (zonnig, regenachtig, sneeuw en meer) worden direct getekend, zonder bitmapbestanden.

4.3(10)
22
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)

Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.

4.7(7)
12
ESP32 kleurenmixlamp (3 potmeters + RGB-led + OLED)
ES-36Gevorderd
Premium

ESP32 kleurenmixlamp (3 potmeters + RGB-led + OLED)

Een slimme kleurenmixlamp: draai aan 3 potmeters op de ESP32 en mix elke kleur die je wilt! Terwijl je aan de rode, groene en blauwe potmeter draait, verandert de RGB-led met gemeenschappelijke kathode meteen van kleur. Het SSD1306 OLED-display toont per kanaal de waarde van 0-255, vulbalken en de HEX-webkleurcode (zoals #FF8040) live.

4.7(6)
10
ESP32 parkeersensor (HC-SR04 + 5-ledbalk + buzzer + OLED)
ES-38Gevorderd
Premium

ESP32 parkeersensor (HC-SR04 + 5-ledbalk + buzzer + OLED)

De ESP32-versie van een parkeersensor voor auto's! De HC-SR04-ultrasoonsensor meet de afstand tot het voorwerp ervoor. Naarmate je dichterbij komt, vult een balk van 5 leds zich (groen → geel → rood) en piept de buzzer sneller. Heel dichtbij (onder 10 cm) klinkt een continu alarm en branden alle leds. Het SSD1306 OLED-display toont de live afstand in cm in grote tekst, plus een statusbericht.

14
Paddleballspel - SSD1306
AR-86Gemiddeld
Premium

Paddleballspel - SSD1306

Een bal, twee batjes en jij: op een klein OLED-scherm speel je tafeltennis, een van de allereerste videogames.

4.5(47)
65
OLED T-Rex Run: Arduino-dinosaurusspel
AR-87Gevorderd
Premium

OLED T-Rex Run: Arduino-dinosaurusspel

Het dinosaurusspel dat verschijnt als je internet wegvalt, nu op je bureau: de dinosaurus rent over het kleine OLED-scherm, cactussen komen op je af en jij springt met één knop.

4.7(33)
53
ESP32 I2C-LCD-display (16x2)
ES-17Gemiddeld
Premium

ESP32 I2C-LCD-display (16x2)

In dit project sluit je een 16x2-tekens-LCD via I2C aan op de ESP32 en toon je tekst. Met I2C bedien je het scherm met slechts 2 datapinnen (SDA en SCL), in plaats van de 6+ pinnen die een klassieke parallelle aansluiting verspilt. De code toont op de eerste regel een vaste tekst en op de tweede regel een teller die elke seconde oploopt. Bij het opstarten schrijft een I2C-scanner ook het adres van het display naar de Serial Monitor (meestal 0x27 of 0x3F).

4.9(23)
40
Arduino-lcd-runnerspel
AR-96Gemiddeld
Premium

Arduino-lcd-runnerspel

Zijwaarts scrollend endless-runnerspel op een 16x2-tekens-lcd. De held rent vanzelf en de speler springt over obstakels met een druk op de knop. Op de bovenste en onderste regel verschijnen willekeurige obstakels. Een passieve buzzer speelt een openingsmelodie, een springgeluid, een feestgeluid bij 50 punten en een eindmelodie. Bij het opstarten verschijnt "BlueGrays - Arduino Projects". De score staat rechtsboven.

4.6(32)
56