Tinkercad Arduino Simulation: Schaltung, Code und Messen lernen

Eine Tinkercad Arduino Simulation ist der einfachste Weg, eine Arduino-Schaltung aufzubauen und ihren Code laufen zu lassen, bevor du überhaupt ein Bauteil besitzt. Im kostenlosen, browserbasierten Tinkercad Circuits von Autodesk verbindest du einen Arduino Uno mit einem virtuellen Breadboard, fügst LEDs, Widerstände, Taster und Sensoren hinzu, schreibst den Code und klickst auf Start Simulation: Die LED leuchtet, der Servo dreht sich und Daten erscheinen im seriellen Monitor. Keine LED brennt durch und kein Board geht wegen einer falschen Verbindung kaputt, denn alles passiert auf dem Bildschirm. Deshalb beginnen so viele Arduino-Kurse an Schulen mit Tinkercad.

In dieser Anleitung legst du zuerst ein Konto an, baust deine erste Schaltung auf dem Breadboard, siehst den Unterschied zwischen Block-Code und Text-Code, verfolgst Sensordaten im seriellen Monitor und als Diagramm und misst Spannung, Strom und Widerstand mit dem virtuellen Multimeter. Danach erfährst du, wie Klassenkonten für Lehrkräfte funktionieren, welche Bauteile Tinkercad hat und welche fehlen, wo sich die Simulation von einer echten Schaltung unterscheidet und warum du für ESP32 und Raspberry Pi Pico zu Wokwi wechseln solltest.

Was ist Tinkercad Circuits und wie funktioniert es?

Tinkercad ist die kostenlose Web-App von Autodesk, die 3D-Konstruktion, Elektronik und Programmieren vereint. Der Elektronikbereich Circuits ist der Nachfolger von 123D Circuits, das 2017 eingestellt wurde, und läuft ohne Installation in jedem aktuellen Browser. Deine Entwürfe werden in der Cloud gespeichert, sodass du eine in der Schule begonnene Schaltung zu Hause weiterbauen kannst. Tinkercad führt nicht nur deinen Code aus, sondern berechnet auch die Elektrik der Schaltung: den Strom durch einen Widerstand, die Spannung an einer LED, das Potenzial an jedem Punkt. Als programmierbare Boards gibt es den Arduino Uno R3, den ATtiny und den BBC micro:bit. Dein Arduino-Code wird wie mit dem echten Arduino-Compiler übersetzt und auf einem virtuellen ATmega328P ausgeführt; deshalb läuft Code, der in Tinkercad funktioniert, auch auf einem echten Board.

Wie legst du ein Tinkercad-Konto an?

1. Öffne tinkercad.com im Browser und klicke oben rechts auf Sign Up (registrieren).
2. Wähle den passenden Weg: ein persönliches Konto, wenn du allein lernst, ein Konto als Lehrkraft (Educators), wenn du unterrichtest, oder Join Class, wenn du von deiner Lehrkraft einen Klassencode bekommen hast.
3. Für ein persönliches Konto meldest du dich mit deiner E-Mail-Adresse oder deinem Google-Konto an. Ein Tinkercad-Konto ist eigentlich ein Autodesk-Konto; mit denselben Daten kommst du auch in andere Autodesk-Dienste.
4. Öffne nach der Anmeldung im Menü links auf deinem Dashboard den Bereich Circuits und starte mit Create (erstellen) eine neue Schaltung.
5. Dein Entwurf wird automatisch gespeichert. Tinkercad gibt ihm einen zufälligen, lustigen Namen; klicke oben links auf den Namen und gib etwas Sinnvolles wie "LED und Taster" ein, damit du ihn später wiederfindest.

Für Schülerinnen und Schüler unter 13 Jahren ist die Anmeldung mit Klassencode und Spitzname (Nickname) der Lehrkraft am einfachsten: Es braucht weder E-Mail noch Passwort. Man klickt auf tinkercad.com auf Join Class, gibt den Code ein und danach den zugeteilten Spitznamen. Jüngere Nutzer, die ein persönliches Konto anlegen möchten, werden bei der Registrierung eventuell nach der Zustimmung der Eltern gefragt. Die Details zu Lehrerkonten findest du weiter unten in einem eigenen Abschnitt.

