Gesture Hero

npm install -g edge-impulse-cli

# Vérifier l'installation :
edge-impulse-daemon --version

pip install pyserial pynput

edge-impulse-data-forwarder

#include <ArduinoBLE.h>
#include <NOM_DE_TON_PROJET_inferencing.h>
#include <Arduino_LSM9DS1.h>

// ── UUIDs du service BLE ──
#define SERVICE_UUID "19B10000-E8F2-537E-4F6C-D104768A1214"
#define CHAR_UUID    "19B10001-E8F2-537E-4F6C-D104768A1214"

BLEService gestureService(SERVICE_UUID);
BLEStringCharacteristic gestureChar(CHAR_UUID, BLERead | BLENotify, 20);

#define CONFIDENCE_THRESHOLD 0.70f
#define IDLE_LABEL "idle"

float features[EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE];

void setup() {
  Serial.begin(115200);
  if (!IMU.begin()) { Serial.println("IMU ERREUR"); while(1); }
  if (!BLE.begin()) { Serial.println("BLE ERREUR"); while(1); }

  BLE.setLocalName("GestureHero");
  BLE.setAdvertisedService(gestureService);
  gestureService.addCharacteristic(gestureChar);
  BLE.addService(gestureService);
  BLE.advertise();
  Serial.println("GestureHero prêt — en attente BLE...");
}

void loop() {
  BLEDevice central = BLE.central();
  if (!central) return;

  while (central.connected()) {
    // 1. Remplir le buffer IMU
    int samples = EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE / 6;
    for (int i = 0; i < samples; i++) {
      float ax, ay, az, gx, gy, gz;
      while (!IMU.accelerationAvailable());
      IMU.readAcceleration(ax, ay, az);
      IMU.readGyroscope(gx, gy, gz);
      int idx = i * 6;
      features[idx] = ax; features[idx+1] = ay; features[idx+2] = az;
      features[idx+3] = gx; features[idx+4] = gy; features[idx+5] = gz;
      delay(1000 / EI_CLASSIFIER_FREQUENCY);
    }

    // 2. Inférence
    signal_t signal;
    numpy::signal_from_buffer(features, EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE, &signal);
    ei_impulse_result_t result = { 0 };
    run_classifier(&signal, &result, false);

    // 3. Meilleure classe
    String best = ""; float score = 0;
    for (int j = 0; j < EI_CLASSIFIER_LABEL_COUNT; j++) {
      if (result.classification[j].value > score) {
        score = result.classification[j].value;
        best = result.classification[j].label;
      }
    }

    // 4. Envoyer via BLE
    if (score >= CONFIDENCE_THRESHOLD && best != IDLE_LABEL) {
      gestureChar.writeValue(best);
    }
  }
  BLE.advertise();
}

#include "BLEDevice.h"

static BLEUUID serviceUUID("19B10000-E8F2-537E-4F6C-D104768A1214");
static BLEUUID charUUID   ("19B10001-E8F2-537E-4F6C-D104768A1214");

BLEClient* pClient = nullptr;
BLERemoteCharacteristic* pChar = nullptr;
BLEAdvertisedDevice* myDevice = nullptr;
bool doConnect = false, connected = false;

// Callback : notification BLE reçue → envoyer au PC
void notifyCallback(BLERemoteCharacteristic* pCh,
                    uint8_t* data, size_t length, bool isNotify) {
  String gesture = "";
  for (int i = 0; i < (int)length; i++) gesture += (char)data[i];
  Serial.println(gesture); // ← Le PC Python lit cette ligne
}

// Callback : scan BLE — trouver "GestureHero"
class MyCallbacks : public BLEAdvertisedDeviceCallbacks {
  void onResult(BLEAdvertisedDevice adv) {
    if (adv.getName() == "GestureHero") {
      BLEDevice::getScan()->stop();
      myDevice = new BLEAdvertisedDevice(adv);
      doConnect = true;
    }
  }
};

void connectToServer() {
  pClient = BLEDevice::createClient();
  pClient->connect(myDevice);
  auto pSvc = pClient->getService(serviceUUID);
  if (!pSvc) { pClient->disconnect(); return; }
  pChar = pSvc->getCharacteristic(charUUID);
  if (pChar && pChar->canNotify())
    pChar->registerForNotify(notifyCallback);
  connected = true;
}

void setup() {
  Serial.begin(115200);
  BLEDevice::init("");
  auto pScan = BLEDevice::getScan();
  pScan->setAdvertisedDeviceCallbacks(new MyCallbacks());
  pScan->setActiveScan(true);
  pScan->start(30, false);
}

void loop() {
  if (doConnect && !connected) connectToServer();
  if (connected && !pClient->isConnected()) {
    connected = false; doConnect = false;
    BLEDevice::getScan()->start(30, false);
  }
  delay(100);
}

import serial
import time
from pynput.keyboard import Key, Controller

# ── Configuration ──
SERIAL_PORT = '/dev/ttyUSB0'  # Windows: 'COM3'
BAUD_RATE   = 115200
KEY_PRESS   = 0.15  # secondes

# ── Mapping geste → touche ──
KEY_MAP = {
    'haut':    Key.up,
    'bas':     Key.down,
    'gauche':  Key.left,
    'droite':  Key.right,
}

keyboard = Controller()
print(f"[GestureHero] Connexion sur {SERIAL_PORT}...")

try:
    port = serial.Serial(SERIAL_PORT, BAUD_RATE, timeout=1)
    print("[GestureHero] Connecté. En attente de gestes...")

    while True:
        try:
            raw = port.readline()
            if not raw: continue
            gesture = raw.decode('utf-8').strip().lower()
            if not gesture: continue

            if gesture in KEY_MAP:
                key = KEY_MAP[gesture]
                print(f"[GestureHero] {gesture:8s} → touche simulée")
                keyboard.press(key)
                time.sleep(KEY_PRESS)
                keyboard.release(key)
        except UnicodeDecodeError:
            pass

except serial.SerialException as e:
    print(f"[ERREUR] Port série : {e}")