Mikrocontroller-Programmierung: All-in-One Starter Kits für Arduino und Pico 2

Wer beginnt, sich mit Embedded-Systemen zu beschäftigen, speziell solchen mit Mikrocontrollern wie Arduino, Raspberry Pi Pico 2 oder ESP32, sollte sich zunächst mit entsprechenden Lerninhalten vertraut machen. Das gilt insbesondere für Anfänger, die sich für IT und Elektronik interessieren. Der harte Weg besteht darin, einen Lötkolben, verschiedene Bauteile und Komponenten sowie einen Mikrocontroller aufzutreiben, um dann im Internet nach entsprechenden Projekten und Lerninhalten zu suchen. Nicht alle, die sich mit Mikrocontrollern beschäftigen, verspüren jedoch Lust aufs Löten oder aufs Verlegen von Kabeln und Komponenten auf einem Breadboard. Zum Glück gibt es hierfür auch den leichten Weg mithilfe von "lötfreien" Starter Kits.

Der Pragmatische Architekt – Michael Stal

Prof. Dr. Michael Stal arbeitet seit 1991 bei Siemens Technology. Seine Forschungsschwerpunkte umfassen Softwarearchitekturen für große komplexe Systeme (Verteilte Systeme, Cloud Computing, IIoT), Eingebettte Systeme und Künstliche Intelligenz. Er berät Geschäftsbereiche in Softwarearchitekturfragen und ist für die Architekturausbildung der Senior-Software-Architekten bei Siemens verantwortlich.

Zwar existierte die Idee und entsprechende Produkte schon länger, aber die beiden Kits von Elecrow kommen in einem handlichen Format und voll integrierten Komponenten für einen moderaten Preis zum Kunden (siehe unten). Die Kits für Arduino und Pico2 bieten eine Vielzahl an Lektionen, die speziell darauf ausgelegt sind, Anfängern die Grundlagen der Elektronik und Programmierung näherzubringen. Im Folgenden bespricht der Artikel jeweils eine Reihe detaillierter Beispiellektionen aus den Kits, um die Lerninhalte und die praktischen Anwendungen zu veranschaulichen.

All-in-One Starter Kit für Arduino

Das Arduino-Kit enthält 21 Lektionen, die von einfachen Grundlagen bis zu komplexeren Projekten reichen. Dazu stellt es fünfzehn integrierte Module zur Verfügung, die man in eigenen Projekten verwenden kann. Zwei Beispiellektionen:

Lektion 1: LED-Blinken

Diese Lektion ist eine der ersten und einfachsten Übungen, die mit der Arduino-Programmierung vertraut macht. Ziel ist es, eine LED zum Blinken zu bringen.

Lernziele:

• Einführung in die Arduino-IDE.
• Verständnis der grundlegenden Funktionen setup() und loop().
• Steuerung eines digitalen Ausgangs.

Ablauf:

Das Blinken einer LED gehört zu den fundamentalen "Hello World"-Pendants bei Mikrocontrollern.

1. Man verbindet die integrierte LED (Pin 13) mit dem Arduino-Board und
2. schreibt ein einfaches Programm, um die LED ein- und auszuschalten.

Codebeispiel in C:

int ledPin = 13; // LED an Pin 13

void setup() {
  pinMode(ledPin, OUTPUT); // Pin als Ausgang definieren
}

void loop() {
  digitalWrite(ledPin, HIGH); // LED einschalten
  delay(1000); // 1 Sekunde warten
  digitalWrite(ledPin, LOW); // LED ausschalten
  delay(1000); // 1 Sekunde warten
}

Ergebnisse:

Die LED blinkt im Sekundentakt, was ein erstes Erfolgserlebnis vermittelt und zum Weitermachen motiviert.

Lektion 2: Temperaturmessung

In dieser Lektion lernen die Nutzer, wie sie den integrierten Temperatursensor verwenden, um die Umgebungstemperatur zu messen und auf dem seriellen Monitor anzuzeigen.

Lernziele:

• Einführung in analoge Eingänge.
• Nutzung des seriellen Monitors zur Ausgabe von Daten.
• Verständnis der Umwandlung von analogen Werten in Temperaturwerte.

Ablauf:

1. Man verbindet den Temperatursensor mit dem Arduino-Board und
2. schreibt anschließend ein Programm, das die analogen Werte des Sensors liest und in Grad Celsius umrechnet.

Codebeispiel in C:

int sensorPin = A0; // Temperatursensor an Pin A0
float voltage, temperature;