Die Oberfläche kennenlernen: Arbeitsfläche, Bauteile und Tastenkürzel

Im Schaltungseditor liegt links eine große Arbeitsfläche und rechts das Bauteilfenster. Standardmäßig zeigt es die beliebtesten Grundbauteile (Basic Components); für alle Teile wählst du im Aufklappmenü All Components oder tippst einen Namen wie "servo" oder "ultrasonic" ins Suchfeld. Weiter unten im Fenster findest du im Bereich Starters rund zwei Dutzend fertige Arduino-Schaltungen. Eine davon auf die Arbeitsfläche zu ziehen, die Simulation zu starten und den Code zu lesen, ist der schnellste Weg, ein neues Bauteil kennenzulernen. Mit den Schaltflächen in der oberen Leiste wechselst du zwischen Schaltungsansicht, automatisch gezeichneter Schaltplanansicht und Bauteilliste.

Erste Schaltung: LED, Widerstand und Taster auf dem Breadboard

1. Ziehe einen Arduino Uno R3 und ein Breadboard aus dem Bauteilfenster und lege sie nebeneinander. Wenn du nicht weißt, wie ein Breadboard innen verbunden ist, lies zuerst Was ist ein Breadboard?.
2. Setze eine LED auf das Breadboard. Bei der LED in Tinkercad ist das gebogene Bein die Anode (+) und das gerade Bein die Kathode (−); fährst du mit der Maus über ein Bein, zeigt Tinkercad seinen Namen an. Ist die LED ausgewählt, kannst du im eingeblendeten Fenster ihre Farbe ändern.
3. Füge einen Widerstand hinzu und schalte ihn in Reihe mit der Anode der LED. Stelle im Fenster des ausgewählten Widerstands den Wert 220 und die Einheit Ω ein; voreingestellt ist 1 kΩ. Den passenden Vorwiderstand für deine LED findest du mit dem LED-Vorwiderstandsrechner.
4. Setze einen Taster (Pushbutton) über den Spalt in der Mitte des Breadboards, damit die gegenüberliegenden Beine voneinander getrennt bleiben.
5. Für einen Draht klickst du auf einen Pin oder ein Loch und dann auf das Ziel; mit Klicks auf freie Stellen dazwischen biegst du den Draht. Verbinde das freie Ende des Widerstands mit D9, die Kathode der LED mit GND, ein Bein des Tasters mit D2 und das diagonal gegenüberliegende Bein mit GND.
6. Färbe die Drähte ein: Plus rot und Masse schwarz macht die Fehlersuche viel leichter. Gib dann den Code unten ein und klicke auf Start Simulation.

Code schreiben: die Modi Blöcke, Blöcke + Text und Text

Die Schaltfläche Code oben rechts öffnet das Code-Fenster. Im Aufklappmenü oben im Fenster gibt es drei Modi. Im Modus Blocks (Blöcke) ziehst du bunte Blöcke im Scratch-Stil zusammen; ein vergessenes Semikolon oder ein Tippfehler ist unmöglich. Im Modus Blocks + Text bleiben die Blöcke links, und rechts siehst du live den Arduino-C++-Code, den Tinkercad daraus erzeugt; änderst du einen Block, ändert sich sofort auch der Text. Dieser Modus ist die beste Brücke von Blöcken zu echtem Code. Im Modus Text schreibst du C++ direkt, genau wie in der Arduino IDE. Die Blöcke sind farblich in Ausgabe (Output), Eingabe (Input), Notiz (Notation), Steuerung (Control), Mathematik (Math) und Variablen (Variables) gegliedert.

Erstes Programm im Text-Code: Taster, LED und serieller Monitor

