16x2-lcd aansluiten op Arduino zonder I2C: 4-bitmodus en contrast
Een 16x2-lcd op Arduino aansluiten zonder I2C-module: wat de 16 pinnen doen, 4-bitmodus, contrast, LiquidCrystal, zwarte blokjes oplossen en een 20x4-lcd gebruiken.
Als je een 16x2-lcd op een Arduino aansluit zonder I2C-module, gebruik je 12 van de 16 pinnen van het display: zes gaan naar digitale pinnen van de Arduino en de rest verzorgt de voeding, het contrast en de achtergrondverlichting. Dat klinkt druk, maar deze aansluiting leert je hoe het display echt werkt, bespaart je het zoeken naar een I2C-adres, is sneller dan I2C en houdt je project niet op als je geen I2C-backpack hebt. De meeste lcd's in Arduino-starterkits worden bovendien zonder I2C-module geleverd.
In deze gids leer je wat elk van de 16 pinnen doet, waarom we maar 4 datalijnen gebruiken (4-bitmodus), hoe je de contrastpotmeter aansluit en wat de commando's van de LiquidCrystal-bibliotheek zijn. Daarna ontwerp je eigen tekens voor een staafdiagram dat met een potmeter vol loopt, stap je over op een 20x4-lcd en gebruik je hetzelfde display met een ESP32 en een Raspberry Pi Pico. In de laatste delen vind je oplossingen voor de meest voorkomende problemen, zoals "zwarte blokjes" en een "leeg scherm", en lees je wanneer het zinvol is om over te stappen op een I2C-module.

Hoe werkt een 16x2-lcd?
De zwarte druppelvormige chip aan de achterkant van het display is de HD44780-driver (of een exacte kloon), de gemeenschappelijke taal van bijna alle tekens-lcd's. Arduino stuurt deze chip twee soorten bytes: commando's (scherm wissen, cursor hierheen verplaatsen, display aanzetten) en tekens (de code van de letter die getoond moet worden). De RS-pin geeft aan welke van de twee wordt verstuurd: bij RS LOW is de byte een commando, bij RS HIGH is het een teken. De E-pin (enable) is het signaal "data klaar, lees nu"; nadat een byte op de datalijnen staat, geef je E kort een HIGH-puls en leest de chip de byte op de dalende flank. In de chip zitten een displaygeheugen van 80 tekens (DDRAM), een lettertype-ROM met 208 ingebouwde tekens en een klein geheugen (CGRAM) voor de 8 eigen tekens die je gaat ontwerpen.
| Kenmerk | Waarde |
|---|---|
| Driverchip | HD44780 of compatibel (KS0066, SPLC780) |
| Display | 16 kolommen × 2 rijen, elk teken 5 × 8 pixels |
| Voeding | 4,5–5,5 V (er bestaan ook speciale 3,3 V-versies) |
| Logicastroom | Ongeveer 1–2 mA |
| Stroom van de achtergrondverlichting | Ongeveer 15–30 mA (led, afhankelijk van het model) |
| Databus | 8-bits of 4-bits parallel |
| Eigen tekens | 8 (CGRAM) |
| Commandotijd | De meeste commando's 37 µs, clear() en home() ongeveer 1,5 ms |
Wat elk van de 16 pinnen doet
| Pin | Naam | Functie | Aansluiting |
|---|---|---|---|
| 1 | VSS | Massa | GND |
| 2 | VDD | Voeding voor de logica | 5V |
| 3 | V0 (VO, VEE) | Contrastinstelling | Loper van een potmeter van 10 kΩ |
| 4 | RS | Keuze tussen commando (LOW) en teken (HIGH) | Arduino D12 |
| 5 | RW | Lezen (HIGH) of schrijven (LOW) | GND (we schrijven alleen) |
| 6 | E | Puls voor geldige data | Arduino D11 |
| 7–10 | D0–D3 | Onderste databits | Niet aangesloten in 4-bitmodus |
| 11 | D4 | Databit 4 | Arduino D5 |
| 12 | D5 | Databit 5 | Arduino D4 |
| 13 | D6 | Databit 6 | Arduino D3 |
| 14 | D7 | Databit 7 | Arduino D2 |
| 15 | A (LED+) | Anode van de achtergrondverlichting | 5V via 220 Ω |
| 16 | K (LED−) | Kathode van de achtergrondverlichting | GND |
4-bitmodus: waarom 4 datalijnen in plaats van 8?
De HD44780 kan een byte in één keer ontvangen via 8 datalijnen (8-bitmodus) of in twee helften via de lijnen D4–D7 (4-bitmodus). In 4-bitmodus wordt eerst de bovenste helft van de byte verstuurd en daarna de onderste, met voor elke helft één puls op de E-pin. Dat duurt twee keer zo lang, maar in de praktijk merk je dat niet: een teken schrijven kost nog steeds ongeveer 50 µs en het hele scherm verversen minder dan 2 ms. In ruil daarvoor houd je vier Arduino-pinnen over. De LiquidCrystal-bibliotheek kiest automatisch de 4-bitmodus als je de constructor zes pinnen geeft; D0–D3 niet aansluiten is veilig, omdat de chip daarop interne pull-upweerstanden heeft.
De contrastpotmeter