void setup() {
  Serial.begin(9600); // Serielle Kommunikation starten
}

void loop() {
  int sensorValue = analogRead(sensorPin); // Sensorwert lesen
  voltage = sensorValue * (5.0 / 1023.0); // Spannung berechnen
  temperature = (voltage - 0.5) * 100; // Temperatur berechnen
  Serial.print("Temperatur: ");
  Serial.print(temperature);
  Serial.println(" °C");
  delay(1000); // 1 Sekunde warten
}

Ergebnisse:

Die gemessene Temperatur erscheint auf dem seriellen Monitor. Diese Lektion zeigt, wie sich Sensoren in realen Anwendungen nutzen lassen.

All-in-One Starter Kit für Pico2

Das Pico-2-Kit bietet ebenfalls 21 Lektionen, die sich auf die Nutzung des RP2350-Mikrocontrollers und die Integration des Touchscreens konzentrieren. Es enthält 17 fest integrierte Bausteine zur Verwendung in eigenen Projekten.

Hier sind drei Beispiele:

Lektion 1: RGB-LED-Steuerung

Diese Lektion zeigt, wie die RGB-LEDs des Kits gesteuert werden können, um verschiedene Farben darzustellen.

Lernziele:

• Einführung in PWM (Pulsweitenmodulation).
• Steuerung von RGB-LEDs.
• Verständnis der Farbmischung durch unterschiedliche Intensitäten.

Ablauf:

1. Man programmiert die RGB-LEDs, um verschiedene Farben darzustellen und
2. experimentier mit unterschiedlichen PWM-Werten, um eigene Farbkombinationen zu erstellen.

Codebeispiel in Python:

from machine import Pin, PWM
import time

red = PWM(Pin(15))
green = PWM(Pin(14))
blue = PWM(Pin(13))

def set_color(r, g, b):
    red.duty_u16(r)
    green.duty_u16(g)
    blue.duty_u16(b)

while True:
    set_color(65535, 0, 0)  # Rot
    time.sleep(1)
    set_color(0, 65535, 0)  # Grün
    time.sleep(1)
    set_color(0, 0, 65535)  # Blau
    time.sleep(1)

Ergebnisse:

Die RGB-LEDs leuchten in verschiedenen Farben, was ein Verständnis für Farbmischung und PWM vermittelt.

Lektion 2: Touchscreen-Benutzeroberfläche

Diese Lektion zeigt die Nutzung des Touchscreens, um eine einfache Bedienoberfläche zu erstellen.

Lernziele:

• Einführung in die Touchscreen-Programmierung.
• Erstellung interaktiver Benutzeroberflächen.
• Verständnis der Koordinatensysteme auf dem Bildschirm.

Ablauf:

1. Die Lernenden programmieren den Touchscreen, um Berührungen zu erkennen.
2. Sie erstellen eine einfache Bedienoberfläche mit Schaltflächen, die verschiedene Aktionen auslösen.

Codebeispiel in Python:

from machine import Pin, PWM
import time

red = PWM(Pin(15))
green = PWM(Pin(14))
blue = PWM(Pin(13))

def set_color(r, g, b):
    red.duty_u16(r)
    green.duty_u16(g)
    blue.duty_u16(b)

while True:
    set_color(65535, 0, 0)  # Rot
    time.sleep(1)
    set_color(0, 65535, 0)  # Grün
    time.sleep(1)
    set_color(0, 0, 65535)  # Blau
    time.sleep(1)

Ergebnisse:

Man kann den Touchscreen einsetzen, um interaktive Anwendungen zu erstellen, wie ein einfaches Menü oder ein Spiel.

Lektion 3: Ein komplexeres Programmbeispiel: Intelligentes Umweltüberwachungs- und Sicherheitssystem:

Das Beispiel benutzt eine ganze Vielzahl von Lektionen:

• Echtzeit-Temperatur-/Luftfeuchtigkeitsmessung
• Umgebungslicht-Erkennung
• Bewegungsbasierte Sicherheitsalarme
• LCD-Statusanzeige
• LED-Matrix-Visualisierung
• Summer-Benachrichtigungen
• Benutzerinteraktion via Tasten
• RGB-LED-Statusanzeige

Die dafür verwendeten Komponenten sind:

• DHT11 Temperatur-/Luftfeuchtigkeitssensor
• Fotowiderstand (Lichtsensor)
• PIR-Bewegungssensor
• 16x2 LCD-Display
• 8x8 LED-Matrix
• Aktiver Summer
• Taster
• RGB-LED
• RGB-Modultaster