1// Tinkercad ilk program: buton, LED ve Seri Monitör / First Tinkercad sketch: button, LED and Serial Monitor
2const int LED_PIN = 9;      // LED + 220 ohm direnç / LED + 220 ohm resistor
3const int BUTON_PIN = 2;    // butonun diğer ucu GND'de / other button leg goes to GND
4
5int basmaSayisi = 0;        // basma sayacı / press counter
6int oncekiDurum = HIGH;     // önceki buton durumu / previous button state
7bool ledAcik = false;       // LED durumu / LED state
8
9void setup() {
10  pinMode(LED_PIN, OUTPUT);
11  pinMode(BUTON_PIN, INPUT_PULLUP);   // basılınca LOW okunur / reads LOW when pressed
12  Serial.begin(9600);
13  Serial.println("Hazir / Ready");
14}
15
16void loop() {
17  int durum = digitalRead(BUTON_PIN);
18  if (durum != oncekiDurum) {                       // durum değişti / state changed
19    if (durum == LOW) {                             // yeni basış / new press
20      basmaSayisi++;
21      ledAcik = !ledAcik;                           // LED'i tersine çevir / toggle the LED
22      digitalWrite(LED_PIN, ledAcik ? HIGH : LOW);
23      Serial.print("Basma / Presses: ");
24      Serial.println(basmaSayisi);
25    }
26    delay(50);                                      // basma ve bırakmada debounce / debounce on press and release
27    oncekiDurum = durum;
28  }
29}

Der Taster wird mit INPUT_PULLUP gelesen: Ein interner Widerstand von etwa 20–50 kΩ im Arduino hält den Pin auf HIGH, ein Druck auf den Taster zieht ihn auf GND, sodass LOW gelesen wird; ein zusätzlicher Widerstand ist deshalb nicht nötig. Das Programm reagiert nur auf den Wechsel von HIGH nach LOW, also auf einen neuen Tastendruck, und schaltet die LED jedes Mal um. Klicke nach dem Start der Simulation unten im Code-Fenster auf Serial Monitor und dann mit der Maus auf den Taster: Mit jedem Druck steigt der Zähler um eins. Wie du dieselbe Schaltung auf einem echten Board aufbaust, steht in Taster am Arduino anschließen.

Serieller Monitor und Diagramm: Sensordaten beobachten

Das Schönste an Sensoren in Tinkercad ist, dass du ihre Werte mit der Maus verändern kannst. Klickst du während der Simulation auf den Temperatursensor TMP36, erscheint ein Schieberegler, mit dem du die Temperatur zwischen −40 und 125 °C einstellst. Beim Fotowiderstand änderst du so die Helligkeit, beim Bodenfeuchtesensor die Feuchte; beim Ultraschall-Abstandssensor und beim PIR-Bewegungsmelder ziehst du das Ziel, das vor ihnen erscheint, und ahmst so Abstand oder Bewegung nach. Der TMP36 liefert bei 0 °C 0,5 V und steigt um 10 mV pro Grad, bei 25 °C also 0,75 V. Verbinde den mittleren Pin mit A1 und die äußeren mit 5V und GND; der folgende Code liest diese Spannung und rechnet sie in Grad Celsius um:

1// TMP36 ile sıcaklık: Seri Monitör ve grafik / Temperature with TMP36: Serial Monitor and graph
2const int TMP36_PIN = A1;   // TMP36 orta ucu (Vout) / TMP36 middle pin (Vout)
3
4void setup() {
5  Serial.begin(9600);
6}
7
8void loop() {
9  int ham = analogRead(TMP36_PIN);         // 0-1023 arası ham değer / raw value 0-1023
10  float volt = ham * 5.0 / 1023.0;         // gerilime çevir / convert to volts
11  float sicaklik = (volt - 0.5) * 100.0;   // 0,5 V = 0 °C ve 10 mV/°C / 0.5 V = 0 °C and 10 mV/°C
12  Serial.println(sicaklik, 1);             // yalnız sayı: grafik için / number only: for the graph
13  delay(500);
14}