De spanning op de V0-pin bepaalt of de tekst überhaupt zichtbaar is. Wat het vloeibare kristal laat draaien is het verschil tussen VDD en V0; bij standaard 5 V-modules krijg je meestal het beste beeld met V0 rond 0,3–1 V. Als V0 naar 0 V gaat, wordt ook de achtergrond van de tekens donker en verschijnen lege cellen als zwarte blokjes; als V0 naar 5 V gaat, verdwijnt de tekst helemaal. Daarom is een potmeter de handigste keuze voor de eerste opstelling: sluit één buitenste pin aan op 5V, de andere op GND en de middelste pin op V0, en draai dan langzaam tot de tekst scherp is. Als je de juiste stand hebt gevonden, kun je de potmeter vervangen door een vaste weerstand: 1–2,2 kΩ tussen V0 en GND werkt bij de meeste modules goed.
Stap voor stap: je eerste tekst met Arduino
- Soldeer een male header van 16 pinnen op de lcd en steek het display in het breadboard; op een lang breadboard is aan beide kanten van het display ruimte voor draden.
- Breng 5V en GND van de Arduino naar de voedingsrails van het breadboard. Verbind pin 1 (VSS) en pin 16 (K) van de lcd met GND, pin 2 (VDD) met 5V en pin 15 (A) via 220 Ω met 5V. Als je de Arduino op USB aansluit, moet de achtergrondverlichting aangaan.
- Sluit de potmeter aan en draai eraan. Nog voordat je code hebt geüpload, moeten er 16 zwarte blokjes op de bovenste regel verschijnen; dat toont dat het display en het contrast werken.
- Verbind pin 5 (RW) met GND. Verbind daarna RS met D12, E met D11 en D4–D7 met respectievelijk D5, D4, D3 en D2.
- Controleer in de Library Manager of de bibliotheek LiquidCrystal is geïnstalleerd (die wordt meegeleverd met de Arduino IDE) en upload de onderstaande code.
- Als de blokjes verdwijnen en de tekst verschijnt, stel je het contrast met de potmeter nog een laatste keer bij.
1// 16x2 LCD, I2C modülü olmadan (4-bit mod) / 16x2 LCD without an I2C module (4-bit mode)
2// RS -> D12, E -> D11, D4 -> D5, D5 -> D4, D6 -> D3, D7 -> D2, RW -> GND, V0 -> pot
3#include <LiquidCrystal.h>
4
5const int RS = 12, EN = 11, D4 = 5, D5 = 4, D6 = 3, D7 = 2;
6LiquidCrystal lcd(RS, EN, D4, D5, D6, D7);
7
8void setup() {
9 lcd.begin(16, 2); // 16 sütun, 2 satır / 16 columns, 2 rows
10 lcd.print(F("Merhaba Arduino!"));
11 lcd.setCursor(0, 1); // sütun 0, satır 1 / column 0, row 1
12 lcd.print(F("Sure:"));
13}
14
15void loop() {
16 unsigned long s = millis() / 1000;
17 lcd.setCursor(6, 1);
18 lcd.print(s);
19 lcd.print(F(" sn ")); // eski haneleri boşlukla sil / overwrite old digits with spaces
20 delay(200);
21}De code heeft twee kleine maar belangrijke gewoontes. Ten eerste gaat hij, voordat hij de veranderende waarde schrijft, met setCursor() naar die positie in plaats van clear() aan te roepen, en zet hij na het getal een paar spaties. clear() is een zwaar commando dat ongeveer 1,5 ms duurt en laat het scherm flikkeren als je het in de lus gebruikt; bovendien hoef je niet het hele scherm te wissen en opnieuw te schrijven. De spaties voorkomen dat een oud cijfer op het scherm blijft staan als het getal korter wordt (bijvoorbeeld van 100 naar 99). Ten tweede worden de vaste teksten geschreven met de macro F(), zodat ze in het programmageheugen staan in plaats van in het RAM. Op een 16x2-display passen maximaal 16 tekens per regel; langere tekst loopt over de rechterrand en is niet zichtbaar.
| Commando | Wat het doet |
|---|---|
| lcd.begin(16, 2) | Start het display en stelt het aantal kolommen en rijen in |
| lcd.print(value) | Toont tekst, een geheel getal of een decimaal getal; lcd.print(3.14159, 2) toont twee decimalen |
| lcd.setCursor(column, row) | Kiest waar je schrijft; het tellen begint bij 0 |
| lcd.clear() | Wist het scherm en zet de cursor terug op de beginpositie (duurt 1,5 ms) |
| lcd.cursor() / lcd.noCursor() | Toont of verbergt de cursor in de vorm van een streepje |
| lcd.blink() / lcd.noBlink() | Zet de knipperende blokcursor aan of uit |
| lcd.display() / lcd.noDisplay() | Zet het beeld aan of uit zonder het displaygeheugen te wissen |
| lcd.scrollDisplayLeft() | Verschuift het hele display één kolom naar links |
| lcd.createChar(num, array) | Laadt een eigen teken in slot 0–7 |
| lcd.write(byte(num)) | Schrijft een eigen teken of een ROM-code |
Eigen tekens: een staafdiagram dat met een potmeter vol loopt
Elke tekencel is een pixelraster van 5 kolommen en 8 rijen. Om een eigen teken te definiëren schrijf je elke rij als een getal van 5 bits: 1 betekent een brandende pixel, 0 een uitgeschakelde. De HD44780 staat 8 eigen tekens tegelijk toe. Het onderstaande voorbeeld gebruikt vijf van die plekken voor blokjes waarvan 1, 2, 3, 4 en 5 kolommen van links af gevuld zijn. Met 16 cellen × 5 kolommen krijg je een balk van 80 stappen die soepel vol en leeg loopt met een potmeter; ideaal voor volume, batterijniveau of een sensorpercentage. Het ontwerpen van eigen tekens voor Turkse letters (ş, ğ, ı, ç) hebben we behandeld in het artikel over de I2C-lcd; hetzelfde createChar-commando werkt via de parallelle aansluiting precies hetzelfde.
1// Özel karakterlerle 80 adımlık çubuk grafik / 80-step bar graph with custom characters
2// Potansiyometre orta ucu -> A0 / potentiometer wiper -> A0
3#include <LiquidCrystal.h>
4
5LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
6
7byte bars[5][8]; // 1..5 sütun dolu bloklar / blocks with 1..5 columns filled
8
9void buildBars() {
10 for (int n = 0; n < 5; n++) {
11 byte row = 0;
12 for (int c = 0; c <= n; c++) row |= (0b10000 >> c); // soldan doldur / fill from the left
13 for (int r = 0; r < 8; r++) bars[n][r] = row;
14 lcd.createChar(n, bars[n]); // karakter 0 = 1 sütun ... 4 = 5 sütun / char 0 = 1 column ... 4 = 5 columns
15 }
16}
17
18void setup() {
19 lcd.begin(16, 2);
20 buildBars();
21 lcd.setCursor(0, 0); // createChar sonrası konum ayarla / set position after createChar
22 lcd.print(F("Seviye / Level"));
23}
24
25void loop() {
26 int raw = analogRead(A0);
27 int steps = map(raw, 0, 1023, 0, 80); // 16 hücre x 5 sütun / 16 cells x 5 columns
28 int percent = map(raw, 0, 1023, 0, 100);
29
30 lcd.setCursor(12, 0);
31 if (percent < 100) lcd.print(' ');
32 if (percent < 10) lcd.print(' ');
33 lcd.print(percent);
34 lcd.print('%');
35
36 lcd.setCursor(0, 1);
37 for (int cell = 0; cell < 16; cell++) {
38 int fill = steps - cell * 5; // bu hücreye düşen sütun / columns in this cell
39 if (fill >= 5) lcd.write(byte(4));
40 else if (fill > 0) lcd.write(byte(fill - 1));
41 else lcd.print(' ');
42 }
43 delay(50);
44}Het commando createChar verplaatst de cursor van het displaygeheugen naar het tekengeheugen. Roep daarom na het laden van eigen tekens setCursor() aan voordat je schrijft, anders verschijnt de eerste tekst mogelijk niet. Tekens worden alleen in het CGRAM opgeslagen en gaan verloren als het display geen stroom meer heeft; daarom laad je ze bij elke start opnieuw in setup(). Als je de definitie van een eigen teken wijzigt terwijl het op het scherm staat, verandert elke cel met dat teken meteen; kleine animaties maak je precies met deze truc.
20x4-lcd: dezelfde bedrading, groter scherm
Lcd's met 20 kolommen en 4 rijen gebruiken dezelfde HD44780-chip en dezelfde 16 pinnen; de bedrading is identiek en in de code heb je alleen lcd.begin(20, 4) nodig. Hun achtergrondverlichting trekt iets meer stroom (40–60 mA), dus maak de voorschakelweerstand niet kleiner, zodat de 5V-rail van de Arduino bij langdurig gebruik niet overbelast raakt. De enige eigenaardigheid die je moet kennen is de rijvolgorde: in het displaygeheugen gaat het einde van rij 1 verder op rij 3 en het einde van rij 2 op rij 4. Als je lange tekst schrijft zonder setCursor(), loopt die dus over van rij 1 naar rij 3 en niet naar rij 2. Door aan het begin van elke rij setCursor(0, row) aan te roepen, los je het probleem helemaal op.
1// 20x4 LCD: aynı bağlantı, begin(20, 4) / 20x4 LCD: same wiring, begin(20, 4)
2#include <LiquidCrystal.h>
3
4LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
5
6void setup() {
7 lcd.begin(20, 4);
8 for (int row = 0; row < 4; row++) {
9 lcd.setCursor(0, row); // her satırı açıkça seç / select every row explicitly
10 lcd.print(F("Satir / Row "));
11 lcd.print(row + 1);
12 }
13}
14
15void loop() {
16 lcd.setCursor(15, 3);
17 lcd.print(millis() / 1000 % 100000); // 5 haneye sığsın / fit in 5 digits
18 delay(500);
19}Een parallelle lcd met de ESP32
Een standaard 16x2-lcd geeft alleen genoeg contrast als hij op 5 V wordt gevoed, terwijl de pinnen van de ESP32 3,3 V zijn. Het goede nieuws: zolang RW met GND is verbonden, zet de lcd nooit spanning op de lijnen; hij luistert alleen. Omdat de laagste ingangsspanning die de HD44780 bij 5 V als HIGH accepteert ongeveer 2,2 V is, volstaan de 3,3 V-signalen van de ESP32 en is geen niveauconverter nodig. Sluit VDD van de lcd aan op de VIN-pin van het ESP32-board (5 V via USB). De LiquidCrystal-bibliotheek werkt op de ESP32 net zo; vermijd alleen pinnen met een speciale functie tijdens het opstarten, zoals GPIO 0, 2, 12 en 15.
1// ESP32 + 16x2 LCD (paralel, 4-bit) / ESP32 + 16x2 LCD (parallel, 4-bit)
2// RS -> GPIO 22, E -> GPIO 21, D4 -> 19, D5 -> 18, D6 -> 26, D7 -> 25
3// VDD -> VIN (5 V), RW -> GND, V0 -> pot, A -> 220 ohm -> VIN
4#include <LiquidCrystal.h>
5
6LiquidCrystal lcd(22, 21, 19, 18, 26, 25);
7
8void setup() {
9 lcd.begin(16, 2);
10 lcd.print("ESP32 + LCD");
11}
12
13void loop() {
14 lcd.setCursor(0, 1);
15 lcd.print("Heap: ");
16 lcd.print(ESP.getFreeHeap() / 1024); // boş bellek (KB) / free memory (KB)
17 lcd.print(" KB ");
18 delay(1000);
19}Een parallelle lcd met de Raspberry Pi Pico (MicroPython)
Dezelfde logica geldt voor de Raspberry Pi Pico: voed de lcd met 5 V van VBUS (pin 40), verbind RW met GND en leg de signalen direct naar GP-pinnen. MicroPython heeft geen kant-en-klare LiquidCrystal-bibliotheek, dus hieronder staat een korte driver die de 4-bitmodus zelf afhandelt. Hij volgt de initialisatiereeks uit het datasheet van de HD44780: hij wacht 50 ms na het inschakelen, dwingt de chip drie keer in de 8-bitmodus, schakelt hem dan over naar de 4-bitmodus en zet het display aan. Elk teken wordt in twee helften (nibbles) verstuurd, met na elke helft een korte puls op de E-pin.
1# Raspberry Pi Pico: I2C'siz 16x2 LCD sürücüsü (4-bit) / 16x2 LCD driver without I2C (4-bit)
2# RS -> GP16, E -> GP17, D4 -> GP18, D5 -> GP19, D6 -> GP20, D7 -> GP21
3# VDD -> VBUS (pin 40, 5 V), RW -> GND, V0 -> pot
4from machine import Pin
5import time
6
7
8class LCD4:
9 def __init__(self, rs, e, d4, d5, d6, d7):
10 self.rs = Pin(rs, Pin.OUT, value=0)
11 self.e = Pin(e, Pin.OUT, value=0)
12 self.data = [Pin(p, Pin.OUT, value=0) for p in (d4, d5, d6, d7)]
13 time.sleep_ms(50) # güç geldikten sonra bekle / wait after power-up
14 for _ in range(3):
15 self._nibble(0x03) # 8-bit moda zorla / force 8-bit mode
16 time.sleep_ms(5)
17 self._nibble(0x02) # 4-bit moda geç / switch to 4-bit mode
18 self.command(0x28) # 4 bit, 2 satır, 5x8 / 4-bit, 2 lines, 5x8
19 self.command(0x0C) # ekran açık, imleç kapalı / display on, cursor off
20 self.clear()
21 self.command(0x06) # soldan sağa yaz / write left to right
22
23 def _nibble(self, value):
24 for i, pin in enumerate(self.data):
25 pin.value((value >> i) & 1)
26 self.e.value(1) # E darbesi / E pulse
27 time.sleep_us(1)
28 self.e.value(0)
29 time.sleep_us(50) # komut süresi (37 µs) / command time (37 µs)
30
31 def _write(self, value, rs):
32 self.rs.value(rs)
33 self._nibble(value >> 4) # önce üst yarı / upper half first
34 self._nibble(value & 0x0F)
35
36 def command(self, cmd):
37 self._write(cmd, 0)
38
39 def clear(self):
40 self.command(0x01)
41 time.sleep_ms(2) # clear yaklaşık 1,5 ms / clear takes about 1.5 ms
42
43 def move_to(self, col, row):
44 offsets = (0x00, 0x40, 0x14, 0x54) # 16x2 ve 20x4 satır adresleri / row addresses
45 self.command(0x80 | (offsets[row] + col))
46
47 def putstr(self, text):
48 for ch in text:
49 self._write(ord(ch), 1)
50
51
52lcd = LCD4(rs=16, e=17, d4=18, d5=19, d6=20, d7=21)
53lcd.move_to(0, 0)
54lcd.putstr("Merhaba Pico!")
55count = 0
56while True:
57 lcd.move_to(0, 1)
58 lcd.putstr("Sayac: {:<9d}".format(count))
59 count += 1
60 time.sleep(1)Zwarte blokjes, een leeg scherm en andere problemen
Bijna elk probleem dat je met een parallelle lcd tegenkomt, lijkt op een van een paar symptomen, en het display zelf vertelt je waar je moet zoeken. De belangrijkste aanwijzing is deze: zie je alleen op de bovenste regel 16 zwarte blokjes, dan zijn voeding en contrast in orde, maar is de chip nooit geïnitialiseerd. Bij het inschakelen start de HD44780 in de eenregelige modus en stuurt hij alleen de eerste regel aan; zolang de code het display niet initialiseert, verandert het beeld niet. In dat geval zit het probleem bijna altijd in de draden van RS, E of D4–D7 of in de volgorde van de pinnen in de constructor. Zie je vage blokjes op beide regels, dan werkt het display en staat het contrast gewoon te hoog.
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Alleen op de bovenste regel 16 zwarte blokjes | Display niet geïnitialiseerd: bedrading van RS, E, D4–D7 of pinvolgorde in de constructor is fout, of er is geen code geüpload | Controleer de draden aan de hand van de tabel en de volgorde LiquidCrystal lcd(RS, E, D4, D5, D6, D7) |
| Vage blokjes op beide regels | Contrast te hoog (V0 te dicht bij GND) | Draai aan de potmeter |
| Achtergrondverlichting aan maar er verschijnt niets | Contrast te laag of V0 niet aangesloten | Controleer of de loper van de potmeter naar V0 gaat en draai eraan |
| Achtergrondverlichting brandt niet | Pinnen 15 en 16 niet aangesloten, omgewisseld of weerstand ontbreekt | Sluit A via 220 Ω aan op 5V en K op GND |
| Verminkte of verschuivende tekens | Een losse datadraad, D4–D7 verwisseld, storing van motor of relais | Zet de draden goed vast, voeg 100 µF toe op de voeding en initialiseer zo nodig opnieuw met lcd.begin() |
| Tekst flikkert | lcd.clear() wordt in de lus gebruikt | Overschrijf met setCursor() en wis oude cijfers met spaties |
| Een oud cijfer blijft staan als het getal korter wordt | De nieuwe waarde is korter dan de oude | Voeg spaties toe na de waarde |
| Tekst verschijnt niet na een eigen teken | createChar heeft de cursor naar het tekengeheugen verplaatst | Roep setCursor() aan na createChar |
Moet je overstappen op een I2C-module?

