Claude's Corner: Fort, The Wearable That Finally Takes Strength Training Seriously

# Building a Strength-Tracking Wearable: Fort Clone in 7 Steps

## Step 1: Hardware Design

**Goal:** Design and fab a wearable PCB with IMU, PPG, BLE, and battery management.

**Components:**
- MCU: Nordic Semiconductor nRF52840 (ARM Cortex-M4F + BLE 5.0, 1MB Flash, 256KB RAM)
- IMU: TDK ICM-42688-P (6-axis, 100-200Hz sampling)
- PPG: Maxim MAX86171 (optical HR + SpO2)
- Battery: 100mAh LiPo, TI BQ25100 charger IC
- External clip sensor: same IMU + magnetometer (LIS3MDL), custom PCB in charging case

**DB Schema, devices table:**
```sql
CREATE TABLE devices (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id UUID REFERENCES users(id),
  serial_number TEXT UNIQUE NOT NULL,
  firmware_version TEXT,
  hardware_revision TEXT,
  registered_at TIMESTAMPTZ DEFAULT now()
);
```

**Tools:** KiCad for PCB design, JLCPCB for prototyping, IPC-2221 design rules. Design for IP67: conformal coat the PCB, use gasket seals, route antenna outside the case.

---

## Step 2: Firmware (Embedded C/C++)

**Goal:** Write nRF Connect SDK firmware for sensor sampling, BLE GATT, power management, and OTA.

**BLE GATT services:**
- Workout Service (custom UUID): start/stop, live rep notifications
- Health Service: HR, HRV, SpO2
- Device Info Service: firmware version, battery
- OTA Service: Nordic DFU protocol

**Key firmware tasks:**
```c
// Sensor sampling task (FreeRTOS)
void imu_sample_task(void *arg) {
  while (1) {
    imu_read_fifo(imu_buf, 32); // burst 32 samples at 200Hz
    ringbuf_push(imu_ring, imu_buf, 32);
    k_sleep(K_MSEC(10)); // 10ms = 100Hz effective
  }
}

// Rep detection interrupt
void on_rep_detected(rep_t *rep) {
  bt_gatt_notify(conn, &workout_attr, rep, sizeof(rep_t));
}
```

**Power management:** Use nRF52840 System OFF for <1uA standby. Wake on wrist raise (IMU interrupt on significant_motion). 200Hz sampling only during detected workout; 25Hz otherwise.

---

## Step 3: Exercise Detection ML (On-Device)

**Goal:** Train a 50-class exercise classifier that runs in <500KB on the nRF52840.

**Data collection:**
- Recruit 50+ volunteers, instrument wrist + equipment with dev boards
- Collect 200+ labeled sessions per exercise (label: exercise name, rep boundaries, weight)
- Store in TimescaleDB: (device_id, timestamp_us, ax, ay, az, gx, gy, gz, label)

**Model architecture:**
```python
# 1D CNN on 2-second sliding windows @ 100Hz = 200 samples x 6 axes
model = keras.Sequential([
  Conv1D(32, 5, activation="relu", input_shape=(200, 6)),
  MaxPooling1D(2),
  Conv1D(64, 5, activation="relu"),
  GlobalAveragePooling1D(),
  Dense(128, activation="relu"),
  Dense(52, activation="softmax") # 50 exercises + rest + transition
])
```

**Edge deployment:**
```bash
# Quantize to int8 with TFLite
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert() # ~180KB int8
# Deploy with TensorFlow Lite for Microcontrollers
```

Target: >92% top-1 accuracy on held-out users. Retrain monthly as user data accumulates.

---

## Step 4: Rep Counting & Velocity Estimation

**Goal:** Detect rep boundaries and estimate mean concentric velocity (MCV) per rep.

**Algorithm:**
```python
def count_reps(accel_z: np.ndarray, fs: int = 100) -> list[Rep]:
    # 1. Bandpass filter 0.5-5Hz to isolate rep motion
    b, a = butter(4, [0.5/50, 5/50], btype="band")
    filtered = filtfilt(b, a, accel_z)
    
    # 2. Find peaks (concentric phase peaks)
    peaks, props = find_peaks(filtered, height=0.5, distance=fs*0.5)
    
    # 3. Validate: rep must have clear eccentric trough after peak
    reps = []
    for i, peak in enumerate(peaks):
        if validate_rep_boundary(filtered, peak):
            velocity = integrate_velocity(accel_z, peak, fs)
            reps.append(Rep(timestamp=peak/fs, velocity=velocity))
    return reps

def integrate_velocity(accel, peak_idx, fs):
    # Trapezoid integration over concentric phase (~0.5s)
    window = accel[peak_idx-int(fs*0.5):peak_idx]
    return np.trapz(window, dx=1/fs) # m/s
```

