Bauteile · 7 Min. Lesezeit

PCF8574 Arduino: I2C-Portexpander für 8 Pins, Adressen, Code

PCF8574 am Arduino: 8 zusätzliche Ein- und Ausgänge per I2C, Adresstabelle A0–A2, LEDs und Taster anschließen, INT-Interrupt, LCD-Modul, MCP23017.

Der PCF8574 ist ein günstiger I2C-Portexpander, der deinem Arduino über nur zwei Leitungen (SDA und SCL) 8 zusätzliche Ein- und Ausgänge verschafft. PCF8574 und Arduino sind ein ideales Team, sobald die Pins knapp werden: Wenn LCD, Sensor und ein paar Relais schon fast alle Pins belegen, hängt der PCF8574 einfach mit am I2C-Bus und liefert dir 8 weitere Pins für Taster und LEDs. Über die Adresspins A0, A1 und A2 kannst du bis zu 8 Module an denselben Bus hängen und so auf 64 zusätzliche Pins kommen.

In diesem Artikel lernst du die quasi-bidirektionalen Pins des PCF8574 kennen, erfährst, warum LEDs deshalb bei LOW leuchten, und wie du Taster einliest. Du bekommst die Adresstabelle (PCF8574 und PCF8574A), liest Taster per Interrupt über den INT-Pin, siehst, dass dein bekanntes I2C-LCD-Modul in Wahrheit ein PCF8574 ist, und vergleichst ihn mit dem MCP23017. Die Codes sind fertig für Arduino Uno, ESP32 und Raspberry Pi Pico (MicroPython).

I2C-Modul mit PCF8574
I2C-Modul: Der PCF8574 darauf verbindet 8 Pins mit dem Zweidraht-I2C-Bus; auch LCD-Adapterplatinen nutzen genau diesen Chip.

Was ist der PCF8574 und wie funktioniert er?

Im PCF8574 steckt ein 8-Bit-Ausgangsregister (Latch). Der Arduino schickt über I2C ein einziges Byte, und jedes Bit bestimmt den Zustand eines Pins: P0 ist das niederwertigste, P7 das höchstwertige Bit. Die Pins arbeiten nicht wie klassische Push-Pull-Ausgänge. Bei LOW wird der Pin über einen kräftigen Schalter mit GND verbunden und kann bis zu 25 mA aufnehmen. Bei HIGH hält ihn dagegen nur eine schwache Stromquelle von etwa 100 µA oben. Diese Bauart heißt quasi-bidirektional und hat zwei wichtige Folgen: LEDs schließt du so an, dass der Pin den Strom zieht (Anode an VCC), und um einen Pin als Eingang zu nutzen, musst du zuerst eine 1 hineinschreiben. Zieht ein Taster den HIGH-Pin auf GND, liest du eine 0. Nach dem Einschalten sind alle Pins HIGH.

MerkmalWert
Pins8 (P0–P7), quasi-bidirektional
Versorgung2,5–6 V (läuft mit 3,3 V und 5 V)
SchnittstelleI2C, höchstens 100 kHz
AdressePCF8574: 0x20–0x27, PCF8574A: 0x38–0x3F
Ausgangsstrom LOWBis 25 mA pro Pin (Sink)
Ausgangsstrom HIGHEtwa 100 µA (schwacher Pull-up)
InterruptINT-Pin, Open-Drain, aktiv LOW
GehäuseDIP-16 (PCF8574P) und SO-16 (PCF8574T)

PCF8574 Pinbelegung und Anschluss

PCF8574 / ModulArduino UnoESP32Raspberry Pi Pico
VCC5V3V33V3 (OUT)
GNDGNDGNDGND
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
INT (optional)D2GPIO 4GP6
P0–P3LEDs: Anode über Vorwiderstand an VCC, Kathode an den PinGleichGleich
P4–P7Taster: ein Bein an den Pin, das andere an GNDGleichGleich