Ist der serielle Monitor offen, zeigt die Diagramm-Schaltfläche im Fenster die eintreffenden Zahlen als Liniendiagramm; bewegst du den Sensorregler, steigt und fällt die Kurve. Damit das Diagramm sauber gezeichnet wird, gib in jeder Zeile nur die Zahl aus; fügst du eine Beschriftung wie "Temp: 24.5" hinzu, kann das Diagramm gestört sein oder gar nicht erscheinen. Du kannst auch Text in das Feld unten im Monitor tippen, ihn senden und im Code mit Serial.read() lesen, etwa für ein Programm, das eine LED per Tastatur einschaltet. Alles über die serielle Kommunikation findest du in Arduino Serial Monitor.

Spannung, Strom und Widerstand mit dem virtuellen Multimeter messen

Der größte Unterschied zwischen Tinkercad und der Arduino IDE ist, dass Tinkercad die Schaltung elektrisch berechnet; deshalb kannst du wie mit einem echten Multimeter messen. Ziehe ein Multimeter aus dem Bauteilfenster; von den beiden Anschlüssen unten ist der schwarze COM (−) und der rote der Messanschluss (+). Klicke auf das Multimeter, um im eingeblendeten Fenster die Messart zu wählen; der Wert erscheint auf der Anzeige, solange die Simulation läuft:

• Spannung (Voltage): Schließe die Messspitzen parallel an die zwei Punkte an, zwischen denen du messen willst, zum Beispiel rot an den Mittelanschluss des Potentiometers und schwarz an GND.
• Strom (Current): Trenne die Schaltung an einer Stelle auf und setze das Multimeter in Reihe dazwischen, zum Beispiel zwischen D9 und den Widerstand. Ein Multimeter im Strommodus parallel zu einem Bauteil ist ein Kurzschluss.
• Widerstand (Resistance): Trenne das Bauteil aus der Schaltung oder lass es stromlos und verbinde die Messspitzen mit seinen beiden Beinen. Widerstände sind in Tinkercad mit echten Farbringen gezeichnet; das Ablesen übst du mit dem Werkzeug Widerstand-Farbcode.

1// Potansiyometre ile LED parlaklığı ve multimetre karşılaştırması
2// Potentiometer LED brightness and multimeter comparison
3const int POT_PIN = A0;   // potansiyometre orta ucu / potentiometer wiper
4const int LED_PIN = 9;    // PWM destekli pin / PWM-capable pin
5
6void setup() {
7  pinMode(LED_PIN, OUTPUT);
8  Serial.begin(9600);
9}
10
11void loop() {
12  int ham = analogRead(POT_PIN);                // 0-1023
13  float volt = ham * 5.0 / 1023.0;              // multimetreyle karşılaştır / compare with the multimeter
14  int parlaklik = map(ham, 0, 1023, 0, 255);    // PWM değeri / PWM value
15  analogWrite(LED_PIN, parlaklik);
16
17  Serial.print(ham);
18  Serial.print("  ");
19  Serial.print(volt, 2);
20  Serial.println(" V");
21  delay(300);
22}

Für diesen Versuch fügst du ein Potentiometer hinzu: die äußeren Anschlüsse an 5V und GND, den Mittelanschluss an A0. Steht der Drehknopf genau in der Mitte, zeigt das Multimeter 2,50 V und der serielle Monitor einen Rohwert um 511 und 2,50 V, denn 2,5 / 5 × 1023 ≈ 511. Dass beide Werte übereinstimmen, zeigt am besten, wie analogRead eine Spannung in eine Zahl umwandelt. Schalte das Multimeter nun auf Strom, setze es in Reihe zwischen D9 und den Widerstand und drehe das Potentiometer ganz auf: Mit einer roten LED und 220 Ω siehst du ungefähr (5 − 2) / 220 ≈ 14 mA. Diese Rechnung kannst du auch mit dem Ohmsches-Gesetz-Rechner nachvollziehen. Bei Zwischenstellungen gibt D9 ein PWM-Signal aus, das ständig ein- und ausschaltet; um es zu sehen, fügst du ein Oszilloskop hinzu und verbindest die rote Messspitze mit D9, die schwarze mit GND. An Pin 9 des Uno liegt die PWM-Frequenz bei etwa 490 Hz, und analogWrite(128) zeichnet ein Rechtecksignal, das die Hälfte der Zeit HIGH ist. Das Prinzip erklärt Was ist PWM?.

