Assignments

Week 15 – System Integration

Assignment

Individual assignment
  • Define and apply system integration to your final project

Project Overview – Octopus Gripper

A soft robotic gripper inspired by octopus tentacles, designed as a modular end-effector for the UR3 robotic arm. The operator controls the gripper intuitively by bending their fingers while wearing a glove equipped with flex sensors. Bending a finger causes the corresponding tentacle to replicate the motion in real time via Bluetooth Low Energy, no cables between glove and gripper.

Each tentacle is printed in TPU 95A with 12 segmented vertebrae and a Dyneema tendon through the central channel. The servo pulls the tendon bending the tentacle up to 120°. Two independent microcontrollers: an ESP32-C3 on the glove (TX) and an XIAO nRF52840 on the gripper (RX). Both communicate exclusively via BLE.

TPU Tentacles

12 segmented vertebrae per tentacle. Dyneema tendon through central channel pulled by SG90 servo — bends up to 120°.

Flex Sensor Glove

3 flex sensors (10–40 kΩ) sewn onto the glove. Voltage divider → ESP32 12-bit ADC → 4096 resolution steps at 20 Hz.

BLE — 2 independent boards

ESP32-C3 (TX/glove) packs "A1,A2,A3". XIAO nRF52840 (RX/gripper) parses and drives the 3 servos. No physical cables.

UR3 Integration

3D-printed ISO 9283 adapter fixes the gripper to the UR3 flange. The arm positions in 3D; BLE handles grasping autonomously.


UR3 Robotic Arm – Integration

UR3 Robotic Arm

The Universal Robots UR3 is a 6-axis cobot with 3 kg payload and 500 mm reach. The arm handles 3D positioning while the BLE system independently manages gripper opening and closing.

  • Payload: 3 kg  ·  Reach: 500 mm
  • Axes: 6 DOF
  • Gripper mount: 3D-printed ISO 9283 adapter
  • Gripper control: Wireless BLE, independent from arm controller

Tentacle CAD Design – Fusion 360 + TPU

The tentacle was modeled in Fusion 360 with 12 identical vertebrae linked by flexible hinges. After 12 print iterations the optimal parameters were found. The tapered profile replicates real cephalopod arm geometry and distributes stress evenly along the full length.

Tentacle CAD – Fusion 360

CAD design in Fusion 360 — TPU 95A tentacle, 12 vertebrae, central Dyneema channel.


Flex Sensor Glove – Electronics

How does the flex sensor work?

Flex sensors are variable resistors: at rest they measure ~10 kΩ and increase up to ~40 kΩ when bent. They are wired in a voltage divider with 10 kΩ to GND. The output reaches the ESP32-C3 ADC with 12-bit resolution (0–4095) sampled at 20 Hz. The firmware maps each ADC value to the 0°–120° range and packs it as "A1,A2,A3" for BLE.

  • Range: 10 kΩ (flat) → 40 kΩ (bent 90°)
  • Supply: 3.3 V from XIAO ESP32-C3
  • Pull-down: 10 kΩ voltage divider
  • ADC Resolution: 12 bits = 4096 steps/channel
  • Sampling: 20 Hz — 50 ms cycle
  • Pins: A0, A1, A2 on ESP32-C3
Flex sensor glove

My PCBs – Glove & Gripper Boards

Two custom boards designed in Fusion 360 and milled on a Roland MDX-50. Each hosts a microcontroller and communicates via BLE, no shared wiring between glove and gripper.

SMD Assembly with solder paste

SMD resistive components are soldered using solder paste. Process: apply paste through stencil, place components with tweezers, cure with heat gun. Ensures more reliable and compact connections than hand soldering.

Glove PCB – Fusion 360
GLOVE BOARD — TX  JP1–JP3 flex connectors · 6× SMD resistors
Gripper PCB – Fusion 360
GRIPPER BOARD — RX  SERVO1 · SERVO2 · SERVO3 · LED indicator
Glove PCB – TX (ESP32-C3)

JP1, JP2, JP3 connectors for the three flex sensors. Six SMD resistors form the voltage dividers. Runs BLE GATT TX firmware.

Gripper PCB – RX (XIAO nRF52840)

Three servo headers (Signal/5V/GND). BLE status LED. XIAO nRF52840 with high-efficiency BLE 5.0.


OLED Display – Eyes Interface

The gripper incorporates a small 128×64 OLED screen connected to the nRF52840 via I2C. Instead of showing technical data, the screen draws animated eyes that react to the gripper state, giving the robot personality while visually indicating BLE connection status and active grip level.

The eyes animate based on system state: when BLE is not connected they blink slowly, upon connection they open fully, and when gripping activates they narrow simulating focus.

C++ / Arduino – OLED Eyes on Gripper nRF52840
// OLED Eyes — Gripper Expression System
#include <Adafruit_SSD1306.h>
#define SCREEN_W 128
#define SCREEN_H 64
Adafruit_SSD1306 display(SCREEN_W, SCREEN_H, &Wire);

enum EyeState { IDLE, CONNECTED, GRIPPING, BLINK };