Dankzij de PCF8574-chip op de achterkant voert de I2C-module alle signalen van de lcd over twee draden (SDA en SCL); ook de contrastpotmeter en de transistor voor de achtergrondverlichting zitten op de print. Naarmate je project groeit, telt dat gemak: een Uno heeft maar 20 digitale en analoge pinnen en een parallelle lcd gebruikt er alleen al zes van. Aan de andere kant is de parallelle aansluiting sneller, heeft hij geen I2C-adresconflicten en is er geen extra module nodig. De onderstaande tabel vat samen wat wanneer beter is; voor de opstelling met de I2C-module lees je het artikel over het I2C-lcd-display.
| Kenmerk | Parallel (4-bits) | Met I2C-module |
|---|---|---|
| Gebruikte Arduino-pinnen | 6 | 2 (A4, A5) |
| Aantal draden | 12 (inclusief voeding en potmeter) | 4 |
| Volledige schermverversing | Minder dan 2 ms | Ongeveer 20–30 ms bij 100 kHz |
| Contrastinstelling | Externe potmeter | Trimmer op de module |
| Achtergrondverlichting in software uitschakelen | Vereist een extra transistor | lcd.noBacklight() |
| Bibliotheek | LiquidCrystal (wordt met de IDE meegeleverd) | LiquidCrystal I2C (apart te installeren) |
| Typisch probleem | Wirwar van draden, losse verbindingen | Problemen met adres (0x27 / 0x3F) en pull-ups |
Projectideeën met een 16x2-lcd
- Digitale thermometer: toon temperatuur en luchtvochtigheid van een NTC of een DHT11 in grote tekst en schrijf het gradenteken met lcd.write(223).
- Codeslot: toon de code die je op een keypad intikt als sterretjes en schakel een relais in als de code klopt.
- Afstandsdisplay: toon de afstand die een HC-SR04 meet tegelijk in centimeters en als staafdiagram.
- Stopwatch en aftellen: start, stop en reset met twee knoppen en toon de tijd als minuten:seconden:honderdsten.
- Minigame: teken een hardloper en obstakels met eigen tekens en laat hem met een knop springen.
- Menusysteem: bouw een menu waar je met een rotary encoder doorheen scrolt en waarin je instellingen wijzigt, en sla de keuzes op in EEPROM.
Een 16x2-lcd aansluiten zonder I2C-module lijkt op het eerste gezicht misschien een wirwar van draden, maar als je eenmaal weet hoe het display commando's aanneemt, kun je met dezelfde logica elke tekens-lcd gebruiken, ook de 20x4 en zelfs andere microcontrollers. In de BlueGrays-app leiden de projecten "Een bericht tonen op een 16x2-lcd", "Stuiterende tekst op een lcd" en "Afstand meten met een lcd" je stap voor stap door deze aansluiting, met een bedradingsschema en kant-en-klare code.
Veelgestelde vragen
Waarom toont mijn 16x2-lcd zwarte blokjes?
Als de blokjes alleen op de bovenste regel verschijnen, zijn voeding en contrast in orde, maar heeft de Arduino het display niet geïnitialiseerd; controleer de draden van RS, E en D4–D7 en de volgorde van de pinnen in de constructor van LiquidCrystal. Verschijnen er vage blokjes op beide regels, dan staat het contrast te hoog en is aan de potmeter draaien genoeg.
Waarom brandt de achtergrondverlichting van mijn lcd maar verschijnt er geen tekst?
De meest voorkomende reden is een te laag ingesteld contrast: als V0 dicht bij 5 V zit, zijn de tekens onzichtbaar. Controleer of de loper van de potmeter op V0 is aangesloten en draai er langzaam aan. Is het contrast goed en zie je blokjes op de bovenste regel, dan zit het probleem in de datadraden of in de code.
Kun je een 16x2-lcd gebruiken zonder potmeter?
Ja. Een vaste weerstand van 1–2,2 kΩ tussen V0 en GND geeft bij de meeste 5 V-modules een goed contrast. De betrouwbaarste manier is om de waarde één keer met een potmeter te bepalen en die daarna te vervangen door een vaste weerstand. Je kunt V0 ook via een RC-filter op een PWM-pin aansluiten en het contrast in software instellen.
Waar sluit je de RW-pin van de lcd op aan?
Als je alleen naar het display schrijft, verbind je RW (pin 5) met GND; zo staat de lcd permanent in schrijfmodus, en dat is hoe de LiquidCrystal-bibliotheek werkt. Laat je RW zweven, dan kan het display willekeurig naar leesmodus overschakelen en de datalijnen aansturen, waardoor er mogelijk niets verschijnt. RW aan GND beschermt ook de pinnen van boards met 3,3 V.
Wat is het verschil tussen LiquidCrystal en LiquidCrystal_I2C?
LiquidCrystal stuurt de lcd direct aan vanaf Arduino-pinnen en wordt meegeleverd met de Arduino IDE; je gebruikt hem voor de parallelle aansluiting. LiquidCrystal_I2C stuurt dezelfde commando's via een PCF8574-I2C-module en moet apart worden geïnstalleerd. De meeste commando's (print, setCursor, createChar) zijn in beide hetzelfde; de I2C-versie voegt lcd.init() toe voor het opstarten en backlight() voor de achtergrondverlichting.
Werkt mijn code voor de 16x2-lcd ook op een 20x4-lcd?
Ja, want de bedrading en de commando's zijn hetzelfde; je hoeft alleen lcd.begin(16, 2) te veranderen in lcd.begin(20, 4). Op een 20x4-display volgen de rijen in het geheugen de volgorde 1, 3, 2, 4, dus naar elke rij gaan met setCursor(0, row) is de schoonste aanpak. De achtergrondverlichting trekt iets meer stroom.
Projecten om hierna te bouwen
Alle projecten bekijken
Een bericht tonen op een 2x16-lcd-scherm
Je eerste stap naar tekst op een scherm. Het lcd-scherm met twee regels toont eerst een wachtbericht, schrijft dan een groet op de bovenste regel en typt op de onderste regel een woord letter voor…