In den Beispielen hängen an P0–P3 vier LEDs und an P4–P7 vier Taster. Die Anode jeder LED geht über einen 330-Ω-Vorwiderstand an VCC, die Kathode an den PCF8574-Pin; schreibst du eine 0 auf den Pin, fließt der Strom durch die LED in den Pin und sie leuchtet. Bei 5 V bedeuten 330 Ω für eine rote LED (5 - 2) / 330 ≈ 9 mA; den passenden Wert für deine LED findest du mit dem LED-Vorwiderstandsrechner. Die Taster brauchen keinen eigenen Widerstand, die schwache Stromquelle im Chip wirkt als Pull-up. Bei langen Leitungen auf dem Steckbrett ist ein externer 10-kΩ-Pull-up gegen Störungen trotzdem sinnvoll; die Grundlagen stehen im Artikel Pull-up- und Pull-down-Widerstand. Beim nackten Chip im DIP-16-Gehäuse sind die Pins 1–3 A0–A2, 4–7 und 9–12 P0–P7, 8 GND, 13 INT, 14 SCL, 15 SDA und 16 VCC.

Schließt du die LED andersherum an, also Anode an den PCF8574-Pin und Kathode an GND, leuchtet sie gar nicht oder nur sehr schwach, weil ein HIGH-Pin nur etwa 100 µA liefert. Mit ESP32 und Pico versorgst du das Modul aus 3,3 V: Läuft es an 5 V, ziehen seine Pull-up-Widerstände SDA und SCL auf 5 V, und das kann die Pins der 3,3-V-Boards beschädigen. Wenn viele LEDs gleichzeitig leuchten, halte den Gesamtstrom unter 80 mA.

Adresse einstellen: A0, A1, A2 und PCF8574A

A2A1A0PCF8574PCF8574A
0000x200x38
0010x210x39
0100x220x3A
0110x230x3B
1000x240x3C
1010x250x3D
1100x260x3E
1110x270x3F

Die Adresse ergibt sich daraus, ob A0–A2 an GND oder VCC liegen; in der Tabelle steht 1 für VCC und 0 für GND. Die verbreiteten lila Erweiterungsmodule haben für diese drei Pins Jumper oder kleine DIP-Schalter, ab Werk ist meist 0x20 eingestellt. Mit 8 Modulen desselben Typs kommst du auf 64 Pins, mischst du PCF8574 und PCF8574A, auf 16 Module und 128 Pins. Bist du dir bei der Adresse unsicher, lass den I2C-Scanner aus Was ist I2C oder I2C-LCD-Display laufen; steht auf dem Chip ein "A" im Namen, liegt die Adresse zwischen 0x38 und 0x3F.

Erstes Programm ohne Bibliothek: Taster lesen, LEDs schalten

C++ (Arduino IDE)
1// PCF8574: P0-P3 LED (LOW = yanar), P4-P7 düğme (GND'ye) / P0-P3 LEDs (LOW = on), P4-P7 buttons (to GND)
2#include <Wire.h>
3
4const uint8_t PCF_ADDR = 0x20;           // A0, A1, A2 = GND
5uint8_t lastButtons = 0x0F;
6
7void pcfWrite(uint8_t value) {
8  Wire.beginTransmission(PCF_ADDR);
9  Wire.write(value);                     // 8 pinin hepsi tek baytta / all 8 pins in one byte
10  Wire.endTransmission();
11}
12
13uint8_t pcfRead() {
14  Wire.requestFrom(PCF_ADDR, (uint8_t)1);
15  return Wire.available() ? Wire.read() : 0xFF;
16}
17
18void setup() {
19  Serial.begin(9600);
20  Wire.begin();                          // Uno: SDA = A4, SCL = A5
21  pcfWrite(0xFF);                        // hepsi HIGH: LED'ler sönük, girişler hazır / all HIGH: LEDs off, inputs ready
22}
23
24void loop() {
25  uint8_t buttons = pcfRead() >> 4;      // P4-P7, basılı = 0 / pressed = 0
26  // Üst 4 bit 1 kalmalı (giriş); basılı düğme kendi LED'ini yakar
27  // Upper 4 bits must stay 1 (inputs); a pressed button lights its LED
28  pcfWrite(0xF0 | buttons);
29  if (buttons != lastButtons) {
30    lastButtons = buttons;
31    Serial.print("Buttons P7..P4: ");
32    Serial.println(buttons | 0x10, BIN); // baştaki 1 sıfırları göstermek için / leading 1 keeps the zeros visible
33  }
34  delay(20);
35}

