Dieses Repositorium beinhaltet den Code um alle Sensorwerte des Calliope V1.3 auszulesen und über Bluetooth LE UART zu versenden. Nach erfolgreicher Kopplung mit dem Calliope fängt dieser an, die Sensorwerte zu senden.

Kodiert sind die Sensorwerte wie folgt:

• M: Mikrophonelautstärke (Bereich 0-100),
• T: Temperatur (° C) ,
• L: Lichtintensität (Bereich 0-100 , dunkel -> hell) ,
• C: Grad (Bereich 0 - 360 , (360° = Nord, 90° = Ost, 180° = Süd , 270° = West)),
• AX: Beschleunigung auf der x-Achse (in millig (Gravitation)) ,
• AY: Beschleunigung auf der y-Achse (in millig),
• AZ: Beschleunigung auf der z-Achse (in millig),
• AS: aktuell wirkende Gravitation auf dem Calliope,
• BA: Button A betätigt (0 falsch, 1 wahr) ,
• BB: Button B betätigt (0 falsch, 1 wahr)

1. Firmware auf Calliope flashen

   1. Calliope per USB an den PC anschließen
   2. Hex Datei welche unter build/calliope-mini-classic-gcc/source/fh-frankfurt-ss2020-combined.hex zu finden ist auf den Calliope kopieren
   3. Nach erfolgreichem flashen des Calliope leuchtet eine weiße LED

2. Smartphone mit Calliope koppeln

   1. Calliope starten
   2. Button A und Button B drücken
   3. Reset Button kurz antippen
   4. Sobald das Bluetooth Symbol auf dem Bildschirm des Calliope erscheint, Button A und Button B loslassen
   5. Calliope auf dem Smartphone Bluetooth Manager auswählen
   6. Zahlencode (PIN) der auf dem Calliope erscheint notieren und bei der Verbindungsanfrage auf dem Smartphone eingeben
   7. Mit folgender App können die Daten auf dem Smartphone angezeigt werden --> https://play.google.com/store/apps/details?id=de.kai_morich.serial_bluetooth_terminal

   Hardware

   

   Version 1.3

   Entwicklungsumgebung

1. Installation von python LINK
   • Wichtig während der Installation die Option “add to path” auswählen um die Umgebungsvariable zu setzen.
2. Installtion von CMAKE (Yotta nutzt CMake für den Buildprozess) LINK
   • Wichtig während der Installation die Option “add to path” auswählen um die Umgebungsvariable zu setzen.
3. Installation von Ninja 1.10 LINK
   • Die ninja.exe unter C:\ninja speichern und unter PATH in der Umgebungsvariablen angeben.
4. Installation von GNU Arm Embedded Toolchain LINK
5. Yotta installieren über Powershell pip install -U yotta
6. Installation von SRecord LINK
   • SRecord unter C:\srecord speichern und unter PATH in der Umgebungsvariablen angeben.
7. Installation von Visual Studio Code LINK
8. Repositorium herunterladen und Daten in einem seperaten Ordner entpacken. Anschließend diesen mit VSC öffnen.
9. Terminal in VSC öffnen und target compiler definieren yt target calliope-mini-classic-gcc
10. Über den Befehl yt clean und yt build wird die Firmware gebaut und unter build/calliope-mini-classic-gcc/source/fh-frankfurt-ss2020-combined.hex gespeichert.

• Wichtig kein yt update durchführen ansonsten muss MicroBitConfig.h & MicroBitUARTService.h angepasst werden

1. Repositorium der Calliope Projektgruppe herunterladen.
2. Innerhalb des Calliope_WORKING Repositoriums den Ordner "target" anlegen. mkdir target
3. Repositorium der OpenRoberta Lab Crosscompiler Resources herunterladen. LINK
4. Via Compile Script,welches sich im RobotMbed Ordner befindet, wird das Projekt zusammen mit vorkompilierten statischen Bibliotheken kompiliert. ./compile.sh /usr/bin/ Main ./Calliope_WORKING/ ./RobotMbed/libs2017/ -b

• **Wichtig: auf Grund der statischen Bibliotheken ist keine Anpassung der MicroBitConfig.h bzw. MicroBitUARTService.h möglich, ohne diese selbständig neu zu kompilieren. Dies führt je nach Umfang des Projektcodes zu Instabilität der Firmware.

1. Installation von python, cmake, ninja, arm embedded toolchain, yotta (siehe Windows)
2. Der Kompilierprozess per yotta scheitert mit der Fehlermeldung: Region RAM overflowed with stack Dies scheint auf die Bibliotheken zurückzuführen, welche der ARM Compiler während des Linking Vorganges verwendet.

1. Installation von Docker gemäß offizieller Docker Installationsanleitung
2. Im Calliope_WORKING Repositorium muss zunächst das /build/ Verzeichnis geleert werden.
3. Ausführen von docker run -v "/absoluter/Pfad/Calliope_WORKING/:/build/" boonto/yotta:1. Das Docker Image ist zu finden unter LINK
4. Die erzeugte firmware befindet sich im Verzeichnis /Calliope_WORKING/build/calliope-mini-classic-gcc/source/ und trägt die Bezeichnung fh-frankfurt-ss2020-combined.hex

Micro:bit DAL beinhaltet eine Menge an freiparametisierbaren Werten. Die untengenannten Parameter sind speziell für die Firmware angepasst. Eine genaue Aufschlüsselung jedes Parameters ist unter LINK zu finden. Zusätzlich muss der UART Buffer LINK '''MICROBIT_UART_S_DEFAULT_BUF_SIZE''' auf 40 erhöht werden.

{
  "microbit-dal": {
    "bluetooth": {
      "enabled": 1,
      "pairing_mode": 1,
      "private_addressing": 0,
      "open": 1,
      "security_level": null,
      "whitelist": 0,
      "advertising_timeout": 0,
      "tx_power": 7,
      "dfu_service": 0,
      "event_service": 0,
      "device_info_service": 1
    },
    "gatt_table_size": "0x700",
    "debug": 0,
    "heap_debug": 0,
    "reuse_sd": 0,
    "default_pullmode": "PullDown",
    "heap_allocator": 0,
    "nested_heap_proportion": 0.5,
    "system_tick_period": 6,
    "system_components": 10,
    "idle_components": 6,
    "use_accel_lsb": 0,
    "min_display_brightness": 1,
    "max_display_brightness": 255,
    "display_scroll_speed": 120,
    "display_scroll_stride": -1,
    "display_print_speed": 400,
    "panic_on_heap_full": 0,
    "stack_size": 2560,
    "sram_base": "0x20000008",
    "sram_end": "0x20004000",
    "sd_limit": "0x20002000"
  }
}