The 2D sketch defines the cross-section of each vertebra. Key dimensions: 3.5 mm wide at the hinge neck, 12.5 mm body width, 6 mm height, 2.5 mm tendon channel diameter. The 120° angles on the side faces allow the vertebrae to lock together at angle without binding when the tentacle bends.

Extrusion 1 takes 3 profiles — the outer body, the tendon channel bore, and the hinge tab geometry — and extrudes them 10 mm to form the solid vertebra block. The three profiles are selected together so all features are cut in one operation, keeping the model clean.

A 4 mm boolean cut removes material to create the flexible neck between vertebrae. This thin section is what allows the TPU to flex at each joint. The 4 mm depth was calibrated so the neck is flexible enough to reach 120° but strong enough to survive hundreds of bend cycles without tearing.

The tendon channel is extended 9.8 mm through the hinge zone using 3 profiles. This ensures the Dyneema line runs continuously from tip to base without kinking at each joint. The 9.8 mm was chosen to align the channel exit exactly at the center of the hinge pivot point.

The complete tentacle: 12 vertebrae linked by flexible hinges, with a tapered profile (wider at the base, narrower at the tip) and the Dyneema channel running the full length. At the bottom, the connector base locks into the hub servo pocket; at the top, the tip cap anchors the Dyneema line. Total printed length: approximately 140 mm.

The first extrusion defines the outer geometry of the hub using 14 profiles simultaneously — the circular base plate, three servo pockets at 120° from each other, three tentacle slot openings, and the bolt pattern that matches the UR3 tool flange dimensions. 14 profiles in one operation keeps the feature tree clean. The 25 mm height gives enough structural depth to hold the servos rigidly without the tentacles pulling them loose under load.

This extrusion adds the inner concentric ring that creates the PCB mounting shelf and the servo wire routing channel between the inner and outer walls. The 15 mm height positions the shelf at the right depth so the gripper PCB sits flush with the top of the hub. The two circular profiles define the inner bore where the PCB and PCA9685 sit, and the servo cavity wall that keeps the wiring separated from the servo horn rotation path.

A 17 mm rectangular boolean cut on the side of the hub creates the cable management channel. This slot is positioned exactly where the LiPo power cable and the BLE antenna of the XIAO ESP32-C6 exit the hub body. Routing the cable through a dedicated slot — rather than letting it hang loose — keeps it away from the servo horns rotating inside and makes the assembly look clean from the outside.

The final extrusion adds the retention geometry for the electronics stack: 4 profiles define the PCB clip tab that holds the gripper board in place, the PCA9685 mounting recess below it, and the three leg posts at the base (3 mm and 10 mm features visible in the dimension callouts) that lock the entire hub assembly onto the custom UR3 adapter. The 8 mm height is the exact clearance needed to stack the XIAO ESP32-C6 on top of the PCA9685 with the I2C header connected between them.

/*
  =====================================================
  TRANSMISOR BLE — Seeed XIAO ESP32-C6
  3 flex sensors (A0, A1, A2) → 3 servos
  =====================================================
  Sensor Flex 1 → A0
  Sensor Flex 2 → A1
  Sensor Flex 3 → A2
  (3.3V → flex → pin ADC → 10kΩ → GND)
  =====================================================
*/
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>

#define SERVICE_UUID        "12345678-1234-1234-1234-123456789abc"
#define CHARACTERISTIC_UUID "abcd1234-ab12-ab12-ab12-abcdef012345"

// ── Pines flex ───────────────────────────────────────
const int FLEX_PIN[3] = { A0, A1, A2 };

// ── Calibración ──────────────────────────────────────
const int ADC_MIN = 900;   // mano cerrada  → 0°
const int ADC_MAX = 750;   // mano estirada → 180°

// ── Objetos BLE ──────────────────────────────────────
BLEServer*         pServer         = nullptr;
BLECharacteristic* pCharacteristic = nullptr;
bool deviceConnected    = false;
bool oldDeviceConnected = false;

