Componenten · 11 min leestijd

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.

16x2-tekens-lcd
16x2-lcd: tekens van 5 × 8 pixels in 16 kolommen en 2 rijen. De 16 pinnen langs de bovenrand sluit je direct aan, zonder 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.

KenmerkWaarde
DriverchipHD44780 of compatibel (KS0066, SPLC780)
Display16 kolommen × 2 rijen, elk teken 5 × 8 pixels
Voeding4,5–5,5 V (er bestaan ook speciale 3,3 V-versies)
LogicastroomOngeveer 1–2 mA
Stroom van de achtergrondverlichtingOngeveer 15–30 mA (led, afhankelijk van het model)
Databus8-bits of 4-bits parallel
Eigen tekens8 (CGRAM)
CommandotijdDe meeste commando's 37 µs, clear() en home() ongeveer 1,5 ms

Wat elk van de 16 pinnen doet

PinNaamFunctieAansluiting
1VSSMassaGND
2VDDVoeding voor de logica5V
3V0 (VO, VEE)ContrastinstellingLoper van een potmeter van 10 kΩ
4RSKeuze tussen commando (LOW) en teken (HIGH)Arduino D12
5RWLezen (HIGH) of schrijven (LOW)GND (we schrijven alleen)
6EPuls voor geldige dataArduino D11
7–10D0–D3Onderste databitsNiet aangesloten in 4-bitmodus
11D4Databit 4Arduino D5
12D5Databit 5Arduino D4
13D6Databit 6Arduino D3
14D7Databit 7Arduino D2
15A (LED+)Anode van de achtergrondverlichting5V via 220 Ω
16K (LED−)Kathode van de achtergrondverlichtingGND
Bij sommige lcd's is de volgorde van de pinnen anders, of zitten de pinnen 15 en 16 van de achtergrondverlichting helemaal vooraan. Controleer de opdruk op de print en de markering van pin 1 voordat je aansluit. Sluit de achtergrondverlichting niet zonder weerstand direct aan op 5 V: als de module geen voorschakelweerstand heeft, trekt de led te veel stroom en gaat hij dof branden. Op de achterkant zit meestal een weerstand van ongeveer 100 Ω met opdruk R8 of R9; als je het niet zeker weet, voeg dan toch de weerstand van 220 Ω toe. De juiste waarde vind je met de ledweerstandcalculator.

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

Potmeter van 10 kΩ
Een potmeter van 10 kΩ is alles wat je voor het contrast nodig hebt: de buitenste pinnen naar 5V en GND, de middelste pin naar V0 van de lcd.

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

  1. 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.
  2. 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.
  3. 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.
  4. Verbind pin 5 (RW) met GND. Verbind daarna RS met D12, E met D11 en D4–D7 met respectievelijk D5, D4, D3 en D2.
  5. Controleer in de Library Manager of de bibliotheek LiquidCrystal is geïnstalleerd (die wordt meegeleverd met de Arduino IDE) en upload de onderstaande code.
  6. Als de blokjes verdwijnen en de tekst verschijnt, stel je het contrast met de potmeter nog een laatste keer bij.
C++ (Arduino IDE)
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.

CommandoWat 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

MicroPython
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.

SymptoomWaarschijnlijke oorzaakOplossing
Alleen op de bovenste regel 16 zwarte blokjesDisplay niet geïnitialiseerd: bedrading van RS, E, D4–D7 of pinvolgorde in de constructor is fout, of er is geen code geüploadControleer de draden aan de hand van de tabel en de volgorde LiquidCrystal lcd(RS, E, D4, D5, D6, D7)
Vage blokjes op beide regelsContrast te hoog (V0 te dicht bij GND)Draai aan de potmeter
Achtergrondverlichting aan maar er verschijnt nietsContrast te laag of V0 niet aangeslotenControleer of de loper van de potmeter naar V0 gaat en draai eraan
Achtergrondverlichting brandt nietPinnen 15 en 16 niet aangesloten, omgewisseld of weerstand ontbreektSluit A via 220 Ω aan op 5V en K op GND
Verminkte of verschuivende tekensEen losse datadraad, D4–D7 verwisseld, storing van motor of relaisZet de draden goed vast, voeg 100 µF toe op de voeding en initialiseer zo nodig opnieuw met lcd.begin()
Tekst flikkertlcd.clear() wordt in de lus gebruiktOverschrijf met setCursor() en wis oude cijfers met spaties
Een oud cijfer blijft staan als het getal korter wordtDe nieuwe waarde is korter dan de oudeVoeg spaties toe na de waarde
Tekst verschijnt niet na een eigen tekencreateChar heeft de cursor naar het tekengeheugen verplaatstRoep setCursor() aan na createChar
In projecten met motoren, relais of servo's gaat de lcd soms na een paar uur rommel tonen: een spanningsdip heeft de chip in een ongedefinieerde toestand gebracht. Door met tussenpozen, bijvoorbeeld één keer per minuut, lcd.begin(16, 2) aan te roepen en het scherm opnieuw te tekenen, los je dit op zonder dat de gebruiker het merkt.

Moet je overstappen op een I2C-module?

I2C-backpack voor lcd (PCF8574)
De I2C-backpack met PCF8574 wordt op de achterkant van de lcd gesoldeerd en brengt de 16 pinnen terug tot slechts vier draden.

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.

KenmerkParallel (4-bits)Met I2C-module
Gebruikte Arduino-pinnen62 (A4, A5)
Aantal draden12 (inclusief voeding en potmeter)4
Volledige schermverversingMinder dan 2 msOngeveer 20–30 ms bij 100 kHz
ContrastinstellingExterne potmeterTrimmer op de module
Achtergrondverlichting in software uitschakelenVereist een extra transistorlcd.noBacklight()
BibliotheekLiquidCrystal (wordt met de IDE meegeleverd)LiquidCrystal I2C (apart te installeren)
Typisch probleemWirwar van draden, losse verbindingenProblemen 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.

Alle projecten bekijken
Een bericht tonen op een 2x16-lcd-scherm
AR-29Gevorderd
Premium

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…

4.6(37)
51
Stuiterende tekstanimatie op een lcd
AR-30Gevorderd
Premium

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.

4.5(29)
40
Afstand meten met een lcd-scherm
AR-31Gevorderd
Premium

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.

4.6(45)
59
Temperatuur meten met NTC en 2x16 LCD-display
AR-44Beginner
Premium

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…

4.5(33)
44
DS1302 RTC-klok met LCD-display
AR-46Gemiddeld
Premium

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…

4.7(41)
51
Digitale voltmeter met lcd-scherm
AR-56Gemiddeld
Premium

Digitale voltmeter met lcd-scherm

Ontdek hoeveel spanning een batterij of voedingsadapter geeft met een meter die je zelf hebt gebouwd.

4.5(27)
36
Codeslot met 4x4-keypad en LCD
AR-64Gevorderd
Premium

Codeslot met 4x4-keypad en LCD

Een klein elektronisch deurslot dat iedereen buiten houdt die de code niet kent.

4.8(59)
75
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