Smart 3D-Sensor: Sprachgesteuerte Lampensteuerung für Amazon Echo mit Walabot

Komponenten und Materialien

Amazon Echo (Alexa)	×	1
Walabot Creator (3D-RF-Sensor)	×	1
Arduino Leonardo (auf LattePanda onboard)	×	1
Relais (generic)	×	2
LattePanda 2G/32GB (Windows 10, Intel Atom x8300)	×	1
LattePanda 7″ 1024×600 IPS Display	×	1
Lampe (2× zum Demo)	×	2

Projektbeschreibung

Motivation

Bei vielen Smart-Home-Geräten muss man sich Gerätenamen merken („Alexa, schalte Wohnzimmerlampe ein“). Vergisst man den Namen, schaltet Alexa das falsche Gerät oder gar nichts. Die Idee: „Alexa, schalte diese Lampe ein“ – und Alexa erkennt über die Position des Nutzers, welche Lampe gemeint ist.

Statt Kameras (Datenschutz!) kommt der Walabot zum Einsatz: ein programmierbarer 3D-RF-Sensor, der Bewegungen und Positionen hinter Wänden/Objekten erkennt, ohne optische Bilder zu liefern.

Hardware-Architektur

• LattePanda: x86-SBC (Windows 10) mit integriertem ATMega32u4 (Arduino Leonardo) – verbindet Walabot (USB) und Relais (GPIO).
• Walabot: Erfasst 3D-Position (x,y,z) von Personen/Objekten per RF.
• Relais: Schalten die Lampen (Netzspannung).
• Amazon Echo: Spracherkennung, Smart-Home-Skill (simuliert Philips Hue).

Software: Node-RED

Node-RED (auf Node.js) orchestriert den Datenfluss:

• node-red-contrib-alexa-local: Emuliert Hue-Bridge für Alexa – Geräte werden per Sprache gefunden.
• node-red-node-arduino: Kommuniziert mit dem onboard Leonardo (StandardFirmata).
• Python-Skript liest Walabot-Daten, streamt JSON per TCP (Port 1890) an Node-RED.

Funktionsweise (3 Schritte im Node-RED-Flow)

1. Handle Walabot Service: Python-Skript scannt mit Walabot (MTI-Filter für Bewegung), sendet JSON {"targets":[{"x":...,"y":...,"z":...}]} an TCP-Port 1890.
2. Get & Save Walabot Object Data: Node-RED empfängt TCP-Daten, parst JSON, speichert letzte Position (x,y,z) in Global Context.
3. Handle Alexa Commands: Bei Sprachbefehl („turn on lamp“) prüft Flow die letzte bekannte Position → entscheidet, welches Relais (welche Lampe) geschaltet wird.

Installation & Einrichtung

1. Walabot SDK installieren: walabot.com/getting-started.
2. Arduino auf LattePanda einrichten: Developer Mode in Windows aktivieren. Arduino IDE: „StandardFirmata“ auf „Arduino Leonardo“ (COM-Port des onboard ATMega32u4) hochladen.
3. Relais an LattePanda GPIO anschließen (siehe Foto).
4. Node.js & Node-RED installieren: npm install -g node-red, dann node-red starten. UI unter https://localhost:8080/red/.
5. Python 3 installieren, Projekt-Repo klonen: GitHub.
6. Im Repo: npm install → npm start (startet Python-Walabot-Service & Node-RED).
7. In Alexa-App: Smart Home Skills aktivieren, „Geräte suchen“ – die Lampen erscheinen.

Wichtige Code-Schnipsel

Walabot Python Service (TCP Server auf Port 1890)

from __future__ import print_function
from sys import platform
from os import system
from imp import load_source
WalabotAPI = load_source('WalabotAPI', 'C:\\Program Files\\Walabot\\WalabotSDK\\python\\WalabotAPI.py')
import socket, sys

if __name__ == '__main__':
    WalabotAPI.Init()
    WalabotAPI.SetSettingsFolder()
    WalabotAPI.ConnectAny()
    WalabotAPI.SetProfile(WalabotAPI.PROF_SENSOR)
    WalabotAPI.SetThreshold(35)
    WalabotAPI.SetArenaR(50, 400, 4)
    WalabotAPI.SetArenaPhi(-45, 45, 2)
    WalabotAPI.SetArenaTheta(-20, 20, 10)
    WalabotAPI.SetDynamicImageFilter(WalabotAPI.FILTER_TYPE_MTI)
    WalabotAPI.Start()
    system('cls' if platform == 'win32' else 'clear')
    numOfTargetsToDisplay = 1
    if len(sys.argv) == 2:
        TCP_IP = '127.0.0.1'
        TCP_PORT = int(sys.argv[1])
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.bind((TCP_IP, TCP_PORT))
        s.listen(1)
        conn, addr = s.accept()
        while True:
            WalabotAPI.Trigger()
            targets = WalabotAPI.GetSensorTargets()
            finds = '{"targets": ['
            index = 0
            for i, t in enumerate(targets):
                if i < numOfTargetsToDisplay:
                    index += 1
                    print('Target {}\nx = {}\ny = {}\nz = {}'.format(i+1, t.xPosCm, t.yPosCm, t.zPosCm))
                    finds += '{"x": "%s", "y": "%s", "z": "%s"}' % (t.xPosCm, t.yPosCm, t.zPosCm)
            finds += ']}'
            conn.sendall(str.encode(finds))
        conn.close()
        WalabotAPI.Stop()
        WalabotAPI.Disconnect()

Node-RED Function Node: JSON parsen & Global Context speichern

raw = msg.payload.toString('UTF-8');
j = JSON.parse(raw);
var msg1 = { payload: raw };
var msg2 = { payload: j };
if (raw.length > 20) {
    X = msg2.payload.targets[0].x;
    Y = msg2.payload.targets[0].y;
    Z = msg2.payload.targets[0].z;
    global.set("X", X);
    global.set("Y", Y);
    global.set("Z", Z);
    var msg3 = { payload: X };
    var msg4 = { payload: Y };
    var msg5 = { payload: Z };
}
return [ msg1, msg2, msg3, msg4, msg5 ];

Node-RED Alexa Handling

Der alexa-local Node triggert bei Sprachbefehl. Ein Function-Node liest global.get("X") etc. und routet den Schaltbefehl an den passenden Arduino-Pin (Relais 1 oder 2).

Code-Repository

Gesamtes Projekt (Node-RED Flows, Python, Konfiguration): GitHub

Hinweis: Es wird kein Custom Alexa Skill erstellt, sondern die eingebaute Hue-Emulation von node-red-contrib-alexa-local genutzt. Das macht die Einrichtung extrem einfach.