Realtime Robothand Fingertracking

Pan and zoom to explore the wiring. Remix the project to edit it in your own workspace.

1. 01

   Maak de voeding spanningsloos

   Koppel de ESP32 los van de computer en laat de externe 5 V-servoadapter nog uit het stopcontact. Zet de vier servohevels voorlopig los van de servoassen; zo kunnen ze later mechanisch in de juiste nulstand worden gemonteerd.

   • Tip: Gebruik een geregelde 5 V-voeding van minimaal 3 A. Voor vier SG90/MG90S-servo's is meer stroomreserve beter.
   • Tip: Servo-kleuren zijn doorgaans: rood = VCC, bruin/zwart = GND, oranje/geel/wit = signaal.

   • ⚠ Voed de servo's niet vanaf de 5V- of 3V3-pin van de ESP32 en niet vanaf de USB-poort van de computer.
   • ⚠ Controleer de kleurcodering van elk servosnoer; goedkope klonen kunnen afwijken.
2. 02

   Verdeel de externe 5 V naar alle servo's

   Verbind de +5 V-uitgang van servo_supply parallel met de rode VCC-draad van servo_pink, servo_ring, servo_middle en servo_index. Verbind de GND-uitgang van servo_supply parallel met de bruine/zwarte GND-draad van alle vier servo's. Gebruik een degelijke klemmenstrook of verdeelblok voor deze gezamenlijke voedingsverbindingen.

   • Tip: Houd de voedingsdraden kort en gebruik voldoende dikke draad voor de gezamenlijke 5 V- en GND-verbindingen.
   • Tip: Een elco van ongeveer 470–1000 µF, minimaal 10 V, over +5 V en GND bij het verdeelpunt helpt spanningsdips door servo's opvangen; plus naar +5 V, min (gestreepte zijde) naar GND.

   • ⚠ Verwissel +5 V en GND nooit; dit kan servo's en de voeding beschadigen.
   • ⚠ Schakel de externe voeding pas in nadat alle aansluitingen zijn gecontroleerd.
3. 03

   Maak één gemeenschappelijke massa

   Verbind de GND-rail van de servo's (de GND van servo_supply en alle bruine/zwarte servodraden) met een GND-pin van de ESP32. De ESP32 wordt daarna via zijn USB-kabel met de computer verbonden voor data en eigen voeding. Verbind de externe +5 V hierbij NIET met de 5V/VIN-pin van de ESP32.

   • Tip: De gemeenschappelijke GND is noodzakelijk: zonder die referentie herkennen de servo's het 3,3 V-PWM-signaal niet betrouwbaar.
   • Tip: Een van de GND-pinnen op de ESP32 DevKit v1 mag worden gebruikt.

   • ⚠ Alleen GND wordt gedeeld tussen servo-voeding en ESP32. Sluit de +5 V van servo_supply niet op een ESP32-GPIO aan.
   • ⚠ Laat de ESP32 via USB aan de computer; USB levert de seriële verbinding die dit project gebruikt.
4. 04

   Verbind de vier PWM-signaaldraden

   Verbind uitsluitend de signaaldraad van elke servo met de aangegeven ESP32-GPIO: servo_pink SIGNAL naar GPIO25, servo_ring SIGNAL naar GPIO26, servo_middle SIGNAL naar GPIO27 en servo_index SIGNAL naar GPIO33. Dit zijn de oranje/gele/witte draden van de servo's.

   • Tip: De GPIO's geven alleen een 3,3 V-stuursignaal; de servo's krijgen hun vermogen nog steeds rechtstreeks van servo_supply.
   • Tip: Markeer de vier servo's fysiek met Pink, Ring, Middel en Wijs om verwisseling bij montage te voorkomen.

   • ⚠ Sluit geen servosignaal aan op GPIO0, GPIO2, GPIO12 of GPIO15: dat zijn opstart-/strappingpinnen.
   • ⚠ Controleer vóór inschakelen dat er geen losse draad of kortsluiting is tussen +5 V en GND.
