LK1

🔧 Präprozessor

• Läuft vor dem Kompilieren.

• Verarbeitet #include, #define und andere Anweisungen.

• Bindet Bibliotheken ein und ersetzt Makros.

  
  

⚙️ Compiler

• Übersetzt den Arduino-Sketch (.ino) in Maschinencode.

• Prüft Syntax, wandelt C/C++ in Objektdateien um.

• Meldungen der Kompilierung erscheinen unten in der IDE.

🔗 Linker

• Verknüpft die kompilierten Objektdateien + eingebundene Bibliotheken zu einem lauffähigen Programm (.hex).

• Ergebnis wird anschließend per USB/seriell auf den Mikrocontroller übertragen.

Quellcode

• Menschlich lesbarer Code (.ino / .c / .h)

• Wird in der Arduino IDE geschrieben und editiert

• Enthält Logik, Funktionen, Variablen, Präprozessoranweisungen

Programmcode

• Vom Compiler/Linker erzeugter Maschinencode

• Nicht mehr lesbar, aber vom Mikrocontroller ausführbar

• Wird per USB/seriell auf den Arduino übertragen

Merksatz:

➡️ Quellcode ✍️ → Compiler/Linker ⚙️ → Programmcode ▶️ (läuft auf dem Arduino)

Präprozessor

• Läuft vor dem Kompilieren

• Bearbeitet Befehle, die mit # anfangen

  
  

#include

• Bindet Bibliotheken ein

• Macht deren Funktionen im Sketch nutzbar

#define

• Erzeugt Konstanten/Makros