class MyServerCallbacks : public BLEServerCallbacks {
  void onConnect(BLEServer* pServer) override {
    deviceConnected = true;
    Serial.println("✅ Cliente BLE conectado");
  }
  void onDisconnect(BLEServer* pServer) override {
    deviceConnected = false;
    Serial.println("❌ Cliente BLE desconectado");
  }
};

int flexToAngle(int rawADC) {
  return constrain(map(rawADC, ADC_MIN, ADC_MAX, 0, 180), 0, 180);
}

void setup() {
  Serial.begin(115200);
  Serial.println("=== TRANSMISOR BLE — 3 Flex → 3 Servos ===");
  analogReadResolution(12);
  BLEDevice::init("TentaculoBot_TX");
  BLEDevice::setPower(ESP_PWR_LVL_P9);
  pServer = BLEDevice::createServer();
  pServer->setCallbacks(new MyServerCallbacks());
  BLEService* pService = pServer->createService(SERVICE_UUID);
  pCharacteristic = pService->createCharacteristic(
    CHARACTERISTIC_UUID,
    BLECharacteristic::PROPERTY_NOTIFY
  );
  pCharacteristic->addDescriptor(new BLE2902());
  pService->start();
  BLEAdvertising* pAdvertising = BLEDevice::getAdvertising();
  pAdvertising->addServiceUUID(SERVICE_UUID);
  pAdvertising->setScanResponse(true);
  pAdvertising->setMinPreferred(0x06);
  BLEDevice::startAdvertising();
  Serial.println("📡 Esperando conexión BLE...");
}

void loop() {
  if (deviceConnected) {
    int raw[3], ang[3];
    for (int i = 0; i < 3; i++) {
      raw[i] = analogRead(FLEX_PIN[i]);
      ang[i] = flexToAngle(raw[i]);
    }
    char payload[32];
    snprintf(payload, sizeof(payload), "%d,%d,%d", ang[0], ang[1], ang[2]);
    pCharacteristic->setValue(payload);
    pCharacteristic->notify();
    Serial.printf("📤 Enviado: %s  (raw: %d, %d, %d)\n", payload, raw[0], raw[1], raw[2]);
    delay(50);
  }
  if (!deviceConnected && oldDeviceConnected) {
    delay(500);
    pServer->startAdvertising();
    Serial.println("📡 Re-advertising...");
    oldDeviceConnected = deviceConnected;
  }
  if (deviceConnected && !oldDeviceConnected) {
    oldDeviceConnected = deviceConnected;
  }
}

/*
  =====================================================
  RECEPTOR BLE — Seeed XIAO ESP32-C6 + PCA9685
  =====================================================
  PCA9685:
    SDA → D4 | SCL → D5 | VCC → 3.3V | V+ → 5V ext
  Servos:
    Canal 0 → Servo 1 (Flex A0)
    Canal 1 → Servo 2 (Flex A1)
    Canal 2 → Servo 3 (Flex A2)
  Suavizado: SMOOTH = 0.3 (cambiar a 1.0 para respuesta directa)
  =====================================================
*/
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEScan.h>
#include <BLEClient.h>
#include <BLEAdvertisedDevice.h>
#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

#define SERVICE_UUID        "12345678-1234-1234-1234-123456789abc"
#define CHARACTERISTIC_UUID "abcd1234-ab12-ab12-ab12-abcdef012345"

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);
#define SERVO_MIN  102
#define SERVO_MAX  512
#define SERVO_CH1  0
#define SERVO_CH2  1
#define SERVO_CH3  2

static BLEAddress*   pServerAddress = nullptr;
static bool          doConnect      = false;
static bool          connected      = false;
static BLEClient*    pClient        = nullptr;
static BLERemoteCharacteristic* pRemoteChar = nullptr;