void drawEyes(EyeState state) {
  display.clearDisplay();
  int eyeH = (state == GRIPPING) ? 14 :
              (state == BLINK)    ? 4  :
              (state == IDLE)     ? 22 : 30;
  display.fillRoundRect(20, (64-eyeH)/2, 36, eyeH, eyeH/2, WHITE);
  display.fillRoundRect(72, (64-eyeH)/2, 36, eyeH, eyeH/2, WHITE);
  if (state != BLINK) {
    display.fillCircle(38, 32, 7, BLACK);
    display.fillCircle(90, 32, 7, BLACK);
  }
  display.display();
}

void setup() {
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  drawEyes(IDLE);
}

void loop() {
  // drawEyes(CONNECTED) when BLE connects
  // drawEyes(GRIPPING) when angles[] > 60
  // drawEyes(BLINK) every 4 seconds
}

Interactive System Diagram

Full signal path from glove to tentacle — click each node to see details.

1Wearable Glove
3× Flex Sensors · Voltage divider
2BLE TX Board
ESP32-C3
3BLE RX Board
XIAO nRF52840
6UR3 Robotic Arm
ISO 9283 Adapter
5TPU Tentacles
3 axes · Dyneema Tendon
4Servo Control
3× SG90 · PWM 50 Hz
1. Wearable Glove – Flex Sensors

Three flex sensors sewn onto the glove fingers. Each sensor changes resistance from 10 kΩ (flat) to 40 kΩ (bent). A voltage divider converts to 0–3.3 V, read by the ESP32 12-bit ADC at 4096 resolution steps and 20 Hz sampling rate.


BLE Packet Visualizer

Every 50 milliseconds, the glove reads the three flex sensors and packs the angles into a single text string, for example "30,60,90". This string travels wirelessly via Bluetooth to the gripper, where the nRF52840 unpacks it and moves each servo to the corresponding angle. Move the sliders to simulate bending your fingers.

TX — Glove
ESP32-C3
A0: --°
A1: --°
A2: --°
BLE GATT · 2.4 GHz
connected · 20 Hz
RX — Gripper
nRF52840
T1: --°
T2: --°
T3: --°
30°
60°
90°
0Packets sent
60°Avg angle
50 msInterval

Firmware – BLE Transmitter (Glove)

C++ / Arduino – XIAO ESP32-C3 (Glove TX)
// BLE Transmitter — Wearable Glove
// XIAO ESP32-C3 | Fab Academy W15
#include <BLEDevice.h>
#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHAR_UUID    "beb5483e-36e1-4688-b7f5-ea07361b26a8"
#define FLEX1 A0
#define FLEX2 A1
#define FLEX3 A2
BLECharacteristic *pChar;

void setup() {
  BLEDevice::init("OctopusGlove");
  BLEServer *srv = BLEDevice::createServer();
  BLEService *svc = srv->createService(SERVICE_UUID);
  pChar = svc->createCharacteristic(
    CHAR_UUID, BLECharacteristic::PROPERTY_NOTIFY);
  svc->start(); BLEDevice::startAdvertising();
}

void loop() {
  int a1 = map(analogRead(FLEX1), 0, 4095, 0, 120);
  int a2 = map(analogRead(FLEX2), 0, 4095, 0, 120);
  int a3 = map(analogRead(FLEX3), 0, 4095, 0, 120);
  String pkt = String(a1)+","+String(a2)+","+String(a3);
  pChar->setValue(pkt.c_str()); pChar->notify();
  delay(50);
}

Firmware – BLE Receiver (Gripper)

C++ / Arduino – XIAO nRF52840 (Gripper RX)
// BLE Receiver — Gripper Controller
// XIAO nRF52840 | Fab Academy W15
#include <BLEDevice.h>
#include <ESP32Servo.h>
Servo s1, s2, s3;
int angles[3] = {0,0,0};

class CB: public BLECharacteristicCallbacks {
  void onWrite(BLECharacteristic *p) {
    String v = p->getValue().c_str();
    int i1=v.indexOf(','), i2=v.indexOf(',',i1+1);
    angles[0]=v.substring(0,i1).toInt();
    angles[1]=v.substring(i1+1,i2).toInt();
    angles[2]=v.substring(i2+1).toInt();
  }
};

void setup() {
  s1.attach(3); s2.attach(4); s3.attach(5);
  BLEDevice::init("");
}

void loop() {
  s1.write(angles[0]);
  s2.write(angles[1]);
  s3.write(angles[2]);
  delay(20);
}

Communication Protocols

Protocol Speed Range Cables Use
I2C400 kHzOn Board2Sensor bus
UART115200 baudShort cable2Debug / serial
SPI8 MHzOn board4Display / peripherals
BLE ✓1 Mbps~10 m0Gripper
Why BLE and not WiFi, UART or I2C?
Low power consumption

The nRF52840 in BLE mode consumes ~3 mA, ideal for battery-powered operation on the gripper.

No cables between glove and gripper

Eliminates tangled cable issues during UR3 arm movement.

Sufficient latency at 20 Hz

BLE GATT notifications deliver angles at 50 ms per cycle, sufficient for smooth servo control.

Autonomous end-effector

The gripper operates as an independent moduleno need to connect to the UR3 controller.


Project Timeline – Gantt

Task Week 1Week 2Week 3Week 4Week 5Week 6
CAD Fusion 360
TPU Printing
PCB + Milling
SMD Solder paste
Firmware BLE TX/RX
OLED Eyes
UR3 Integration
Testing & Demo ✓ Demo