Code Schritt für Schritt mit dem Debugger ausführen

Lässt sich dein Code nicht kompilieren, öffnet Tinkercad automatisch die Fehlerkonsole unter dem Code-Fenster und markiert die betroffene Zeile; die Meldungen ähneln denen der Arduino IDE. Kompiliert der Code, verhält sich aber falsch, nimm den Debugger: Klicke im Text-Modus auf eine Zeilennummer, um einen Haltepunkt (Breakpoint) zu setzen, und starte die Simulation. Das Programm hält an dieser Zeile an, und wenn du mit der Maus über eine Variable fährst, siehst du ihren aktuellen Wert. Mit den Schaltflächen über dem Code-Fenster gehst du zur nächsten Zeile oder lässt das Programm weiterlaufen. Um herauszufinden, warum ein Taster doppelt gezählt wird oder eine if-Bedingung nie erfüllt ist, ist das viel schneller, als überall Serial.print einzufügen. Die Bedeutung häufiger Compiler-Meldungen haben wir in Arduino-Kompilierfehler gesammelt.

Welche Bauteile hat Tinkercad und welche fehlen?

Um eine Bibliothek einzubinden, klickst du im Code-Fenster auf die Bibliotheks-Schaltfläche (Symbol eines Dateikastens); wählst du eine der rund elf Bibliotheken aus der Liste, wird die #include-Zeile oben in den Code eingefügt. Schreibst du eine Bibliothek, die nicht in der Liste steht, etwa DHT.h, meldet der Compiler, dass er die Datei nicht findet; eigene Bibliotheken lassen sich in Tinkercad nicht hochladen. Bei kleinen Bibliotheken kannst du den Inhalt der .h- und .cpp-Dateien direkt in deinen Code kopieren, aber eine Bibliothek für Hardware, die es in Tinkercad nicht gibt, funktioniert auch so nicht. Noch ein wichtiges Detail: Das I2C-LCD in Tinkercad wird in Beispielen mit der Bibliothek Adafruit_LiquidCrystal angesteuert, während gekaufte Module mit PCF8574 meist mit LiquidCrystal_I2C und der Adresse 0x27 oder 0x3F arbeiten. Beim Umstieg auf ein echtes Board musst du diese Zeilen anpassen; Details stehen in I2C-LCD-Display.

Grenzen der Simulation: Unterschiede zur echten Schaltung

• Timing: Die Simulation läuft im Browser; bei einer vollen Schaltung oder einem langsamen Computer kann sie langsamer als Echtzeit sein. Dann dauert delay(1000) auf dem Bildschirm länger als eine Sekunde, während millis() die eigene Uhr der Simulation zählt.
• Ideale Bauteile: Taster prellen in Tinkercad nicht, Drähte lockern sich nie, und analoge Messwerte rauschen weniger als in einer echten Schaltung. Auf einem echten Board brauchst du Entprellung und Mittelwerte über mehrere Messungen.
• Grenzen der Versorgung: Ein Motor oder viele LEDs, die in der Simulation problemlos laufen, können einen echten Arduino zum Neustart bringen oder seinen Spannungsregler überhitzen. Mach es dir zur Regel, aus einem Pin höchstens etwa 20 mA zu ziehen und Motoren aus einer eigenen Quelle zu versorgen.
• Verbunden aussehen heißt nicht verbunden sein: Sitzt ein Bein nicht richtig in einem Loch des Breadboards, sieht der Draht verbunden aus, aber die Schaltung funktioniert nicht. Fahre mit der Maus über das Loch und prüfe, ob die verbundenen Löcher derselben Reihe hervorgehoben werden.
• Eine Datei, wenige Bibliotheken: Dein Code besteht aus einem einzigen Tab und du kannst keine externen Bibliotheken hinzufügen; größere Projekte lassen sich so schwer gliedern.
• Umlaute: Der serielle Monitor unterstützt UTF-8 nicht vollständig, sodass ä, ö, ü oder ß verstümmelt erscheinen können. Am sichersten verzichtest du in seriellen Ausgaben auf Sonderzeichen.
• Kein Funk: WLAN, Bluetooth und Internet werden nicht simuliert; für Projekte im Internet der Dinge (IoT) ist Tinkercad nicht geeignet.

