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

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.
| Merkmal | Wert |
|---|---|
| Pins | 8 (P0–P7), quasi-bidirektional |
| Versorgung | 2,5–6 V (läuft mit 3,3 V und 5 V) |
| Schnittstelle | I2C, höchstens 100 kHz |
| Adresse | PCF8574: 0x20–0x27, PCF8574A: 0x38–0x3F |
| Ausgangsstrom LOW | Bis 25 mA pro Pin (Sink) |
| Ausgangsstrom HIGH | Etwa 100 µA (schwacher Pull-up) |
| Interrupt | INT-Pin, Open-Drain, aktiv LOW |
| Gehäuse | DIP-16 (PCF8574P) und SO-16 (PCF8574T) |
PCF8574 Pinbelegung und Anschluss
| PCF8574 / Modul | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | 5V | 3V3 | 3V3 (OUT) |
| GND | GND | GND | GND |
| SDA | A4 | GPIO 21 | GP4 |
| SCL | A5 | GPIO 22 | GP5 |
| INT (optional) | D2 | GPIO 4 | GP6 |
| P0–P3 | LEDs: Anode über Vorwiderstand an VCC, Kathode an den Pin | Gleich | Gleich |
| P4–P7 | Taster: ein Bein an den Pin, das andere an GND | Gleich | Gleich |
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.
Adresse einstellen: A0, A1, A2 und PCF8574A
| A2 | A1 | A0 | PCF8574 | PCF8574A |
|---|---|---|---|---|
| 0 | 0 | 0 | 0x20 | 0x38 |
| 0 | 0 | 1 | 0x21 | 0x39 |
| 0 | 1 | 0 | 0x22 | 0x3A |
| 0 | 1 | 1 | 0x23 | 0x3B |
| 1 | 0 | 0 | 0x24 | 0x3C |
| 1 | 0 | 1 | 0x25 | 0x3D |
| 1 | 1 | 0 | 0x26 | 0x3E |
| 1 | 1 | 1 | 0x27 | 0x3F |
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
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.
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.
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-Pin | LCD-Anschluss |
|---|---|
| P0 | RS (Befehl oder Daten) |
| P1 | RW (Lesen oder Schreiben) |
| P2 | E (Enable) |
| P3 | Hintergrundbeleuchtung (über Transistor) |
| P4–P7 | D4–D7 (4-Bit-Datenbus) |

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.
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?
| Merkmal | PCF8574 | MCP23017 | 74HC595 |
|---|---|---|---|
| Zusätzliche Pins | 8 | 16 | 8 Ausgänge (kaskadierbar) |
| Schnittstelle | I2C, 2 Leitungen | I2C, 2 Leitungen (SPI-Version MCP23S17) | 3-Draht-seriell (SPI-ähnlich) |
| Pinrichtung | Quasi-bidirektional | Jeder Pin als Ein- oder Ausgang wählbar | Nur Ausgang |
| Ausgangsstrom | 25 mA gegen GND, bei HIGH sehr schwach | 25 mA pro Pin in beide Richtungen | Wenige mA pro Pin empfohlen |
| Interner Pull-up | Schwache Stromquelle (fest) | 100 kΩ, per Software zuschaltbar | Keiner |
| Interrupt | 1 INT | 2 INT (INTA, INTB) | Keiner |
| I2C-Takt | 100 kHz | Bis 1,7 MHz | - |
| Ideal für | Taster, LEDs und einfache Ein- und Ausgänge | Viele Pins, echter Ausgangsstrom, Tempo | Viele 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
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Taucht im I2C-Scan nicht auf | SDA und SCL vertauscht oder keine gemeinsame Masse | Verdrahtung prüfen; am Uno SDA = A4, SCL = A5 |
| Adresse anders als erwartet | Chip ist ein PCF8574A oder A0–A2 anders eingestellt | Bereich 0x38–0x3F prüfen, Jumper kontrollieren |
| LED leuchtet nicht oder sehr schwach | LED soll per HIGH getrieben werden | Anode über Widerstand an VCC, Kathode an den Pin; 0 schreiben |
| Taster liest immer 0 oder immer 1 | Auf den Eingangspin wurde vorher 0 geschrieben | Bei jedem Schreiben 1 an die Eingänge senden (0xF0 | ...) |
| Interrupt kommt einmal und dann nie wieder | Port nicht gelesen, INT bleibt LOW | Nach jedem Interrupt den Port mit read8() lesen |
| Kommunikation stört bei vielen Modulen | Parallele Pull-ups ergeben zusammen einen zu kleinen Widerstand | Bei 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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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…

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.

LED mit Taster schalten (Push)
Wie bei einer Türklingel: Das Licht leuchtet, solange du drückst, und geht aus, wenn du loslässt.

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.

Verwendung des LCD-Bildschirms mit I2C
Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.

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

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.

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.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

