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
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.
CAD design in Fusion 360 — TPU 95A tentacle, 12 vertebrae, central Dyneema channel.
Final print parameters – TPU 95A
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
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 – 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.
// 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.
3× Flex Sensors · Voltage divider
ESP32-C3
XIAO nRF52840
ISO 9283 Adapter
3 axes · Dyneema Tendon
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.
A1: --°
A2: --°
T2: --°
T3: --°
Firmware – BLE Transmitter (Glove)
// 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)
// 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 |
|---|---|---|---|---|
| I2C | 400 kHz | On Board | 2 | Sensor bus |
| UART | 115200 baud | Short cable | 2 | Debug / serial |
| SPI | 8 MHz | On board | 4 | Display / peripherals |
| BLE ✓ | 1 Mbps | ~10 m | 0 | Gripper |
Why BLE and not WiFi, UART or I2C?
The nRF52840 in BLE mode consumes ~3 mA, ideal for battery-powered operation on the gripper.
Eliminates tangled cable issues during UR3 arm movement.
BLE GATT notifications deliver angles at 50 ms per cycle, sufficient for smooth servo control.
The gripper operates as an independent moduleno need to connect to the UR3 controller.
Project Timeline – Gantt
| Task | Week 1 | Week 2 | Week 3 | Week 4 | Week 5 | Week 6 |
|---|---|---|---|---|---|---|
| CAD Fusion 360 | ||||||
| TPU Printing | ||||||
| PCB + Milling | ||||||
| SMD Solder paste | ||||||
| Firmware BLE TX/RX | ||||||
| OLED Eyes | ||||||
| UR3 Integration | ||||||
| Testing & Demo | ✓ Demo |