Tinkercad Classrooms für Lehrkräfte

1. Lege bei der Registrierung oder in den Profileinstellungen deine Rolle als Lehrkraft fest; die Klassenfunktionen stehen in Lehrerkonten zur Verfügung.
2. Öffne im oberen Menü die Seite Classes und erstelle mit Create new class eine Klasse, indem du Namen, Alters- oder Klassenstufe und Fach angibst.
3. Trage mit Add Students die Namen der Schüler ein; Tinkercad erzeugt für jeden einen in der Klasse eindeutigen Spitznamen. Lange Listen musst du nicht einzeln tippen, du kannst sie einfügen; eine Klasse fasst bis zu 250 Schüler.
4. Zeige mit Class Code den Klassencode und den Klassenlink an. Die Schüler treten bei, indem sie den Link öffnen und ihren Spitznamen eingeben oder auf tinkercad.com über Join Class den Code eingeben; E-Mail oder Passwort sind nicht nötig.
5. Verfolge die Arbeiten deiner Schüler im Tab Designs auf der Klassenseite; mit einem Klick auf einen Namen öffnest und bearbeitest du die Entwürfe dieses Schülers.

Klassen starten standardmäßig im Safe Mode (sicherer Modus): Schüler können ihre Entwürfe nicht öffentlich machen, nicht in der Galerie suchen und keine Kommentare sehen. Für die Unterrichtsvorbereitung kannst du die interaktiven Arduino-Lektionen im Learn-Bereich von Tinkercad und die Starters-Schaltungen nutzen. Bewährt hat sich, dass die Lehrkraft eine Beispielschaltung teilt und die Schüler sie kopieren und abwandeln. Gibt es in der Klasse echte Bausätze, sorgt der Aufbau zuerst in Tinkercad und danach mit echten Teilen spürbar für weniger verpolte LEDs und falsch versorgte Boards.

Von Tinkercad zum echten Arduino

1. Speichere den Code mit der Download-Schaltfläche im Code-Fenster als .ino-Datei auf deinem Computer oder kopiere den Text.
2. Öffne die Datei in der Arduino IDE; bietet die IDE an, sie in einen gleichnamigen Ordner zu verschieben, bestätige das. Ist die IDE noch nicht installiert, hilft die Anleitung Arduino IDE installieren.
3. Wähle unter Werkzeuge > Board den Arduino Uno und unter Port den Anschluss deines Boards, dann klicke auf Hochladen. Schlägt das Hochladen fehl, folge den Schritten in Arduino-Sketch lässt sich nicht hochladen.
4. Baue die Schaltung nach deiner Tinkercad-Zeichnung mit denselben Pins auf; die Schaltplanansicht auf einem zweiten Bildschirm erleichtert das.
5. Behebe die Unterschiede, die die Simulation nicht zeigt: Ergänze eine Software-Entprellung für Taster, passe Bibliothek und Adresse des I2C-LCD an, und wenn du statt des TMP36 einen anderen Sensor wie den DHT11 verwendest, ändere den Code entsprechend.

ESP32 und Raspberry Pi Pico: Tinkercad oder Wokwi?

Tinkercad hat weder ESP32 noch Raspberry Pi Pico und simuliert weder WLAN noch MicroPython. Für diese Boards nimmst du Wokwi, einen anderen Simulator, der ebenfalls im Browser läuft. Neben Arduino Uno, Mega und Nano unterstützt Wokwi die ESP32-Familie und den Pico, verbindet den ESP32 mit einem virtuellen WLAN und lässt dich die meisten Bibliotheken aus dem Arduino-Bibliotheksverwalter nutzen. Dafür berechnet Wokwi die Schaltung nicht elektrisch: Ein anderer Widerstandswert ändert den LED-Strom nicht, und statt eines Multimeters für Spannung und Strom gibt es einen Logikanalysator für digitale Signale. Kurz gesagt: Elektronik-Grundlagen lernst du am besten in Tinkercad, ESP32- und Pico-Code testest du in Wokwi. Eine ausführliche Einführung findest du in Wokwi-Simulator.