• Gut für Einstellungen & Debug-Schalter

  (z.B. #define DEBUGGING true)

  
  

Merksatz:

➡️ Präprozessor = „Vorbereitung des Codes“, bevor der Compiler übernimmt.

Globale Variablen

• Überall sichtbar

• Von überall veränderbar

• Fehleranfällig → laut PDF: nur im Ausnahmefall nutzen!

  
  

Lokale Variablen

• Nur im Block/Funktion/Klasse gültig

• Standard in OOP: private Attribute („Kapselung“)

  
  

• Sicher, übersichtlich, empfohlen

setup()

• Wird einmal beim Start ausgeführt

• Hier alles initialisieren: Pins, serielle Schnittstelle, Objekte, Timer

• PDF zeigt setup/loop als Bestandteil des Basis-Sketches

  
  

• 
  

loop()

• Läuft endlos in einer Schleife

• Hauptprogramm → reagiert auf Eingaben, führt Logik fortlaufend aus

• Wird im PDF bei „Analyse des Source Codes“ erwähnt

  
  

Weitere wichtige Funktionen

pinMode(pin, MODE) – Pin als INPUT/OUTPUT setzen

digitalWrite(pin, HIGH/LOW) – Schaltet Pins ein/aus

digitalRead(pin) – Liest Taster/Signale

millis() – Zeitmessung ohne delay() (in deinen OOP-Aufgaben entscheidend)

delay(ms) – Pausiert Programm (aber blockierend, schlechter als millis())

Was sind Bibliotheksfunktionen?

• Extra-Funktionen aus #include-Bibliotheken

• Erweitern den Arduino um neue Fähigkeiten

  
  

Wie nutzt man sie?

1. #include <Lib.h>

2. Objekt erstellen

3. Funktionen der Lib aufrufen

Beispiele

• Servo: attach(), write()

• LCD: begin(), print()

• Wire/I2C: begin(), write(), requestFrom()

Merksatz

➡️ Bibliothek einbinden → Objekt erstellen → Funktionen nutzen

Digital OUTPUT

• Mit pinMode(pin, OUTPUT) setzen

• Mit digitalWrite(pin, HIGH/LOW) schalten

• Beispiel aus PDF: LED an Pin 13

  
  

  
  

Digital INPUT

• Mit pinMode(pin, INPUT) setzen

• Mit digitalRead(pin) Taster/Sensorstatus lesen

• HIGH = nicht gedrückt, LOW = gedrückt (bei Pullup)

  
  

• 
  

Pullup

• Offene Eingänge „springen“ → daher Pullup aktivieren

  pinMode(tasterPin, INPUT_PULLUP);

analog INPUT – analogRead()

• Liest analoge Spannung (0–5 V)

• Wird über ADC in Wert 0–1023 umgewandelt

• Typisch: Potentiometer → A0-A5

  int sensorValue = analogRead(A0);

Analog OUTPUT – analogWrite() (PWM)

• Gibt PWM-Signal aus (Pseudo-Analog)

• Wertebereich 0–255

• Nur an Pins mit ~ (z.B. 9,10,11)

• Dient z.B. für: LED dimmen, Motoren steuern

  
  

analogWrite(9, 180);

Merksatz

➡️ analogRead → echter Spannungswert (ADC)

➡️ analogWrite → PWM (8-Bit) „simuliert“ analog

Initialisierung – Serial.begin()

Startet die serielle Schnittstelle mit Baudrate (z.B. 9600).

Syntax:

Serial.begin(9600);

Gibt Werte oder Text an den PC aus.

Syntax:

Serial.print("Wert: ");

Serial.println(sensorValue);

Daten empfangen – Serial.read()

Liest eingehende Bytes vom PC (seltener genutzt).

Syntax:

int eingang = Serial.read();

Was ist I²C?

• Zweidraht-Bus: SDA = Daten, SCL = Takt

• Master–Slave-System → Arduino = Master

• Mehrere Geräte teilen sich die gleichen Leitungen, eindeutig über Adressen

• Synchron, seriell, adressiert

• Pins auf Arduino UNO fest vorgegeben: ➜ A4 = SDA, A5 = SCL (Pinübersicht)

• ❌ Andere Pins NICHT möglich, da Hardware-I²C nur an A4/A5 liegt.

Ablauf (Theorie-Shorty)

1. Start

2. Slave-Adresse senden

3. Schreiben oder Lesen

4. Stop ➡️ Ein Bus für viele Sensoren.

Wire.begin(); // Start I²C

Wire.beginTransmission(0x68); // Slave-Adresse

Wire.write(0x00); // Register

Wire.write(0x10); // Wert

Wire.endTransmission(); // Stop

Wire.requestFrom(0x68, 1);    // 1 Byte holen

int v = Wire.read();          // Wert lesen

KARTEIKARTE – SPI-BUS (Theorie + Mini-Code)

Was ist SPI?

• High-Speed Vierdraht-Bus

• Rollen: Master (Arduino) → Slaves (Sensor/Display/Modul)

• Extrem schnell, ideal für Displays, SD-Karten, DAC/ADC

• Jeder Slave bekommt eigene CS/SS-Leitung (Chip Select)

SPI-Pins (Arduino UNO – fix!)

• MOSI → D11

• MISO → D12

• SCK → D13

• SS → D10 (Standard-Slave-Select) ➡️ Diese Pins sind hardwarefest, daher NICHT frei wählbar.

Wie funktioniert SPI? (Theorie ultrakurz)

• Voll-Duplex: gleichzeitig senden & empfangen

• Master erzeugt Takt (SCK)

• Daten fließen über MOSI → Slave und MISO → zurück

• Jeder Slave wird einzeln über SS aktiviert (LOW = aktiv)

#include <SPI.h>

void setup() {

SPI.begin();

digitalWrite(10, LOW); // SS aktiv

SPI.transfer(0x42); // Byte senden

digitalWrite(10, HIGH); // SS inaktiv

}

GPIO

pinMode(pin, INPUT/OUTPUT);

digitalRead(pin);

digitalWrite(pin, HIGH/LOW);

Analog

analogRead(A0); // 0–1023

analogWrite(9, 180); // PWM (Pins mit ~)

Zeit

millis(); // Zeit seit Start (nicht blockierend)

delay(ms); // Wartet, blockiert alles

⸻

📘 Karteikarte – BME280 (Anbindung + Basics)

Was ist der BME280?

• Umwelt-Sensor für Temperatur, Luftfeuchtigkeit, Luftdruck

• Läuft über I²C (Standard) oder SPI

• Auf Arduino üblich: I²C → SDA/SCL (A4/A5)

⸻

Benötigte Bibliotheken

#include <Wire.h>

#include <Adafruit_BME280.h>

Adafruit_BME280 bme;

Initialisierung

bme.begin(0x76); // typische I²C-Adresse: 0x76 oder 0x77

Werte auslesen:

float t = bme.readTemperature(); // °C

float h = bme.readHumidity(); // %

float p = bme.readPressure(); // Pa

Breadboard / Versorgung

• GND → blaue Linie, 5V → rote Linie



• Bauteile immer zwischen zwei getrennten Reihen stecken

• Polaritäten beachten (LED, Displays, Sensoren)

⸻

LED anschließen (Arduino UNO)

• Anode (langes Bein) → Vorwiderstand → Arduino-Pin (z. B. D9)

• Kathode (kurzes Bein) → GND

Vorwiderstand:

➡️ 220–330 Ω (Standard aus deinem LED-Taster-Projekt)

Beispiel:

D9 ── 220Ω ──►|── GND

I²C-Display (z. B. SSD1306)

(typisch 4-Pin-OLED)

• GND → GND

• VCC → 5V

• SDA → A4

• SCL → A5

➡️ I²C braucht immer nur 2 Signalleitungen (SDA/SCL), egal wie viele Geräte.

SPI-Display (z. B. TFT, LCD-Treiber)

(typisch 6–7 Pins)

• MOSI → D11

• MISO → D12

• SCK → D13

• CS → frei wählbar (z. B. D10)

• DC / RS → beliebiger Digital-Pin

• RST → beliebiger Pin oder RESET

➡️ SPI ist schneller, aber braucht mehr Leitungen als I²C.

📘 Karteikarte 1 – Programmierstil (ultra kurz)

Ziel

• Code lesbar, verständlich, wartbar machen

Wichtigste Regeln

1. Einrücken

→ Struktur sichtbar machen (4 Spaces empfohlen)

2. Kommentare nutzen

→ erklären warum etwas passiert, nicht nur wie

→ Einzelzeilen, End-of-line, mehrzeilig

3. Gute Bezeichner

→ englisch, eindeutig, sinnvoll (z. B. resistor, voltage)

4. Funktionen nutzen

→ Doppelcode vermeiden, modular denken

5. TODO / FIXME Marker

→ Problemstellen markieren

// TODO: improve logic

// FIXME: wrong value

Was ist das?

• Debuggen über Serielle Ausgabe

• Programmablauf live beobachten

• Ideal für Arduino, weil kein echter Debugger vorhanden

  
  

Wie benutzt man’s?

#define DEBUGGING true

Debug-Schalter anlegen:

if (DEBUGGING) {

Serial.println(variable);

}

Serial.println("Error: ...");