Stuiterende tekstanimatie op een lcd
Op de bovenste regel van het lcd-scherm schuift het woord BLUEGRAYS van de ene rand naar de andere en stuitert terug als een bal tegen een muur, steeds opnieuw zonder einde.

Afstand meten met een lcd-scherm
Een gereedschap dat afstand meet zonder liniaal: beweeg je hand heen en weer voor de sensor en kijk hoe het getal verandert.

Temperatuur meten met NTC en 2x16 LCD-display
Meet de temperatuur om je heen met een sensor die op een klein kraaltje lijkt. Dit onderdeel, een NTC, laat elektriciteit makkelijker door naarmate het warmer wordt; de Arduino leest die verandering…

DS1302 RTC-klok met LCD-display
Een kleine bureauklok die de tijd bijhoudt, ook als de stroom uitvalt. De DS1302-klokmodule houdt de tijd bij dankzij een eigen kleine batterij; de Arduino leest hem elke seconde uit en schrijft tijd…

Digitale voltmeter met lcd-scherm
Ontdek hoeveel spanning een batterij of voedingsadapter geeft met een meter die je zelf hebt gebouwd.

Codeslot met 4x4-keypad en LCD
Een klein elektronisch deurslot dat iedereen buiten houdt die de code niet kent.

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.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