Unten findest du die MicroPython-Version des Taster-LED-Programms für den Raspberry Pi Pico. Mit den Anschlüssen GP14 und GP2 aus der Pin-Tabelle läuft es in Wokwi oder auf einem echten Pico mit Thonny. Auf dem ESP32 nutzt du den Arduino-Code unverändert und setzt nur LED_PIN auf 18 und BUTON_PIN auf 4. Für den Einstieg mit dem Pico lies Was ist der Raspberry Pi Pico?, für den ESP32 Was ist der ESP32?.

1# Aynı program Raspberry Pi Pico'da (MicroPython) / The same program on Raspberry Pi Pico (MicroPython)
2from machine import Pin
3import time
4
5led = Pin(14, Pin.OUT)                  # LED + 220 ohm direnç / LED + 220 ohm resistor
6buton = Pin(2, Pin.IN, Pin.PULL_UP)     # butonun diğer ucu GND'de / other button leg goes to GND
7
8basma = 0                               # basma sayacı / press counter
9onceki = 1                              # önceki buton durumu / previous button state
10
11while True:
12    durum = buton.value()
13    if durum != onceki:                 # durum değişti / state changed
14        if durum == 0:                  # yeni basış / new press
15            basma += 1
16            led.toggle()                # LED'i tersine çevir / toggle the LED
17            print("Basma / Presses:", basma)
18        time.sleep_ms(50)               # basma ve bırakmada debounce / debounce on press and release
19        onceki = durum
20    time.sleep_ms(5)

Projektideen zum Ausprobieren in Tinkercad

• Ampel: Eine Kreuzung mit drei LEDs und Fußgängertaster; den Aufbau Schritt für Schritt zeigt Arduino-Ampel.
• Nachtlicht: Eine LED, die bei Dunkelheit angeht; den Fotowiderstand auf einem echten Board erklärt LDR-Lichtsensor.
• Einparkhilfe: Ultraschallsensor und Piezo-Summer, der beim Annähern schneller piept; das Messprinzip steht in HC-SR04-Abstandssensor.
• Servosteuerung: Stelle den Winkel eines Servos mit einem Potentiometer ein; der Code aus Servomotor läuft auch in Tinkercad.
• Codeschloss: Ein Türschloss mit 4x4-Tastenfeld, LCD und Servo; die Keypad-Bibliothek aus dem Artikel Keypad gibt es auch in Tinkercad.
• Viele LEDs an wenigen Pins: Steuere 8 LEDs über 3 Pins mit einem Schieberegister 74HC595; Details in 74HC595.
• Zwei Arduinos im Gespräch: Verbinde TX und RX zweier Unos über Kreuz und schicke Nachrichten von einem zum anderen; Tinkercad simuliert mehrere Boards gleichzeitig.
• Blinker mit dem 555: Baue eine blinkende LED ohne Mikrocontroller und miss die Frequenz mit dem Oszilloskop; die Berechnung steht in 555-Timer.

Häufige Fehler und ihre Lösung

Tinkercad ist der beste Einstieg, um Arduino kostenlos und ohne Risiko zu lernen: Du baust die Schaltung, misst nach, verfolgst den Code Schritt für Schritt und lädst denselben Code auf ein echtes Board, sobald du bereit bist. Jede Schaltung, die virtuell funktioniert, erleichtert auch deinen ersten Versuch auf dem Tisch. In der BlueGrays-App findest du viele Projekte mit Schaltplänen und Code Schritt für Schritt, von der ersten LED und der Ampel über Taster- und LDR-Projekte bis zur Abstandsmessung mit dem HC-SR04 und zwei kommunizierenden Arduinos; so kannst du die Schaltungen aus Tinkercad mit echten Bauteilen nachbauen. Weitere Anregungen liefert unsere Liste mit Arduino-Projektideen.