Proxi AI — Spielzeug-Roboter mit natürlicher Sprache steuern
Firmware, Bluetooth-Brücke und Agent-Skill für den KOSMOS-Proxi: einmal flashen, danach hört der Roboter über Bluetooth LE auf Textbefehle. Was die Befehle schickt, ist ihm egal — ein Skript, ein curl, oder ein KI-Agent, der aus "mach mal was Lustiges" eine Choreografie baut. firmware/ MakeCode-Projekt (TypeScript) und fertige .hex für V1 und V2 bridge/ BLE-Brücke und HTTP-API, einzige Abhängigkeit ist bleak agent/ Skill-Definition: Alltagssprache -> Befehle tools/ Quelltext aus .hex extrahieren, Musik-Tabellen prüfen docs/ Protokoll, Einrichtung, Hardware, Lizenzen Zwei Dinge, die sonst nirgends stehen und in docs/HARDWARE.md dokumentiert sind: die Pin-Belegung des Roboters ist nicht öffentlich, sie wurde aus den mitgelieferten .hex-Dateien rekonstruiert (tools/hex_source.py holt sie heraus). Und der Ton braucht zwingend eine ganzzahlige Frequenz sowie Pin P0 — sonst kracht der Lautsprecher, der Aufruf hängt und die Bluetooth- Verbindung stirbt. Am echten Roboter durchgetestet: Verbindung, Sensoren, Display, 41 Sekunden Musik am Stück, alle Bewegungsrichtungen, Musik und Fahren gleichzeitig, Tanzfiguren, Not-Stopp mitten in der Bewegung, Autostart nach Neustart. MIT-Lizenz. Die Hardware-Extension stammt von kaku111 (TobbieII) und die Notendaten aus pxt-microbit, beide ebenfalls MIT — siehe THIRD-PARTY-NOTICES.
This commit is contained in:
@@ -0,0 +1,2 @@
|
|||||||
|
__pycache__/
|
||||||
|
*.pyc
|
||||||
@@ -0,0 +1,27 @@
|
|||||||
|
MIT License
|
||||||
|
|
||||||
|
Copyright (c) 2026 Christian Gärtner
|
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
of this software and associated documentation files (the "Software"), to deal
|
||||||
|
in the Software without restriction, including without limitation the rights
|
||||||
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||||
|
copies of the Software, and to permit persons to whom the Software is
|
||||||
|
furnished to do so, subject to the following conditions:
|
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included in all
|
||||||
|
copies or substantial portions of the Software.
|
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
SOFTWARE.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
Dieses Projekt enthält fremden Code, der ebenfalls unter der MIT-Lizenz steht.
|
||||||
|
Die zugehörigen Copyright-Vermerke stehen in THIRD-PARTY-NOTICES; Herkunft und
|
||||||
|
Umfang sind in docs/LICENSES.md beschrieben.
|
||||||
@@ -0,0 +1,144 @@
|
|||||||
|
<div align="center">
|
||||||
|
|
||||||
|
<img src="docs/img/proxi.png" width="360" alt="Der Proxi-Roboter">
|
||||||
|
|
||||||
|
# Proxi AI
|
||||||
|
|
||||||
|
**Einen Spielzeug-Roboter mit natürlicher Sprache steuern.**
|
||||||
|
Ein Kind sagt „lass ihn tanzen" — eine KI macht daraus Befehle, der Roboter tanzt.
|
||||||
|
|
||||||
|
[](LICENSE)
|
||||||
|
[](#)
|
||||||
|
[](#)
|
||||||
|
|
||||||
|
</div>
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
Der [KOSMOS Proxi](https://kosmos.de/proxi) ist ein Bausatz-Roboter mit einem
|
||||||
|
BBC micro:bit als Kopf. Ab Werk programmiert man ihn mit Blöcken im Browser und
|
||||||
|
spielt das Ergebnis per USB auf.
|
||||||
|
|
||||||
|
Dieses Projekt ersetzt das durch eine Firmware, die **einmal** geflasht wird und
|
||||||
|
danach über Bluetooth auf Textbefehle hört. Was die Befehle schickt, ist ihr
|
||||||
|
egal — ein Skript, ein `curl`, oder eben ein KI-Agent, der aus „mach mal was
|
||||||
|
Lustiges" eine Choreografie baut.
|
||||||
|
|
||||||
|
```
|
||||||
|
„Proxi, freu dich!"
|
||||||
|
│
|
||||||
|
▼
|
||||||
|
KI-Agent ──HTTP──▶ Brücke (Python) ──Bluetooth LE──▶ Proxi
|
||||||
|
Raspberry Pi
|
||||||
|
```
|
||||||
|
|
||||||
|
## In drei Schritten
|
||||||
|
|
||||||
|
```bash
|
||||||
|
# 1. Firmware aufspielen: firmware/proxi-ai.hex auf das MICROBIT-Laufwerk kopieren
|
||||||
|
|
||||||
|
# 2. Brücke starten (irgendein Rechner mit Bluetooth)
|
||||||
|
pip install bleak
|
||||||
|
python3 bridge/proxi_bridge.py --serve 8080
|
||||||
|
|
||||||
|
# 3. Proxi etwas sagen lassen
|
||||||
|
curl -X POST localhost:8080/command \
|
||||||
|
-H 'Content-Type: application/json' \
|
||||||
|
-d '{"command":"DANCE:3"}'
|
||||||
|
```
|
||||||
|
|
||||||
|
> ⚠️ Die Brücke hat **keine Authentifizierung** — wer sie erreicht, fährt den
|
||||||
|
> Roboter. Im Heimnetz ist das gewollt und unproblematisch; gib den Port aber
|
||||||
|
> nicht nach außen frei. Details in [docs/SETUP.md](docs/SETUP.md).
|
||||||
|
|
||||||
|
Ausführlich: **[docs/SETUP.md](docs/SETUP.md)**
|
||||||
|
|
||||||
|
## Was Proxi kann
|
||||||
|
|
||||||
|
| | |
|
||||||
|
|---|---|
|
||||||
|
| 🚶 **Laufen** | `MOVE:FWD:1200` · `TURN:LEFT:700` — vor, zurück, drehen, Kurven |
|
||||||
|
| 💃 **Tanzen** | `DANCE:3` · `STAMP:2` · `SHAKE:2` — oder eigene Choreografien |
|
||||||
|
| 😀 **Gesichter** | `FACE:HAPPY` · `FACE:RAW:0:10:0:17:14` — 34 Symbole oder eigene Pixelbilder |
|
||||||
|
| 🎵 **Musik** | `MELODY:NYAN` · `TONE:880:200` — 20 Melodien oder Ton für Ton komponiert |
|
||||||
|
| 📝 **Text** | `TEXT:Hallo Ben` — läuft über das LED-Display |
|
||||||
|
| 👀 **Sehen** | `SENSOR:ALL` — Infrarot links und rechts, erkennt Hindernisse |
|
||||||
|
| 🛑 **Not-Stopp** | `STOP` — wirkt auch mitten in einer Bewegung. Taste A am Roboter immer |
|
||||||
|
|
||||||
|
Vollständig: **[docs/PROTOCOL.md](docs/PROTOCOL.md)**
|
||||||
|
|
||||||
|
## Warum das interessant ist
|
||||||
|
|
||||||
|
**Die Bausteine sind fest, das Gebaute nicht.** Eine KI kann keine neuen
|
||||||
|
Grundbefehle erfinden — aber aus `FACE:RAW` jedes denkbare Gesicht malen, aus
|
||||||
|
`TONE` eigene Melodien komponieren und aus `MOVE`/`TURN` Choreografien bauen,
|
||||||
|
die niemand vorgegeben hat. [`agent/proxi-control.md`](agent/proxi-control.md)
|
||||||
|
ist der fertige Skill dafür.
|
||||||
|
|
||||||
|
**Die Pin-Belegung stand nirgends.** Kosmos dokumentiert sie nicht. Sie steckte
|
||||||
|
in den mitgelieferten `.hex`-Dateien — MakeCode hängt jedes Projekt komprimiert
|
||||||
|
an die kompilierte Firmware an. [`tools/hex_source.py`](tools/hex_source.py)
|
||||||
|
holt sie wieder heraus und funktioniert mit jeder micro:bit-`.hex`, nicht nur
|
||||||
|
mit denen von Proxi.
|
||||||
|
|
||||||
|
**Zwei Fallstricke, die je einen Abend gekostet haben.** Die Frequenz für
|
||||||
|
`music.playTone()` muss ganzzahlig sein — als Kommazahl kracht der Lautsprecher,
|
||||||
|
der Aufruf hängt und die Bluetooth-Verbindung stirbt. Und der Ton muss
|
||||||
|
ausdrücklich auf Pin P0 gelegt werden, sonst läuft er über den Audio-Mixer
|
||||||
|
des micro:bit V2 und lässt den Funk nicht mehr zum Zug kommen. Beides steht mit
|
||||||
|
Messwerten in [docs/HARDWARE.md](docs/HARDWARE.md).
|
||||||
|
|
||||||
|
## Aufbau
|
||||||
|
|
||||||
|
| | |
|
||||||
|
|---|---|
|
||||||
|
| [`firmware/`](firmware) | MakeCode-Projekt (TypeScript) und fertige `.hex` für V1 und V2 |
|
||||||
|
| [`bridge/`](bridge) | Bluetooth-Brücke und HTTP-API — nur `bleak` als Abhängigkeit |
|
||||||
|
| [`agent/`](agent) | Skill-Definition: Alltagssprache → Befehle |
|
||||||
|
| [`tools/`](tools) | Quelltext aus `.hex` extrahieren, Musik-Tabellen prüfen |
|
||||||
|
| [`docs/`](docs) | Protokoll, Einrichtung, Hardware, Lizenzen |
|
||||||
|
|
||||||
|
## Stand
|
||||||
|
|
||||||
|
Am echten Roboter durchgetestet: Verbindung, Sensoren, Display, 41 Sekunden
|
||||||
|
Musik am Stück, alle Bewegungsrichtungen, Musik und Fahren gleichzeitig,
|
||||||
|
Tanzfiguren, Not-Stopp mitten in der Bewegung, Autostart nach Neustart.
|
||||||
|
|
||||||
|
## Lizenz
|
||||||
|
|
||||||
|
MIT — siehe [LICENSE](LICENSE). Die Hardware-Extension und die Notendaten
|
||||||
|
stammen aus fremden MIT-Projekten, ihre Vermerke stehen in
|
||||||
|
[THIRD-PARTY-NOTICES](THIRD-PARTY-NOTICES).
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Wer das gebaut hat
|
||||||
|
|
||||||
|
Ich bin **Christian Gärtner**, selbstständiger **KI-Dozent und Berater**. Ich
|
||||||
|
zeige Unternehmen und Teams, wie künstliche Intelligenz im Alltag tatsächlich
|
||||||
|
funktioniert — ohne Buzzword-Bingo, dafür an echten Projekten.
|
||||||
|
|
||||||
|
Dieses hier ist eins davon, und es zeigt ziemlich genau, was ich meine: Ein
|
||||||
|
KI-Agent steuert keine Tabellen, sondern einen Roboter, der im Kinderzimmer
|
||||||
|
herumläuft. Die Bausteine sind fest, was daraus gebaut wird nicht — dieselbe
|
||||||
|
Frage stellt sich in jedem Unternehmen, das überlegt, wo KI bei ihm konkret
|
||||||
|
etwas beiträgt. Und die Fallstricke stehen hier dokumentiert statt versteckt,
|
||||||
|
weil das der Teil ist, an dem Projekte in der Praxis hängenbleiben.
|
||||||
|
|
||||||
|
<div align="center">
|
||||||
|
|
||||||
|
**KI-Schulungen · KI-Beratung · KI-Projekte**
|
||||||
|
|
||||||
|
**[gaertner.onl](https://gaertner.onl)** — Künstliche Intelligenz verständlich gemacht
|
||||||
|
|
||||||
|
[**Termin vereinbaren**](https://gaertner.onl/termin/) · [Kontakt](https://gaertner.onl/kontakt/) · [Blog](https://gaertner.onl/blog/)
|
||||||
|
|
||||||
|
</div>
|
||||||
|
|
||||||
|
<!--
|
||||||
|
Dieser Ordner ist in sich geschlossen und lässt sich am Stück in ein
|
||||||
|
eigenes Repo kopieren.
|
||||||
|
|
||||||
|
docs/img/proxi.png ist das Produktbild von KOSMOS. Wer das vermeiden will,
|
||||||
|
ersetzt es durch ein eigenes Foto — es ist genau diese eine Zeile oben.
|
||||||
|
-->
|
||||||
@@ -0,0 +1,60 @@
|
|||||||
|
Fremder Code in diesem Projekt
|
||||||
|
=============================
|
||||||
|
|
||||||
|
Beide Bestandteile stehen unter der MIT-Lizenz und sind damit mit der Lizenz
|
||||||
|
dieses Projekts verträglich. Ihre Copyright-Vermerke müssen bei jeder
|
||||||
|
Weitergabe erhalten bleiben — dafür ist diese Datei da.
|
||||||
|
|
||||||
|
Welche Datei woher stammt und warum, steht in docs/LICENSES.md.
|
||||||
|
|
||||||
|
|
||||||
|
-------------------------------------------------------------------------------
|
||||||
|
1. firmware/proxi.ts — Hardware-Extension
|
||||||
|
-------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
Ursprünglich "TobbieII" von kaku111
|
||||||
|
https://github.com/kaku111/20190209
|
||||||
|
|
||||||
|
Übernommen in der von Kosmos eingedeutschten Fassung, die in den .hex-Dateien
|
||||||
|
der Proxi-Beispielprogramme mitgeliefert wird. Unverändert bis auf einen
|
||||||
|
Herkunftshinweis im Dateikopf.
|
||||||
|
|
||||||
|
Lizenztext aus LICENSE.txt des Originals:
|
||||||
|
|
||||||
|
Copyright (c) Microsoft Corporation
|
||||||
|
|
||||||
|
All rights reserved.
|
||||||
|
|
||||||
|
MIT License
|
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
of this software and associated documentation files (the "Software"), to deal
|
||||||
|
in the Software without restriction, including without limitation the rights
|
||||||
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||||
|
copies of the Software, and to permit persons to whom the Software is
|
||||||
|
furnished to do so, subject to the following conditions:
|
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included in
|
||||||
|
all copies or substantial portions of the Software.
|
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||||
|
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||||
|
DEALINGS IN THE SOFTWARE.
|
||||||
|
|
||||||
|
|
||||||
|
-------------------------------------------------------------------------------
|
||||||
|
2. Notendaten in firmware/main.ts — melodyBuffer()
|
||||||
|
-------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
Die 20 Melodien sind die eingebauten Melodien von MakeCode für den micro:bit,
|
||||||
|
Byte für Byte übernommen aus libs/core/melodies.ts von
|
||||||
|
|
||||||
|
Microsoft MakeCode für micro:bit (pxt-microbit)
|
||||||
|
https://github.com/microsoft/pxt-microbit
|
||||||
|
|
||||||
|
Lizenz: MIT, Copyright (c) Microsoft Corporation. Der Lizenztext entspricht
|
||||||
|
wortgleich dem oben abgedruckten.
|
||||||
@@ -0,0 +1,233 @@
|
|||||||
|
---
|
||||||
|
name: proxi-control
|
||||||
|
description: Steuert den Proxi-Roboter. Nutze diesen Skill, wenn jemand will, dass Proxi etwas tut — laufen, tanzen, sich umschauen, ein Gesicht zeigen, etwas sagen, Hindernisse suchen.
|
||||||
|
---
|
||||||
|
|
||||||
|
# Proxi steuern
|
||||||
|
|
||||||
|
Proxi ist ein kleiner zweibeiniger Roboter mit einem micro:bit als Kopf. Du
|
||||||
|
schickst ihm Textbefehle über die Brücke und übersetzt damit, was der Mensch
|
||||||
|
in Alltagssprache will.
|
||||||
|
|
||||||
|
## Befehle senden
|
||||||
|
|
||||||
|
Du brauchst **keine Dateien und kein Python**. Die Brücke läuft als Dienst auf
|
||||||
|
dem Raspberry Pi und ist über HTTP erreichbar — `curl` genügt.
|
||||||
|
|
||||||
|
Die Adresse der Brücke steht in der Umgebungsvariablen `PROXI_URL`:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
PROXI="${PROXI_URL:?PROXI_URL ist nicht gesetzt — Adresse der Proxi-Brücke, z.B. http://proxi.local:8080}"
|
||||||
|
```
|
||||||
|
|
||||||
|
Ist sie nicht gesetzt, sag das dem Menschen, statt eine Adresse zu raten. Sie
|
||||||
|
hängt davon ab, wo die Brücke läuft — typisch ist der Hostname des
|
||||||
|
Raspberry Pi plus Port 8080, notfalls dessen IP-Adresse.
|
||||||
|
|
||||||
|
Ein einzelner Befehl:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
curl -sX POST $PROXI/command \
|
||||||
|
-H 'Content-Type: application/json' \
|
||||||
|
-d '{"command":"MOVE:FWD:1000"}'
|
||||||
|
```
|
||||||
|
|
||||||
|
Mehrere am Stück — die Brücke arbeitet sie der Reihe nach ab, inklusive der
|
||||||
|
`WAIT`-Pausen. **So schickst du Choreografien:**
|
||||||
|
|
||||||
|
```bash
|
||||||
|
curl -sX POST $PROXI/commands \
|
||||||
|
-H 'Content-Type: application/json' \
|
||||||
|
-d '{"commands":["FACE:HAPPY","MELODY:FUNK","TURN:LEFT:400","WAIT:450","TURN:RIGHT:400","WAIT:450","STOP"]}'
|
||||||
|
```
|
||||||
|
|
||||||
|
Nachsehen, ob Proxi überhaupt da ist:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
curl -s $PROXI/status # {"connected": true, ...}
|
||||||
|
```
|
||||||
|
|
||||||
|
Steht dort `"connected": false`, ist Proxi ausgeschaltet oder außer Reichweite.
|
||||||
|
Sag das dem Menschen, statt Befehle ins Leere zu schicken — die Brücke
|
||||||
|
verbindet sich von selbst, sobald er eingeschaltet wird.
|
||||||
|
|
||||||
|
### Nicht selbst starten
|
||||||
|
|
||||||
|
`proxi_bridge.py` brauchst du nicht und sollst du **nicht** aufrufen. Das Skript
|
||||||
|
liegt auf dem Pi und läuft dort bereits als Dienst. Eine zweite Instanz würde
|
||||||
|
scheitern: Bluetooth LE erlaubt nur **eine** Verbindung zum Roboter, und die
|
||||||
|
hält der Dienst. Alles läuft über HTTP.
|
||||||
|
|
||||||
|
## Was Proxi kann
|
||||||
|
|
||||||
|
| Befehl | Wirkung |
|
||||||
|
|---|---|
|
||||||
|
| `MOVE:FWD[:ms]` / `MOVE:BWD[:ms]` / `MOVE:STOP` | laufen |
|
||||||
|
| `TURN:LEFT[:ms]` / `TURN:RIGHT[:ms]` / `TURN:STOP` | Oberkörper drehen |
|
||||||
|
| `DANCE[:n]` / `STAMP[:n]` / `SHAKE[:n]` | tanzen, aufstampfen, Kopf schütteln |
|
||||||
|
| `FACE:<name>` / `FACE:RAW:z0:z1:z2:z3:z4` | Gesicht zeigen |
|
||||||
|
| `TEXT:<text>` | Text über das Display laufen lassen |
|
||||||
|
| `MELODY:<name>` / `TONE:<hz>[:ms]` | Musik und Töne |
|
||||||
|
| `SENSOR:ALL` / `SENSOR:IR_L` / `SENSOR:IR_R` | Sensoren lesen |
|
||||||
|
| `CLEAR` / `STOP` / `PING` / `STATUS` | System |
|
||||||
|
|
||||||
|
Die vollständige Liste aller Namen für `FACE` und `MELODY` steht in
|
||||||
|
[`docs/PROTOCOL.md`](../docs/PROTOCOL.md). Rate keine Namen — nimm einen aus
|
||||||
|
der Liste oder frag nach.
|
||||||
|
|
||||||
|
## Regeln
|
||||||
|
|
||||||
|
**Es gibt keine Geschwindigkeit.** Die Motoren können nur an oder aus. Alles,
|
||||||
|
was du steuerst, ist die *Dauer*. "Langsam" gibt es nicht — "kurz" schon.
|
||||||
|
Erfinde keinen Speed-Parameter.
|
||||||
|
|
||||||
|
**Realistische Zeiten.** Grobe Anhaltspunkte, jeder Untergrund ist anders:
|
||||||
|
|
||||||
|
| Was | Dauer |
|
||||||
|
|---|---|
|
||||||
|
| ein, zwei Schritte | 800–1500 ms |
|
||||||
|
| durchs Zimmer | 4000–6000 ms |
|
||||||
|
| Vierteldrehung | ~700 ms |
|
||||||
|
| halbe Drehung | ~1400 ms |
|
||||||
|
|
||||||
|
**Zwischen Bewegungen `WAIT:<ms>` setzen.** Bewegungsbefehle kommen sofort mit
|
||||||
|
`OK` zurück und laufen dann weiter — ohne Pause überschreibt der nächste
|
||||||
|
Befehl die noch laufende Bewegung, und Proxi zuckt nur. `WAIT` ist eine Pause in
|
||||||
|
der Brücke, kein Befehl an den Roboter. Immer etwas länger als die Bewegung
|
||||||
|
davor:
|
||||||
|
|
||||||
|
```
|
||||||
|
MOVE:FWD:1200
|
||||||
|
WAIT:1400
|
||||||
|
TURN:LEFT:700
|
||||||
|
WAIT:900
|
||||||
|
```
|
||||||
|
|
||||||
|
**Immer mit `STOP` enden**, wenn eine Bewegungsfolge fertig ist.
|
||||||
|
|
||||||
|
**Ohne Dauer stoppt eine Bewegung nach 10 Sekunden von selbst.** Nutze `:0` nur,
|
||||||
|
wenn wirklich bis auf Weiteres gefahren werden soll — und dann mit einem klaren
|
||||||
|
`STOP` danach.
|
||||||
|
|
||||||
|
**Lauf- und Drehmotor sind unabhängig.** Beide zusammen ergibt eine Kurve:
|
||||||
|
`MOVE:FWD:0` plus `TURN:LEFT:800`.
|
||||||
|
|
||||||
|
**Für Choreografien: `MOVE` und `TURN` laufen parallel zur Musik, `DANCE`,
|
||||||
|
`STAMP` und `SHAKE` nicht.** Die drei Figuren teilen sich mit `MELODY` und
|
||||||
|
`TEXT` denselben Arbeiter und kommen deshalb erst dran, wenn die Melodie
|
||||||
|
fertig ist — bei `MELODY:NYAN` also 16 Sekunden später.
|
||||||
|
|
||||||
|
Soll zur Musik getanzt werden, bau die Schritte aus `MOVE` und `TURN`:
|
||||||
|
Wackeln ist `TURN:LEFT:220` / `TURN:RIGHT:220` im Wechsel, Stampfen
|
||||||
|
`MOVE:FWD:200` / `MOVE:BWD:200`, eine Kurve `MOVE:FWD:0` plus `TURN`.
|
||||||
|
`DANCE` und Co. gehören vor oder nach die Melodie, nicht mittenrein.
|
||||||
|
|
||||||
|
Ein fertiges Beispiel liegt in `bridge/nyan-dance.txt`.
|
||||||
|
|
||||||
|
**Aber immer nur ein Klang.** Ein neues `MELODY` oder `TONE` bricht das ab, was
|
||||||
|
gerade läuft. Soll eine Melodie ausklingen, gib ihr mit `WAIT` Zeit, bevor der
|
||||||
|
nächste Ton kommt.
|
||||||
|
|
||||||
|
## Kleine Choreografie
|
||||||
|
|
||||||
|
Auf "Proxi, freu dich!":
|
||||||
|
|
||||||
|
```json
|
||||||
|
{"commands": [
|
||||||
|
"FACE:FABULOUS",
|
||||||
|
"MELODY:POWERUP",
|
||||||
|
"STAMP:2", "WAIT:1200",
|
||||||
|
"TURN:LEFT:600", "WAIT:800",
|
||||||
|
"TURN:RIGHT:1200", "WAIT:1400",
|
||||||
|
"TURN:LEFT:600", "WAIT:800",
|
||||||
|
"DANCE:2", "WAIT:1500",
|
||||||
|
"FACE:HEART",
|
||||||
|
"STOP"
|
||||||
|
]}
|
||||||
|
```
|
||||||
|
|
||||||
|
## Eine Choreografie zur Musik bauen
|
||||||
|
|
||||||
|
Das ist die Königsdisziplin — und es gibt ein paar Regeln, ohne die es
|
||||||
|
auseinanderfällt. Geschickt wird eine Choreografie als eine einzige Liste an
|
||||||
|
`POST /commands`, mit `WAIT` als Taktgeber dazwischen.
|
||||||
|
|
||||||
|
**Getanzt wird mit `MOVE` und `TURN`, nicht mit `DANCE`.** Nur die beiden
|
||||||
|
laufen wirklich parallel zur Musik.
|
||||||
|
|
||||||
|
**Melodien reihen sich von selbst aneinander.** Schickst du `MELODY:B`,
|
||||||
|
während A noch läuft, startet B nahtlos danach. So baust du mehrteilige
|
||||||
|
Stücke.
|
||||||
|
|
||||||
|
**Rechne mit den Laufzeiten.** So lange spielt jede Melodie:
|
||||||
|
|
||||||
|
| | |
|
||||||
|
|---|---|
|
||||||
|
| ~0,5–1 s | `BADING` `JUMPUP` `JUMPDOWN` `POWERUP` `POWERDOWN` |
|
||||||
|
| ~2,5–3,5 s | `WAWAWAWAA` `PUNCHLINE` `RINGTONE` `BADDY` `ENTERTAINER` `FUNERAL` |
|
||||||
|
| ~4 s | `DADADUM` `FUNK` |
|
||||||
|
| ~8 s | `CHASE` `WEDDING` `PRELUDE` |
|
||||||
|
| ~12 s | `BIRTHDAY` `BLUES` |
|
||||||
|
| ~16 s | `ODE` `NYAN` |
|
||||||
|
|
||||||
|
**`WAIT` ist rund 150 ms kürzer als die Bewegung davor** — so lange braucht
|
||||||
|
die Brücke selbst zwischen zwei Befehlen. Ohne diesen Abzug läuft der Tanz
|
||||||
|
der Musik davon.
|
||||||
|
|
||||||
|
**Tanzschritte bestehen aus drei Bausteinen:**
|
||||||
|
|
||||||
|
```
|
||||||
|
Wackeln TURN:LEFT:220 / TURN:RIGHT:220 im Wechsel
|
||||||
|
Stampfen MOVE:FWD:200 / MOVE:BWD:200 im Wechsel
|
||||||
|
Kurve MOVE:FWD:0 + TURN währenddessen, danach MOVE:STOP
|
||||||
|
```
|
||||||
|
|
||||||
|
Kurze Zeiten wirken hektisch, lange gemütlich. Genau daraus entsteht Rhythmus.
|
||||||
|
|
||||||
|
**Ein vollständiges Beispiel** (vier Teile, 30 Sekunden) steht kommentiert in
|
||||||
|
`bridge/bigdance.txt` im Repo. Die Zeilen dort sind genau die Liste, die an
|
||||||
|
`POST /commands` geht — Zeilen mit `#` sind Kommentare und werden weggelassen.
|
||||||
|
|
||||||
|
**Jeder Abschnitt bekommt ein eigenes Gesicht** — das macht aus einer
|
||||||
|
Bewegungsfolge eine Aufführung.
|
||||||
|
|
||||||
|
**Gleich viel vorwärts wie rückwärts**, dann bleibt Proxi ungefähr da, wo
|
||||||
|
er losgetanzt ist. Und am Ende immer `STOP`.
|
||||||
|
|
||||||
|
## Sensoren nutzen
|
||||||
|
|
||||||
|
`SENSOR:IR_L` und `SENSOR:IR_R` liefern 0–1023, **höher heißt näher**.
|
||||||
|
Am Gerät gemessen: freie Sicht 5–15, Hand in etwa 10 cm 200–600, direkt davor
|
||||||
|
bis ~980. Ab 400 steht etwas im Weg — das entspricht ungefähr einer Handbreit.
|
||||||
|
|
||||||
|
**Proxi kann kein Licht messen.** Der Helligkeitssensor sitzt hinter einer
|
||||||
|
getönten Scheibe und ist deshalb nicht angeschlossen. Sag nicht, Proxi könne
|
||||||
|
sehen, ob es hell oder dunkel ist — er kann es nicht.
|
||||||
|
|
||||||
|
Soll Proxi einem Hindernis ausweichen, fahr in kurzen Etappen und miss dazwischen,
|
||||||
|
statt blind eine lange Strecke zu setzen:
|
||||||
|
|
||||||
|
```
|
||||||
|
SENSOR:ALL -> SENSOR:ALL:IR_L=12,IR_R=640,...
|
||||||
|
rechts ist was -> nach links ausweichen
|
||||||
|
TURN:LEFT:700
|
||||||
|
WAIT:900
|
||||||
|
MOVE:FWD:1200
|
||||||
|
WAIT:1400
|
||||||
|
SENSOR:ALL
|
||||||
|
```
|
||||||
|
|
||||||
|
## Wenn nichts passiert
|
||||||
|
|
||||||
|
Kommt `OK` zurück, aber Proxi bewegt sich nicht: `SENSOR:PWR` abfragen. Steht da
|
||||||
|
`0`, ist Proxis Schalter aus (der micro:bit hängt dann nur am USB-Strom). Sag
|
||||||
|
das dem Menschen, statt weiter Fahrbefehle zu schicken.
|
||||||
|
|
||||||
|
## Sicherheit
|
||||||
|
|
||||||
|
Proxi fährt auf dem Boden herum, oft mit einem Kind daneben.
|
||||||
|
|
||||||
|
* Keine Dauerfahrten ohne Zeitlimit
|
||||||
|
* Nach jeder Folge `STOP`
|
||||||
|
* Taste A am Roboter ist der Not-Stopp und geht immer, auch ohne Verbindung
|
||||||
|
* Wenn jemand "Stopp" sagt: sofort `STOP` schicken, Nachfragen kommen danach
|
||||||
@@ -0,0 +1,3 @@
|
|||||||
|
__pycache__/
|
||||||
|
*.pyc
|
||||||
|
.venv/
|
||||||
@@ -0,0 +1,170 @@
|
|||||||
|
# bigdance.txt — große Choreografie in vier Teilen, rund 30 Sekunden
|
||||||
|
#
|
||||||
|
# python3 proxi_bridge.py --script bigdance.txt
|
||||||
|
#
|
||||||
|
# ===========================================================================
|
||||||
|
# WIE SO EINE CHOREOGRAFIE GEBAUT WIRD
|
||||||
|
# ===========================================================================
|
||||||
|
#
|
||||||
|
# 1. MELODY blockiert die Tanzfiguren, MOVE und TURN nicht.
|
||||||
|
# DANCE, STAMP und SHAKE teilen sich mit MELODY einen Arbeiter und würden
|
||||||
|
# erst NACH der Musik loslaufen. Zur Musik getanzt wird deshalb mit MOVE und
|
||||||
|
# TURN — die starten sofort.
|
||||||
|
#
|
||||||
|
# 2. Melodien reihen sich von selbst aneinander.
|
||||||
|
# Schickt man MELODY:B während A läuft, wartet B und startet nahtlos,
|
||||||
|
# sobald A fertig ist. So entstehen mehrteilige Stücke.
|
||||||
|
#
|
||||||
|
# 3. Die Länge jeder Melodie ist bekannt — danach wird die Zeit eingeteilt:
|
||||||
|
# ENTERTAINER 3.4s | FUNK 4.0s | CHASE 8.0s | NYAN 16.0s
|
||||||
|
# Zusammen 31.4 Sekunden, die mit Bewegung gefüllt werden wollen.
|
||||||
|
#
|
||||||
|
# 4. WAIT ist immer rund 150 ms kürzer als die Bewegung davor.
|
||||||
|
# So lange braucht die Brücke selbst zwischen zwei Befehlen. Ohne diesen
|
||||||
|
# Abzug läuft der Tanz der Musik langsam davon.
|
||||||
|
#
|
||||||
|
# 5. Tanzschritte entstehen aus drei Bausteinen:
|
||||||
|
# Wackeln TURN:LEFT:220 / TURN:RIGHT:220 im Wechsel
|
||||||
|
# Stampfen MOVE:FWD:200 / MOVE:BWD:200 im Wechsel
|
||||||
|
# Kurve MOVE:FWD:0 plus TURN währenddessen, danach MOVE:STOP
|
||||||
|
# Kurze Zeiten wirken hektisch, lange gemütlich — das ist der Rhythmus.
|
||||||
|
#
|
||||||
|
# 6. Jeder Teil bekommt ein eigenes Gesicht. Das macht aus einer Bewegungsfolge
|
||||||
|
# eine Aufführung.
|
||||||
|
#
|
||||||
|
# 7. Am Ende immer STOP.
|
||||||
|
#
|
||||||
|
# Gleich viel vorwärts wie rückwärts halten — dann bleibt Proxi ungefähr
|
||||||
|
# da stehen, wo er losgetanzt ist, und fällt nicht vom Tisch.
|
||||||
|
#
|
||||||
|
|
||||||
|
FACE:ASLEEP
|
||||||
|
|
||||||
|
# --- TEIL 1: Aufwachen (Entertainer, 3.4s) ---
|
||||||
|
MELODY:ENTERTAINER
|
||||||
|
WAIT:250
|
||||||
|
FACE:SURPRISED
|
||||||
|
TURN:LEFT:300
|
||||||
|
WAIT:230
|
||||||
|
TURN:RIGHT:600
|
||||||
|
WAIT:550
|
||||||
|
TURN:LEFT:300
|
||||||
|
WAIT:230
|
||||||
|
WAIT:1240
|
||||||
|
|
||||||
|
# --- TEIL 2: Groove (Funk, 4.0s) ---
|
||||||
|
MELODY:FUNK
|
||||||
|
FACE:HAPPY
|
||||||
|
TURN:LEFT:420
|
||||||
|
WAIT:320
|
||||||
|
TURN:RIGHT:420
|
||||||
|
WAIT:320
|
||||||
|
TURN:LEFT:420
|
||||||
|
WAIT:320
|
||||||
|
TURN:RIGHT:420
|
||||||
|
WAIT:320
|
||||||
|
MOVE:FWD:500
|
||||||
|
WAIT:410
|
||||||
|
MOVE:BWD:500
|
||||||
|
WAIT:410
|
||||||
|
WAIT:700
|
||||||
|
|
||||||
|
# --- TEIL 3: Jagd (Chase, 8.0s) ---
|
||||||
|
MELODY:CHASE
|
||||||
|
FACE:SILLY
|
||||||
|
TURN:LEFT:200
|
||||||
|
WAIT:100
|
||||||
|
TURN:RIGHT:200
|
||||||
|
WAIT:100
|
||||||
|
TURN:LEFT:200
|
||||||
|
WAIT:100
|
||||||
|
TURN:RIGHT:200
|
||||||
|
WAIT:100
|
||||||
|
TURN:LEFT:200
|
||||||
|
WAIT:100
|
||||||
|
TURN:RIGHT:200
|
||||||
|
WAIT:100
|
||||||
|
TURN:LEFT:200
|
||||||
|
WAIT:100
|
||||||
|
TURN:RIGHT:200
|
||||||
|
WAIT:100
|
||||||
|
FACE:NORTH
|
||||||
|
MOVE:FWD:0
|
||||||
|
TURN:LEFT:700
|
||||||
|
WAIT:650
|
||||||
|
TURN:RIGHT:700
|
||||||
|
WAIT:650
|
||||||
|
MOVE:STOP
|
||||||
|
MOVE:BWD:900
|
||||||
|
WAIT:850
|
||||||
|
WAIT:2650
|
||||||
|
|
||||||
|
# --- TEIL 4: Finale (Nyan, 16.0s) ---
|
||||||
|
MELODY:NYAN
|
||||||
|
FACE:FABULOUS
|
||||||
|
MOVE:FWD:220
|
||||||
|
WAIT:130
|
||||||
|
MOVE:BWD:220
|
||||||
|
WAIT:130
|
||||||
|
MOVE:FWD:220
|
||||||
|
WAIT:130
|
||||||
|
MOVE:BWD:220
|
||||||
|
WAIT:130
|
||||||
|
FACE:HEART
|
||||||
|
TURN:LEFT:230
|
||||||
|
WAIT:140
|
||||||
|
TURN:RIGHT:230
|
||||||
|
WAIT:140
|
||||||
|
TURN:LEFT:230
|
||||||
|
WAIT:140
|
||||||
|
TURN:RIGHT:230
|
||||||
|
WAIT:140
|
||||||
|
TURN:LEFT:230
|
||||||
|
WAIT:140
|
||||||
|
TURN:RIGHT:230
|
||||||
|
WAIT:140
|
||||||
|
FACE:DIAMOND
|
||||||
|
MOVE:FWD:0
|
||||||
|
TURN:LEFT:1200
|
||||||
|
WAIT:1150
|
||||||
|
TURN:RIGHT:1200
|
||||||
|
WAIT:1150
|
||||||
|
MOVE:STOP
|
||||||
|
FACE:SILLY
|
||||||
|
TURN:RIGHT:180
|
||||||
|
WAIT:80
|
||||||
|
TURN:LEFT:180
|
||||||
|
WAIT:80
|
||||||
|
TURN:RIGHT:180
|
||||||
|
WAIT:80
|
||||||
|
TURN:LEFT:180
|
||||||
|
WAIT:80
|
||||||
|
TURN:RIGHT:180
|
||||||
|
WAIT:80
|
||||||
|
TURN:LEFT:180
|
||||||
|
WAIT:80
|
||||||
|
FACE:TARGET
|
||||||
|
MOVE:BWD:200
|
||||||
|
WAIT:110
|
||||||
|
MOVE:FWD:200
|
||||||
|
WAIT:110
|
||||||
|
MOVE:BWD:200
|
||||||
|
WAIT:110
|
||||||
|
MOVE:FWD:200
|
||||||
|
WAIT:110
|
||||||
|
FACE:FABULOUS
|
||||||
|
TURN:LEFT:260
|
||||||
|
WAIT:170
|
||||||
|
TURN:RIGHT:260
|
||||||
|
WAIT:170
|
||||||
|
TURN:LEFT:260
|
||||||
|
WAIT:170
|
||||||
|
TURN:RIGHT:260
|
||||||
|
WAIT:170
|
||||||
|
FACE:HEART
|
||||||
|
TURN:LEFT:1500
|
||||||
|
WAIT:1450
|
||||||
|
TURN:RIGHT:1500
|
||||||
|
WAIT:1450
|
||||||
|
STOP
|
||||||
|
FACE:HEART
|
||||||
@@ -0,0 +1,32 @@
|
|||||||
|
# demo.txt — kleine Vorführung
|
||||||
|
# Abspielen: python3 proxi_bridge.py --script demo.txt
|
||||||
|
|
||||||
|
FACE:HAPPY
|
||||||
|
MELODY:POWERUP
|
||||||
|
TEXT:Hallo!
|
||||||
|
|
||||||
|
# einmal umschauen
|
||||||
|
TURN:LEFT:700
|
||||||
|
WAIT:900
|
||||||
|
TURN:RIGHT:1400
|
||||||
|
WAIT:1600
|
||||||
|
TURN:LEFT:700
|
||||||
|
WAIT:900
|
||||||
|
|
||||||
|
# ein paar Schritte
|
||||||
|
FACE:NORTH
|
||||||
|
MOVE:FWD:1500
|
||||||
|
WAIT:1700
|
||||||
|
MOVE:BWD:1500
|
||||||
|
WAIT:1700
|
||||||
|
|
||||||
|
# großer Auftritt
|
||||||
|
FACE:FABULOUS
|
||||||
|
MELODY:FUNK
|
||||||
|
DANCE:3
|
||||||
|
WAIT:2000
|
||||||
|
STAMP:2
|
||||||
|
WAIT:1200
|
||||||
|
|
||||||
|
FACE:HEART
|
||||||
|
STOP
|
||||||
@@ -0,0 +1,83 @@
|
|||||||
|
# nyan-dance.txt — Choreografie zu MELODY:NYAN (16 s)
|
||||||
|
#
|
||||||
|
# python3 proxi_bridge.py --script nyan-dance.txt
|
||||||
|
#
|
||||||
|
# Getanzt wird ausschließlich mit MOVE und TURN, nicht mit DANCE/STAMP/SHAKE:
|
||||||
|
# die teilen sich mit MELODY denselben Worker und würden erst NACH der Melodie
|
||||||
|
# loslaufen. MOVE und TURN laufen dagegen parallel zur Musik.
|
||||||
|
#
|
||||||
|
# Die WAIT-Zeiten sind um 150 ms kürzer als der Schritt davor — so lange
|
||||||
|
# braucht die Brücke selbst zwischen zwei Befehlen.
|
||||||
|
|
||||||
|
FACE:FABULOUS
|
||||||
|
MELODY:NYAN
|
||||||
|
WAIT:300
|
||||||
|
|
||||||
|
# 1. Groove von einer Seite zur anderen
|
||||||
|
TURN:LEFT:400
|
||||||
|
WAIT:300
|
||||||
|
TURN:RIGHT:400
|
||||||
|
WAIT:300
|
||||||
|
TURN:LEFT:400
|
||||||
|
WAIT:300
|
||||||
|
TURN:RIGHT:400
|
||||||
|
WAIT:300
|
||||||
|
|
||||||
|
# 2. Vor und zurück im Takt
|
||||||
|
FACE:SURPRISED
|
||||||
|
MOVE:FWD:550
|
||||||
|
WAIT:470
|
||||||
|
MOVE:BWD:550
|
||||||
|
WAIT:470
|
||||||
|
MOVE:FWD:550
|
||||||
|
WAIT:470
|
||||||
|
MOVE:BWD:550
|
||||||
|
WAIT:470
|
||||||
|
|
||||||
|
# 3. Kurve — laufen und drehen gleichzeitig
|
||||||
|
FACE:HAPPY
|
||||||
|
MOVE:FWD:0
|
||||||
|
TURN:LEFT:800
|
||||||
|
WAIT:750
|
||||||
|
TURN:RIGHT:800
|
||||||
|
WAIT:750
|
||||||
|
MOVE:STOP
|
||||||
|
|
||||||
|
# 4. Schnelles Wackeln
|
||||||
|
FACE:SILLY
|
||||||
|
TURN:LEFT:220
|
||||||
|
WAIT:130
|
||||||
|
TURN:RIGHT:220
|
||||||
|
WAIT:130
|
||||||
|
TURN:LEFT:220
|
||||||
|
WAIT:130
|
||||||
|
TURN:RIGHT:220
|
||||||
|
WAIT:130
|
||||||
|
TURN:LEFT:220
|
||||||
|
WAIT:130
|
||||||
|
TURN:RIGHT:220
|
||||||
|
WAIT:130
|
||||||
|
|
||||||
|
# 5. Stampfen
|
||||||
|
FACE:FABULOUS
|
||||||
|
MOVE:FWD:200
|
||||||
|
WAIT:110
|
||||||
|
MOVE:BWD:200
|
||||||
|
WAIT:110
|
||||||
|
MOVE:FWD:200
|
||||||
|
WAIT:110
|
||||||
|
MOVE:BWD:200
|
||||||
|
WAIT:110
|
||||||
|
MOVE:FWD:200
|
||||||
|
WAIT:110
|
||||||
|
MOVE:BWD:200
|
||||||
|
WAIT:110
|
||||||
|
|
||||||
|
# 6. Große Schlussdrehung
|
||||||
|
FACE:HEART
|
||||||
|
TURN:LEFT:1300
|
||||||
|
WAIT:1250
|
||||||
|
TURN:RIGHT:1300
|
||||||
|
WAIT:1250
|
||||||
|
STOP
|
||||||
|
FACE:HEART
|
||||||
Executable
+412
@@ -0,0 +1,412 @@
|
|||||||
|
#!/usr/bin/env python3
|
||||||
|
"""
|
||||||
|
proxi_bridge.py — Bluetooth-LE-Brücke zum Proxi-Roboter.
|
||||||
|
|
||||||
|
Verbindet sich per BLE mit dem micro:bit im Roboter und schiebt Textbefehle
|
||||||
|
über dessen UART-Service. Läuft auf allem mit Linux + Bluetooth (Pi Zero W,
|
||||||
|
Laptop, NUC). Die einzige Abhängigkeit ist `bleak`, der Rest ist Stdlib.
|
||||||
|
|
||||||
|
pip install bleak
|
||||||
|
|
||||||
|
python3 proxi_bridge.py --scan Geräte suchen
|
||||||
|
python3 proxi_bridge.py --ping Lebenszeichen
|
||||||
|
python3 proxi_bridge.py "MOVE:FWD:1500" einzelner Befehl
|
||||||
|
python3 proxi_bridge.py -i interaktiv
|
||||||
|
python3 proxi_bridge.py --script demo.txt Skript abspielen
|
||||||
|
python3 proxi_bridge.py --serve 8080 HTTP-API für die KI
|
||||||
|
|
||||||
|
Befehlsreferenz: ../docs/PROTOCOL.md
|
||||||
|
"""
|
||||||
|
|
||||||
|
import argparse
|
||||||
|
import asyncio
|
||||||
|
import json
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
import threading
|
||||||
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||||
|
|
||||||
|
try:
|
||||||
|
from bleak import BleakClient, BleakScanner
|
||||||
|
except ImportError:
|
||||||
|
sys.exit("bleak fehlt. pip install bleak")
|
||||||
|
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# micro:bit BLE UART
|
||||||
|
#
|
||||||
|
# Aus codal-microbit-v2/source/bluetooth/MicroBitUARTService.cpp:
|
||||||
|
# mbbs_cIdxTX = 0x0002 -> propINDICATE micro:bit -> Host
|
||||||
|
# mbbs_cIdxRX = 0x0003 -> propWRITE | WRITE_WITHOUT Host -> micro:bit
|
||||||
|
#
|
||||||
|
# Die Namen sind aus Sicht des micro:bit vergeben. Wer sie mit den Nordic-UART-
|
||||||
|
# Konventionen verwechselt, schreibt auf das Indicate-Handle und wartet auf
|
||||||
|
# Benachrichtigungen vom Write-Handle — es passiert dann schlicht nichts.
|
||||||
|
#
|
||||||
|
# MICROBIT_UART_S_ATTRSIZE ist 20 Byte, längere Zeilen müssen gestückelt werden.
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
|
||||||
|
UART_SERVICE = "6e400001-b5a3-f393-e0a9-e50e24dcca9e"
|
||||||
|
UART_FROM_MICROBIT = "6e400002-b5a3-f393-e0a9-e50e24dcca9e" # indicate
|
||||||
|
UART_TO_MICROBIT = "6e400003-b5a3-f393-e0a9-e50e24dcca9e" # write
|
||||||
|
ATTR_SIZE = 20
|
||||||
|
|
||||||
|
#: Zeilen mit diesen Präfixen sind unaufgefordert und keine Antwort auf einen Befehl.
|
||||||
|
UNSOLICITED = ("EVENT:", "DONE:", "READY:")
|
||||||
|
|
||||||
|
|
||||||
|
class ProxiBLE:
|
||||||
|
"""Asynchrone BLE-Verbindung zum Roboter."""
|
||||||
|
|
||||||
|
def __init__(self, address=None, timeout=15.0):
|
||||||
|
self.address = address
|
||||||
|
#: vom Aufrufer vorgegebene Adresse; None heißt "jedes Mal neu suchen"
|
||||||
|
self.fixed_address = address
|
||||||
|
self.timeout = timeout
|
||||||
|
self.client = None
|
||||||
|
self._rx = bytearray()
|
||||||
|
self._responses = None
|
||||||
|
self.events = []
|
||||||
|
self.on_event = None
|
||||||
|
|
||||||
|
# -- Verbindung ---------------------------------------------------------
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
async def discover(timeout=8.0):
|
||||||
|
"""Alle micro:bits in Reichweite."""
|
||||||
|
found = []
|
||||||
|
for dev in await BleakScanner.discover(timeout=timeout):
|
||||||
|
name = dev.name or ""
|
||||||
|
if "micro:bit" in name.lower() or "microbit" in name.lower():
|
||||||
|
found.append((name, dev.address))
|
||||||
|
return found
|
||||||
|
|
||||||
|
async def connect(self):
|
||||||
|
if not self.address:
|
||||||
|
found = await self.discover()
|
||||||
|
if not found:
|
||||||
|
raise RuntimeError(
|
||||||
|
"kein micro:bit gefunden — ist Proxi an und nicht schon "
|
||||||
|
"mit einem anderen Gerät verbunden?"
|
||||||
|
)
|
||||||
|
name, self.address = found[0]
|
||||||
|
print(f"gefunden: {name} — {self.address}", file=sys.stderr)
|
||||||
|
|
||||||
|
self._responses = asyncio.Queue()
|
||||||
|
self.client = BleakClient(self.address, timeout=self.timeout)
|
||||||
|
await self.client.connect()
|
||||||
|
|
||||||
|
# start_notify deckt auch Indications ab — der micro:bit nutzt Indicate.
|
||||||
|
await self.client.start_notify(UART_FROM_MICROBIT, self._on_data)
|
||||||
|
return self.address
|
||||||
|
|
||||||
|
async def disconnect(self):
|
||||||
|
if self.client and self.client.is_connected:
|
||||||
|
try:
|
||||||
|
await self.send("STOP", wait=False)
|
||||||
|
await asyncio.sleep(0.2)
|
||||||
|
except Exception:
|
||||||
|
pass
|
||||||
|
await self.client.disconnect()
|
||||||
|
|
||||||
|
@property
|
||||||
|
def connected(self):
|
||||||
|
return bool(self.client and self.client.is_connected)
|
||||||
|
|
||||||
|
# -- Datenstrom ---------------------------------------------------------
|
||||||
|
|
||||||
|
def _on_data(self, _handle, data):
|
||||||
|
"""Bytes einsammeln und in Zeilen zerlegen."""
|
||||||
|
self._rx.extend(data)
|
||||||
|
while b"\n" in self._rx:
|
||||||
|
head, _, rest = bytes(self._rx).partition(b"\n")
|
||||||
|
self._rx = bytearray(rest)
|
||||||
|
line = head.decode("utf-8", "replace").strip()
|
||||||
|
if not line:
|
||||||
|
continue
|
||||||
|
if line.startswith(UNSOLICITED):
|
||||||
|
self.events.append(line)
|
||||||
|
if self.on_event:
|
||||||
|
self.on_event(line)
|
||||||
|
else:
|
||||||
|
self._responses.put_nowait(line)
|
||||||
|
|
||||||
|
# -- Senden -------------------------------------------------------------
|
||||||
|
|
||||||
|
async def send(self, command, wait=True, timeout=10.0):
|
||||||
|
if not self.connected:
|
||||||
|
return "ERR:not_connected"
|
||||||
|
|
||||||
|
while not self._responses.empty():
|
||||||
|
self._responses.get_nowait()
|
||||||
|
|
||||||
|
payload = (command.strip() + "\n").encode("utf-8")
|
||||||
|
for i in range(0, len(payload), ATTR_SIZE):
|
||||||
|
await self.client.write_gatt_char(
|
||||||
|
UART_TO_MICROBIT, payload[i:i + ATTR_SIZE], response=False
|
||||||
|
)
|
||||||
|
|
||||||
|
if not wait:
|
||||||
|
return None
|
||||||
|
try:
|
||||||
|
return await asyncio.wait_for(self._responses.get(), timeout=timeout)
|
||||||
|
except asyncio.TimeoutError:
|
||||||
|
return "ERR:timeout"
|
||||||
|
|
||||||
|
async def send_many(self, commands, gap=0.15):
|
||||||
|
"""Befehle der Reihe nach senden.
|
||||||
|
|
||||||
|
`WAIT:<ms>` ist kein Roboter-Befehl, sondern eine Pause hier in der
|
||||||
|
Brücke. Bewegungsbefehle kommen sofort mit OK zurück und laufen dann
|
||||||
|
weiter — ohne WAIT dazwischen würde der nächste Befehl die laufende
|
||||||
|
Bewegung sofort überschreiben.
|
||||||
|
"""
|
||||||
|
results = []
|
||||||
|
for raw in commands:
|
||||||
|
cmd = raw.strip()
|
||||||
|
if not cmd or cmd.startswith("#"):
|
||||||
|
continue
|
||||||
|
|
||||||
|
head, sep, rest = cmd.partition(":")
|
||||||
|
if head.upper() == "WAIT":
|
||||||
|
try:
|
||||||
|
ms = int(rest) if sep else 0
|
||||||
|
except ValueError:
|
||||||
|
results.append((cmd, "ERR:WAIT:bad_ms"))
|
||||||
|
continue
|
||||||
|
await asyncio.sleep(max(0, min(ms, 60000)) / 1000)
|
||||||
|
results.append((cmd, f"OK:WAIT:{ms}"))
|
||||||
|
continue
|
||||||
|
|
||||||
|
results.append((cmd, await self.send(cmd)))
|
||||||
|
await asyncio.sleep(gap)
|
||||||
|
return results
|
||||||
|
|
||||||
|
|
||||||
|
class Bridge:
|
||||||
|
"""Synchrone Hülle: hält die Verbindung in einem eigenen Event-Loop-Thread."""
|
||||||
|
|
||||||
|
def __init__(self, address=None):
|
||||||
|
self.ble = ProxiBLE(address)
|
||||||
|
self._loop = asyncio.new_event_loop()
|
||||||
|
self._thread = threading.Thread(target=self._run_loop, daemon=True)
|
||||||
|
self._thread.start()
|
||||||
|
|
||||||
|
def _run_loop(self):
|
||||||
|
asyncio.set_event_loop(self._loop)
|
||||||
|
self._loop.run_forever()
|
||||||
|
|
||||||
|
def _call(self, coro, timeout=60):
|
||||||
|
return asyncio.run_coroutine_threadsafe(coro, self._loop).result(timeout)
|
||||||
|
|
||||||
|
def connect(self):
|
||||||
|
return self._call(self.ble.connect(), timeout=90)
|
||||||
|
|
||||||
|
def start_autoconnect(self, interval=10.0):
|
||||||
|
"""Im Hintergrund verbinden und verbunden halten.
|
||||||
|
|
||||||
|
Für den Dauerbetrieb als Dienst: der Roboter ist nicht immer an. Ohne
|
||||||
|
das beendet sich die Brücke beim Startversuch, systemd startet sie neu,
|
||||||
|
und der HTTP-Server kommt nie hoch — die API wäre also genau dann tot,
|
||||||
|
wenn jemand den Roboter einschaltet.
|
||||||
|
"""
|
||||||
|
asyncio.run_coroutine_threadsafe(self._keep_connected(interval), self._loop)
|
||||||
|
|
||||||
|
async def _keep_connected(self, interval):
|
||||||
|
while True:
|
||||||
|
if not self.ble.connected:
|
||||||
|
try:
|
||||||
|
await self.ble.connect()
|
||||||
|
print(f"verbunden mit {self.ble.address}", file=sys.stderr)
|
||||||
|
except Exception as exc:
|
||||||
|
# Roboter aus oder außer Reichweite — gleich nochmal probieren
|
||||||
|
print(f"warte auf Proxi ({exc})", file=sys.stderr)
|
||||||
|
self.ble.address = self.ble.fixed_address
|
||||||
|
await asyncio.sleep(interval)
|
||||||
|
|
||||||
|
def send(self, command, wait=True):
|
||||||
|
return self._call(self.ble.send(command, wait=wait))
|
||||||
|
|
||||||
|
def send_many(self, commands):
|
||||||
|
return self._call(self.ble.send_many(commands), timeout=600)
|
||||||
|
|
||||||
|
def close(self):
|
||||||
|
try:
|
||||||
|
self._call(self.ble.disconnect(), timeout=20)
|
||||||
|
finally:
|
||||||
|
self._loop.call_soon_threadsafe(self._loop.stop)
|
||||||
|
|
||||||
|
@property
|
||||||
|
def connected(self):
|
||||||
|
return self.ble.connected
|
||||||
|
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# HTTP-API
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
|
||||||
|
def make_handler(bridge):
|
||||||
|
class Handler(BaseHTTPRequestHandler):
|
||||||
|
protocol_version = "HTTP/1.1"
|
||||||
|
|
||||||
|
def log_message(self, fmt, *args):
|
||||||
|
print(f"[http] {fmt % args}", file=sys.stderr)
|
||||||
|
|
||||||
|
def _send(self, code, payload):
|
||||||
|
body = json.dumps(payload).encode("utf-8")
|
||||||
|
self.send_response(code)
|
||||||
|
self.send_header("Content-Type", "application/json")
|
||||||
|
self.send_header("Content-Length", str(len(body)))
|
||||||
|
self.send_header("Access-Control-Allow-Origin", "*")
|
||||||
|
self.send_header("Access-Control-Allow-Headers", "Content-Type")
|
||||||
|
self.end_headers()
|
||||||
|
self.wfile.write(body)
|
||||||
|
|
||||||
|
def do_OPTIONS(self):
|
||||||
|
self._send(204, {})
|
||||||
|
|
||||||
|
def do_GET(self):
|
||||||
|
if self.path.rstrip("/") in ("", "/status"):
|
||||||
|
self._send(200, {
|
||||||
|
"connected": bridge.connected,
|
||||||
|
"address": bridge.ble.address,
|
||||||
|
"events": bridge.ble.events[-20:],
|
||||||
|
})
|
||||||
|
else:
|
||||||
|
self._send(404, {"error": "not found"})
|
||||||
|
|
||||||
|
def do_POST(self):
|
||||||
|
length = int(self.headers.get("Content-Length") or 0)
|
||||||
|
try:
|
||||||
|
data = json.loads(self.rfile.read(length) or b"{}")
|
||||||
|
except json.JSONDecodeError:
|
||||||
|
return self._send(400, {"error": "kein gültiges JSON"})
|
||||||
|
|
||||||
|
path = self.path.rstrip("/")
|
||||||
|
if path == "/command":
|
||||||
|
cmd = data.get("command")
|
||||||
|
if not isinstance(cmd, str):
|
||||||
|
return self._send(400, {"error": "Feld 'command' fehlt"})
|
||||||
|
response = bridge.send(cmd)
|
||||||
|
self._send(200, {
|
||||||
|
"command": cmd,
|
||||||
|
"response": response,
|
||||||
|
"ok": not str(response).startswith("ERR:"),
|
||||||
|
})
|
||||||
|
elif path == "/commands":
|
||||||
|
cmds = data.get("commands")
|
||||||
|
if not isinstance(cmds, list):
|
||||||
|
return self._send(400, {"error": "Feld 'commands' fehlt"})
|
||||||
|
results = bridge.send_many([str(c) for c in cmds])
|
||||||
|
self._send(200, {"results": [
|
||||||
|
{"command": c, "response": r, "ok": not str(r).startswith("ERR:")}
|
||||||
|
for c, r in results
|
||||||
|
]})
|
||||||
|
else:
|
||||||
|
self._send(404, {"error": "not found"})
|
||||||
|
|
||||||
|
return Handler
|
||||||
|
|
||||||
|
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
# CLI
|
||||||
|
# --------------------------------------------------------------------------
|
||||||
|
|
||||||
|
def run_scan():
|
||||||
|
found = asyncio.run(ProxiBLE.discover())
|
||||||
|
if not found:
|
||||||
|
print("kein micro:bit gefunden.")
|
||||||
|
return 1
|
||||||
|
for name, address in found:
|
||||||
|
print(f"{address} {name}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
def run_interactive(bridge):
|
||||||
|
print("Interaktiv — 'quit' beendet, leere Zeile wiederholt nichts.")
|
||||||
|
print("Befehle z.B.: MOVE:FWD:1500 | TURN:LEFT:600 | FACE:HAPPY | DANCE:3")
|
||||||
|
while True:
|
||||||
|
try:
|
||||||
|
line = input("proxi> ").strip()
|
||||||
|
except (EOFError, KeyboardInterrupt):
|
||||||
|
print()
|
||||||
|
return 0
|
||||||
|
if not line:
|
||||||
|
continue
|
||||||
|
if line.lower() in ("quit", "exit", "q"):
|
||||||
|
return 0
|
||||||
|
print(" ", bridge.send(line))
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
ap = argparse.ArgumentParser(
|
||||||
|
description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||||
|
ap.add_argument("command", nargs="*", help="Befehl(e), direkt gesendet")
|
||||||
|
ap.add_argument("--address", "-a", help="BLE-Adresse, überspringt die Suche")
|
||||||
|
ap.add_argument("--scan", action="store_true", help="micro:bits suchen und beenden")
|
||||||
|
ap.add_argument("--ping", action="store_true", help="PING senden")
|
||||||
|
ap.add_argument("--interactive", "-i", action="store_true", help="Eingabeschleife")
|
||||||
|
ap.add_argument("--script", help="Datei mit einem Befehl pro Zeile")
|
||||||
|
ap.add_argument("--serve", type=int, metavar="PORT", help="HTTP-API starten")
|
||||||
|
args = ap.parse_args()
|
||||||
|
|
||||||
|
if args.scan:
|
||||||
|
return run_scan()
|
||||||
|
|
||||||
|
address = args.address or os.environ.get("PROXI_ADDRESS")
|
||||||
|
bridge = Bridge(address)
|
||||||
|
bridge.ble.on_event = lambda line: print(f"[proxi] {line}", file=sys.stderr)
|
||||||
|
|
||||||
|
if args.serve:
|
||||||
|
# Erst den Server, dann die Verbindung: die API muss auch dann
|
||||||
|
# erreichbar sein, wenn Proxi gerade aus ist.
|
||||||
|
server = ThreadingHTTPServer(("0.0.0.0", args.serve), make_handler(bridge))
|
||||||
|
bridge.start_autoconnect()
|
||||||
|
print(f"HTTP-API auf http://0.0.0.0:{args.serve} "
|
||||||
|
f"(POST /command, POST /commands, GET /status)", file=sys.stderr)
|
||||||
|
try:
|
||||||
|
server.serve_forever()
|
||||||
|
except KeyboardInterrupt:
|
||||||
|
pass
|
||||||
|
finally:
|
||||||
|
bridge.close()
|
||||||
|
return 0
|
||||||
|
|
||||||
|
# Alle anderen Modi sind interaktiv — da ist sofortiges Scheitern richtig.
|
||||||
|
try:
|
||||||
|
bridge.connect()
|
||||||
|
except Exception as exc:
|
||||||
|
print(f"Verbindung fehlgeschlagen: {exc}", file=sys.stderr)
|
||||||
|
return 1
|
||||||
|
print(f"verbunden mit {bridge.ble.address}", file=sys.stderr)
|
||||||
|
|
||||||
|
try:
|
||||||
|
if args.interactive:
|
||||||
|
return run_interactive(bridge)
|
||||||
|
|
||||||
|
if args.script:
|
||||||
|
with open(args.script) as fh:
|
||||||
|
for cmd, response in bridge.send_many(fh.readlines()):
|
||||||
|
print(f"{cmd:<28} {response}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
commands = list(args.command)
|
||||||
|
if args.ping:
|
||||||
|
commands.insert(0, "PING")
|
||||||
|
if not commands:
|
||||||
|
ap.error("kein Befehl angegeben — siehe --help")
|
||||||
|
|
||||||
|
failed = False
|
||||||
|
for cmd, response in bridge.send_many(commands):
|
||||||
|
print(f"{cmd:<28} {response}")
|
||||||
|
failed = failed or str(response).startswith("ERR:")
|
||||||
|
return 1 if failed else 0
|
||||||
|
|
||||||
|
except KeyboardInterrupt:
|
||||||
|
return 0
|
||||||
|
finally:
|
||||||
|
bridge.close()
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
@@ -0,0 +1 @@
|
|||||||
|
bleak>=0.21
|
||||||
@@ -0,0 +1,168 @@
|
|||||||
|
# Proxi — Hardware
|
||||||
|
|
||||||
|
Wie der Roboter wirklich verdrahtet ist, und woher diese Angaben stammen.
|
||||||
|
|
||||||
|
## Herkunft
|
||||||
|
|
||||||
|
Kosmos dokumentiert die Pin-Belegung nirgends: die Anleitung richtet sich an
|
||||||
|
Kinder, programmiert wird ausschließlich mit den fertigen Blöcken von
|
||||||
|
[kosmos.de/proxi](https://kosmos.de/proxi). Die Angaben hier sind also nicht
|
||||||
|
abgeschrieben, sondern rekonstruiert.
|
||||||
|
|
||||||
|
Möglich ist das, weil MakeCode jedes Projekt komprimiert an die kompilierte
|
||||||
|
Firmware anhängt. Die `.hex`-Dateien der Kosmos-Beispielprogramme (Download
|
||||||
|
über [kosmos.de/proxi](https://kosmos.de/proxi)) enthalten damit ihren eigenen
|
||||||
|
Quelltext. Herausholen lässt er sich mit dem Werkzeug in diesem Repo:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
python3 tools/hex_source.py 00_Funktionstest.hex -o ./quellen
|
||||||
|
```
|
||||||
|
|
||||||
|
Die interessante Datei darin ist `custom.ts`: die Kosmos-Extension mit allen
|
||||||
|
Hardware-Zugriffen. Sie liegt hier unverändert als
|
||||||
|
[`firmware/proxi.ts`](../firmware/proxi.ts) — wer wissen will,
|
||||||
|
wie sich eine Funktion in Grenzfällen verhält, liest am besten dort nach.
|
||||||
|
|
||||||
|
Sie ist eine eingedeutschte Fassung der MIT-lizenzierten Extension
|
||||||
|
[`kaku111/20190209`](https://github.com/kaku111/20190209) für den **Tobbie II**.
|
||||||
|
Proxi ist derselbe Roboter unter anderem Namen — Kosmos' eigenes Programm
|
||||||
|
`12_APP_Fernbedienung` hängt noch direkt an dieser Extension:
|
||||||
|
|
||||||
|
```json
|
||||||
|
"TobbieII": "github:kaku111/20190209#9c728847d1a08815275108ec42009211d57c2f0d"
|
||||||
|
```
|
||||||
|
|
||||||
|
Herkunft und Lizenzen im Detail: [LICENSES.md](LICENSES.md).
|
||||||
|
|
||||||
|
## Pin-Belegung
|
||||||
|
|
||||||
|
| Pin | Richtung | Funktion |
|
||||||
|
|---|---|---|
|
||||||
|
| **P13** | Ausgang | Laufmotor vorwärts |
|
||||||
|
| **P14** | Ausgang | Laufmotor rückwärts |
|
||||||
|
| **P15** | Ausgang | Drehmotor links (Oberkörper/Kopf) |
|
||||||
|
| **P16** | Ausgang | Drehmotor rechts |
|
||||||
|
| **P12** | Ausgang | IR-Sendediode (Messpuls) |
|
||||||
|
| **P1** | Analog-Eingang | IR-Empfänger links |
|
||||||
|
| **P2** | Analog-Eingang | IR-Empfänger rechts |
|
||||||
|
| **P8** | Digital-Eingang | Enable — wird vor jeder Bewegung geprüft |
|
||||||
|
| **P0** | Ausgang | Summer (Standard-Audiopin des micro:bit) |
|
||||||
|
|
||||||
|
### Motoren
|
||||||
|
|
||||||
|
Zwei Motoren, beide an einer H-Brücke mit **zwei digitalen Leitungen** —
|
||||||
|
eine je Drehrichtung:
|
||||||
|
|
||||||
|
```
|
||||||
|
P13=1, P14=0 -> vorwärts
|
||||||
|
P13=0, P14=1 -> rückwärts
|
||||||
|
P13=0, P14=0 -> aus
|
||||||
|
|
||||||
|
P15=1, P16=0 -> Drehung nach links
|
||||||
|
P15=0, P16=1 -> Drehung nach rechts
|
||||||
|
P15=0, P16=0 -> aus
|
||||||
|
```
|
||||||
|
|
||||||
|
**Es gibt keine Geschwindigkeitsregelung.** Kein PWM, kein Servo, keine
|
||||||
|
Zwischenstufen — ein Motor läuft oder er läuft nicht. Gesteuert wird
|
||||||
|
ausschließlich über die Dauer, deshalb hat kein Befehl im
|
||||||
|
[Protokoll](PROTOCOL.md) einen Speed-Parameter.
|
||||||
|
|
||||||
|
Der Laufmotor bewegt die Beine, der Drehmotor den Oberkörper. Laufen beide
|
||||||
|
gleichzeitig, geht Proxi eine Kurve.
|
||||||
|
|
||||||
|
### IR-Sensoren
|
||||||
|
|
||||||
|
Gemessen wird als Differenz, damit Umgebungslicht herausfällt:
|
||||||
|
|
||||||
|
1. Empfänger analog lesen (Grundhelligkeit)
|
||||||
|
2. Sendediode P12 einschalten
|
||||||
|
3. 250 µs warten
|
||||||
|
4. Empfänger erneut lesen
|
||||||
|
5. Sendediode aus — Messwert ist die Differenz beider Messungen
|
||||||
|
|
||||||
|
Hoher Wert = Hindernis nah. Am Gerät gemessen: freie Sicht 5-15, Hand in etwa
|
||||||
|
10 cm 200-600, Hand direkt davor bis ~980. Beide Seiten erreichen den vollen
|
||||||
|
Bereich. Die Schwellen 400-600 aus Kosmos' eigenen Programmen entsprechen damit
|
||||||
|
ungefähr einer Handbreit Abstand.
|
||||||
|
|
||||||
|
### Helligkeitssensor: durch die Scheibe blockiert
|
||||||
|
|
||||||
|
Den gibt es hier nicht, und zwar aus einem Grund, den keine Software behebt.
|
||||||
|
|
||||||
|
`input.lightLevel()` misst über die LED-Matrix — und die sitzt bei Proxi
|
||||||
|
hinter einer **getönten Scheibe**. Nimmt man die weg, misst der Sensor
|
||||||
|
einwandfrei. Eingebaut liefert er konstant 0, auch mit einer Taschenlampe
|
||||||
|
direkt davor.
|
||||||
|
|
||||||
|
Deshalb kennt das Protokoll kein `SENSOR:LIGHT`. Wer den Sensor braucht, muss
|
||||||
|
an der Mechanik ansetzen, nicht am Code.
|
||||||
|
|
||||||
|
Die 0 sah lange nach einem Softwarefehler aus: Kosmos' eigenes Programm
|
||||||
|
`04_Licht-Tracker` benutzt denselben Sensor erfolgreich (mit Schwellen von 1
|
||||||
|
bis 10 — die Werte sind klein). Widerlegt wurde die Softwarespur erst, als
|
||||||
|
jemand die Scheibe abgenommen hat.
|
||||||
|
|
||||||
|
### P8
|
||||||
|
|
||||||
|
`custom.ts` prüft `P8 == 1` vor jeder Motorbewegung, beim Abbremsen der Drehung
|
||||||
|
und bei der rechten IR-Auswertung. Was genau daran hängt, ist nicht
|
||||||
|
dokumentiert — plausibel ist der Batterieschalter beziehungsweise eine
|
||||||
|
Power-Good-Leitung, denn der micro:bit läuft auch dann weiter, wenn Proxis
|
||||||
|
Schalter auf OFF steht und nur USB-Strom anliegt.
|
||||||
|
|
||||||
|
Diese Firmware rät nicht daran herum: alle Motorzugriffe laufen über die
|
||||||
|
unveränderten Extension-Funktionen, und `SENSOR:PWR` gibt den Rohwert von P8
|
||||||
|
zurück. **Reagiert Proxi auf Fahrbefehle mit `OK`, bewegt sich aber nicht,
|
||||||
|
lohnt zuerst ein Blick auf `SENSOR:PWR`** — steht da `0`, ist der Schalter aus.
|
||||||
|
|
||||||
|
## micro:bit V1 oder V2
|
||||||
|
|
||||||
|
Die Firmware wird als **Universal Hex** gebaut und läuft auf beiden.
|
||||||
|
|
||||||
|
Knapp ist es beim V1 trotzdem: der Bluetooth-Stack frisst dort den Großteil des
|
||||||
|
Flash. Erste Fassungen dieser Firmware passten nicht hinein — Platz geschaffen
|
||||||
|
hat erst der Verzicht auf den eingebauten Melodie-Player von MakeCode (siehe
|
||||||
|
`playMelodyBuffer` in [`main.ts`](../firmware/main.ts), der Grund dafür
|
||||||
|
war allerdings ein anderer). Wer die Firmware erweitert, sollte die V1-Variante
|
||||||
|
im Blick behalten: `pxt build` bricht ab, sobald sie nicht mehr passt.
|
||||||
|
|
||||||
|
V2 erkennt man am goldenen Logo-Taster oben mittig und dem Mikrofon oben rechts.
|
||||||
|
|
||||||
|
## Ton: keine Kommazahlen
|
||||||
|
|
||||||
|
Die Frequenz für `music.playTone()` **muss** eine Ganzzahl sein.
|
||||||
|
|
||||||
|
Sie wurde hier anfangs mit `Math.pow()` gerechnet. Der Wert war korrekt — eine
|
||||||
|
Diagnoseabfrage lieferte für MIDI 79 sauber 784 —, kam als Kommazahl im
|
||||||
|
Tonausgang aber falsch an. Der micro:bit machte daraus eine unsinnige
|
||||||
|
Schwingungsdauer, krachte laut, blieb hängen und bediente den Funk nicht mehr;
|
||||||
|
nach ein paar Sekunden starb die BLE-Verbindung an `Connection Timeout (0x08)`.
|
||||||
|
|
||||||
|
Ein Fehler, drei Symptome, die wie drei verschiedene Probleme aussahen. Gefunden
|
||||||
|
wurde er durch den direkten Vergleich zweier Aufrufe, die sich nur in diesem
|
||||||
|
einen Punkt unterschieden:
|
||||||
|
|
||||||
|
```
|
||||||
|
gerechnete 784 Hz -> Krachen, hängt, Verbindung weg
|
||||||
|
übergebene 784 -> sauberer Ton
|
||||||
|
```
|
||||||
|
|
||||||
|
`midiToFreq()` in `main.ts` rechnet deshalb rein ganzzahlig über eine Tabelle.
|
||||||
|
`tools/check_melodies.py` prüft das bei jedem Build mit.
|
||||||
|
|
||||||
|
Zwei Dinge, die dabei **nicht** die Ursache waren, obwohl sie lange danach
|
||||||
|
aussahen: der eingebaute Melodie-Player von MakeCode und der interne
|
||||||
|
Lautsprecher des micro:bit V2. Beides wurde gegengeprüft und entlastet.
|
||||||
|
|
||||||
|
## Nicht vorhanden
|
||||||
|
|
||||||
|
Damit niemand erneut danach sucht — Proxi hat **keine** Touch-Sensoren, **keinen**
|
||||||
|
Servo und **keine** regelbaren Motoren. Früher lagen in diesem Repo
|
||||||
|
`Source/*.py`-Dateien, die genau das behaupteten. Sie waren KI-generiert und
|
||||||
|
frei erfunden; ihre Pin-Belegung (P0–P3 als PWM-Motoren, P4/P10 als IR, P6/P7 als
|
||||||
|
Touch, P8 als Servo) stimmt an keiner Stelle mit der Hardware überein. Sie sind
|
||||||
|
durch die echten, aus den `.hex`-Dateien extrahierten Quellen ersetzt.
|
||||||
|
|
||||||
|
Nebenbei: MicroPython auf dem micro:bit hat überhaupt kein Bluetooth. Wer BLE
|
||||||
|
will, muss über MakeCode gehen — daher TypeScript statt Python.
|
||||||
@@ -0,0 +1,78 @@
|
|||||||
|
# Lizenzen und Herkunft
|
||||||
|
|
||||||
|
## Eigener Code
|
||||||
|
|
||||||
|
**MIT**, Copyright (c) 2026 Christian Gärtner — siehe [`../LICENSE`](../LICENSE).
|
||||||
|
|
||||||
|
Betrifft alles in diesem Ordner außer den unten aufgeführten Teilen:
|
||||||
|
|
||||||
|
```
|
||||||
|
firmware/main.ts bridge/proxi_bridge.py tools/hex_source.py
|
||||||
|
firmware/build.sh bridge/*.txt tools/check_melodies.py
|
||||||
|
agent/proxi-control.md docs/
|
||||||
|
```
|
||||||
|
|
||||||
|
Damit steht das gesamte Projekt unter MIT — auch die beiden fremden
|
||||||
|
Bestandteile sind MIT-lizenziert, es gibt also keine Reibung zwischen den
|
||||||
|
Lizenzen. Die fremden Copyright-Vermerke müssen bei der Weitergabe erhalten
|
||||||
|
bleiben; sie stehen dafür in
|
||||||
|
[`../THIRD-PARTY-NOTICES`](../THIRD-PARTY-NOTICES).
|
||||||
|
|
||||||
|
## Fremder Code
|
||||||
|
|
||||||
|
### `firmware/proxi.ts` — Hardware-Extension
|
||||||
|
|
||||||
|
Die komplette Hardware-Anbindung (Motoren, IR-Sensoren) stammt nicht von uns.
|
||||||
|
|
||||||
|
| | |
|
||||||
|
|---|---|
|
||||||
|
| Ursprünglich | Extension **TobbieII** von [kaku111](https://github.com/kaku111/20190209) |
|
||||||
|
| Lizenz | MIT (`LICENSE.txt` im Repo, `"license": "MIT"` in dessen `pxt.json`) |
|
||||||
|
| Weg hierher | Kosmos liefert eine eingedeutschte Fassung als `custom.ts` in den `.hex`-Dateien der Beispielprogramme mit; von dort mit `tools/hex_source.py` extrahiert |
|
||||||
|
| Änderungen | keine — nur ein Herkunftshinweis als Kommentar im Kopf |
|
||||||
|
|
||||||
|
Proxi und Tobbie II sind derselbe Roboter unter verschiedenen Namen. Kosmos'
|
||||||
|
eigenes Programm `12_APP_Fernbedienung` hängt noch direkt an der
|
||||||
|
Original-Extension:
|
||||||
|
|
||||||
|
```json
|
||||||
|
"TobbieII": "github:kaku111/20190209#9c728847d1a08815275108ec42009211d57c2f0d"
|
||||||
|
```
|
||||||
|
|
||||||
|
Der MIT-Lizenztext des Originals liegt im Wortlaut in
|
||||||
|
[`../THIRD-PARTY-NOTICES`](../THIRD-PARTY-NOTICES).
|
||||||
|
|
||||||
|
### Notendaten in `firmware/main.ts`
|
||||||
|
|
||||||
|
Die Melodien in `melodyBuffer()` sind die 20 eingebauten Melodien von MakeCode,
|
||||||
|
Byte für Byte übernommen aus
|
||||||
|
[`pxt-microbit`](https://github.com/microsoft/pxt-microbit)
|
||||||
|
(`libs/core/melodies.ts`, MIT, Copyright Microsoft Corporation).
|
||||||
|
|
||||||
|
Warum kopiert statt benutzt: der eingebaute Melodie-Player spielt in einem
|
||||||
|
eigenen Fiber ab und stürzt ab, sobald ein anderer Fiber gleichzeitig den
|
||||||
|
Audio-Pin anfasst. Die Begründung steht ausführlich im Kopf des
|
||||||
|
Musik-Abschnitts von `main.ts`.
|
||||||
|
|
||||||
|
## Nicht mitveröffentlichen
|
||||||
|
|
||||||
|
Der Rest dieses Repos gehört Kosmos und ist **kein** Teil des
|
||||||
|
Proxi-AI-Projekts:
|
||||||
|
|
||||||
|
```
|
||||||
|
Kosmos-Programme/ Beispielprogramme (.hex und extrahierter Quelltext)
|
||||||
|
Proxi_Manual.pdf Bedienungsanleitung
|
||||||
|
logo.png proxi.png Produktbilder
|
||||||
|
```
|
||||||
|
|
||||||
|
Für ein öffentliches Repo wandert dieser Ordner am Stück mit — er ist in
|
||||||
|
sich geschlossen:
|
||||||
|
|
||||||
|
```
|
||||||
|
firmware/ bridge/ agent/ docs/ tools/
|
||||||
|
LICENSE THIRD-PARTY-NOTICES README.md
|
||||||
|
```
|
||||||
|
|
||||||
|
`docs/HARDWARE.md` ist so geschrieben, dass es auch ohne die übrigen
|
||||||
|
Kosmos-Programme verständlich bleibt, und `README.md` in diesem Ordner taugt
|
||||||
|
als Startseite des neuen Repos.
|
||||||
@@ -0,0 +1,226 @@
|
|||||||
|
# Proxi Command Protocol 1.0
|
||||||
|
|
||||||
|
Textbefehle über Bluetooth-LE-UART. Ein Befehl pro Zeile, eine Antwortzeile
|
||||||
|
zurück.
|
||||||
|
|
||||||
|
```
|
||||||
|
BEFEHL:PARAM:PARAM\n -> OK:...\n | ERR:...\n | <Wert>\n
|
||||||
|
```
|
||||||
|
|
||||||
|
* Befehlsname und Schlüsselwörter sind **nicht** groß-/kleinschreibungsabhängig
|
||||||
|
* Parameter trennt `:`
|
||||||
|
* Jede Zeile endet mit `\n`
|
||||||
|
* Fehlende Parameter fallen auf den Default zurück, unlesbare ebenso
|
||||||
|
* Es gibt **keinen Speed-Parameter** — die Motoren können nur an oder aus,
|
||||||
|
siehe [HARDWARE.md](HARDWARE.md)
|
||||||
|
|
||||||
|
## Dauer-Parameter
|
||||||
|
|
||||||
|
Alle Bewegungsbefehle nehmen als letzten Parameter eine Dauer in Millisekunden.
|
||||||
|
|
||||||
|
| Angabe | Wirkung |
|
||||||
|
|---|---|
|
||||||
|
| weggelassen | fährt los und stoppt nach **10 s** von selbst (Sicherheitsnetz) |
|
||||||
|
| `1..60000` | fährt genau so lange und stoppt |
|
||||||
|
| `0` | fährt weiter, bis ein Stopp-Befehl kommt |
|
||||||
|
|
||||||
|
Die Firmware blockiert während der Fahrt nicht: der Befehl wird sofort mit `OK`
|
||||||
|
quittiert, ein Watchdog schaltet die Motoren zur Deadline ab. `STOP` kommt
|
||||||
|
deshalb auch mitten in einer laufenden Bewegung durch.
|
||||||
|
|
||||||
|
## Bewegung
|
||||||
|
|
||||||
|
| Befehl | Wirkung |
|
||||||
|
|---|---|
|
||||||
|
| `MOVE:FWD[:ms]` | vorwärts laufen |
|
||||||
|
| `MOVE:BWD[:ms]` | rückwärts laufen |
|
||||||
|
| `MOVE:STOP` | Laufmotor aus |
|
||||||
|
| `TURN:LEFT[:ms]` | Oberkörper nach links drehen |
|
||||||
|
| `TURN:RIGHT[:ms]` | nach rechts drehen |
|
||||||
|
| `TURN:STOP` | Drehmotor aus |
|
||||||
|
| `STOP` | alles aus: beide Motoren, Ton, Display, laufende Jobs |
|
||||||
|
|
||||||
|
Lauf- und Drehmotor sind unabhängig. Beide gleichzeitig ergibt eine Kurve:
|
||||||
|
|
||||||
|
```
|
||||||
|
MOVE:FWD:0
|
||||||
|
TURN:LEFT:800
|
||||||
|
```
|
||||||
|
|
||||||
|
## Bewegungsfiguren
|
||||||
|
|
||||||
|
Laufen im Hintergrund und melden sich mit `DONE:<name>`, wenn sie fertig sind —
|
||||||
|
oder mit `DONE:<name>:aborted`, wenn `STOP` oder Taste A dazwischenkam.
|
||||||
|
|
||||||
|
| Befehl | Default | Wirkung |
|
||||||
|
|---|---|---|
|
||||||
|
| `DANCE[:n]` | 2 | n Takte tanzen (vor/zurück + links/rechts) |
|
||||||
|
| `STAMP[:n]` | 3 | n mal aufstampfen |
|
||||||
|
| `SHAKE[:n]` | 3 | n mal den Kopf schütteln |
|
||||||
|
|
||||||
|
`n` wird auf 1..20 begrenzt.
|
||||||
|
|
||||||
|
**Sie laufen nicht parallel zur Musik.** `DANCE`, `STAMP`, `SHAKE`, `TEXT`,
|
||||||
|
`TONE` und `MELODY` teilen sich einen Arbeiter und werden nacheinander
|
||||||
|
abgearbeitet — eine Figur startet also erst, wenn die Melodie durch ist.
|
||||||
|
`MOVE` und `TURN` laufen dagegen sofort und damit echt gleichzeitig zur Musik.
|
||||||
|
Für eine Choreografie zur Melodie deshalb `MOVE`/`TURN` verwenden; ein
|
||||||
|
Beispiel liegt in `bridge/nyan-dance.txt`.
|
||||||
|
|
||||||
|
## Display
|
||||||
|
|
||||||
|
| Befehl | Wirkung |
|
||||||
|
|---|---|
|
||||||
|
| `FACE:<name>` | Symbol anzeigen (bleibt stehen) |
|
||||||
|
| `FACE:RAW:z0:z1:z2:z3:z4` | eigenes 5×5-Bild, je Zeile eine Bitmaske 0–31 |
|
||||||
|
| `TEXT:<text>` | Text durchlaufen lassen, danach Display leer |
|
||||||
|
| `CLEAR` | Display löschen |
|
||||||
|
|
||||||
|
**Namen für `FACE`:**
|
||||||
|
`HAPPY` `SAD` `ANGRY` `CONFUSED` `ASLEEP` `SURPRISED` `SILLY` `FABULOUS` `MEH`
|
||||||
|
`YES` `NO` `HEART` `SMALLHEART` `SKULL` `GHOST` `DUCK` `HOUSE` `GIRAFFE` `COW`
|
||||||
|
`RABBIT` `SNAKE` `BUTTERFLY` `TORTOISE` `STICKFIGURE` `TARGET` `DIAMOND`
|
||||||
|
`SQUARE` `TRIANGLE` `UMBRELLA` `SWORD` `NORTH` `EAST` `SOUTH` `WEST`
|
||||||
|
|
||||||
|
Bei `FACE:RAW` ist in jeder Zeilen-Bitmaske Bit 0 die linke LED:
|
||||||
|
|
||||||
|
```
|
||||||
|
FACE:RAW:0:10:0:17:14 # zwei Augen, lächelnder Mund
|
||||||
|
```
|
||||||
|
|
||||||
|
`TEXT` darf `:` enthalten — alles ab dem ersten Parameter gilt als Text.
|
||||||
|
|
||||||
|
## Ton
|
||||||
|
|
||||||
|
| Befehl | Default | Wirkung |
|
||||||
|
|---|---|---|
|
||||||
|
| `TONE:<hz>[:ms]` | 440, 400 | einzelner Ton (50–5000 Hz, 10–5000 ms) |
|
||||||
|
| `MELODY:<name>` | — | eingebaute Melodie, spielt im Hintergrund |
|
||||||
|
|
||||||
|
**Namen für `MELODY`:**
|
||||||
|
`DADADUM` `ENTERTAINER` `PRELUDE` `ODE` `NYAN` `RINGTONE` `FUNK` `BLUES`
|
||||||
|
`BIRTHDAY` `WEDDING` `FUNERAL` `PUNCHLINE` `BADDY` `CHASE` `BADING` `WAWAWAWAA`
|
||||||
|
`JUMPUP` `JUMPDOWN` `POWERUP` `POWERDOWN`
|
||||||
|
|
||||||
|
**Laufzeiten** (für Choreografien):
|
||||||
|
|
||||||
|
| | |
|
||||||
|
|---|---|
|
||||||
|
| ~0,5–1 s | `BADING` `JUMPUP` `JUMPDOWN` `POWERUP` `POWERDOWN` |
|
||||||
|
| ~2,5–3,5 s | `WAWAWAWAA` `PUNCHLINE` `RINGTONE` `BADDY` `ENTERTAINER` `FUNERAL` |
|
||||||
|
| ~4 s | `DADADUM` `FUNK` |
|
||||||
|
| ~8 s | `CHASE` `WEDDING` `PRELUDE` |
|
||||||
|
| ~12 s | `BIRTHDAY` `BLUES` |
|
||||||
|
| ~16 s | `ODE` `NYAN` |
|
||||||
|
|
||||||
|
Mehrere `MELODY` hintereinander reihen sich in der Warteschlange und spielen
|
||||||
|
nahtlos nacheinander.
|
||||||
|
|
||||||
|
## Sensoren
|
||||||
|
|
||||||
|
| Befehl | Antwort |
|
||||||
|
|---|---|
|
||||||
|
| `SENSOR:ALL` | `SENSOR:ALL:IR_L=..,IR_R=..,TEMP=..,PWR=..` |
|
||||||
|
| `SENSOR:IR_L` | `SENSOR:IR_L:<0..1023>` — höher = Hindernis näher |
|
||||||
|
| `SENSOR:IR_R` | `SENSOR:IR_R:<0..1023>` |
|
||||||
|
| `SENSOR:TEMP` | `SENSOR:TEMP:<°C>` (Prozessortemperatur, träge) |
|
||||||
|
| `SENSOR:PWR` | `SENSOR:PWR:<0\|1>` — Zustand von P8, siehe HARDWARE.md |
|
||||||
|
|
||||||
|
Ohne Parameter verhält sich `SENSOR` wie `SENSOR:ALL`.
|
||||||
|
|
||||||
|
**IR-Werte, am Gerät gemessen:**
|
||||||
|
|
||||||
|
| Situation | Wert |
|
||||||
|
|---|---|
|
||||||
|
| freie Sicht | 5–15 |
|
||||||
|
| Hand in ~20 cm | 30–90 |
|
||||||
|
| Hand in ~10 cm | 200–600 |
|
||||||
|
| Hand direkt davor | bis ~980 |
|
||||||
|
|
||||||
|
Als Hindernis-Schwelle taugen die 400–600, die auch Kosmos' eigene Programme
|
||||||
|
verwenden — das entspricht etwa einer Handbreit Abstand. Beide Sensoren
|
||||||
|
erreichen den vollen Bereich; ein dauerhaft niedriger Wert auf einer Seite ist
|
||||||
|
also ein Defekt und keine Eigenart.
|
||||||
|
|
||||||
|
## System
|
||||||
|
|
||||||
|
`<build>` ist eine siebenstellige Kennung des Quellstands, die `build.sh` aus
|
||||||
|
main.ts, proxi.ts und pxt.json errechnet. Geflasht wird von Hand — daran sieht
|
||||||
|
man, welcher Stand tatsächlich auf dem Roboter liegt. Gleicher Code ergibt
|
||||||
|
immer dieselbe Kennung.
|
||||||
|
|
||||||
|
| Befehl | Antwort |
|
||||||
|
|---|---|
|
||||||
|
| `PING` | `PONG` |
|
||||||
|
| `STATUS` | `STATUS:proxi-ai/1.0+<build>:PWR=<0\|1>` |
|
||||||
|
|
||||||
|
## `WAIT:<ms>` — Pause in der Brücke
|
||||||
|
|
||||||
|
`WAIT` ist **kein Roboter-Befehl**. Die Firmware kennt ihn nicht;
|
||||||
|
`proxi_bridge.py` fängt ihn ab und legt die angegebene Pause ein, bevor der
|
||||||
|
nächste Befehl rausgeht (maximal 60000 ms).
|
||||||
|
|
||||||
|
Er wird gebraucht, weil Bewegungsbefehle sofort mit `OK` quittieren und dann im
|
||||||
|
Hintergrund weiterlaufen. Ohne Pause dazwischen überschreibt der nächste
|
||||||
|
Befehl die noch laufende Bewegung — Proxi zuckt nur kurz:
|
||||||
|
|
||||||
|
```
|
||||||
|
MOVE:FWD:1200 # läuft 1,2 s ...
|
||||||
|
WAIT:1400 # ... so lange warten
|
||||||
|
TURN:LEFT:700
|
||||||
|
WAIT:900
|
||||||
|
STOP
|
||||||
|
```
|
||||||
|
|
||||||
|
Faustregel: `WAIT` etwas größer wählen als die Dauer davor.
|
||||||
|
|
||||||
|
## Unaufgeforderte Meldungen
|
||||||
|
|
||||||
|
Diese Zeilen kommen ohne passenden Befehl und sind keine Antwort:
|
||||||
|
|
||||||
|
| Zeile | Bedeutung |
|
||||||
|
|---|---|
|
||||||
|
| `READY:proxi-ai/1.0+<build>` | BLE verbunden, Firmware bereit — kommt oft nicht an, weil der Client die Indications meist erst kurz nach dem Verbindungsaufbau aktiviert. Verlass dich nicht darauf, nimm `PING` |
|
||||||
|
| `DONE:<job>` | `DANCE`/`STAMP`/`SHAKE`/`TEXT`/`TONE`/`MELODY` fertig |
|
||||||
|
| `DONE:<job>:aborted` | derselbe Job, aber vorzeitig gestoppt |
|
||||||
|
| `EVENT:ESTOP` | Taste A gedrückt — Not-Stopp |
|
||||||
|
|
||||||
|
`proxi_bridge.py` hält sie von den Befehlsantworten getrennt.
|
||||||
|
|
||||||
|
## Fehler
|
||||||
|
|
||||||
|
| Antwort | Bedeutung |
|
||||||
|
|---|---|
|
||||||
|
| `ERR:unknown:<CMD>` | Befehl gibt es nicht |
|
||||||
|
| `ERR:MOVE:bad_dir` | erwartet `FWD`, `BWD` oder `STOP` |
|
||||||
|
| `ERR:TURN:bad_dir` | erwartet `LEFT`, `RIGHT` oder `STOP` |
|
||||||
|
| `ERR:FACE:unknown` | Symbolname unbekannt |
|
||||||
|
| `ERR:MELODY:unknown` | Melodiename unbekannt |
|
||||||
|
| `ERR:SENSOR:bad_type` | Sensorname unbekannt |
|
||||||
|
| `ERR:TEXT:empty` | kein Text angegeben |
|
||||||
|
| `ERR:<CMD>:busy` | Warteschlange voll (8 Aufträge). Betrifft `TEXT`, `TONE`, `MELODY`, `DANCE`, `STAMP`, `SHAKE` — mit `WAIT` entzerren |
|
||||||
|
|
||||||
|
## Tasten am Roboter
|
||||||
|
|
||||||
|
Funktionieren auch ohne Verbindung.
|
||||||
|
|
||||||
|
| Taste | Wirkung |
|
||||||
|
|---|---|
|
||||||
|
| **A** | Not-Stopp — alles aus, sendet `EVENT:ESTOP` |
|
||||||
|
| **B** | Status senden |
|
||||||
|
|
||||||
|
Bricht die BLE-Verbindung ab, stoppen die Motoren sofort von selbst.
|
||||||
|
|
||||||
|
## Beispiel
|
||||||
|
|
||||||
|
```
|
||||||
|
PING -> PONG
|
||||||
|
FACE:HAPPY -> OK:FACE:HAPPY
|
||||||
|
MOVE:FWD:1500 -> OK:MOVE:FWD:1500
|
||||||
|
SENSOR:IR_L -> SENSOR:IR_L:612
|
||||||
|
TURN:RIGHT:700 -> OK:TURN:RIGHT:700
|
||||||
|
MELODY:POWERUP -> OK:MELODY:POWERUP
|
||||||
|
DANCE:3 -> OK:DANCE:3
|
||||||
|
-> DONE:DANCE (später, unaufgefordert)
|
||||||
|
STOP -> OK:STOP
|
||||||
|
```
|
||||||
+185
@@ -0,0 +1,185 @@
|
|||||||
|
# Einrichtung
|
||||||
|
|
||||||
|
Zwei Schritte: Firmware auf den micro:bit, Brücke auf irgendeinen Rechner mit
|
||||||
|
Bluetooth.
|
||||||
|
|
||||||
|
```
|
||||||
|
KI / LLM --HTTP--> proxi_bridge.py --BLE--> micro:bit im Proxi
|
||||||
|
(Pi Zero W, Laptop, ...)
|
||||||
|
```
|
||||||
|
|
||||||
|
## 1. Firmware flashen
|
||||||
|
|
||||||
|
Läuft auf micro:bit **V1 und V2** — die `.hex` ist ein Universal Hex und
|
||||||
|
enthält beides.
|
||||||
|
|
||||||
|
1. micro:bit per USB anschließen — er meldet sich als Laufwerk `MICROBIT`
|
||||||
|
2. [`firmware/proxi-ai.hex`](../firmware/proxi-ai.hex) darauf kopieren
|
||||||
|
3. Die gelbe LED blinkt, das Laufwerk verschwindet und kommt zurück — fertig
|
||||||
|
|
||||||
|
Danach zeigt Proxi ein schlafendes Gesicht: Firmware läuft, wartet auf
|
||||||
|
Bluetooth.
|
||||||
|
|
||||||
|
Ein Nachflashen ist nie nötig. Alles Weitere passiert über Befehle.
|
||||||
|
|
||||||
|
### Selbst bauen
|
||||||
|
|
||||||
|
Nur nötig, wenn du am Code etwas änderst.
|
||||||
|
|
||||||
|
```bash
|
||||||
|
cd firmware/proxi-ai
|
||||||
|
npm install pxt
|
||||||
|
./node_modules/.bin/pxt target microbit
|
||||||
|
./node_modules/.bin/pxt install
|
||||||
|
./build.sh # -> proxi-ai.hex
|
||||||
|
```
|
||||||
|
|
||||||
|
Der C++-Teil wird vom MakeCode-Build-Service kompiliert, dafür braucht der
|
||||||
|
erste Build Internet. `build.sh` prüft am Ende, ob die erzeugte `.hex`
|
||||||
|
tatsächlich den aktuellen `main.ts` enthält.
|
||||||
|
|
||||||
|
Auf dem V1 ist der Flash mit Bluetooth-Stack fast voll. Kommt beim Erweitern
|
||||||
|
`program too big by ... bytes`, betrifft das die V1-Variante.
|
||||||
|
|
||||||
|
Alternativ im Browser: [makecode.microbit.org](https://makecode.microbit.org)
|
||||||
|
öffnen, neues Projekt, in der JavaScript-Ansicht `main.ts` einfügen, über den
|
||||||
|
Explorer eine Datei `proxi.ts` anlegen und deren Inhalt einfügen. Die
|
||||||
|
Bluetooth-Extension muss hinzugefügt und in den Projekteinstellungen
|
||||||
|
`bluetooth.open` auf `1` gesetzt werden — sonst verlangt der micro:bit Pairing
|
||||||
|
und die Brücke kommt nicht rein.
|
||||||
|
|
||||||
|
## 2. Brücke einrichten
|
||||||
|
|
||||||
|
Läuft auf allem mit Linux und Bluetooth. Ein Pi Zero W reicht.
|
||||||
|
|
||||||
|
```bash
|
||||||
|
pip3 install bleak
|
||||||
|
cd bridge
|
||||||
|
python3 proxi_bridge.py --scan
|
||||||
|
```
|
||||||
|
|
||||||
|
Ausgabe etwa:
|
||||||
|
|
||||||
|
```
|
||||||
|
C4:1F:2B:AA:BB:CC BBC micro:bit [tuvig]
|
||||||
|
```
|
||||||
|
|
||||||
|
Testen:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
python3 proxi_bridge.py --ping
|
||||||
|
python3 proxi_bridge.py "FACE:HEART" "MOVE:FWD:1000" "DANCE:2"
|
||||||
|
python3 proxi_bridge.py --script demo.txt
|
||||||
|
python3 proxi_bridge.py -i # interaktiv
|
||||||
|
```
|
||||||
|
|
||||||
|
Die Adresse lässt sich festnageln, das spart den Suchlauf:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
export PROXI_ADDRESS=C4:1F:2B:AA:BB:CC
|
||||||
|
```
|
||||||
|
|
||||||
|
## 3. HTTP-API für die KI
|
||||||
|
|
||||||
|
```bash
|
||||||
|
python3 proxi_bridge.py --serve 8080
|
||||||
|
```
|
||||||
|
|
||||||
|
| Route | Zweck |
|
||||||
|
|---|---|
|
||||||
|
| `POST /command` | `{"command": "MOVE:FWD:1000"}` |
|
||||||
|
| `POST /commands` | `{"commands": ["FACE:HAPPY", "DANCE:2"]}` |
|
||||||
|
| `GET /status` | Verbindungszustand und die letzten Meldungen vom Roboter |
|
||||||
|
|
||||||
|
```bash
|
||||||
|
curl -X POST localhost:8080/command \
|
||||||
|
-H 'Content-Type: application/json' \
|
||||||
|
-d '{"command":"DANCE:3"}'
|
||||||
|
```
|
||||||
|
|
||||||
|
```json
|
||||||
|
{"command": "DANCE:3", "response": "OK:DANCE:3", "ok": true}
|
||||||
|
```
|
||||||
|
|
||||||
|
> ### ⚠️ Nur im eigenen Netz betreiben
|
||||||
|
>
|
||||||
|
> Die API hat **keine Authentifizierung**. Wer sie erreicht, fährt den Roboter —
|
||||||
|
> ohne Passwort, ohne Rückfrage.
|
||||||
|
>
|
||||||
|
> Im heimischen WLAN ist das unproblematisch und bewusst so gehalten: es soll
|
||||||
|
> ohne Hürden funktionieren. **Aber gib den Port nicht nach außen frei** und
|
||||||
|
> richte keine Portweiterleitung darauf ein. Sonst lässt sich ein Roboter, der
|
||||||
|
> im Kinderzimmer herumfährt, von jedem beliebigen Fremden steuern.
|
||||||
|
>
|
||||||
|
> Soll er über das Heimnetz hinaus erreichbar sein, gehört ein VPN davor —
|
||||||
|
> nicht eine Portfreigabe.
|
||||||
|
|
||||||
|
Im `--serve`-Modus startet der HTTP-Server **sofort** und sucht den Roboter
|
||||||
|
danach im Hintergrund, alle 10 Sekunden. Die API ist damit auch erreichbar,
|
||||||
|
wenn Proxi gerade aus ist — `GET /status` meldet dann `"connected": false`,
|
||||||
|
Befehle antworten mit `ERR:not_connected`. Sobald Proxi eingeschaltet wird,
|
||||||
|
verbindet sich die Brücke von selbst; niemand muss sich einloggen.
|
||||||
|
|
||||||
|
Das ist der Unterschied zu den interaktiven Modi: die brechen sofort ab, wenn
|
||||||
|
der Roboter nicht da ist, weil man dort auf eine Antwort wartet.
|
||||||
|
|
||||||
|
Als Autostart auf einem Pi:
|
||||||
|
|
||||||
|
```ini
|
||||||
|
# /etc/systemd/system/proxi-bridge.service
|
||||||
|
[Unit]
|
||||||
|
Description=Proxi BLE Bridge
|
||||||
|
After=bluetooth.target
|
||||||
|
|
||||||
|
[Service]
|
||||||
|
ExecStart=/usr/bin/python3 /home/pi/proxi/proxi_bridge.py --serve 8080
|
||||||
|
Environment=PROXI_ADDRESS=C4:1F:2B:AA:BB:CC
|
||||||
|
Restart=always
|
||||||
|
RestartSec=5
|
||||||
|
User=pi
|
||||||
|
|
||||||
|
[Install]
|
||||||
|
WantedBy=multi-user.target
|
||||||
|
```
|
||||||
|
|
||||||
|
## 4. KI anbinden
|
||||||
|
|
||||||
|
[`agent/proxi-control.md`](../agent/proxi-control.md) ist ein fertiger
|
||||||
|
Agent-Skill: er enthält das Protokoll und die Regeln, nach denen aus
|
||||||
|
"lass ihn tanzen" eine Befehlsfolge wird.
|
||||||
|
|
||||||
|
Der Skill enthält **keine feste Adresse** — er erwartet sie in der
|
||||||
|
Umgebungsvariablen `PROXI_URL`. Die muss in der Umgebung des Agenten gesetzt
|
||||||
|
sein:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
export PROXI_URL=http://<hostname-des-pi>.local:8080
|
||||||
|
# oder, falls der Name nicht auflöst:
|
||||||
|
export PROXI_URL=http://<ip-des-pi>:8080
|
||||||
|
```
|
||||||
|
|
||||||
|
Absichtlich so: die Adresse hängt vom eigenen Netz ab und hat in einer Datei,
|
||||||
|
die weitergegeben wird, nichts verloren.
|
||||||
|
|
||||||
|
**mDNS-Namen (`*.local`) funktionieren nur im selben Netz.** Sitzt der Agent in
|
||||||
|
einem anderen VLAN als der Pi, nimm die IP-Adresse — oder aktiviere im Router
|
||||||
|
die mDNS-Weiterleitung.
|
||||||
|
|
||||||
|
Der Agent braucht **nur HTTP-Zugriff**, weder das Repo noch Python. Er soll
|
||||||
|
`proxi_bridge.py` ausdrücklich nicht selbst starten: Bluetooth LE erlaubt nur
|
||||||
|
eine Verbindung zum Roboter, und die hält der Dienst.
|
||||||
|
|
||||||
|
## Wenn etwas klemmt
|
||||||
|
|
||||||
|
| Symptom | Ursache |
|
||||||
|
|---|---|
|
||||||
|
| `--scan` findet nichts | Proxi aus, oder schon mit einem anderen Gerät verbunden — BLE erlaubt nur eine Verbindung |
|
||||||
|
| Verbindung bricht sofort ab | Firmware ohne `bluetooth.open=1` gebaut, der micro:bit verlangt dann Pairing |
|
||||||
|
| Befehle kommen mit `OK` zurück, Proxi bewegt sich nicht | `SENSOR:PWR` prüfen. `0` heißt: Enable-Leitung P8 ist low, meist der Batterieschalter |
|
||||||
|
| Antworten bleiben aus, Befehle wirken | Auf dem falschen Characteristic gelauscht. Host schreibt auf `…0003`, der micro:bit meldet sich auf `…0002` |
|
||||||
|
| Lange `TEXT:`-Zeilen abgeschnitten | BLE-Attribute sind 20 Byte, längere Zeilen müssen gestückelt werden — `proxi_bridge.py` macht das |
|
||||||
|
| Dienst startet immer wieder neu, Port nie offen | Alte Fassung: die Brücke verband sich zuerst und startete den Server danach. Ab Werk behoben — im `--serve`-Modus kommt der Server zuerst |
|
||||||
|
| Pi nach dem Abziehen des Kabels nicht mehr da | Er hat per WLAN eine **andere** Adresse als per Kabel. `avahi-daemon` installieren, dann geht `<hostname>.local`. mDNS bleibt aber im eigenen Netz — über VLAN-Grenzen hinweg braucht es einen mDNS-Repeater im Router |
|
||||||
|
| Display bleibt schwarz | Firmware ohne Bluetooth-Extension gebaut, `bluetooth.startUartService()` stirbt dann still beim Start |
|
||||||
|
| Ton kracht, Proxi hängt, Verbindung weg | Eine Frequenz kam als Kommazahl in `music.playTone()`. Siehe HARDWARE.md, "Ton: keine Kommazahlen" |
|
||||||
|
| Ein behobener Fehler tritt wieder auf | Vermutlich läuft noch die alte Firmware. `STATUS` schicken und die Build-Kennung dahinter mit der Ausgabe von `build.sh` vergleichen |
|
||||||
Binary file not shown.
|
After Width: | Height: | Size: 134 KiB |
@@ -0,0 +1,5 @@
|
|||||||
|
node_modules/
|
||||||
|
pxt_modules/
|
||||||
|
built/
|
||||||
|
package.json.npm
|
||||||
|
package-lock.json
|
||||||
Executable
+53
@@ -0,0 +1,53 @@
|
|||||||
|
#!/usr/bin/env bash
|
||||||
|
# Baut die Proxi-AI-Firmware zu einer flashbaren .hex.
|
||||||
|
#
|
||||||
|
# ./build.sh -> proxi-ai.hex
|
||||||
|
#
|
||||||
|
# Das Ergebnis ist ein "Universal Hex": es enthaelt den Code für micro:bit V1
|
||||||
|
# und V2 und läuft auf beiden.
|
||||||
|
#
|
||||||
|
# Erstmalige Einrichtung (einmalig, braucht Internet — der C++-Teil wird vom
|
||||||
|
# MakeCode-Build-Service kompiliert):
|
||||||
|
# npm install pxt
|
||||||
|
# ./node_modules/.bin/pxt target microbit
|
||||||
|
# ./node_modules/.bin/pxt install
|
||||||
|
|
||||||
|
set -euo pipefail
|
||||||
|
cd "$(dirname "$0")"
|
||||||
|
|
||||||
|
OUT="built/binary.hex"
|
||||||
|
|
||||||
|
if [[ ! -d node_modules/pxt-microbit ]]; then
|
||||||
|
echo "pxt-microbit fehlt. Erst einrichten:" >&2
|
||||||
|
echo " npm install pxt && ./node_modules/.bin/pxt target microbit && ./node_modules/.bin/pxt install" >&2
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
|
|
||||||
|
# Build-Kennung aus dem Quellstand erzeugen. Geflasht wird von Hand — ohne
|
||||||
|
# diese Kennung sieht man dem Roboter nicht an, welcher Stand auf ihm liegt.
|
||||||
|
# Der Hash läuft nur über die Quellen, version.ts selbst zählt nicht mit;
|
||||||
|
# gleicher Code ergibt also immer dieselbe Kennung.
|
||||||
|
BUILD_ID=$(cat main.ts proxi.ts pxt.json | sha256sum | cut -c1-7)
|
||||||
|
cat > version.ts <<EOF
|
||||||
|
// Erzeugt von build.sh — nicht von Hand ändern.
|
||||||
|
const FW_BUILD = "$BUILD_ID"
|
||||||
|
EOF
|
||||||
|
echo "Build-Kennung: $BUILD_ID"
|
||||||
|
|
||||||
|
# Musik-Tabellen prüfen, bevor überhaupt gebaut wird. Der Fehler, der das
|
||||||
|
# hier nötig gemacht hat, war am Schreibtisch unsichtbar und nur am Gerät zu
|
||||||
|
# sehen — dieser Test fängt ihn vorher ab.
|
||||||
|
python3 ../tools/check_melodies.py
|
||||||
|
|
||||||
|
rm -f "$OUT"
|
||||||
|
./node_modules/.bin/pxt build
|
||||||
|
|
||||||
|
cp "$OUT" proxi-ai.hex
|
||||||
|
|
||||||
|
# Gegenprobe: die eingebetteten Quellen aus der .hex zurückholen und vergleichen.
|
||||||
|
python3 ../tools/hex_source.py --check proxi-ai.hex main.ts
|
||||||
|
python3 ../tools/hex_source.py --check proxi-ai.hex proxi.ts
|
||||||
|
|
||||||
|
echo
|
||||||
|
echo "Fertig: $(pwd)/proxi-ai.hex"
|
||||||
|
echo "Auf das MICROBIT-Laufwerk kopieren — fertig."
|
||||||
@@ -0,0 +1,718 @@
|
|||||||
|
/**
|
||||||
|
* Proxi AI — BLE UART Command Interface
|
||||||
|
* =====================================
|
||||||
|
*
|
||||||
|
* Firmware für den micro:bit im KOSMOS-Proxi-Roboter (baugleich Tobbie II).
|
||||||
|
* Nimmt Textbefehle über Bluetooth-LE-UART entgegen und antwortet auf demselben Weg.
|
||||||
|
*
|
||||||
|
* Protokoll: CMD:PARAM:PARAM\n -> OK:...\n | ERR:...\n
|
||||||
|
* Vollständige Referenz: docs/PROTOCOL.md
|
||||||
|
*
|
||||||
|
* Wichtig: Die Motoren sind reine An/Aus-H-Brücken — es gibt KEINE
|
||||||
|
* Geschwindigkeitsregelung. Gesteuert wird ausschließlich über die Dauer.
|
||||||
|
* Die Hardware-Zugriffe laufen komplett über die Kosmos-Extension in proxi.ts.
|
||||||
|
*/
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// KONFIGURATION
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
/** Obergrenze für eine Bewegung ohne explizite Dauer (ms). Sicherheitsnetz. */
|
||||||
|
const SAFETY_MS = 10000
|
||||||
|
|
||||||
|
/** Obergrenze für jede einzelne Bewegung (ms). */
|
||||||
|
const MAX_MOVE_MS = 60000
|
||||||
|
|
||||||
|
const FW_VERSION = "proxi-ai/1.0"
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Kurzkennung des Quellstands, erzeugt von build.sh in version.ts.
|
||||||
|
* Geflasht wird von Hand — ohne die Kennung lässt sich nicht feststellen,
|
||||||
|
* welcher Stand gerade auf dem Roboter liegt, und man testet gegen die
|
||||||
|
* falsche Firmware. STATUS gibt sie deshalb mit zurück.
|
||||||
|
*/
|
||||||
|
function fwId(): string {
|
||||||
|
return FW_VERSION + "+" + FW_BUILD
|
||||||
|
}
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// ZUSTAND
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
let connected = false
|
||||||
|
|
||||||
|
/** control.millis(), zu dem der Laufmotor abgeschaltet wird. 0 = kein Timer. */
|
||||||
|
let walkUntil = 0
|
||||||
|
/** control.millis(), zu dem der Drehmotor abgeschaltet wird. 0 = kein Timer. */
|
||||||
|
let turnUntil = 0
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Warteschlange für den Aux-Fiber (alles was länger blockiert).
|
||||||
|
* Ein einzelner Slot reichte nicht: während ein langer Job lief, hat der
|
||||||
|
* nächste den übernächsten überschrieben — quittiert war er da aber
|
||||||
|
* längst mit OK. Lieber eine kurze Schlange und ein ehrliches "busy".
|
||||||
|
*/
|
||||||
|
const AUX_QUEUE_MAX = 8
|
||||||
|
let auxKinds: string[] = []
|
||||||
|
let auxTexts: string[] = []
|
||||||
|
let auxNums: number[] = []
|
||||||
|
let auxNums2: number[] = []
|
||||||
|
/** Bricht einen laufenden Job ab. Setzt stopAll(). */
|
||||||
|
let auxAbort = false
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Sicherung gegen einen hängenden Lautsprecher.
|
||||||
|
* Reißt die Verbindung mitten in einem Ton ab, kommt der Aux-Fiber unter
|
||||||
|
* Umständen nicht mehr dazu, ihn abzuschalten — dann tönt der Pin weiter,
|
||||||
|
* bis jemand den Roboter ausmacht. Vor jedem Ton wird deshalb notiert, wann
|
||||||
|
* er spätestens vorbei sein muss; der Watchdog-Fiber legt ihn danach still.
|
||||||
|
* 0 = gerade kein Ton erwartet.
|
||||||
|
*/
|
||||||
|
let audioUntil = 0
|
||||||
|
|
||||||
|
/** Ton anmelden. ms = erwartete Dauer. */
|
||||||
|
function audioBegin(ms: number): void {
|
||||||
|
audioUntil = control.millis() + ms + 300
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Lautsprecher stilllegen.
|
||||||
|
*
|
||||||
|
* Bewusst NICHT music.stopAllSounds(): das ruft intern stopMelody() auf und
|
||||||
|
* zieht damit den kompletten Melodie-Player wieder mit ins Programm — also
|
||||||
|
* genau die rund 3 KB, wegen derer die Firmware nicht mehr auf den micro:bit
|
||||||
|
* V1 passt. playTone mit Frequenz 0 legt den Pin genauso still.
|
||||||
|
*/
|
||||||
|
function audioSilence(): void {
|
||||||
|
music.playTone(0, 1)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Ton abmelden — der Aux-Fiber hat regulär zu Ende gespielt. */
|
||||||
|
function audioEnd(): void {
|
||||||
|
audioUntil = 0
|
||||||
|
audioSilence()
|
||||||
|
}
|
||||||
|
|
||||||
|
/** false = Schlange voll. */
|
||||||
|
function queueAux(kind: string, text: string, n1: number, n2: number): boolean {
|
||||||
|
if (auxKinds.length >= AUX_QUEUE_MAX) return false
|
||||||
|
auxKinds.push(kind)
|
||||||
|
auxTexts.push(text)
|
||||||
|
auxNums.push(n1)
|
||||||
|
auxNums2.push(n2)
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
function clearAuxQueue(): void {
|
||||||
|
auxKinds = []
|
||||||
|
auxTexts = []
|
||||||
|
auxNums = []
|
||||||
|
auxNums2 = []
|
||||||
|
}
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// STRING-HILFEN
|
||||||
|
// (MakeCode kennt weder split(), noch toUpperCase(), noch trim())
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
function trimLine(s: string): string {
|
||||||
|
let a = 0
|
||||||
|
let b = s.length
|
||||||
|
while (a < b) {
|
||||||
|
const c = s.charAt(a)
|
||||||
|
if (c == " " || c == "\t" || c == "\r" || c == "\n") a++
|
||||||
|
else break
|
||||||
|
}
|
||||||
|
while (b > a) {
|
||||||
|
const c = s.charAt(b - 1)
|
||||||
|
if (c == " " || c == "\t" || c == "\r" || c == "\n") b--
|
||||||
|
else break
|
||||||
|
}
|
||||||
|
return s.substr(a, b - a)
|
||||||
|
}
|
||||||
|
|
||||||
|
function upper(s: string): string {
|
||||||
|
let out = ""
|
||||||
|
for (let i = 0; i < s.length; i++) {
|
||||||
|
let c = s.charCodeAt(i)
|
||||||
|
if (c >= 97 && c <= 122) c = c - 32
|
||||||
|
out = out + String.fromCharCode(c)
|
||||||
|
}
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
function splitColon(s: string): string[] {
|
||||||
|
const out: string[] = []
|
||||||
|
let cur = ""
|
||||||
|
for (let i = 0; i < s.length; i++) {
|
||||||
|
const c = s.charAt(i)
|
||||||
|
if (c == ":") {
|
||||||
|
out.push(cur)
|
||||||
|
cur = ""
|
||||||
|
} else {
|
||||||
|
cur = cur + c
|
||||||
|
}
|
||||||
|
}
|
||||||
|
out.push(cur)
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
function arg(p: string[], i: number): string {
|
||||||
|
return i < p.length ? p[i] : ""
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Parameter als Zahl, mit Default bei fehlend/unlesbar. */
|
||||||
|
function argNum(p: string[], i: number, dflt: number): number {
|
||||||
|
const s = arg(p, i)
|
||||||
|
if (s == "") return dflt
|
||||||
|
const v = parseInt(s)
|
||||||
|
// NaN-Test ohne isNaN(): NaN ist der einzige Wert, der sich selbst ungleich ist.
|
||||||
|
if (v != v) return dflt
|
||||||
|
return v
|
||||||
|
}
|
||||||
|
|
||||||
|
function clamp(v: number, lo: number, hi: number): number {
|
||||||
|
if (v < lo) return lo
|
||||||
|
if (v > hi) return hi
|
||||||
|
return v
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Alles ab Index i wieder mit ":" zusammensetzen — für Freitext. */
|
||||||
|
function joinFrom(p: string[], i: number): string {
|
||||||
|
let out = ""
|
||||||
|
for (let k = i; k < p.length; k++) {
|
||||||
|
if (k > i) out = out + ":"
|
||||||
|
out = out + p[k]
|
||||||
|
}
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// ANTWORTEN
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
function reply(line: string): void {
|
||||||
|
if (connected) bluetooth.uartWriteLine(line)
|
||||||
|
}
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// BEWEGUNG
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Dauer eines Bewegungsbefehls auflösen.
|
||||||
|
* fehlt / leer -> SAFETY_MS (Sicherheitsnetz)
|
||||||
|
* 0 -> 0 = dauerhaft, bis STOP (bewusste Entscheidung des Aufrufers)
|
||||||
|
*/
|
||||||
|
function moveDuration(p: string[], i: number): number {
|
||||||
|
const s = arg(p, i)
|
||||||
|
if (s == "") return SAFETY_MS
|
||||||
|
const v = argNum(p, i, SAFETY_MS)
|
||||||
|
if (v == 0) return 0
|
||||||
|
if (v < 0) return SAFETY_MS
|
||||||
|
return clamp(v, 1, MAX_MOVE_MS)
|
||||||
|
}
|
||||||
|
|
||||||
|
function stopWalk(): void {
|
||||||
|
walkUntil = 0
|
||||||
|
Proxi.stehenbleiben()
|
||||||
|
}
|
||||||
|
|
||||||
|
function stopTurn(): void {
|
||||||
|
turnUntil = 0
|
||||||
|
Proxi.drehungsstopp()
|
||||||
|
}
|
||||||
|
|
||||||
|
function stopAll(): void {
|
||||||
|
clearAuxQueue()
|
||||||
|
auxAbort = true
|
||||||
|
stopWalk()
|
||||||
|
stopTurn()
|
||||||
|
// Der Ton muss hier weg, auch wenn stopAll() aus einem fremden Fiber
|
||||||
|
// kommt: ohne das tönt der Lautsprecher nach einem Verbindungsabbruch
|
||||||
|
// einfach weiter. Die kurze Frist des Watchdogs fängt den Rest ab.
|
||||||
|
audioUntil = control.millis() + 50
|
||||||
|
}
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// BEWEGUNGSFIGUREN
|
||||||
|
//
|
||||||
|
// Die Extension bringt tanz()/stampfen()/kopf_schuetteln() schon mit, die
|
||||||
|
// laufen aber am Stück durch — ein STOP mittendrin käme erst danach an.
|
||||||
|
// Deshalb hier nachgebaut, Schritt für Schritt und mit Abbruchprüfung.
|
||||||
|
// Die Pins fasst weiterhin ausschließlich die Extension an.
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
/** Pause in kleinen Scheiben. false = abgebrochen. */
|
||||||
|
function figurePause(ms: number): boolean {
|
||||||
|
let left = ms
|
||||||
|
while (left > 0) {
|
||||||
|
if (auxAbort) return false
|
||||||
|
const slice = left > 50 ? 50 : left
|
||||||
|
basic.pause(slice)
|
||||||
|
left = left - slice
|
||||||
|
}
|
||||||
|
return !auxAbort
|
||||||
|
}
|
||||||
|
|
||||||
|
function doDance(times: number): void {
|
||||||
|
for (let i = 0; i < times; i++) {
|
||||||
|
Proxi.rückwärts()
|
||||||
|
Proxi.rechtsdrehung()
|
||||||
|
if (!figurePause(250)) break
|
||||||
|
Proxi.vorwärts()
|
||||||
|
Proxi.linksdrehung()
|
||||||
|
if (!figurePause(250)) break
|
||||||
|
}
|
||||||
|
Proxi.stehenbleiben()
|
||||||
|
Proxi.drehungsstopp()
|
||||||
|
}
|
||||||
|
|
||||||
|
function doStamp(times: number): void {
|
||||||
|
for (let i = 0; i < times; i++) {
|
||||||
|
Proxi.vorwärts()
|
||||||
|
if (!figurePause(150)) break
|
||||||
|
Proxi.rückwärts()
|
||||||
|
if (!figurePause(150)) break
|
||||||
|
}
|
||||||
|
Proxi.stehenbleiben()
|
||||||
|
}
|
||||||
|
|
||||||
|
function doShake(times: number): void {
|
||||||
|
for (let i = 0; i < times; i++) {
|
||||||
|
Proxi.linksdrehung()
|
||||||
|
if (!figurePause(250)) break
|
||||||
|
Proxi.rechtsdrehung()
|
||||||
|
if (!figurePause(250)) break
|
||||||
|
}
|
||||||
|
Proxi.drehungsstopp()
|
||||||
|
}
|
||||||
|
|
||||||
|
function cmdMove(p: string[]): string {
|
||||||
|
const dir = upper(arg(p, 1))
|
||||||
|
if (dir == "STOP") {
|
||||||
|
stopWalk()
|
||||||
|
return "OK:MOVE:STOP"
|
||||||
|
}
|
||||||
|
if (dir != "FWD" && dir != "BWD") return "ERR:MOVE:bad_dir"
|
||||||
|
|
||||||
|
const ms = moveDuration(p, 2)
|
||||||
|
if (dir == "FWD") Proxi.vorwärts()
|
||||||
|
else Proxi.rückwärts()
|
||||||
|
|
||||||
|
walkUntil = ms > 0 ? control.millis() + ms : 0
|
||||||
|
return "OK:MOVE:" + dir + ":" + ms
|
||||||
|
}
|
||||||
|
|
||||||
|
function cmdTurn(p: string[]): string {
|
||||||
|
const dir = upper(arg(p, 1))
|
||||||
|
if (dir == "STOP") {
|
||||||
|
stopTurn()
|
||||||
|
return "OK:TURN:STOP"
|
||||||
|
}
|
||||||
|
if (dir != "LEFT" && dir != "RIGHT") return "ERR:TURN:bad_dir"
|
||||||
|
|
||||||
|
const ms = moveDuration(p, 2)
|
||||||
|
if (dir == "LEFT") Proxi.linksdrehung()
|
||||||
|
else Proxi.rechtsdrehung()
|
||||||
|
|
||||||
|
turnUntil = ms > 0 ? control.millis() + ms : 0
|
||||||
|
return "OK:TURN:" + dir + ":" + ms
|
||||||
|
}
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// DISPLAY
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
/** Icon anzeigen, ohne zu blockieren (Intervall 0 = sofort zurück). */
|
||||||
|
function showIconNow(icon: IconNames): void {
|
||||||
|
basic.showIcon(icon, 0)
|
||||||
|
}
|
||||||
|
|
||||||
|
function cmdFace(p: string[]): string {
|
||||||
|
const name = upper(arg(p, 1))
|
||||||
|
|
||||||
|
if (name == "RAW") {
|
||||||
|
// FACE:RAW:r0:r1:r2:r3:r4 — je Zeile eine Bitmaske 0..31, Bit 0 = links
|
||||||
|
basic.clearScreen()
|
||||||
|
for (let y = 0; y < 5; y++) {
|
||||||
|
let bits = clamp(argNum(p, 2 + y, 0), 0, 31)
|
||||||
|
for (let x = 0; x < 5; x++) {
|
||||||
|
if (bits % 2 == 1) led.plot(x, y)
|
||||||
|
bits = Math.idiv(bits, 2)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return "OK:FACE:RAW"
|
||||||
|
}
|
||||||
|
|
||||||
|
if (name == "HAPPY") showIconNow(IconNames.Happy)
|
||||||
|
else if (name == "SAD") showIconNow(IconNames.Sad)
|
||||||
|
else if (name == "ANGRY") showIconNow(IconNames.Angry)
|
||||||
|
else if (name == "CONFUSED") showIconNow(IconNames.Confused)
|
||||||
|
else if (name == "ASLEEP") showIconNow(IconNames.Asleep)
|
||||||
|
else if (name == "SURPRISED") showIconNow(IconNames.Surprised)
|
||||||
|
else if (name == "SILLY") showIconNow(IconNames.Silly)
|
||||||
|
else if (name == "FABULOUS") showIconNow(IconNames.Fabulous)
|
||||||
|
else if (name == "MEH") showIconNow(IconNames.Meh)
|
||||||
|
else if (name == "YES") showIconNow(IconNames.Yes)
|
||||||
|
else if (name == "NO") showIconNow(IconNames.No)
|
||||||
|
else if (name == "HEART") showIconNow(IconNames.Heart)
|
||||||
|
else if (name == "SMALLHEART") showIconNow(IconNames.SmallHeart)
|
||||||
|
else if (name == "SKULL") showIconNow(IconNames.Skull)
|
||||||
|
else if (name == "GHOST") showIconNow(IconNames.Ghost)
|
||||||
|
else if (name == "DUCK") showIconNow(IconNames.Duck)
|
||||||
|
else if (name == "HOUSE") showIconNow(IconNames.House)
|
||||||
|
else if (name == "GIRAFFE") showIconNow(IconNames.Giraffe)
|
||||||
|
else if (name == "COW") showIconNow(IconNames.Cow)
|
||||||
|
else if (name == "RABBIT") showIconNow(IconNames.Rabbit)
|
||||||
|
else if (name == "SNAKE") showIconNow(IconNames.Snake)
|
||||||
|
else if (name == "BUTTERFLY") showIconNow(IconNames.Butterfly)
|
||||||
|
else if (name == "TORTOISE") showIconNow(IconNames.Tortoise)
|
||||||
|
else if (name == "STICKFIGURE") showIconNow(IconNames.StickFigure)
|
||||||
|
else if (name == "TARGET") showIconNow(IconNames.Target)
|
||||||
|
else if (name == "DIAMOND") showIconNow(IconNames.Diamond)
|
||||||
|
else if (name == "SQUARE") showIconNow(IconNames.Square)
|
||||||
|
else if (name == "TRIANGLE") showIconNow(IconNames.Triangle)
|
||||||
|
else if (name == "UMBRELLA") showIconNow(IconNames.Umbrella)
|
||||||
|
else if (name == "SWORD") showIconNow(IconNames.Sword)
|
||||||
|
else if (name == "NORTH") basic.showArrow(ArrowNames.North, 0)
|
||||||
|
else if (name == "EAST") basic.showArrow(ArrowNames.East, 0)
|
||||||
|
else if (name == "SOUTH") basic.showArrow(ArrowNames.South, 0)
|
||||||
|
else if (name == "WEST") basic.showArrow(ArrowNames.West, 0)
|
||||||
|
else return "ERR:FACE:unknown"
|
||||||
|
|
||||||
|
return "OK:FACE:" + name
|
||||||
|
}
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// MUSIK
|
||||||
|
//
|
||||||
|
// Der eingebaute Melodie-Player von MakeCode spielt in einem EIGENEN Fiber ab,
|
||||||
|
// auf den man von außen keinen Zugriff hat. Ruft irgendein anderer Fiber
|
||||||
|
// gleichzeitig playTone() oder stopAllSounds() auf, greifen zwei Fibers
|
||||||
|
// parallel auf den Audio-Pin zu und der micro:bit stürzt ab (Panic).
|
||||||
|
// Ausgelöst hat das hier zuverlässig die Folge MELODY -> TONE -> MELODY.
|
||||||
|
//
|
||||||
|
// Deshalb wird er nicht benutzt. Die Notendaten sind dieselben wie in der
|
||||||
|
// MakeCode-Bibliothek (je zwei Bytes: MIDI-Notennummer und Dauer in
|
||||||
|
// Viertel-Schlägen, Notennummer 0 = Pause), abgespielt werden sie hier Note
|
||||||
|
// für Note — ausschließlich aus dem Aux-Fiber. Damit fasst genau ein Fiber
|
||||||
|
// jemals den Lautsprecher an, und ein Not-Stopp greift zwischen zwei Noten.
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
const MELODY_BPM = 120
|
||||||
|
|
||||||
|
function melodyBuffer(name: string): Buffer {
|
||||||
|
if (name == "DADADUM") return hex`00024f024f024f024b0800024d024d024d024a08`
|
||||||
|
if (name == "ENTERTAINER") return hex`4a014b014c0154024c0154024c0154035401560157015801540156015802530156025404`
|
||||||
|
if (name == "PRELUDE") return hex`48014c014f01540158014f015401580148014c014f01540158014f015401580148014a014f01560159014f015601590148014a014f01560159014f015601590147014a014f01560159014f015601590147014a014f01560159014f015601590148014c014f01540158014f015401580148014c014f01540158014f0154015801`
|
||||||
|
if (name == "ODE") return hex`4c044c044d044f044f044d044c044a04480448044a044c044c064a024a084c044c044d044f044f044d044c044a04480448044a044c044a0648024808`
|
||||||
|
if (name == "NYAN") return hex`5a025c02550157025301560155015302530255025602560155015301550157015a015c0157015a015501560153015501530157025a025c0157015a0155015701530156015701560155015301550156025301550157015a01550156015501530155025302550253024e01500153024e01500153015501570153015801570158015a01530253024e01500153014e0158015701550153014e014b014c014e0153024e01500153024e015001530153015501570153014e0150014e0153025301520153014e01500153015801570158015a0153025502`
|
||||||
|
if (name == "RINGTONE") return hex`48014a014c024f024a014c014d0251024c014d014f0253025404`
|
||||||
|
if (name == "FUNK") return hex`300230023302300135023001350236023702300230023702300136023001360235023302`
|
||||||
|
if (name == "BLUES") return hex`30023402370239023a0239023702340230023402370239023a02390237023402350239023c023e023f023e023c02390230023402370239023a0239023702340237023b023e024102350239023c023f0230023402370234023702350234023202`
|
||||||
|
if (name == "BIRTHDAY") return hex`480348014a0448044d044c08480348014a0448044f044d0848034801540451044d044c044a045203520151044d044f044d08`
|
||||||
|
if (name == "WEDDING") return hex`48044d034d014d0848044f034c014d0848044d035101540451034d014d044c034d014f08`
|
||||||
|
if (name == "FUNERAL") return hex`3c043c033c013c043f033e013e033c013c033b013c04`
|
||||||
|
if (name == "PUNCHLINE") return hex`480343014201430144034303000347034803`
|
||||||
|
if (name == "BADDY") return hex`3c0300033e023f0200023c0200024208`
|
||||||
|
if (name == "CHASE") return hex`5101530154015301510200025101530154015301510200025102580257025802590258025702580253015401560154015302000253015401560154015302000253025802570258025902580257025802`
|
||||||
|
if (name == "BADING") return hex`5f016403`
|
||||||
|
if (name == "WAWAWAWAA") return hex`400300013f0300013e0400013d08`
|
||||||
|
if (name == "JUMPUP") return hex`54015601580159015b01`
|
||||||
|
if (name == "JUMPDOWN") return hex`5b015901580156015401`
|
||||||
|
if (name == "POWERUP") return hex`4f01540158015b0258015b03`
|
||||||
|
if (name == "POWERDOWN") return hex`5b01570154014f0253015403`
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Halbtöne der Oktave ab C4 (MIDI 60), mit 16 multipliziert.
|
||||||
|
* Geteilt wird erst ganz am Schluss, damit beim Oktavieren nach unten
|
||||||
|
* nichts wegläuft — sonst liegen tiefe Töne bis zu 11 Cent daneben.
|
||||||
|
*/
|
||||||
|
const NOTE_HZ16 = [4186, 4435, 4699, 4978, 5274, 5588, 5920, 6272, 6645, 7040, 7459, 7902]
|
||||||
|
|
||||||
|
/**
|
||||||
|
* MIDI-Notennummer -> Frequenz in Hz. 69 = A4 = 440 Hz.
|
||||||
|
*
|
||||||
|
* Bewusst reine Ganzzahl-Arithmetik, KEIN Math.pow und kein Math.round.
|
||||||
|
* Das Ergebnis einer Kommazahl-Rechnung ist zwar rechnerisch richtig, kommt
|
||||||
|
* aber in music.playTone() falsch an: der Tonausgang macht daraus eine
|
||||||
|
* unsinnige Schwingungsdauer, kracht laut und bleibt hängen — und riss dabei
|
||||||
|
* zuverlässig die BLE-Verbindung ab. Ein Ton mit ganzzahliger Frequenz
|
||||||
|
* (z.B. direkt aus TONE:784:200) lief dagegen immer sauber durch.
|
||||||
|
*
|
||||||
|
* Also: hier nie wieder Fließkomma einbauen.
|
||||||
|
*/
|
||||||
|
function midiToFreq(midi: number): number {
|
||||||
|
let hz16 = NOTE_HZ16[midi % 12]
|
||||||
|
let oct = Math.idiv(midi, 12) - 5
|
||||||
|
while (oct > 0) {
|
||||||
|
hz16 = hz16 * 2
|
||||||
|
oct = oct - 1
|
||||||
|
}
|
||||||
|
while (oct < 0) {
|
||||||
|
hz16 = Math.idiv(hz16, 2)
|
||||||
|
oct = oct + 1
|
||||||
|
}
|
||||||
|
return Math.idiv(hz16 + 8, 16) | 0
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Spielt eine Notenfolge ab. Nur aus dem Aux-Fiber aufrufen.
|
||||||
|
* Gibt zurück, wie viele Noten tatsächlich gespielt wurden — steht in der
|
||||||
|
* DONE-Meldung und zeigt, wo es hängt, falls es hängt.
|
||||||
|
*/
|
||||||
|
function playMelodyBuffer(buf: Buffer): number {
|
||||||
|
// wie im Original: eine Viertel-Schlag-Einheit bei 120 bpm = 125 ms
|
||||||
|
const beat = Math.idiv(Math.idiv(60000, MELODY_BPM), 4)
|
||||||
|
let played = 0
|
||||||
|
for (let i = 0; i + 1 < buf.length; i += 2) {
|
||||||
|
if (auxAbort) break
|
||||||
|
const midi = buf[i]
|
||||||
|
const ms = buf[i + 1] * beat
|
||||||
|
if (midi == 0) {
|
||||||
|
basic.pause(ms)
|
||||||
|
} else {
|
||||||
|
audioBegin(ms)
|
||||||
|
music.playTone(midiToFreq(midi), ms)
|
||||||
|
audioUntil = 0
|
||||||
|
}
|
||||||
|
played++
|
||||||
|
}
|
||||||
|
audioEnd()
|
||||||
|
return played
|
||||||
|
}
|
||||||
|
|
||||||
|
function cmdMelody(p: string[]): string {
|
||||||
|
const name = upper(arg(p, 1))
|
||||||
|
if (!melodyBuffer(name)) return "ERR:MELODY:unknown"
|
||||||
|
if (!queueAux("MELODY", name, 0, 0)) return "ERR:MELODY:busy"
|
||||||
|
return "OK:MELODY:" + name
|
||||||
|
}
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// SENSOREN
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Es gibt bewusst kein SENSOR:LIGHT.
|
||||||
|
*
|
||||||
|
* Der Helligkeitssensor des micro:bit misst über die LED-Matrix, und die
|
||||||
|
* sitzt bei Proxi hinter einer getönten Scheibe. Ausgebaut misst der Sensor
|
||||||
|
* einwandfrei, eingebaut liefert er 0 — auch mit einer Taschenlampe direkt
|
||||||
|
* davor. Das ist kein Softwareproblem und mit Software auch nicht zu lösen.
|
||||||
|
*/
|
||||||
|
function cmdSensor(p: string[]): string {
|
||||||
|
const what = upper(arg(p, 1))
|
||||||
|
if (what == "" || what == "ALL") {
|
||||||
|
return "SENSOR:ALL:IR_L=" + Proxi.Lese_LBlock()
|
||||||
|
+ ",IR_R=" + Proxi.Lese_RBlock()
|
||||||
|
+ ",TEMP=" + input.temperature()
|
||||||
|
+ ",PWR=" + pins.digitalReadPin(DigitalPin.P8)
|
||||||
|
}
|
||||||
|
if (what == "IR_L" || what == "IR_LEFT") return "SENSOR:IR_L:" + Proxi.Lese_LBlock()
|
||||||
|
if (what == "IR_R" || what == "IR_RIGHT") return "SENSOR:IR_R:" + Proxi.Lese_RBlock()
|
||||||
|
if (what == "TEMP") return "SENSOR:TEMP:" + input.temperature()
|
||||||
|
if (what == "PWR") return "SENSOR:PWR:" + pins.digitalReadPin(DigitalPin.P8)
|
||||||
|
return "ERR:SENSOR:bad_type"
|
||||||
|
}
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// DISPATCHER
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
function execute(raw: string): string {
|
||||||
|
const line = trimLine(raw)
|
||||||
|
if (line == "") return ""
|
||||||
|
|
||||||
|
const p = splitColon(line)
|
||||||
|
const cmd = upper(p[0])
|
||||||
|
|
||||||
|
if (cmd == "PING") return "PONG"
|
||||||
|
if (cmd == "STATUS") return "STATUS:" + fwId() + ":PWR=" + pins.digitalReadPin(DigitalPin.P8)
|
||||||
|
|
||||||
|
if (cmd == "STOP") {
|
||||||
|
stopAll()
|
||||||
|
basic.clearScreen()
|
||||||
|
return "OK:STOP"
|
||||||
|
}
|
||||||
|
|
||||||
|
if (cmd == "MOVE") return cmdMove(p)
|
||||||
|
if (cmd == "TURN") return cmdTurn(p)
|
||||||
|
if (cmd == "FACE") return cmdFace(p)
|
||||||
|
if (cmd == "MELODY") return cmdMelody(p)
|
||||||
|
if (cmd == "SENSOR") return cmdSensor(p)
|
||||||
|
|
||||||
|
if (cmd == "CLEAR") {
|
||||||
|
basic.clearScreen()
|
||||||
|
return "OK:CLEAR"
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Jobs, die blockieren: an den Aux-Fiber übergeben ---
|
||||||
|
|
||||||
|
if (cmd == "TEXT") {
|
||||||
|
const t = joinFrom(p, 1)
|
||||||
|
if (t == "") return "ERR:TEXT:empty"
|
||||||
|
if (!queueAux("TEXT", t, 0, 0)) return "ERR:TEXT:busy"
|
||||||
|
return "OK:TEXT"
|
||||||
|
}
|
||||||
|
if (cmd == "TONE") {
|
||||||
|
const hz = clamp(argNum(p, 1, 440), 50, 5000)
|
||||||
|
const ms = clamp(argNum(p, 2, 400), 10, 5000)
|
||||||
|
if (!queueAux("TONE", "", hz, ms)) return "ERR:TONE:busy"
|
||||||
|
return "OK:TONE:" + hz
|
||||||
|
}
|
||||||
|
if (cmd == "DANCE") {
|
||||||
|
const n = clamp(argNum(p, 1, 2), 1, 20)
|
||||||
|
if (!queueAux("DANCE", "", n, 0)) return "ERR:DANCE:busy"
|
||||||
|
return "OK:DANCE:" + n
|
||||||
|
}
|
||||||
|
if (cmd == "STAMP") {
|
||||||
|
const n = clamp(argNum(p, 1, 3), 1, 20)
|
||||||
|
if (!queueAux("STAMP", "", n, 0)) return "ERR:STAMP:busy"
|
||||||
|
return "OK:STAMP:" + n
|
||||||
|
}
|
||||||
|
if (cmd == "SHAKE") {
|
||||||
|
const n = clamp(argNum(p, 1, 3), 1, 20)
|
||||||
|
if (!queueAux("SHAKE", "", n, 0)) return "ERR:SHAKE:busy"
|
||||||
|
return "OK:SHAKE:" + n
|
||||||
|
}
|
||||||
|
|
||||||
|
return "ERR:unknown:" + cmd
|
||||||
|
}
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// FIBER 1 — Bewegungs-Watchdog
|
||||||
|
// Hält den BLE-Handler frei: Bewegungen laufen mit Deadline,
|
||||||
|
// STOP kommt dadurch auch mitten in einer Fahrt noch durch.
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
control.inBackground(function () {
|
||||||
|
while (true) {
|
||||||
|
const now = control.millis()
|
||||||
|
if (walkUntil > 0 && now >= walkUntil) {
|
||||||
|
walkUntil = 0
|
||||||
|
Proxi.stehenbleiben()
|
||||||
|
}
|
||||||
|
if (turnUntil > 0 && now >= turnUntil) {
|
||||||
|
turnUntil = 0
|
||||||
|
Proxi.drehungsstopp()
|
||||||
|
}
|
||||||
|
if (audioUntil > 0 && now >= audioUntil) {
|
||||||
|
// Notbremse — hier darf der Lautsprecher ausnahmsweise aus einem
|
||||||
|
// fremden Fiber abgeschaltet werden, weil der Aux-Fiber es
|
||||||
|
// offensichtlich nicht mehr selbst tut.
|
||||||
|
audioUntil = 0
|
||||||
|
audioSilence()
|
||||||
|
}
|
||||||
|
basic.pause(10)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// FIBER 2 — Aux-Worker für alles Blockierende
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
control.inBackground(function () {
|
||||||
|
while (true) {
|
||||||
|
if (auxKinds.length > 0) {
|
||||||
|
// Die vier shift() laufen ohne Yield dazwischen und bleiben
|
||||||
|
// dadurch gegenüber den Event-Handlern konsistent.
|
||||||
|
const job = auxKinds.shift()
|
||||||
|
const text = auxTexts.shift()
|
||||||
|
const n1 = auxNums.shift()
|
||||||
|
const n2 = auxNums2.shift()
|
||||||
|
auxAbort = false
|
||||||
|
if (job == "TEXT") {
|
||||||
|
basic.showString(text)
|
||||||
|
basic.clearScreen()
|
||||||
|
} else if (job == "TONE") {
|
||||||
|
audioBegin(n2)
|
||||||
|
music.playTone(n1, n2)
|
||||||
|
audioEnd()
|
||||||
|
} else if (job == "MELODY") {
|
||||||
|
const buf = melodyBuffer(text)
|
||||||
|
if (buf) playMelodyBuffer(buf)
|
||||||
|
} else if (job == "DANCE") {
|
||||||
|
doDance(n1)
|
||||||
|
} else if (job == "STAMP") {
|
||||||
|
doStamp(n1)
|
||||||
|
} else if (job == "SHAKE") {
|
||||||
|
doShake(n1)
|
||||||
|
}
|
||||||
|
reply(auxAbort ? "DONE:" + job + ":aborted" : "DONE:" + job)
|
||||||
|
}
|
||||||
|
basic.pause(20)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// BLUETOOTH
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
bluetooth.onBluetoothConnected(function () {
|
||||||
|
connected = true
|
||||||
|
showIconNow(IconNames.Yes)
|
||||||
|
bluetooth.uartWriteLine("READY:" + fwId())
|
||||||
|
})
|
||||||
|
|
||||||
|
bluetooth.onBluetoothDisconnected(function () {
|
||||||
|
connected = false
|
||||||
|
stopAll()
|
||||||
|
showIconNow(IconNames.Asleep)
|
||||||
|
})
|
||||||
|
|
||||||
|
bluetooth.onUartDataReceived(serial.delimiters(Delimiters.NewLine), function () {
|
||||||
|
const raw = bluetooth.uartReadUntil(serial.delimiters(Delimiters.NewLine))
|
||||||
|
// Ein Absturz im Handler würde den micro:bit anhalten — dann lieber
|
||||||
|
// einen Fehler zurückmelden und weitermachen.
|
||||||
|
let response = ""
|
||||||
|
try {
|
||||||
|
response = execute(raw)
|
||||||
|
} catch (e) {
|
||||||
|
response = "ERR:exception"
|
||||||
|
}
|
||||||
|
if (response != "") reply(response)
|
||||||
|
})
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// TASTEN — funktionieren auch ohne Verbindung
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
input.onButtonPressed(Button.A, function () {
|
||||||
|
stopAll()
|
||||||
|
showIconNow(IconNames.No)
|
||||||
|
reply("EVENT:ESTOP")
|
||||||
|
})
|
||||||
|
|
||||||
|
input.onButtonPressed(Button.B, function () {
|
||||||
|
reply("STATUS:" + fwId() + ":PWR=" + pins.digitalReadPin(DigitalPin.P8))
|
||||||
|
showIconNow(IconNames.Target)
|
||||||
|
})
|
||||||
|
|
||||||
|
// ============================================================
|
||||||
|
// START
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
Proxi.stehenbleiben()
|
||||||
|
Proxi.drehungsstopp()
|
||||||
|
|
||||||
|
// Ton fest auf P0 legen — dort sitzt Proxis Summer, und darüber klingen auch
|
||||||
|
// alle Kosmos-Programme.
|
||||||
|
//
|
||||||
|
// Das ist kein Schönheitsfix, sondern zwingend: der micro:bit V2 gibt Töne
|
||||||
|
// sonst über seinen internen Audio-Mixer aus, und der lässt während des
|
||||||
|
// Tönens den Funk nicht mehr zum Zug kommen. Die BLE-Verbindung stirbt dann
|
||||||
|
// nach wenigen Sekunden an Connection Timeout (0x08) — reproduzierbar mit
|
||||||
|
// jeder längeren Melodie. Auf P0 ist der Mixer aus dem Spiel und die
|
||||||
|
// Verbindung hält auch über die 16 Sekunden von NYAN.
|
||||||
|
//
|
||||||
|
// Der eingebaute Lautsprecher des V2 darf dabei anbleiben; getestet mit
|
||||||
|
// music.setBuiltInSpeakerEnabled(true) und voller Melodie ohne Abbruch.
|
||||||
|
// Entscheidend ist allein der Pitch-Pin.
|
||||||
|
pins.analogSetPitchPin(AnalogPin.P0)
|
||||||
|
|
||||||
|
bluetooth.startUartService()
|
||||||
|
showIconNow(IconNames.Asleep)
|
||||||
+19116
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,365 @@
|
|||||||
|
// ============================================================
|
||||||
|
// Proxi \u2014 Hardware-Extension
|
||||||
|
//
|
||||||
|
// FREMDER CODE. Unveraendert uebernommen bis auf diesen Kopf.
|
||||||
|
// Hier bitte nichts aendern: solange das die Original-Funktionen sind,
|
||||||
|
// verhaelt sich diese Firmware bei den Motoren exakt wie die Programme,
|
||||||
|
// die Kosmos mitliefert \u2014 inklusive der P8-Pruefung, deren genaue
|
||||||
|
// Bedeutung nicht dokumentiert ist (siehe docs/HARDWARE.md).
|
||||||
|
//
|
||||||
|
// Herkunft: aus der .hex von Kosmos' Beispielprogrammen extrahiert
|
||||||
|
// (dort als custom.ts), siehe tools/hex_source.py.
|
||||||
|
// Eingedeutschte Fassung der Extension "TobbieII" von kaku111,
|
||||||
|
// https://github.com/kaku111/20190209 \u2014 MIT.
|
||||||
|
// Lizenz: MIT, siehe docs/LICENSES.md
|
||||||
|
// ============================================================
|
||||||
|
|
||||||
|
//% weight=0 color=#0033E6 icon="\uf1b9" block="KOSMOS - Proxi"
|
||||||
|
//uf1b9
|
||||||
|
namespace Proxi {
|
||||||
|
let ADL_R: number = 0;
|
||||||
|
let ADH_R: number = 0;
|
||||||
|
let ADL_L: number = 0;
|
||||||
|
let ADH_L: number = 0;
|
||||||
|
let Read_LIR: number = 0;
|
||||||
|
let Read_RIR: number = 0;
|
||||||
|
let event_src_ir = 12;
|
||||||
|
let event_ir_sensor = 1;
|
||||||
|
let Motor_R: boolean = false;
|
||||||
|
let Motor_L: boolean = false;
|
||||||
|
let PX: number = 0;
|
||||||
|
let PY: number = 0;
|
||||||
|
let Force: number = 10;
|
||||||
|
|
||||||
|
function IR_sensorL(irdataL: number) { //此為中斷觸發方塊
|
||||||
|
control.inBackground(() => {
|
||||||
|
let flag = false
|
||||||
|
let last_flag = false
|
||||||
|
while (true) {
|
||||||
|
let ob: boolean = LBlock();
|
||||||
|
if (ob) { flag = true } else { flag = false }
|
||||||
|
if (flag != last_flag) {
|
||||||
|
if (flag) {
|
||||||
|
control.raiseEvent(event_src_ir, event_ir_sensor)
|
||||||
|
basic.pause(300) //300ms
|
||||||
|
}
|
||||||
|
last_flag = flag
|
||||||
|
}
|
||||||
|
basic.pause(1)
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
)
|
||||||
|
|
||||||
|
}
|
||||||
|
//
|
||||||
|
// 背景執行紅外線測距
|
||||||
|
// @param irdata_Set ; eg: 512
|
||||||
|
//
|
||||||
|
// //% blockId="IR_EVENTL" block="ON obstacles on the left: |%irdata_Set"
|
||||||
|
// //% irdata_Set.min=0 irdata_Set.max=1023
|
||||||
|
// //% blockGap=10 weight=99 //代表其重要性，越重放越高
|
||||||
|
// export function onIRL(irdata_Set: number = 512, handler: Action) {
|
||||||
|
// IR_sensorL(irdata_Set);
|
||||||
|
// control.onEvent(event_src_ir, event_ir_sensor, handler);
|
||||||
|
|
||||||
|
// }
|
||||||
|
// function IR_sensorR(irdata: number) {
|
||||||
|
// control.inBackground(() => {
|
||||||
|
// let flag = false
|
||||||
|
// let last_flag = false
|
||||||
|
// while (true) {
|
||||||
|
// let ob: boolean = LBlock();
|
||||||
|
// if(ob){flag=true}else{flag=false}
|
||||||
|
// if (flag != last_flag) {
|
||||||
|
// if (flag) {
|
||||||
|
// control.raiseEvent(event_src_ir, event_ir_sensor)
|
||||||
|
// basic.pause(3)
|
||||||
|
// }
|
||||||
|
// last_flag = flag
|
||||||
|
// }
|
||||||
|
// basic.pause(1)
|
||||||
|
// }
|
||||||
|
// }
|
||||||
|
// )
|
||||||
|
// }
|
||||||
|
|
||||||
|
/** Read the value sensed by the right side of the infrared sensor.
|
||||||
|
*/
|
||||||
|
//% blockId="Lese_RBlock" block="Lese rechten IR-Wert aus (Ergebnis 0 - 1024)"
|
||||||
|
//% blockGap=5 weight=65 //與下一個方塊的間隙及排重
|
||||||
|
export function Lese_RBlock(): number {
|
||||||
|
ADL_R = pins.analogReadPin(AnalogPin.P2)
|
||||||
|
pins.digitalWritePin(DigitalPin.P12, 1)
|
||||||
|
control.waitMicros(250)
|
||||||
|
ADH_R = pins.analogReadPin(AnalogPin.P2)
|
||||||
|
pins.digitalWritePin(DigitalPin.P12, 0)
|
||||||
|
if (pins.digitalReadPin(DigitalPin.P8) == 1) Read_RIR = ADH_R - ADL_R;
|
||||||
|
return (Read_RIR)
|
||||||
|
}
|
||||||
|
/** Read the value sensed by the left side of the infrared sensor.
|
||||||
|
*/
|
||||||
|
//% blockId="Lese_LBlock" block="Lese linken IR-Wert aus (Ergebnis 0 - 1024)"
|
||||||
|
//% blockGap=15 weight=60 //與下一個方塊的間隙及排重
|
||||||
|
export function Lese_LBlock(): number {
|
||||||
|
ADL_L = pins.analogReadPin(AnalogPin.P1)
|
||||||
|
pins.digitalWritePin(DigitalPin.P12, 1)
|
||||||
|
control.waitMicros(250)
|
||||||
|
ADH_L = pins.analogReadPin(AnalogPin.P1)
|
||||||
|
pins.digitalWritePin(DigitalPin.P12, 0)
|
||||||
|
|
||||||
|
Read_LIR = ADH_L - ADL_L;
|
||||||
|
return (Read_LIR)
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
*Determine if there are obstacles on the right side.
|
||||||
|
*@param thresholdR ; eg: 512
|
||||||
|
*/
|
||||||
|
//% blockId="RBlock" block="wenn der rechte IR-Wert über %thresholdR liegt"
|
||||||
|
//% thresholdR.min=0 thresholdR.max=1023
|
||||||
|
//% blockGap=5 weight=58
|
||||||
|
export function RBlock(thresholdR: number = 512): boolean {
|
||||||
|
ADL_R = pins.analogReadPin(AnalogPin.P2)
|
||||||
|
pins.digitalWritePin(DigitalPin.P12, 1)
|
||||||
|
control.waitMicros(250)
|
||||||
|
ADH_R = pins.analogReadPin(AnalogPin.P2)
|
||||||
|
pins.digitalWritePin(DigitalPin.P12, 0)
|
||||||
|
|
||||||
|
if (((ADH_R - ADL_R) > thresholdR) && (pins.digitalReadPin(DigitalPin.P8) == 1)) {
|
||||||
|
//basic.showIcon(IconNames.House)
|
||||||
|
return (true)
|
||||||
|
} else {
|
||||||
|
//basic.showIcon(IconNames.Cow)
|
||||||
|
return (false)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
*Determine if there are obstacles on the left side.
|
||||||
|
*@param thresholdL ; eg: 512
|
||||||
|
*/
|
||||||
|
//% blockId="LBlock" block="wenn der linke IR-Wert über %thresholdL liegt"
|
||||||
|
//% thresholdL.min=0 thresholdL.max=1023
|
||||||
|
//% blockGap=10 weight=57
|
||||||
|
export function LBlock(thresholdL: number = 512): boolean {
|
||||||
|
ADL_L = pins.analogReadPin(AnalogPin.P1)
|
||||||
|
pins.digitalWritePin(DigitalPin.P12, 1)
|
||||||
|
control.waitMicros(250)
|
||||||
|
ADH_L = 0
|
||||||
|
if (pins.digitalReadPin(DigitalPin.P8) == 1) {
|
||||||
|
ADH_L = pins.analogReadPin(AnalogPin.P1)
|
||||||
|
pins.digitalWritePin(DigitalPin.P12, 0)
|
||||||
|
}
|
||||||
|
|
||||||
|
if ((ADH_L - ADL_L) > thresholdL) {//512) {
|
||||||
|
//basic.showIcon(IconNames.House)
|
||||||
|
return (true)
|
||||||
|
} else {
|
||||||
|
//basic.showIcon(IconNames.Cow)
|
||||||
|
return (false)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//輸出脈波
|
||||||
|
//% blockId="IRbolck" block="Out pulse & show-04"
|
||||||
|
//% blockGap=10 weight=55
|
||||||
|
//export function IRblock() {
|
||||||
|
// ADL_L = pins.analogReadPin(AnalogPin.P1)
|
||||||
|
// ADL_R = pins.analogReadPin(AnalogPin.P2)
|
||||||
|
// pins.digitalWritePin(DigitalPin.P12, 1)
|
||||||
|
// control.waitMicros(250)
|
||||||
|
// ADH_L = pins.analogReadPin(AnalogPin.P1)
|
||||||
|
// ADH_R = pins.analogReadPin(AnalogPin.P2)
|
||||||
|
// pins.digitalWritePin(DigitalPin.P12, 0)
|
||||||
|
|
||||||
|
// if ((ADH_L-ADL_L) > 512) {
|
||||||
|
//basic.showIcon(IconNames.House)
|
||||||
|
// led.plot(0, 0)
|
||||||
|
// led.unplot(0,4)
|
||||||
|
// } else {
|
||||||
|
//basic.showIcon(IconNames.Cow)
|
||||||
|
// led.plot(0, 4)
|
||||||
|
// led.unplot(0,0)
|
||||||
|
// }
|
||||||
|
|
||||||
|
// if ((ADH_R-ADL_R) > 512) {
|
||||||
|
//basic.showIcon(IconNames.House)
|
||||||
|
// led.plot(4, 0)
|
||||||
|
// led.unplot(4, 4)
|
||||||
|
// } else {
|
||||||
|
//basic.showIcon(IconNames.Cow)
|
||||||
|
// led.plot(4, 4)
|
||||||
|
// led.unplot(4,0)
|
||||||
|
// }
|
||||||
|
|
||||||
|
//return(true)
|
||||||
|
//}
|
||||||
|
/**
|
||||||
|
*Proxi läuft vorwaerts.
|
||||||
|
*/
|
||||||
|
//% blockId="vorwärts" block="Proxi läuft vorwärts"
|
||||||
|
//% blockGap=3 weight=35
|
||||||
|
export function vorwärts() {
|
||||||
|
if (pins.digitalReadPin(DigitalPin.P8) == 1) {
|
||||||
|
pins.digitalWritePin(DigitalPin.P13, 1)
|
||||||
|
pins.digitalWritePin(DigitalPin.P14, 0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
*Proxi läuft rückwärts.
|
||||||
|
*/
|
||||||
|
//% blockId="rückwärts" block="Proxi läuft rückwärts"
|
||||||
|
//% blockGap=3 weight=34
|
||||||
|
export function rückwärts() {
|
||||||
|
if (Force != 0) {
|
||||||
|
pins.digitalWritePin(DigitalPin.P13, 0)
|
||||||
|
pins.digitalWritePin(DigitalPin.P14, 1)
|
||||||
|
Force = Force - 1;
|
||||||
|
}
|
||||||
|
if (pins.digitalReadPin(DigitalPin.P8) == 1) { Force = 10 }
|
||||||
|
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
*Proxi bleibt stehen.
|
||||||
|
*/
|
||||||
|
//% blockId="stehenbleiben" block="Proxi bleibt stehen"
|
||||||
|
//% blockGap=10 weight=33
|
||||||
|
export function stehenbleiben() {
|
||||||
|
pins.digitalWritePin(DigitalPin.P13, 0)
|
||||||
|
pins.digitalWritePin(DigitalPin.P14, 0)
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
*Proxi Rechtsdrehung.
|
||||||
|
*/
|
||||||
|
//% blockId="rechtsdrehung" block="Proxi Rechtsdrehung"
|
||||||
|
//% blockGap=3 weight=32
|
||||||
|
export function rechtsdrehung() {
|
||||||
|
pins.digitalWritePin(DigitalPin.P15, 0)
|
||||||
|
pins.digitalWritePin(DigitalPin.P16, 1)
|
||||||
|
Motor_L = false
|
||||||
|
Motor_R = true
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
*Proxi Linksdrehung.
|
||||||
|
*/
|
||||||
|
//% blockId="linksdrehung" block="Proxi Linksdrehung"
|
||||||
|
//% blockGap=3 weight=31
|
||||||
|
export function linksdrehung() {
|
||||||
|
pins.digitalWritePin(DigitalPin.P15, 1)
|
||||||
|
pins.digitalWritePin(DigitalPin.P16, 0)
|
||||||
|
Motor_L = true
|
||||||
|
Motor_R = false
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
*Proxi stoppt Drehung
|
||||||
|
*/
|
||||||
|
//% blockId="drehungstopp" block="Proxi stoppt Drehung"
|
||||||
|
//% blockGap=10 weight=30
|
||||||
|
export function drehungsstopp() {
|
||||||
|
if (Motor_L || Motor_R) {
|
||||||
|
if (Motor_R) {
|
||||||
|
pins.digitalWritePin(DigitalPin.P15, 1)
|
||||||
|
pins.digitalWritePin(DigitalPin.P16, 0)
|
||||||
|
} else {
|
||||||
|
pins.digitalWritePin(DigitalPin.P15, 0)
|
||||||
|
pins.digitalWritePin(DigitalPin.P16, 1)
|
||||||
|
}
|
||||||
|
basic.pause(50)
|
||||||
|
}
|
||||||
|
if (pins.digitalReadPin(DigitalPin.P8) == 1) {
|
||||||
|
pins.digitalWritePin(DigitalPin.P15, 0)
|
||||||
|
pins.digitalWritePin(DigitalPin.P16, 0)
|
||||||
|
Motor_L = false
|
||||||
|
Motor_R = false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
*Proxi stampft eine bestimmte Anzahl auf.
|
||||||
|
*@param time describe parameter here, eg:5
|
||||||
|
*/
|
||||||
|
//% blockId="stampfen" block="Proxi stampft %time mal auf"
|
||||||
|
//% time.min=1 time.max=100
|
||||||
|
//% blockGap=5 weight=25
|
||||||
|
//% advanced=true
|
||||||
|
export function stampfen(time: number): void {
|
||||||
|
for (let i = 0; i < time; i++) {
|
||||||
|
pins.digitalWritePin(DigitalPin.P13, 1) //向前
|
||||||
|
pins.digitalWritePin(DigitalPin.P14, 0)
|
||||||
|
basic.pause(150)
|
||||||
|
pins.digitalWritePin(DigitalPin.P13, 0) //向後
|
||||||
|
pins.digitalWritePin(DigitalPin.P14, 1)
|
||||||
|
basic.pause(150)
|
||||||
|
}
|
||||||
|
pins.digitalWritePin(DigitalPin.P13, 0) //停止
|
||||||
|
pins.digitalWritePin(DigitalPin.P14, 0)
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
*Proxi schüttelt seinen Kopf eine bestimmte Anzahl.
|
||||||
|
*@param time describe parameter here, eg:5
|
||||||
|
*/
|
||||||
|
//% blockId="kopf_schuetteln" block="Proxi %time mal Kopfschütteln"
|
||||||
|
//% time.min=1 time.max=100
|
||||||
|
//% blockGap=5 weight=26
|
||||||
|
//% advanced=true
|
||||||
|
export function kopf_schuetteln(time: number): void {
|
||||||
|
for (let i = 0; i < time; i++) {
|
||||||
|
pins.digitalWritePin(DigitalPin.P15, 1) //左轉
|
||||||
|
pins.digitalWritePin(DigitalPin.P16, 0)
|
||||||
|
basic.pause(250)
|
||||||
|
pins.digitalWritePin(DigitalPin.P15, 0) //右轉
|
||||||
|
pins.digitalWritePin(DigitalPin.P16, 1)
|
||||||
|
basic.pause(250)
|
||||||
|
}
|
||||||
|
pins.digitalWritePin(DigitalPin.P15, 0) //停止行走
|
||||||
|
pins.digitalWritePin(DigitalPin.P16, 0)
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
*Proxi tanzt eine bestimmte Anzahl.
|
||||||
|
*@param time describe parameter here, eg:5
|
||||||
|
*/
|
||||||
|
//% blockId="tanz" block="Proxi tanzt %time mal"
|
||||||
|
//% time.min=1 time.max=100
|
||||||
|
//% blockGap=5 weight=24
|
||||||
|
//% advanced=true
|
||||||
|
export function tanz(time: number): void {
|
||||||
|
for (let i = 0; i < time; i++) {
|
||||||
|
pins.digitalWritePin(DigitalPin.P13, 0) //向後
|
||||||
|
pins.digitalWritePin(DigitalPin.P14, 1)
|
||||||
|
pins.digitalWritePin(DigitalPin.P15, 0) //右轉
|
||||||
|
pins.digitalWritePin(DigitalPin.P16, 1)
|
||||||
|
basic.pause(250)
|
||||||
|
pins.digitalWritePin(DigitalPin.P13, 1) //向前
|
||||||
|
pins.digitalWritePin(DigitalPin.P14, 0)
|
||||||
|
pins.digitalWritePin(DigitalPin.P15, 1) //左轉
|
||||||
|
pins.digitalWritePin(DigitalPin.P16, 0)
|
||||||
|
basic.pause(250)
|
||||||
|
}
|
||||||
|
pins.digitalWritePin(DigitalPin.P13, 0)
|
||||||
|
pins.digitalWritePin(DigitalPin.P14, 0)
|
||||||
|
pins.digitalWritePin(DigitalPin.P15, 0)
|
||||||
|
pins.digitalWritePin(DigitalPin.P16, 0)
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
*Proxi zeigt Stimmung auf Gesicht an (nur APP).
|
||||||
|
*@param RX_Data describe parameter here
|
||||||
|
*/
|
||||||
|
//% blockId="BLE_DOT" block="Proxi zeigt Stimmung auf Gesicht an (nur APP) %RX_Data"
|
||||||
|
//% blockGap=5 weight=23
|
||||||
|
//% advanced=true
|
||||||
|
export function zeige_Gesicht(RX_Data: string): void {
|
||||||
|
basic.clearScreen()
|
||||||
|
for (let PY = 0; PY <= 4; PY++) {
|
||||||
|
let PLOT_DATA: number = parseInt(RX_Data.substr(PY * 2 + 1, 2))
|
||||||
|
for (let PX = 0; PX <= 4; PX++) {
|
||||||
|
if (PLOT_DATA % 2 == 1) {
|
||||||
|
led.plot(PX, PY)
|
||||||
|
PLOT_DATA = PLOT_DATA - 1
|
||||||
|
}
|
||||||
|
PLOT_DATA = PLOT_DATA / 2
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
@@ -0,0 +1,31 @@
|
|||||||
|
{
|
||||||
|
"name": "proxi-ai",
|
||||||
|
"description": "BLE-Kommando-Interface fuer den KOSMOS-Proxi-Roboter",
|
||||||
|
"dependencies": {
|
||||||
|
"core": "*",
|
||||||
|
"bluetooth": "*",
|
||||||
|
"microphone": "*"
|
||||||
|
},
|
||||||
|
"files": [
|
||||||
|
"version.ts",
|
||||||
|
"main.ts",
|
||||||
|
"proxi.ts"
|
||||||
|
],
|
||||||
|
"preferredEditor": "tsprj",
|
||||||
|
"yotta": {
|
||||||
|
"config": {
|
||||||
|
"microbit-dal": {
|
||||||
|
"bluetooth": {
|
||||||
|
"open": 1,
|
||||||
|
"whitelist": 0,
|
||||||
|
"event_service": 0,
|
||||||
|
"dfu_service": 0,
|
||||||
|
"device_info_service": 0,
|
||||||
|
"eddystone_url": 0,
|
||||||
|
"eddystone_uid": 0,
|
||||||
|
"partial_flashing": 0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,9 @@
|
|||||||
|
{
|
||||||
|
"compilerOptions": {
|
||||||
|
"target": "ES5",
|
||||||
|
"noImplicitAny": true,
|
||||||
|
"outDir": "built",
|
||||||
|
"rootDir": "."
|
||||||
|
},
|
||||||
|
"exclude": ["pxt_modules/**/*test.ts"]
|
||||||
|
}
|
||||||
@@ -0,0 +1,2 @@
|
|||||||
|
// Erzeugt von build.sh — nicht von Hand ändern.
|
||||||
|
const FW_BUILD = "0fae7b1"
|
||||||
Executable
+127
@@ -0,0 +1,127 @@
|
|||||||
|
#!/usr/bin/env python3
|
||||||
|
"""
|
||||||
|
check_melodies.py — prüft die Musik-Tabellen der Firmware, ohne zu flashen.
|
||||||
|
|
||||||
|
python3 tools/check_melodies.py
|
||||||
|
|
||||||
|
Hintergrund: die Frequenzen wurden ursprünglich mit Math.pow() gerechnet. Das
|
||||||
|
Ergebnis war rechnerisch korrekt, kam aber als Kommazahl in music.playTone()
|
||||||
|
an — der micro:bit machte daraus eine unsinnige Schwingungsdauer, krachte laut,
|
||||||
|
blieb hängen und riss dabei die Bluetooth-Verbindung ab (Connection Timeout
|
||||||
|
0x08). Zu finden war das nur am Gerät.
|
||||||
|
|
||||||
|
Damit so etwas künftig schon beim Bauen auffällt, rechnet dieses Skript die
|
||||||
|
Ganzzahl-Tabelle aus main.ts gegen die exakte Formel nach und prüft die
|
||||||
|
Notendaten auf Werte, die den Tonausgang durcheinanderbringen.
|
||||||
|
|
||||||
|
Rückgabewert 0 = alles in Ordnung.
|
||||||
|
"""
|
||||||
|
|
||||||
|
import math
|
||||||
|
import os
|
||||||
|
import re
|
||||||
|
import sys
|
||||||
|
|
||||||
|
MAIN_TS = os.path.join(os.path.dirname(__file__), "..", "firmware", "main.ts")
|
||||||
|
|
||||||
|
#: Ab hier wird es hörbar. 100 Cent sind ein Halbton.
|
||||||
|
MAX_CENTS = 8.0
|
||||||
|
|
||||||
|
|
||||||
|
def strip_comments(src):
|
||||||
|
"""Kommentare entfernen — sonst schlägt die Suche nach Math.pow auf dem
|
||||||
|
Kommentar an, der genau davor warnt."""
|
||||||
|
src = re.sub(r"/\*.*?\*/", "", src, flags=re.S)
|
||||||
|
src = re.sub(r"//[^\n]*", "", src)
|
||||||
|
return src
|
||||||
|
|
||||||
|
|
||||||
|
def parse_main(path):
|
||||||
|
src = open(path, encoding="utf-8").read()
|
||||||
|
|
||||||
|
m = re.search(r"const NOTE_HZ16 = \[([0-9,\s]+)\]", src)
|
||||||
|
if not m:
|
||||||
|
sys.exit("NOTE_HZ16 nicht in main.ts gefunden")
|
||||||
|
table = [int(x) for x in m.group(1).replace("\n", "").split(",") if x.strip()]
|
||||||
|
|
||||||
|
melodies = re.findall(r'name == "([A-Z]+)"\) return hex`([0-9a-f]+)`', src)
|
||||||
|
return src, table, melodies
|
||||||
|
|
||||||
|
|
||||||
|
def midi_to_freq(table, midi):
|
||||||
|
"""Muss sich genauso verhalten wie midiToFreq() in main.ts."""
|
||||||
|
hz16 = table[midi % 12]
|
||||||
|
octave = midi // 12 - 5
|
||||||
|
while octave > 0:
|
||||||
|
hz16 *= 2
|
||||||
|
octave -= 1
|
||||||
|
while octave < 0:
|
||||||
|
hz16 //= 2
|
||||||
|
octave += 1
|
||||||
|
return (hz16 + 8) // 16
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
src, table, melodies = parse_main(MAIN_TS)
|
||||||
|
code = strip_comments(src)
|
||||||
|
problems = []
|
||||||
|
|
||||||
|
if len(table) != 12:
|
||||||
|
problems.append(f"NOTE_HZ16 hat {len(table)} Einträge, erwartet 12")
|
||||||
|
|
||||||
|
# Kein Fließkomma im Tonpfad — das war die Ursache des Fehlers.
|
||||||
|
for bad in ("Math.pow", "Math.round", "parseFloat"):
|
||||||
|
if bad in code:
|
||||||
|
problems.append(f"{bad} steht wieder in main.ts — Frequenzen müssen ganzzahlig bleiben")
|
||||||
|
|
||||||
|
if not melodies:
|
||||||
|
problems.append("keine Melodien gefunden")
|
||||||
|
|
||||||
|
notes = set()
|
||||||
|
for name, hexdata in melodies:
|
||||||
|
data = bytes.fromhex(hexdata)
|
||||||
|
if len(data) % 2:
|
||||||
|
problems.append(f"{name}: ungerade Byte-Zahl, Noten sind Paare aus MIDI und Dauer")
|
||||||
|
continue
|
||||||
|
for i in range(0, len(data) - 1, 2):
|
||||||
|
midi, dur = data[i], data[i + 1]
|
||||||
|
if dur == 0:
|
||||||
|
problems.append(f"{name}: Note {i//2} hat Dauer 0 — der Ton liefe endlos")
|
||||||
|
if midi > 127:
|
||||||
|
problems.append(f"{name}: Note {i//2} hat MIDI {midi} (>127)")
|
||||||
|
if midi:
|
||||||
|
notes.add(midi)
|
||||||
|
|
||||||
|
worst = 0.0
|
||||||
|
worst_note = None
|
||||||
|
for midi in sorted(notes):
|
||||||
|
got = midi_to_freq(table, midi)
|
||||||
|
if got <= 0:
|
||||||
|
problems.append(f"MIDI {midi} ergibt {got} Hz — playTone braucht einen positiven Wert")
|
||||||
|
continue
|
||||||
|
exact = 440.0 * 2 ** ((midi - 69) / 12)
|
||||||
|
cents = abs(1200 * math.log2(got / exact))
|
||||||
|
if cents > worst:
|
||||||
|
worst, worst_note = cents, (midi, got, round(exact))
|
||||||
|
if cents > MAX_CENTS:
|
||||||
|
problems.append(f"MIDI {midi}: {got} Hz statt {exact:.1f} Hz ({cents:.1f} Cent daneben)")
|
||||||
|
|
||||||
|
print(f"{len(melodies)} Melodien, {len(notes)} verschiedene Noten "
|
||||||
|
f"(MIDI {min(notes)}-{max(notes)})")
|
||||||
|
if worst_note:
|
||||||
|
midi, got, exact = worst_note
|
||||||
|
print(f"größte Abweichung: {worst:.2f} Cent bei MIDI {midi} "
|
||||||
|
f"({got} Hz statt {exact} Hz), erlaubt sind {MAX_CENTS}")
|
||||||
|
|
||||||
|
if problems:
|
||||||
|
print("\nFEHLER:", file=sys.stderr)
|
||||||
|
for p in problems:
|
||||||
|
print(f" - {p}", file=sys.stderr)
|
||||||
|
return 1
|
||||||
|
|
||||||
|
print("alles in Ordnung")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
Executable
+164
@@ -0,0 +1,164 @@
|
|||||||
|
#!/usr/bin/env python3
|
||||||
|
"""
|
||||||
|
hex_source.py — holt den eingebetteten MakeCode-Quelltext aus einer micro:bit .hex.
|
||||||
|
|
||||||
|
Jede von MakeCode erzeugte .hex trägt das komplette Projekt (main.ts, alle
|
||||||
|
Extensions, pxt.json) LZMA-komprimiert am Ende mit. Genau daraus stammen die
|
||||||
|
echten Kosmos-Proxi-Quellen inklusive der Hardware-Extension `proxi.ts` — die
|
||||||
|
Pin-Belegung des Roboters ist sonst nirgends dokumentiert (siehe
|
||||||
|
docs/HARDWARE.md).
|
||||||
|
|
||||||
|
Funktioniert mit jeder MakeCode-.hex, nicht nur mit denen von Proxi.
|
||||||
|
|
||||||
|
python3 hex_source.py *.hex -o ./quellen
|
||||||
|
python3 hex_source.py --list 00_Funktionstest.hex
|
||||||
|
python3 hex_source.py --check firmware.hex main.ts
|
||||||
|
|
||||||
|
Format des Anhangs (ab der Magic-Sequenz):
|
||||||
|
+0 8 Byte Magic 41 14 0E 2F B8 2F A2 BB
|
||||||
|
+8 2 Byte Länge des JSON-Kopfes (little endian)
|
||||||
|
+10 4 Byte Länge der komprimierten Nutzdaten (little endian)
|
||||||
|
+14 2 Byte reserviert
|
||||||
|
+16 n Byte JSON-Kopf {"compression":"LZMA","textSize":...,"name":...}
|
||||||
|
+16+n LZMA-Strom (alone/legacy-Header) ->
|
||||||
|
JSON-Kopf (Projekt-Metadaten) + JSON-Objekt {dateiname: inhalt}
|
||||||
|
"""
|
||||||
|
|
||||||
|
import argparse
|
||||||
|
import binascii
|
||||||
|
import json
|
||||||
|
import lzma
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
|
||||||
|
MAGIC = bytes.fromhex("41140E2FB82FA2BB")
|
||||||
|
|
||||||
|
# Intel-HEX-Record-Typen, die Nutzdaten tragen. 0x0D/0x0E sind Erweiterungen des
|
||||||
|
# micro:bit-"Universal Hex" (eine Datei für V1 und V2), 0x0C ist reine Füllung.
|
||||||
|
DATA_RECORDS = {0x00, 0x0C, 0x0D, 0x0E}
|
||||||
|
|
||||||
|
|
||||||
|
def _hex_payload(path):
|
||||||
|
"""Alle Datenbytes der .hex hintereinander — ohne Adressauswertung.
|
||||||
|
|
||||||
|
Reicht hier, weil der Quelltext-Anhang am Stück in aufeinanderfolgenden
|
||||||
|
Records liegt und ab der Magic-Sequenz gelesen wird.
|
||||||
|
"""
|
||||||
|
out = bytearray()
|
||||||
|
with open(path, "r", errors="replace") as fh:
|
||||||
|
for line in fh:
|
||||||
|
line = line.strip()
|
||||||
|
if not line.startswith(":"):
|
||||||
|
continue
|
||||||
|
try:
|
||||||
|
raw = binascii.unhexlify(line[1:])
|
||||||
|
except binascii.Error:
|
||||||
|
continue
|
||||||
|
if len(raw) < 5:
|
||||||
|
continue
|
||||||
|
length, rectype = raw[0], raw[3]
|
||||||
|
if rectype in DATA_RECORDS:
|
||||||
|
out += raw[4:4 + length]
|
||||||
|
return bytes(out)
|
||||||
|
|
||||||
|
|
||||||
|
def read_project(path):
|
||||||
|
"""(metadaten, {dateiname: inhalt}) aus einer .hex lesen."""
|
||||||
|
blob = _hex_payload(path)
|
||||||
|
start = blob.find(MAGIC)
|
||||||
|
if start < 0:
|
||||||
|
raise ValueError("kein eingebetteter MakeCode-Quelltext gefunden")
|
||||||
|
|
||||||
|
header_len = int.from_bytes(blob[start + 8:start + 10], "little")
|
||||||
|
packed_len = int.from_bytes(blob[start + 10:start + 14], "little")
|
||||||
|
packed_at = start + 16 + header_len
|
||||||
|
|
||||||
|
text = lzma.decompress(
|
||||||
|
blob[packed_at:packed_at + packed_len], format=lzma.FORMAT_ALONE
|
||||||
|
).decode("utf-8", "replace")
|
||||||
|
|
||||||
|
decoder = json.JSONDecoder()
|
||||||
|
meta, offset = decoder.raw_decode(text)
|
||||||
|
files, _ = decoder.raw_decode(text[offset:].lstrip())
|
||||||
|
return meta, files
|
||||||
|
|
||||||
|
|
||||||
|
def cmd_extract(paths, outdir):
|
||||||
|
for path in paths:
|
||||||
|
name = os.path.splitext(os.path.basename(path))[0]
|
||||||
|
try:
|
||||||
|
meta, files = read_project(path)
|
||||||
|
except Exception as exc:
|
||||||
|
print(f"!! {name}: {exc}", file=sys.stderr)
|
||||||
|
continue
|
||||||
|
target = os.path.join(outdir, name)
|
||||||
|
os.makedirs(target, exist_ok=True)
|
||||||
|
for filename, content in files.items():
|
||||||
|
dest = os.path.join(target, filename)
|
||||||
|
os.makedirs(os.path.dirname(dest), exist_ok=True)
|
||||||
|
with open(dest, "w") as fh:
|
||||||
|
fh.write(content)
|
||||||
|
print(f"{name}: {', '.join(sorted(files))} -> {target}")
|
||||||
|
|
||||||
|
|
||||||
|
def cmd_list(paths):
|
||||||
|
for path in paths:
|
||||||
|
meta, files = read_project(path)
|
||||||
|
print(f"== {os.path.basename(path)} ({meta.get('name', '?')})")
|
||||||
|
for filename in sorted(files):
|
||||||
|
print(f" {filename:<16} {len(files[filename]):>7} Zeichen")
|
||||||
|
|
||||||
|
|
||||||
|
def _normalize(text):
|
||||||
|
"""Zeilenenden vereinheitlichen.
|
||||||
|
|
||||||
|
MakeCode bettet den Quelltext so ein, wie er auf der Platte lag — bei
|
||||||
|
Dateien mit CRLF also mit CRLF. Beim Lesen übersetzt Python das
|
||||||
|
stillschweigend nach LF. Ohne Normalisierung meldet der Vergleich deshalb
|
||||||
|
einen Unterschied, den es gar nicht gibt.
|
||||||
|
"""
|
||||||
|
return text.replace("\r\n", "\n").replace("\r", "\n").strip()
|
||||||
|
|
||||||
|
|
||||||
|
def cmd_check(hexfile, source):
|
||||||
|
"""Prüft, ob die .hex genau den übergebenen Quelltext enthält."""
|
||||||
|
_, files = read_project(hexfile)
|
||||||
|
name = os.path.basename(source)
|
||||||
|
if name not in files:
|
||||||
|
print(f"FEHLER: {name} steckt nicht in {hexfile}", file=sys.stderr)
|
||||||
|
return 1
|
||||||
|
with open(source) as fh:
|
||||||
|
expected = _normalize(fh.read())
|
||||||
|
found = _normalize(files[name])
|
||||||
|
if found != expected:
|
||||||
|
print(f"FEHLER: {name} in {hexfile} weicht von {source} ab "
|
||||||
|
f"({len(found)} vs. {len(expected)} Zeichen) — "
|
||||||
|
f".hex ist veraltet.", file=sys.stderr)
|
||||||
|
return 1
|
||||||
|
print(f"OK: {hexfile} enthält den aktuellen {name}")
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
ap = argparse.ArgumentParser(description=__doc__,
|
||||||
|
formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||||
|
ap.add_argument("files", nargs="+", help=".hex-Dateien (bei --check: <hex> <quelldatei>)")
|
||||||
|
ap.add_argument("-o", "--outdir", default=".", help="Zielordner für die Extraktion")
|
||||||
|
ap.add_argument("--list", action="store_true", help="nur auflisten, nichts schreiben")
|
||||||
|
ap.add_argument("--check", action="store_true",
|
||||||
|
help="prüfen, ob <hex> den aktuellen <quelldatei>-Stand enthält")
|
||||||
|
args = ap.parse_args()
|
||||||
|
|
||||||
|
if args.check:
|
||||||
|
if len(args.files) != 2:
|
||||||
|
ap.error("--check braucht genau zwei Argumente: <hex> <quelldatei>")
|
||||||
|
return cmd_check(args.files[0], args.files[1])
|
||||||
|
if args.list:
|
||||||
|
cmd_list(args.files)
|
||||||
|
return 0
|
||||||
|
cmd_extract(args.files, args.outdir)
|
||||||
|
return 0
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
sys.exit(main())
|
||||||
Reference in New Issue
Block a user