Für das Experiment sind zahlreiche Hardware-Verbindungen notwendig:

Komponente Pico <-> GPIO-Pin

• DHT11 ↔ GP15
• Fotowiderstand ↔ ADC0 (GP26)
• PIR-Sensor ↔ GP16
• LCD I2C ↔ SDA GP0, SCL GP1
• LED-Matrix ↔ DIN GP3, CS GP5, CLK GP2
• Summer ↔ GP14
• Taster 1 ↔ GP17
• Taster 2 ↔ GP18
• RGB-LED (R,G,B) ↔ GP10, GP11, GP12

Code-Implementierung in Python:

import machine
import utime
from dht import DHT11
from lcd_api import LcdApi
from pico_i2c_lcd import I2cLcd
import max7219

# Komponenten initialisieren
# DHT11 Sensor
dht_pin = machine.Pin(15, machine.Pin.IN, machine.Pin.PULL_UP)
dht = DHT11(dht_pin)

# Lichtsensor
licht_sensor = machine.ADC(26)

# PIR-Sensor
pir = machine.Pin(16, machine.Pin.IN)

# LCD-Display
i2c = machine.I2C(0, sda=machine.Pin(0), scl=machine.Pin(1), freq=400000)
lcd = I2cLcd(i2c, 0x27, 2, 16)

# LED-Matrix
spi = machine.SPI(0, baudrate=10000000, polarity=1, phase=0, sck=machine.Pin(2), mosi=machine.Pin(3))
cs = machine.Pin(5, machine.Pin.OUT)
matrix = max7219.Matrix8x8(spi, cs, 4)

# Summer
summer = machine.PWM(machine.Pin(14))

# Taster
taster1 = machine.Pin(17, machine.Pin.IN, machine.Pin.PULL_UP)
taster2 = machine.Pin(18, machine.Pin.IN, machine.Pin.PULL_UP)

# RGB-LED
rot = machine.PWM(machine.Pin(10))
gruen = machine.PWM(machine.Pin(11))
blau = machine.PWM(machine.Pin(12))

# Systemvariablen
anzeige_modus = 0  # 0: Temperatur/Luftfeuchtigkeit, 1: Licht, 2: Status
alarm_aktiv = False
temp_grenzwert = 30
licht_grenzwert = 20000

def setze_rgb(r, g, b):
    rot.duty_u16(r * 257)
    gruen.duty_u16(g * 257)
    blau.duty_u16(b * 257)

def zeige_alarm(nachricht):
    lcd.clear()
    lcd.move_to(0,0)
    lcd.putstr("ALARM!")
    lcd.move_to(0,1)
    lcd.putstr(nachricht)

def aktiviere_alarm(frequenz=1000, dauer=0.5):
    summer.freq(frequenz)
    summer.duty_u16(32768)
    utime.sleep(dauer)
    summer.duty_u16(0)

def zeige_matrix_ikon(symbol):
    matrix.fill(0)
    for y, zeile in enumerate(symbol):
        for x, wert in enumerate(zeile):
            matrix.pixel(x, y, wert)
    matrix.show()

# Icons für LED-Matrix
temp_icon = [
    [0,1,1,1,1,1,0,0],
    [1,1,1,1,1,1,1,0],
    [1,1,1,0,1,1,1,1],
    [1,1,0,0,0,1,1,1],
    [1,1,0,0,0,1,1,1],
    [1,1,1,0,1,1,1,1],
    [0,1,1,1,1,1,1,0],
    [0,0,1,1,1,1,0,0]
]

bewegungs_icon = [
    [0,0,0,1,1,0,0,0],
    [0,0,1,1,1,1,0,0],
    [0,1,1,1,1,1,1,0],
    [1,1,0,1,1,0,1,1],
    [1,1,0,1,1,0,1,1],
    [0,1,1,1,1,1,1,0],
    [0,0,1,1,1,1,0,0],
    [0,0,0,1,1,0,0,0]
]

while True:
    # Sensoren auslesen
    dht.measure()
    temp = dht.temperature()
    luftfeuchtigkeit = dht.humidity()
    licht = licht_sensor.read_u16()
    bewegung = pir.value()

    # Anzeige aktualisieren
    if anzeige_modus == 0:
        lcd.clear()
        lcd.putstr(f"Temp: {temp}°C")
        lcd.move_to(0,1)
        lcd.putstr(f"Feuchtigkeit: {luftfeuchtigkeit}%")
        zeige_matrix_ikon(temp_icon)
    elif anzeige_modus == 1:
        lcd.clear()
        lcd.putstr(f"Licht: {licht}")
        zeige_matrix_ikon([[1 if licht > licht_grenzwert else 0 for _ in range(8)] for _ in range(8)])
    else:
        lcd.clear()
        status = "Sicher" if bewegung == 0 else "BEWEGUNG!"
        lcd.putstr(f"Status: {status}")
        if bewegung:
            zeige_matrix_ikon(bewegungs_icon)
        else:
            matrix.fill(0)
            matrix.show()

    # Umgebungsbedingungen prüfen
    if temp > temp_grenzwert:
        setze_rgb(255, 0, 0)  # Rot
        zeige_alarm("Hohe Temperatur!")
        aktiviere_alarm(2000, 0.2)
    elif bewegung and licht < licht_grenzwert:
        setze_rgb(0, 0, 255)  # Blau
        aktiviere_alarm(1500, 0.1)
    else:
        setze_rgb(0, 255, 0)  # Grün

    # Tastereingabe verarbeiten
    if not taster1.value():
        anzeige_modus = (anzeige_modus + 1) % 3
        utime.sleep(0.3)
    if not taster2.value():
        alarm_aktiv = not alarm_aktiv
        utime.sleep(0.3)

    utime.sleep(0.5)

Systembetrieb:

In diesem komplexen Beispiel sind verschiedene Arten von Themen integriert.

Als Erstes kommt die Umweltüberwachung:

• Echtzeitdaten auf dem LCD
• Automatische Warnungen bei Grenzwertüberschreitungen

Danach etliche Sicherheitsfunktionen:

• Bewegungserkennung bei Dunkelheit
• Visuelle Warnungen auf der LED-Matrix
• Akustische Signale via Summer
• Farbcodierung der RGB-LED (Grün=Normal, Rot=Überhitzung, Blau=Bewegung)

Und zu guter Letzt die Benutzersteuerung:

• Taster1: Wechselt Anzeigemodi
• Taster2: Aktiviert/deaktiviert Alarm
• LED-Matrix zeigt passende Symbole

Für das Beispiel gibt es diverse Erweiterungsmöglichkeiten:

1. Datenaufzeichnung auf SD-Karte
2. IoT-Anbindung für Fernüberwachung
3. Konfigurierbare Grenzwerte via Tastenkombinationen
4. Zeitgesteuerter Sicherheitsmodus
5. Batterieüberwachung

Preise und Installation

Wer direkt im Elecrow-Shop bestellt, bezahlt 27,70 Dollar für das Arduino-Kit und 37,99 Dollar für das Pico-2-Kit. Die Nutzung der tragbaren Kits erfordert den Anschluss der Hardware an einen Windows-, Linux- oder Mac-Computer. Sie enthalten dafür jeweils einen USB-C-Eingang. Ein entsprechendes USB-Kabel muss man bereitstellen. Im Host-Computer bedarf es bei beiden Kits einer Installation der Arduino IDE Version 1.8.19. Ob das Zusammenspiel auch mit einer aktuellen Arduino IDE Version 2.x funktioniert, hat der Autor nicht überprüft.

Die englischsprachigen Benutzerhandbücher lassen sich über entsprechende Links für die Arduino-Version, siehe hier, und für die Pico2-Version, siehe hier, herunterladen.

Code, Schematik und Bibliotheken für das Arduino-Kit befinden sich auf Code/Schematic/lib.

Code, Schematik und Bibliotheken für das Pico-2-Kit befinden sich auf Code/Schematic/lib.

Fazit

Die Lektionen in den Elecrow All-in-One Starter Kits für Arduino und Pico 2 sind praxisorientiert und bieten eine hervorragende Möglichkeit, Elektronik und Programmierung zu erlernen. Während das Arduino-Kit sich auf grundlegende Sensor- und Aktuatorprojekte konzentriert, ermöglicht das Pico-2-Kit durch den Touchscreen und die RGB-LEDs kreative und interaktive Anwendungen. Beide Kits sind ideal für Anfänger und bieten eine strukturierte Lernumgebung, die Spaß macht und motiviert. Über den Preis lässt sich nicht meckern, aber die jeweiligen Benutzerhandbücher mit den Beispielprojekten könnten bezüglich Format und Umfang Verschönerungen und Erweiterungen erfahren. Die Informationen und Inhalte zu den Lektionen beziehungsweise Beispielprojekten sind sehr knapp gehalten.

Hinweis: Der Autor bekam die beiden Kits vom Hersteller ohne Auflagen zum Test bereitgestellt.

(rme)