Für den PCF8574 brauchst du nicht einmal eine Bibliothek: Ein mit Wire.write() gesendetes Byte setzt alle 8 Pins auf einmal, ein mit Wire.requestFrom() gelesenes Byte liefert den aktuellen Zustand aller 8 Pins. Schiebst du das gelesene Byte um 4 Bit nach rechts, landen die Taster an P4–P7 in den unteren vier Bits; ein gedrückter Taster liefert 0. Beim Schreiben erledigt 0xF0 | buttons zwei Dinge: Die oberen vier Bits bleiben 1, damit P4–P7 Eingänge bleiben, und die unteren vier Bits übernehmen den Zustand der Taster. Weil das Bit eines gedrückten Tasters 0 ist, geht der zugehörige LED-Pin auf LOW und die LED leuchtet. Wenn dir Bitoperationen neu sind, ist der Artikel Zahlensysteme und Bitoperationen ein guter Einstieg.

INT-Pin und Interrupt: Taster lesen ohne Dauerabfrage

Der Code oben belegt den I2C-Bus dutzende Male pro Sekunde. Der INT-Pin des PCF8574 geht auf LOW, sobald sich ein Eingang seit dem letzten Lesen geändert hat, und bleibt dort, bis der Chip gelesen oder beschrieben wird. Verbindest du ihn mit einem Interrupt-Pin des Arduino, liest du nur noch bei einer Änderung; den Rest der Zeit sind Bus und Prozessor frei. Das folgende Beispiel nutzt die Bibliothek PCF8574 von Rob Tillaart, die du über den Bibliotheksverwalter installierst. Ab Version 0.4 der Bibliothek musst du Wire.begin() selbst vor pcf.begin() aufrufen.

C++ (Arduino IDE)
1// PCF8574 + INT pini: yalnız değişiklik olunca oku / read only when something changes
2#include <Wire.h>
3#include <PCF8574.h>                     // Rob Tillaart
4
5#ifndef IRAM_ATTR
6#define IRAM_ATTR                        // AVR'de boş / empty on AVR
7#endif
8
9#if defined(ESP32)
10const int INT_PIN = 4;                   // PCF8574 INT -> GPIO 4
11#else
12const int INT_PIN = 2;                   // PCF8574 INT -> D2 (Uno kesme pini / Uno interrupt pin)
13#endif
14
15PCF8574 pcf(0x20);
16volatile bool changed = false;
17uint8_t lastState = 0xFF;
18
19void IRAM_ATTR onPcfInt() {
20  changed = true;                        // yalnız bayrak kaldır / just raise a flag
21}
22
23void setup() {
24  Serial.begin(115200);
25#if defined(ESP32)
26  Wire.begin(21, 22);                    // SDA, SCL
27#else
28  Wire.begin();
29#endif
30  if (!pcf.begin(0xFF)) Serial.println("PCF8574 not found");
31  pinMode(INT_PIN, INPUT_PULLUP);        // INT open-drain çıkış, pull-up şart / INT is open-drain, needs a pull-up
32  attachInterrupt(digitalPinToInterrupt(INT_PIN), onPcfInt, FALLING);
33}
34
35void loop() {
36  if (!changed) return;
37  delay(20);                             // kontaklar otursun (tuş arkı) / let the contacts settle (bounce)
38  changed = false;
39  uint8_t state = pcf.read8();           // okumak INT'i sıfırlar / reading clears INT
40  uint8_t fell = lastState & ~state;     // 1'den 0'a inen bitler = yeni basışlar / bits that went 1 -> 0 = new presses
41  lastState = state;
42  for (uint8_t i = 4; i < 8; i++) {
43    if (fell & (1 << i)) {
44      pcf.toggle(i - 4);                 // P4 -> P0 LED, P5 -> P1 LED ...
45      Serial.print("LED P");
46      Serial.println(i - 4);
47    }
48  }
49}