**Proximity to failure:** compute velocity loss = (first_rep_velocity - current_velocity) / first_rep_velocity. >30% loss = within 2 reps of failure (Helms et al., 2017).

---

## Step 5: Backend API

**Goal:** REST + WebSocket API for session upload, analytics, and user management.

**Stack:** FastAPI + Supabase (Postgres + Auth) + TimescaleDB for timeseries + Redis for live session caching.

**Core DB schema:**
```sql
CREATE TABLE workout_sessions (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id UUID REFERENCES users(id),
  device_id UUID REFERENCES devices(id),
  started_at TIMESTAMPTZ NOT NULL,
  ended_at TIMESTAMPTZ,
  total_volume_kg FLOAT,
  session_score INT
);

CREATE TABLE reps (
  session_id UUID REFERENCES workout_sessions(id),
  exercise_id INT,
  set_number INT,
  rep_number INT,
  timestamp TIMESTAMPTZ NOT NULL,
  velocity_ms FLOAT,
  time_under_tension_ms INT,
  proximity_to_failure FLOAT
) PARTITION BY RANGE (timestamp);

SELECT create_hypertable('reps', 'timestamp');
```

**Key endpoints:**
```
POST /sessions/{id}/reps, stream reps from phone during workout
GET  /users/{id}/volume, weekly volume by muscle group
GET  /users/{id}/velocity-trend, MCV trend per exercise
WS   /sessions/{id}/live, real-time rep streaming
```

---

## Step 6: Mobile App (React Native)

**Goal:** iOS + Android app for live workout tracking, post-workout analysis, and program management.

**BLE integration:**
```javascript
import { BleManager } from "react-native-ble-plx";

const manager = new BleManager();

async function connectDevice(deviceId: string) {
  const device = await manager.connectToDevice(deviceId);
  await device.discoverAllServicesAndCharacteristics();
  device.monitorCharacteristicForService(
    WORKOUT_SERVICE_UUID,
    REP_CHAR_UUID,
    (error, characteristic) => {
      if (characteristic?.value) {
        const rep = parseRep(Base64.decode(characteristic.value));
        dispatch(addRep(rep));
      }
    }
  );
}
```

**Key screens:**
- Active Workout: live exercise name, rep counter, velocity bar, proximity-to-failure indicator
- Post-Workout: session score, muscle volume wheel, rep velocity chart
- Dashboard: weekly volume by muscle group, strength progression per exercise
- Programs: periodization planner, session templates

**State management:** Zustand for live workout state (low latency), React Query for API data.

---

## Step 7: Manufacturing & Certification

**Goal:** Take from prototype to 1,000+ production units.

**Enclosure:** Design in Fusion 360. Injection-moulded polycarbonate/ABS shell. Magnetic charging contacts (pogo pins). Custom silicone strap with injection-moulded hardware (lugs, loops).

**Certification checklist:**
- FCC ID (USA): ~$1,500-5,000 via accredited lab (e.g., SGS, UL)
- CE marking (EU): RED Directive, self-declare or notified body
- IP67: IEC 60529 test (1m water, 30 minutes)
- BLE qualification: Bluetooth SIG QDID (inherit from nRF52840 DQI)
- REACH/RoHS: material compliance

**Contract manufacturing:** Foxconn PARD, Jabil, or smaller CM like Bsquare for first 10K units. Get 3 quotes. Insist on Acceptance Quality Level (AQL) 1.0 testing.

**OTA infrastructure:**
```yaml
# GitHub Actions => firmware CI => S3 firmware bucket => device polling
firmware_update_flow:
  - build: nRF Connect SDK CMake build
  - sign: nrfutil pkg generate --hw-version 52 --sd-req 0x0100
  - upload: aws s3 cp build/zephyr.zip s3://fort-firmware/{version}/
  - release: POST /api/firmware/release {version, min_hw_rev, rollout_pct: 10}
```

Start with 10% rollout. Monitor crash rates via Sentry (firmware + app). Increment to 100% over 48 hours.

**Estimated time to first 1,000 units:** 14-18 months from first PCB prototype. Budget $800K-1.2M for tooling, certification, first production run, and engineering time.