Gebaren-gestuurde Robotarm met Arduino en AI (TensorFlow Lite) – Handtracking

Onderdelen en benodigdheden

Benodigde tools en machines

• 3D-printer
• PC met Python voor modeltraining (optioneel)

Over dit project

Bestuur een robotarm met handgebaren, herkend door een TensorFlow Lite-model dat draait op de Arduino zelf (Edge AI). Geen cloud, geen latency, volledig offline. Twee benaderingen:

Optie A: IMU-gebaseerd (Arduino Nano 33 BLE Sense)

Draag een IMU-sensor (of de on-board IMU) op je pols/hand. De Arduino herkent gebaren (wijzen, vatten, duwen, trekken, rotatie) via een getraind TFLite-model. De gestuurde robotarm volgt de handpositie/orientatie.

Optie B: Camera-gebaseerd (Portenta H7 + Vision Shield)

Camera films de hand, TFLite-model (bijv. MediaPipe Hand eller HandLandmark) detecteert 21 handlandmarks. Inverse kinematica zet handpositie om in robotarm-joint-hoeken.

Modeltraining (Python)

# Trainen met TensorFlow/Keras, exporteren naar TFLite
import tensorflow as tf
import numpy as np

# Voorbeeld: eenvoudige gesto-classificatie (IMU data)
model = tf.keras.Sequential([
    tf.keras.layers.Conv1D(32, 3, activation='relu', input_shape=(50, 6)), # 50 samples, 6-as IMU
    tf.keras.layers.MaxPooling1D(2),
    tf.keras.layers.Conv1D(64, 3, activation='relu'),
    tf.keras.layers.GlobalAveragePooling1D(),
    tf.keras.layers.Dense(32, activation='relu'),
    tf.keras.layers.Dense(5, activation='softmax') # 5 gebaren
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
# Training met gelabelde data...
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
with open('gesture_model.tflite', 'wb') as f:
    f.write(tflite_model)

Arduino Inference Code

#include <TensorFlowLite.h>
#include <tensorflow/lite/micro/all_ops_resolver.h>
#include <tensorflow/lite/micro/micro_interpreter.h>
#include <tensorflow/lite/schema/schema_generated.h>
#include "gesture_model.h" // gegenereerd via xxd -i gesture_model.tflite

constexpr int tensor_arena_size = 10 * 1024;
uint8_t tensor_arena[tensor_arena_size];

tflite::MicroInterpreter* interpreter;
TfLiteTensor* input;
TfLiteTensor* output;

void setup() {
  // IMU initialiseren (LSM9DS1 op Nano 33 BLE Sense)
  // Model laden
  const tflite::Model* model = tflite::GetModel(gesture_model_tflite);
  static tflite::AllOpsResolver resolver;
  static tflite::MicroInterpreter static_interpreter(model, resolver, tensor_arena, tensor_arena_size);
  interpreter = &static_interpreter;
  interpreter->AllocateTensors();
  input = interpreter->input(0);
  output = interpreter->output(0);
}

void loop() {
  // Lees IMU data (accel + gyro = 6 as)
  float imu_data[50][6];
  for (int i = 0; i < 50; i++) {
    // Vul imu_data[i] met sensor readings
    delay(20); // 50Hz sampling
  }
  // Kopieer naar input tensor
  for (int i = 0; i < 50; i++)
    for (int j = 0; j < 6; j++)
      input->data.f[i*6 + j] = imu_data[i][j];

  // Inference
  interpreter->Invoke();

  // Resultaat
  int gesture = 0;
  float max_prob = 0;
  for (int i = 0; i < 5; i++) {
    if (output->data.f[i] > max_prob) {
      max_prob = output->data.f[i];
      gesture = i;
    }
  }
  if (max_prob > 0.8) executeGesture(gesture);
}

void executeGesture(int gesture) {
  // Map gesto naar robotarm actie via IK
  // 0: wijzen → move to point
  // 1: vatten → close gripper
  // 2: loslaten → open gripper
  // 3: duwen → move -Z
  // 4: trekken → move +Z
}

Camera-gebaseerde Handtracking (Portenta)

Gebruik MediaPipe Hand Landmark model (TFLite versie) op Portenta H7. Detecteert 21 landmarks (x,y,z genormaliseerd). Map indexvinger-tip naar cartesiaans doel voor robotarm IK. Vereist Portenta Vision Shield en camera.

Schema

Arduino Nano 33 BLE Sense: on-board sensoren, I2C naar PCA9685 voor servo's. Portenta H7: Vision Shield op high-density connector, I2C naar PCA9685. Voeding gedeeld 5V/6V 10A+.

Uitdagingen & Oplossingen

• Latentie: Edge AI elimineert netwerklatentie. Doel: <100ms end-to-end.
• Nauwkeurigheid: Data augmentatie, meer trainingdata, confidence threshold (0.8).
• Geheugen: Tensor arena tuning, model quantisatie (INT8).
• Veiligheid: Workspace-begrenzing, krachtlimieten, noodstop.