Die Interrupt-Routine setzt nur ein Flag, denn I2C-Zugriffe innerhalb eines Interrupts machen sowohl auf dem Uno als auch auf dem ESP32 Probleme. Sieht loop() das Flag, wartet es 20 ms, bis das Prellen der Tasterkontakte vorbei ist, liest dann mit read8() den ganzen Port und setzt damit INT zurück. Der Ausdruck lastState & ~state findet die Bits, die von 1 auf 0 gefallen sind, also neu gedrückte Taster. Jeder neue Druck schaltet mit toggle() die passende LED um; da toggle() das in der Bibliothek gespeicherte Ausgangsbyte verwendet, bekommen die Eingangspins weiterhin eine 1. Die Grundlagen zu Interrupts findest du im Artikel Arduino-Interrupts.

Der INT-Pin ist ein Open-Drain-Ausgang und kann nicht selbst auf HIGH gehen; INPUT_PULLUP am Arduino oder ein externer 10-kΩ-Pull-up ist Pflicht. Die INT-Pins mehrerer PCF8574 darfst du auf dieselbe Interrupt-Leitung legen; kommt ein Interrupt, liest du alle nacheinander und findest den geänderten. Auf dem ESP32 muss die Interrupt-Routine mit IRAM_ATTR markiert sein; der #ifndef-Block im Code macht dieses Wort auf dem Uno wirkungslos.

Das I2C-LCD-Modul ist in Wahrheit ein PCF8574

Schau dir die blaue oder schwarze I2C-Adapterplatine auf der Rückseite eines 16x2-LCD genauer an: Darauf sitzt ein Chip mit der Aufschrift PCF8574T oder PCF8574AT. Die Bibliothek LiquidCrystal_I2C steuert die 8 Pins dieses Chips so, als wären sie direkt mit der parallelen Schnittstelle des LCD verbunden, und sendet die Daten im 4-Bit-Modus. Deshalb lautet die LCD-Adresse meist 0x27 oder 0x3F: Auf der Adapterplatine liegen A0–A2 über Pull-up-Widerstände an VCC, alle drei Bits sind also 1; beim PCF8574T ergibt das 0x27, beim PCF8574AT 0x3F. Schließt du die Lötbrücken A0–A2 auf der Rückseite, änderst du die Adresse und kannst mehrere LCDs am selben Bus betreiben.

PCF8574-PinLCD-Anschluss
P0RS (Befehl oder Daten)
P1RW (Lesen oder Schreiben)
P2E (Enable)
P3Hintergrundbeleuchtung (über Transistor)
P4–P7D4–D7 (4-Bit-Datenbus)
2x16-LCD mit I2C-Modul
2x16-LCD mit I2C-Modul: Der PCF8574 auf der Rückseite reduziert die 16-polige Parallelschnittstelle des LCD auf 4 Leitungen (GND, VCC, SDA, SCL).

PCF8574 mit ESP32 und Raspberry Pi Pico

