Arduino Alvik

🤖 KI auf dem Alvik: Dein Roboter lernt!

🧠 Was ist Machine Learning überhaupt?

Machine Learning (auf Deutsch: "Maschinelles Lernen") ist ein Teilbereich der Künstlichen Intelligenz. Statt einem Computer jede einzelne Regel einzuprogrammieren, lernt er aus Beispielen!

🎯 Wie funktioniert unser Mini-KI-Roboter?

Dein Alvik-Roboter lernt in diesem Projekt wie eine KI! Er durchläuft die gleichen Phasen wie echte Machine-Learning-Systeme:

🔬 Das Geheimnis: Kalibrierte Farberkennung

Das Herzstück dieses Programms ist die Funktion detect_color_calibrated(). Sie arbeitet wie ein neuronales Netz bei Bilderkennung:

Technische Funktionen und Code-Struktur

Genutzte Alvik-Funktionen

Sensorik:

• get_color() und rgb2hsv() – Liest RGB-Farbwerte und konvertiert sie in HSV-Format für zuverlässige Farberkennung
• get_color_label() – Gibt Farbbezeichnungen zurück (wird durch eigene HSV-Erkennung ersetzt)
• set_illuminator(True) – Aktiviert die LED-Beleuchtung für konstante Lichtverhältnisse

Bewegung:

• move(distance, 'cm', blocking=True) – Fährt geradeaus (Rot/Gelb)
• rotate(angle, 'deg', blocking=True) – Dreht auf der Stelle (Grün/Blau)

Feedback:

• left_led.set_color(r, g, b) / right_led.set_color(r, g, b) – Visuelles Feedback während Erkennung
• get_touch_ok() – Wartet auf Nutzerbestätigung zum Start

Display (I2C):

• ssd1306.SSD1306_I2C() – Initialisiert das OLED-Display über I2C (Pins 11/12)
• display.text(), display.fill(), display.show() – Textausgabe und Fortschrittsbalken

Code-Struktur (4 Phasen)

1. Initialisierung: Display- und Roboter-Setup, Beleuchtung einschalten, Startbildschirm
2. Lernphase: Schleife erfasst 5 Farben mit detect_color_calibrated(), speichert sie in pattern_memory[], zeigt Fortschritt am Display
3. Bestätigung: Blink-Animation bis OK-Taste gedrückt wird, zeigt gelerntes Muster als Symbolsequenz
4. Ausführung: For-Schleife iteriert durch pattern_memory[] und führt entsprechende Bewegungsbefehle aus, Display zeigt Live-Fortschritt

Kern-Algorithmus: Die Funktion detect_color_calibrated() nimmt 5 HSV-Messungen, bildet Durchschnittswerte und vergleicht diese mit kalibrierten Bereichen (H: Farbton 0-360°, S: Sättigung 0-1, V: Helligkeit 0-1) für präzise Farberkennung.

Alvik-Roboter bei der Mustererkennung

Python Code

from machine import Pin, I2C
import ssd1306
from arduino_alvik import ArduinoAlvik
from time import sleep_ms

# ==================== DISPLAY KONFIGURATION ====================
i2c = I2C(sda=Pin(11), scl=Pin(12))
display = ssd1306.SSD1306_I2C(128, 64, i2c)

def display_text(lines, clear=True):
    if clear:
        display.fill(0)
    y = 0
    for line in lines:
        display.text(line, 0, y, 1)
        y += 10
    display.show()

def display_progress_bar(current, total, label=""):
    display.fill(0)
    display.text(label, 0, 0, 1)
    bar_width = int((current / total) * 120)
    display.rect(4, 20, 120, 15, 1)
    display.fill_rect(5, 21, bar_width, 13, 1)
    percent = f"{current}/{total}"
    x = (128 - len(percent) * 8) // 2
    display.text(percent, x, 45, 1)
    display.show()