float angle1 = 90, angle2 = 90, angle3 = 90;
const float SMOOTH = 0.3f;

uint16_t angleToPulse(float angle) {
  return (uint16_t)map((long)angle, 0, 180, SERVO_MIN, SERVO_MAX);
}

class MyClientCallbacks : public BLEClientCallbacks {
  void onConnect(BLEClient* pClient) override { connected = true; }
  void onDisconnect(BLEClient* pClient) override {
    connected = false;
    BLEDevice::getScan()->start(5, false);
  }
};

void notifyCallback(BLERemoteCharacteristic* pChar,
                    uint8_t* pData, size_t length, bool isNotify) {
  char buf[32] = {0};
  memcpy(buf, pData, min(length, (size_t)31));
  String payload = String(buf);
  int idx1 = payload.indexOf(',');
  int idx2 = payload.indexOf(',', idx1 + 1);
  if (idx1 < 0 || idx2 < 0) return;
  float a1 = payload.substring(0, idx1).toFloat();
  float a2 = payload.substring(idx1 + 1, idx2).toFloat();
  float a3 = payload.substring(idx2 + 1).toFloat();
  angle1 += SMOOTH * (a1 - angle1);
  angle2 += SMOOTH * (a2 - angle2);
  angle3 += SMOOTH * (a3 - angle3);
  pwm.setPWM(SERVO_CH1, 0, angleToPulse(angle1));
  pwm.setPWM(SERVO_CH2, 0, angleToPulse(angle2));
  pwm.setPWM(SERVO_CH3, 0, angleToPulse(angle3));
  Serial.printf("📥 %s  →  %.0f° %.0f° %.0f°\n", buf, angle1, angle2, angle3);
}

class MyAdvertisedDeviceCallbacks : public BLEAdvertisedDeviceCallbacks {
  void onResult(BLEAdvertisedDevice dev) override {
    if (dev.haveServiceUUID() && dev.isAdvertisingService(BLEUUID(SERVICE_UUID))) {
      BLEDevice::getScan()->stop();
      pServerAddress = new BLEAddress(dev.getAddress());
      doConnect = true;
    }
  }
};

bool connectToServer() {
  if (pClient != nullptr) { if (pClient->isConnected()) pClient->disconnect(); delete pClient; pClient = nullptr; }
  pClient = BLEDevice::createClient();
  pClient->setClientCallbacks(new MyClientCallbacks());
  if (!pClient->connect(*pServerAddress)) return false;
  BLERemoteService* pService = pClient->getService(SERVICE_UUID);
  if (!pService) { pClient->disconnect(); return false; }
  pRemoteChar = pService->getCharacteristic(CHARACTERISTIC_UUID);
  if (!pRemoteChar) { pClient->disconnect(); return false; }
  if (pRemoteChar->canNotify()) pRemoteChar->registerForNotify(notifyCallback);
  return true;
}

void setup() {
  Serial.begin(115200);
  Wire.begin();
  pwm.begin();
  pwm.setOscillatorFrequency(27000000);
  pwm.setPWMFreq(50);
  delay(10);
  pwm.setPWM(SERVO_CH1, 0, angleToPulse(90));
  pwm.setPWM(SERVO_CH2, 0, angleToPulse(90));
  pwm.setPWM(SERVO_CH3, 0, angleToPulse(90));
  BLEDevice::init("TentaculoBot_RX");
  BLEDevice::setPower(ESP_PWR_LVL_P9);
  BLEScan* pBLEScan = BLEDevice::getScan();
  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
  pBLEScan->setActiveScan(true);
  pBLEScan->setInterval(100);
  pBLEScan->setWindow(99);
  pBLEScan->start(10, false);
}

void loop() {
  if (doConnect) {
    doConnect = false;
    if (!connectToServer()) {
      delay(5000);
      BLEDevice::getScan()->start(5, false);
    }
  }
  delay(10);
}