Auf dem ESP32 laufen beide Beispiele unverändert; der einzige Unterschied ist, dass Wire.begin(21, 22) die I2C-Pins ausdrücklich angibt, und das Interrupt-Beispiel erledigt das bereits im Block #if defined(ESP32). Auf dem Raspberry Pi Pico übernimmt die Klasse machine.I2C von MicroPython dieselbe Aufgabe in wenigen Zeilen: writeto() schreibt ein Byte, readfrom() liest eines. Der folgende Code scannt beim Start den I2C-Bus, zeigt ohne Tastendruck ein Lauflicht auf P0–P3 und lässt bei gedrücktem Taster die passende LED leuchten. Bleib bei 100 kHz; höhere Geschwindigkeiten garantiert das Datenblatt des PCF8574 nicht.

MicroPython
1# Raspberry Pi Pico + PCF8574 (MicroPython): P0-P3 LED, P4-P7 düğme / P0-P3 LEDs, P4-P7 buttons
2from machine import Pin, I2C
3import time
4
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=100000)   # PCF8574 en fazla 100 kHz / max 100 kHz
6ADDR = 0x20
7print("I2C:", [hex(a) for a in i2c.scan()])          # 0x20 görünmeli / 0x20 should appear
8
9
10def pcf_write(value):
11    i2c.writeto(ADDR, bytes([value]))
12
13
14def pcf_read():
15    return i2c.readfrom(ADDR, 1)[0]
16
17
18pcf_write(0xFF)                       # hepsi HIGH: LED'ler sönük / all HIGH: LEDs off
19led = 0
20while True:
21    buttons = pcf_read() >> 4         # basılı = 0 / pressed = 0
22    if buttons != 0x0F:
23        out = 0xF0 | buttons          # düğmeyi LED'e aynala / mirror buttons to LEDs
24    else:
25        out = 0xF0 | (~(1 << led) & 0x0F)   # yürüyen ışık / running light
26        led = (led + 1) % 4
27    pcf_write(out)
28    time.sleep_ms(150)

PCF8574, MCP23017 oder 74HC595?

MerkmalPCF8574MCP2301774HC595
Zusätzliche Pins8168 Ausgänge (kaskadierbar)
SchnittstelleI2C, 2 LeitungenI2C, 2 Leitungen (SPI-Version MCP23S17)3-Draht-seriell (SPI-ähnlich)
PinrichtungQuasi-bidirektionalJeder Pin als Ein- oder Ausgang wählbarNur Ausgang
Ausgangsstrom25 mA gegen GND, bei HIGH sehr schwach25 mA pro Pin in beide RichtungenWenige mA pro Pin empfohlen
Interner Pull-upSchwache Stromquelle (fest)100 kΩ, per Software zuschaltbarKeiner
Interrupt1 INT2 INT (INTA, INTB)Keiner
I2C-Takt100 kHzBis 1,7 MHz-
Ideal fürTaster, LEDs und einfache Ein- und AusgängeViele Pins, echter Ausgangsstrom, TempoViele LEDs und 7-Segment-Anzeigen

Willst du nur ein paar Taster einlesen und einige LEDs schalten, ist der PCF8574 die günstigste und einfachste Wahl. Möchtest du LEDs mit HIGH treiben, die Richtung pro Pin festlegen, 16 Pins in einem Chip bündeln oder mit 400 kHz und mehr arbeiten, nimm den MCP23017. Brauchst du nur Ausgänge für viele LEDs oder 7-Segment-Anzeigen, ist das Schieberegister 74HC595 schneller und noch günstiger.

Projektideen mit dem PCF8574

  • Relaisplatine: Steuere ein achtkanaliges Relaismodul über einen einzigen I2C-Bus; die low-aktiven Relaiseingänge passen perfekt zur Logik des PCF8574.
  • Tastenfeld: Schließ die 8 Leitungen einer 4x4-Folientastatur an den PCF8574 an und halte die Arduino-Pins frei.
  • Tasterpanel: Lies 8 Taster für ein Spiel oder eine Fernbedienung per INT-Interrupt ein.
  • Statusanzeige: Zeige den Alarmzustand mehrerer Sensoren auf einer Leiste aus 8 LEDs.
  • Mehrere Displays: Betreibe zwei LCDs mit unterschiedlich adressierten Adaptermodulen am selben Arduino.
  • Lauflicht: Lass in einem Projekt ohne freie Pins ein Knight-Rider-Lauflicht über den PCF8574 laufen.

Häufige Fehler und Lösungen

SymptomMögliche UrsacheLösung
Taucht im I2C-Scan nicht aufSDA und SCL vertauscht oder keine gemeinsame MasseVerdrahtung prüfen; am Uno SDA = A4, SCL = A5
Adresse anders als erwartetChip ist ein PCF8574A oder A0–A2 anders eingestelltBereich 0x38–0x3F prüfen, Jumper kontrollieren
LED leuchtet nicht oder sehr schwachLED soll per HIGH getrieben werdenAnode über Widerstand an VCC, Kathode an den Pin; 0 schreiben
Taster liest immer 0 oder immer 1Auf den Eingangspin wurde vorher 0 geschriebenBei jedem Schreiben 1 an die Eingänge senden (0xF0 | ...)
Interrupt kommt einmal und dann nie wiederPort nicht gelesen, INT bleibt LOWNach jedem Interrupt den Port mit read8() lesen
Kommunikation stört bei vielen ModulenParallele Pull-ups ergeben zusammen einen zu kleinen WiderstandBei einigen Modulen SDA/SCL-Widerstände entfernen, Leitungen kürzen

Der PCF8574 löst Pinmangel mit zwei Leitungen und ist leicht zu lernen; hast du die quasi-bidirektionale Logik einmal verstanden, steuerst du LEDs, Taster, Relais und LCDs bequem am selben Bus. In der BlueGrays-App findest du Projekte zu I2C-LCD, Taschenrechner, Tastenfeld, Lauflicht und Tastern mit Schritt-für-Schritt-Schaltplänen und Code und kannst sie mit dem PCF8574 erweitern, wenn die Pins nicht reichen.

Häufige Fragen

Wie finde ich die I2C-Adresse des PCF8574?

Der PCF8574 liegt je nach A0–A2 zwischen 0x20 und 0x27, der PCF8574A zwischen 0x38 und 0x3F. Am sichersten lässt du einen I2C-Scanner laufen und liest die Adresse im seriellen Monitor ab. Bei LCD-Adaptermodulen ist sie meist 0x27 oder 0x3F.

Wie viele PCF8574 kann ich an einen Arduino anschließen?

Jeder PCF8574 bringt 8 Pins, und mit A0–A2 sind 8 Adressen möglich, also 64 Pins mit Modulen desselben Typs. Da PCF8574 und PCF8574A unterschiedliche Adressbereiche haben, kommst du gemischt auf 16 Module und 128 Pins. Achte bei vielen Modulen auf die Summe der I2C-Pull-up-Widerstände.

Warum leuchtet die LED am PCF8574 bei LOW?

Die Pins des PCF8574 können bei LOW bis zu 25 mA aufnehmen, bei HIGH aber nur etwa 100 µA liefern. Deshalb kommt die Anode der LED über einen Vorwiderstand an VCC und die Kathode an den Pin; mit einer 0 auf dem Pin leuchtet sie. Andersherum angeschlossen bleibt die LED dunkel oder sehr schwach.

Wie lese ich Taster am PCF8574 ein?

Schreib zuerst eine 1 auf den Pin, dann wartet er über den schwachen Pull-up auf HIGH. Zieht der Taster den Pin auf GND, liest du eine 0. Schreibst du dagegen eine 0 auf einen Eingang, bleibt er dauerhaft LOW und der Taster lässt sich nicht mehr auslesen.

PCF8574 oder MCP23017: Was ist der Unterschied?