# ==================== PERFEKT KALIBRIERTE FARBERKENNUNG ====================
def detect_color_calibrated(alvik):
    """
    Exakte Farberkennung mit ALLEN gemessenen HSV-Werten:
    
    ROT:    h=5.11,   s=0.68, v=0.59 (hohe Sättigung, mittlere Helligkeit)
    GELB:   h=40.04,  s=0.59, v=0.92 (SEHR hell!)
    GRÜN:   h=96.76,  s=0.37, v=0.56 (niedrige Sättigung, niedrige Helligkeit)
    BLAU:   h=198.13, s=0.36, v=0.80 (niedrige Sättigung, hohe Helligkeit)
    """
    
    # 5 Messungen für maximale Stabilität
    h_values = []
    s_values = []
    v_values = []
    
    for _ in range(5):
        r, g, b = alvik.get_color()
        h, s, v = alvik.rgb2hsv(r, g, b)
        h_values.append(h)
        s_values.append(s)
        v_values.append(v)
        sleep_ms(30)
    
    # Durchschnittswerte berechnen
    h = sum(h_values) / len(h_values)
    s = sum(s_values) / len(s_values)
    v = sum(v_values) / len(v_values)
    
    # Optional: Debug-Ausgabe (auskommentieren zum Testen)
    # print(f"H:{h:.1f} S:{s:.2f} V:{v:.2f}")
    
    # Zu dunkel = keine gültige Farbe
    if v < 0.10:
        return None
    
    # Zu geringe Sättigung UND zu dunkel = Schwarz/Grau
    if s < 0.15 and v < 0.40:
        return None
    
    # ===== PRÄZISE FARBERKENNUNG MIT ALLEN PARAMETERN =====
    
    # ROT: h=5.11, s=0.68, v=0.59
    # Einzige Farbe mit HOHER Sättigung + mittlerer Helligkeit
    if (h < 25 or h > 340) and 0.50 < s < 0.85 and 0.40 < v < 0.75:
        return 'RED'
    
    # GELB: h=40.04, s=0.59, v=0.92
    # SEHR HELL (v=0.92) unterscheidet es von allen anderen!
    elif 28 < h < 52 and 0.40 < s < 0.75 and 0.80 < v:
        return 'YELLOW'
    
    # GRÜN: h=96.76, s=0.37, v=0.56
    # Niedrige Sättigung + niedrigste Helligkeit
    elif 72 < h < 122 and 0.20 < s < 0.55 and 0.40 < v < 0.70:
        return 'GREEN'
    
    # BLAU: h=198.13, s=0.36, v=0.80
    # Niedrige Sättigung aber HOHE Helligkeit (unterscheidet von Grün!)
    elif 173 < h < 223 and 0.20 < s < 0.50 and 0.65 < v < 0.95:
        return 'BLUE'
    
    return None

# ==================== FARB-KONFIGURATION ====================
COLOR_ACTIONS = {
    'RED': {'name': 'Vorwaerts', 'symbol': '^', 'led': (1, 0, 0)},
    'YELLOW': {'name': 'Rueckw.', 'symbol': 'v', 'led': (1, 1, 0)},
    'GREEN': {'name': 'Rechts', 'symbol': '>', 'led': (0, 1, 0)},
    'BLUE': {'name': 'Links', 'symbol': '<', 'led': (0, 0, 1)}
}

MAX_PATTERN_LENGTH = 5
MOVE_DISTANCE = 15
ROTATION_ANGLE = 90

# ==================== INITIALISIERUNG ====================
alvik = ArduinoAlvik()
alvik.begin()
alvik.set_illuminator(True)
sleep_ms(500)

# Startbildschirm
display_text([
    "==================",
    " ALVIK KI-DEMO",
    "==================",
    "",
    "Perfekt",
    "kalibriert!"
])
sleep_ms(2000)

# LEDs Begrüßung
for _ in range(3):
    alvik.left_led.set_color(1, 1, 1)
    alvik.right_led.set_color(1, 1, 1)
    sleep_ms(300)
    alvik.left_led.set_color(0, 0, 0)
    alvik.right_led.set_color(0, 0, 0)
    sleep_ms(300)

# ==================== PHASE 1: LERNEN ====================
display_text([
    "LERNPHASE",
    "----------",
    "Zeige Farben:",
    "ROT   = ^",
    "GELB  = v",
    "GRUEN = >",
    "BLAU  = <"
])
sleep_ms(3000)

pattern_memory = []
last_color = None
no_color_counter = 0

while len(pattern_memory) < MAX_PATTERN_LENGTH:
    display_progress_bar(len(pattern_memory), MAX_PATTERN_LENGTH, "Lerne Farben...")
    
    # Nutze perfekt kalibrierte Farberkennung
    current_color = detect_color_calibrated(alvik)
    
    if current_color and current_color != last_color:
        pattern_memory.append(current_color)
        action = COLOR_ACTIONS[current_color]
        
        # LED-Feedback
        alvik.left_led.set_color(*action['led'])
        alvik.right_led.set_color(*action['led'])
        
        # Display-Anzeige
        display.fill(0)
        display.text(f"Farbe {len(pattern_memory)}/{MAX_PATTERN_LENGTH}", 10, 0, 1)
        display.text(current_color, 20, 20, 1)
        display.text(action['symbol'] * 5, 20, 35, 1)
        display.text(action['name'], 15, 50, 1)
        display.show()
        
        last_color = current_color
        no_color_counter = 0
        sleep_ms(1500)
        
        alvik.left_led.set_color(0, 0, 0)
        alvik.right_led.set_color(0, 0, 0)
    
    elif current_color is None:
        no_color_counter += 1
        if no_color_counter > 15:  # 1.5 Sekunden ohne Farbe
            last_color = None
            no_color_counter = 0
    
    sleep_ms(100)

# Gelerntes Muster anzeigen
display.fill(0)
display.text("Gelernt:", 0, 0, 1)
pattern_str = "".join([COLOR_ACTIONS[c]['symbol'] for c in pattern_memory])
x = (128 - len(pattern_str) * 8) // 2
display.text(pattern_str, x, 28, 1)
display.show()
sleep_ms(2000)