5. 05

   Nulstand instellen en mechanisch monteren

   Verbind de ESP32 via USB met de computer en gebruik Schematik Deploy om de ESP32-firmware te plaatsen. Zet daarna de externe 5 V-servo-voeding aan. De firmware initialiseert alle servo's op 0°. Monteer nu pas de servohevels en vingermechaniek in de gewenste open-hand-nulstand.

   • Tip: Als een vinger de verkeerde richting beweegt, keer dan in de Python-code alleen voor die vinger de hoek om met 180 - angle, of monteer de hevel anders.
   • Tip: Zet de mechanische eindstop nooit tegen de servo-eindstop. Begrens zo nodig de hoekbereiken in Python.

   • ⚠ Houd vingers uit de buurt van hevels en trekkabels tijdens de eerste test; servo's kunnen abrupt naar de ingestelde stand gaan.
   • ⚠ Stop direct met de externe 5 V-voeding als een servo blokkeert, ratelt of erg warm wordt.

#include <Arduino.h>
/*
  ESP32 robothand: ontvangt vier servohoeken via USB-serieel.

  Verwacht exact één regel per update:
    pink,ring,middle,index\n
  Voorbeeld:
    25,80,130,45

  Elke waarde is een hoek van 0 tot 180 graden. De Python-app op de
  computer verzendt deze regel meerdere keren per seconde.
*/
#include <ESP32Servo.h>

// Veilige PWM-pinnen op de ESP32 DevKit v1.

// Forward declarations
int clampAngle(int angle);
void setServoAngles(int pink, int ring, int middle, int index);
void processLine(char* line);

const int PINK_SERVO_PIN = 25;
const int RING_SERVO_PIN = 26;
const int MIDDLE_SERVO_PIN = 27;
const int INDEX_SERVO_PIN = 33;

Servo pinkServo;
Servo ringServo;
Servo middleServo;
Servo indexServo;

// Servohoek die wordt aangehouden wanneer de hand tijdelijk verdwijnt.
int currentAngles[4] = {0, 0, 0, 0};
char inputLine[48];
size_t inputLength = 0;

// Begrens een ontvangen waarde tot het mechanisch veilige bereik.
int clampAngle(int angle) {
  return constrain(angle, 0, 180);
}

// Schrijf alleen gewijzigde waarden. Dit vermindert onnodige servo-updates.
void setServoAngles(int pink, int ring, int middle, int index) {
  const int received[4] = {
    clampAngle(pink), clampAngle(ring), clampAngle(middle), clampAngle(index)
  };
  Servo* servos[4] = {&pinkServo, &ringServo, &middleServo, &indexServo};

  for (int i = 0; i < 4; i++) {
    if (received[i] != currentAngles[i]) {
      currentAngles[i] = received[i];
      servos[i]->write(currentAngles[i]);
    }
  }
}

// Controleer en verwerk een CSV-regel met precies vier gehele getallen.
void processLine(char* line) {
  int pink, ring, middle, index;
  if (sscanf(line, "%d,%d,%d,%d", &pink, &ring, &middle, &index) == 4) {
    setServoAngles(pink, ring, middle, index);
    Serial.printf("OK,%d,%d,%d,%d\n", currentAngles[0], currentAngles[1],
                  currentAngles[2], currentAngles[3]);
  } else {
    Serial.println("ERR: verwacht pink,ring,middle,index");
  }
}

void setup() {
  Serial.begin(115200);

  // Standaardpulsbereik voor gangbare SG90/MG90S-microservo's.
  pinkServo.setPeriodHertz(50);
  ringServo.setPeriodHertz(50);
  middleServo.setPeriodHertz(50);
  indexServo.setPeriodHertz(50);
  pinkServo.attach(PINK_SERVO_PIN, 500, 2400);
  ringServo.attach(RING_SERVO_PIN, 500, 2400);
  middleServo.attach(MIDDLE_SERVO_PIN, 500, 2400);
  indexServo.attach(INDEX_SERVO_PIN, 500, 2400);

  setServoAngles(0, 0, 0, 0);
  Serial.println("Robothand klaar: stuur pink,ring,middle,index");
}

void loop() {
  // Niet-blokkerend seriëel lezen: de ESP32 verwerkt steeds volledige regels.
  while (Serial.available() > 0) {
    char c = static_cast<char>(Serial.read());

    if (c == '\r') {
      continue; // CR van Windows-regels negeren.
    }
    if (c == '\n') {
      inputLine[inputLength] = '\0';
      if (inputLength > 0) {
        processLine(inputLine);
      }
      inputLength = 0;
    } else if (inputLength < sizeof(inputLine) - 1) {
      inputLine[inputLength++] = c;
    } else {
      // Te lange of kapotte regel weggooien en opnieuw synchroniseren.
      inputLength = 0;
      Serial.println("ERR: invoerregel te lang");
    }
  }
}

“Deploy to device” opens this project in Schematik, where you can flash it to your board over USB.