Der PCF8574 ist ein einfacher Chip mit 8 quasi-bidirektionalen Pins und maximal 100 kHz. Der MCP23017 bietet 16 Pins, eine Richtungswahl pro Pin, zuschaltbare Pull-ups, zwei Interrupt-Ausgänge und bis zu 1,7 MHz I2C-Takt. Für einfache Taster- und LED-Aufgaben genügt der PCF8574, für größere Projekte ist der MCP23017 besser.

Funktioniert der PCF8574 mit dem ESP32 und 3,3 V?

Ja, der PCF8574 arbeitet von 2,5 bis 6 V und passt damit direkt zu ESP32 und Raspberry Pi Pico. Wichtig ist die Versorgung mit 3,3 V; an 5 V ziehen die Pull-ups SDA und SCL auf 5 V, was 3,3-V-Boards schaden kann. Am ESP32 gibst du die I2C-Pins mit Wire.begin(21, 22) an.

Alle Projekte ansehen
LED-Lauflicht
AR-5Mittel

LED-Lauflicht

Lichter, die nacheinander aufleuchten, als würden sie laufen. Der Arduino schaltet sechs LEDs einzeln ein; jede leuchtet kurz auf und geht wieder aus, sodass das Licht von vorn nach hinten wandert…

4.6(87)
218
Knight-Rider-Lauflicht
AR-6Mittel

Knight-Rider-Lauflicht

Das klassische Lauflicht, das hin und her wandert: Ein Lichtpunkt gleitet über sechs LEDs von einem Ende zum anderen und kommt wieder zurück.

4.8(107)
214
LED mit Taster schalten (Push)
AR-9Anfänger

LED mit Taster schalten (Push)

Wie bei einer Türklingel: Das Licht leuchtet, solange du drückst, und geht aus, wenn du loslässt.

4.8(114)
253
LED mit Taster ein- und ausschalten
AR-10Anfänger

LED mit Taster ein- und ausschalten

Einmal drücken und das Licht geht an, noch einmal drücken und es geht aus, genau wie der Lichtschalter in deinem Zimmer.

4.7(103)
177
Verwendung des LCD-Bildschirms mit I2C
AR-32Anfänger
Premium

Verwendung des LCD-Bildschirms mit I2C

Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.

4.8(53)
70
ESP32 I2C-LCD-Display (16×2)
ES-17Mittel
Premium

ESP32 I2C-LCD-Display (16×2)

In diesem Projekt schließen wir ein 16x2-Zeichen-LCD über I2C an den ESP32 an und zeigen Text an. Dank I2C reichen 2 Datenpins (SDA und SCL) statt der 6+ Pins einer klassischen Parallelverbindung. Der Code schreibt eine feste Nachricht in die erste Zeile und einen sekündlich steigenden Zähler in die zweite. Beim Start gibt ein I2C-Scanner die Adresse des Displays im Serial Monitor aus (meist 0x27 oder 0x3F).

4.9(23)
40
Arduino I2C-Rechner
AR-94Mittel
Premium

Arduino I2C-Rechner

Es handelt sich um ein Arduino-basiertes Taschenrechnerprojekt, das Addition, Subtraktion, Multiplikation und Division mit einer 4x4-Folientastatur und einem 16x2 I2C-LCD-Display durchführt. Dank I2C ist der Anschluss des Displays mit nur 2 Kabeln möglich, was den Kabelsalat reduziert und mehr Pins für die Verwendung offen hält. Die Eingabe von Dezimalzahlen und die Unterstützung negativer Zahlen sind ebenfalls möglich.

5.0(31)
43
4x4-Tastenfeld verwenden
AR-63Anfänger
Premium

4x4-Tastenfeld verwenden

Auf dem 4x4-Tastenfeld, das an die Tasten eines Telefons erinnert, erkennt der Arduino sofort, welche Taste du gedrückt hast, und schreibt sie auf deinen Computerbildschirm.

4.5(27)
35