# ==================== PHASE 2: BESTÄTIGUNG ====================
blink_state = True
while not alvik.get_touch_ok():
    display.fill(0)
    if blink_state:
        display.text("Bereit!", 35, 15, 1)
        display.text("Druecke OK", 20, 35, 1)
    display.show()
    blink_state = not blink_state
    sleep_ms(500)

# ==================== PHASE 3: AUSFÜHREN ====================
display.fill(0)
display.text("START!", 40, 28, 1)
display.show()
sleep_ms(1000)

for i, color in enumerate(pattern_memory):
    action = COLOR_ACTIONS[color]
    
    display.fill(0)
    display.text(f"Schritt {i+1}/{len(pattern_memory)}", 10, 0, 1)
    done_pattern = "".join([COLOR_ACTIONS[c]['symbol'] for c in pattern_memory[:i+1]])
    display.text(done_pattern, 5, 20, 1)
    display.text(action['symbol'] * 3, 40, 35, 1)
    display.text(action['name'], 20, 50, 1)
    display.show()
    
    alvik.left_led.set_color(*action['led'])
    alvik.right_led.set_color(*action['led'])
    
    if color == 'RED':
        alvik.move(MOVE_DISTANCE, 'cm', blocking=True)
    elif color == 'YELLOW':
        alvik.move(-MOVE_DISTANCE, 'cm', blocking=True)
    elif color == 'GREEN':
        alvik.rotate(-ROTATION_ANGLE, 'deg', blocking=True)
    elif color == 'BLUE':
        alvik.rotate(ROTATION_ANGLE, 'deg', blocking=True)
    
    sleep_ms(300)
    alvik.left_led.set_color(0, 0, 0)
    alvik.right_led.set_color(0, 0, 0)

# ==================== ABSCHLUSS ====================
display_text(["", "  FERTIG!", "", "  Muster", "  ausgefuehrt!", "", "  :-)"])

for _ in range(5):
    alvik.left_led.set_color(0, 1, 0)
    alvik.right_led.set_color(0, 1, 0)
    sleep_ms(200)
    alvik.left_led.set_color(0, 0, 0)
    alvik.right_led.set_color(0, 0, 0)
    sleep_ms(200)

alvik.brake()
alvik.set_illuminator(False)
sleep_ms(5000)
display.fill(0)
display.show()

⚙️ Kalibrierung: Jeden Alvik individuell anpassen

Das liegt daran, dass jeder Farbsensor kleine Fertigungsunterschiede hat. Farben werden dadurch mit leicht anderen HSV-Werten erkannt. Die Lösung: Du misst die Referenzwerte für deinen Alvik neu aus und passt die Bereiche in der Funktion detect_color_calibrated() entsprechend an.

So gehst du vor

1. Lade das Kalibrierungs-Programm (unten) auf deinen Alvik
2. Halte nacheinander jede Farbkarte (Rot, Gelb, Grün, Blau) unter den Sensor
3. Notiere dir die angezeigten H-, S- und V-Werte für jede Farbe
4. Passe die Bereiche in detect_color_calibrated() an deine gemessenen Werte an

Kalibrierungs-Programm

Dieses Programm misst kontinuierlich die HSV-Werte und gibt sie in der Konsole aus. Halte einfach eine Farbkarte unter den Sensor und lies die Werte ab:

from arduino_alvik import ArduinoAlvik
from time import sleep_ms

alvik = ArduinoAlvik()
alvik.begin()
alvik.set_illuminator(True)
sleep_ms(500)

print("Halte jetzt eine Farbkarte unter den Sensor...")
print("=" * 50)

while True:
    h_values, s_values, v_values = [], [], []

    for _ in range(5):
        r, g, b = alvik.get_color()
        h, s, v = alvik.rgb2hsv(r, g, b)
        h_values.append(h)
        s_values.append(s)
        v_values.append(v)
        sleep_ms(30)

    h = sum(h_values) / len(h_values)
    s = sum(s_values) / len(s_values)
    v = sum(v_values) / len(v_values)

    print(f"H={h:6.1f}  S={s:.2f}  V={v:.2f}")
    sleep_ms(500)

Beispiel: Werte anpassen

Angenommen, dein Alvik misst für Rot den Wert H=12.3, S=0.71, V=0.55 statt des kalibrierten H=5.1. Dann passt du den Bereich im Hauptprogramm so an:

# Vorher (Original-Kalibrierung):
if (h < 25 or h > 340) and 0.50 < s < 0.85 and 0.40 < v < 0.75:
    return 'RED'

# Nachher (an deinen Alvik angepasst):
# Dein gemessener Wert: H=12.3 → Bereich großzügig um diesen Wert legen
if (h < 30 or h > 340) and 0.50 < s < 0.85 and 0.35 < v < 0.75:
    return 'RED'

🚀 Deine eigenen KI-Projekte mit dem Alvik

Jetzt wo du verstehst, wie Machine Learning funktioniert, kannst du eigene coole KI-Projekte umsetzen! Hier sind inspirierende Ideen: