AnFlex (2024)

An integrated ankle-pump exercise assistance and management system.

Project Overview

Project Summary

This project addresses the critical risk of Deep Vein Thrombosis (DVT) in cancer patients undergoing chemotherapy by designing and building an Ankle-pump Exercise Assistance System. The system transforms a difficult rehabilitation routine into a manageable task by combining mechanical assistance with a digital management console.

The system utilizes servo motors to physically assist the ankle exercise when fatigue sets in. An IMU sensor is integrated into the pedal collects motion data, which is processed by an Arduino board. This data is transmitted via Python SDK to an Appwrite Cloud backend. Consequently, the system provides immediate haptic feedback (via a vibration motor) to deliver useful information for patients (exercise quality, exercise starting and ending, etc.).

To ensure efficient data management and user engagement, a dual-interface software solution was developed: a mobile app for patients to control the device and track compliance, and a web dashboard for medical workers to monitor real-time patient status and exercise history.

My Contributions

I was fully responsible for the end-to-end development of the interaction and information management system, bridging the gap between hardware sensing and software application:

Microcontroller & Sensor Integration
Cloud Backend & Data Transfer
Hardware Prototyping & Assembly (Collaborating with Mechanical Designers)
Mobile & Web App Development

Tech Stack

Embedded & IoT Hardware: Arduino, Socket/Serial Protocol
Backend & Cloud: Appwrite Cloud, Python SDK
Frontend: React

Acknowledgements

Thanks to Prof. Ting Han and Prof. Xinyang Tan for guidance, and to Fudan University Shanghai Cancer Center and its medical staff for their support.

Problem Framing

Project Background

The project was initiated based on real-world clinical pain points identified by medical staff at Fudan University Shanghai Cancer Center. Deep vein thrombosis (DVT) is a major concern in hospital settings, as it can progress to fatal pulmonary embolism (PE), which carries a mortality rate of 20–30%. While ankle pump exercises have been proven to be the simplest, most cost-effective, and non-invasive method for preventing DVT by promoting lower-limb blood circulation, many patients—particularly those who are bedridden or recovering from surgery—face difficulties in performing these exercises correctly and consistently.

In response to this gap between proven prevention and actual patient compliance, the medical staff at the Cancer Center called for the design and development of a device that can assist and monitor ankle pump movements, specifically targeting high-risk populations such as patients undergoing cancer treatment.

Occurrence of DVT in 6 months following the surgery (p = 0.032)

References:

Active Ankle Movement May Prevent Deep Vein Thrombosis in Patients Undergoing Lower Limb Surgery - https://www.sciencedirect.com/science/article/pii/S0890509616000285

Field Research & Interview

To gain a deep understanding of the problem context, we conducted on-site research at the hospital. Through close observations of the treatment scenarios of cancer chemotherapy patients (especially the physical constraints and ward environment), and interviews with several healthcare professionals, we understood the functional requirements and system design limitations in this clinical setting.

Environment

Patients

Caregivers

Nurses

Pain Points:

Limited space in shared wards (e.g., triple/quadruple rooms)
Privacy concerns (given the sensitive location of femoral artery access)

Demands:

Compact, easy-to-wear device design
No camera-based solutions (compromise privacy)
No voice interactions (disturbing for shared wards)

System Architecture

Mechanical Design

The device uses a compact pedal module mounted on the bed’s footboard via a sliding rail, allowing height adjustment for different patients. A soft orthosis secures the limb while leaving the ankle free for movement. Two servo motors are used to provide motion assistance. Each servo is connected to the pedal via an elastic cord, ensuring that the pulling force changes linearly during movement. This linear force variation prevents sudden tension shifts, making the exercise smooth and comfortable for the patient.

Data Flow

The system follows a three-tier IoT architecture:

Perception Layer — The hardware prototype integrates an IMU sensor embedded in the pedal to capture real‑time motion data. An Arduino microcontroller handles local data processing, control logic, servo motor control for mechanical assistance, and a vibration motor for haptic feedback. It runs closed‑loop algorithms to assess exercise compliance and movement quality.
Network Layer — The microcontroller transmits sensor data to Appwrite Cloud via Python SDK. This layer manages data validation, protocol conversion, and reliable bidirectional communication.
Application Layer — The cloud database (Appwrite) synchronizes data with two client applications: (1) a Mobile App for patients (and caregivers) to control the device, view exercise progress, and receive notifications; and (2) a Web Dashboard for medical professionals to monitor multiple patients’ compliance, analyze training history, and generate reports.

User Flow

The patient starts the session via the app. The device then signals the start with a vibration, prompting the patient to begin the ankle-pump exercise. As the device drives the pedal, an IMU sensor validates the movement. If the motion is correct, the server increments the rep count, and the device provides vibration feedback to the patient. This cycle repeats until the target repetitions are reached. Once completed, the device stops and signals the end of the session, the server generates a report, and both the patient and nurse can view the final records.

For patients, the automated vibration feedback and app-based control eliminate the need for constant manual tracking, making rehabilitation exercises more engaging and easier to perform independently.
For nurses, the real-time dashboard and automated report generation enable efficient remote monitoring of multiple patients’ progress without requiring physical presence during each exercise session.

Hardware Prototyping & Data Transfer

Pedal & Servo Integration

During the construction of the physical prototype, we installed a pair of foot pedals with caster wheels onto a base made of steel bars and slide rails, and connected two 35kg servo motors to the left and right pedals respectively.

Sensor & Data Transfer

At the same time, we tested the IMU sensor on a cardboard model, defined appropriate angle thresholds based on the actual scenario of ankle pump exercises. Then, we developed a step counter according to the thresholds, and uploaded the motion data in real time to the backend of Appwrite Cloud via the Socket io and Python SDK.

Testing Data Collection & Transfer (Arduino -> Python -> Appwrite Cloud) with paper model (and my old laptop)

Python (Data Transfer & Connection with Cloud)

1import serial
2import time
3from datetime import datetime, timezone
4from appwrite.client import Client
5from appwrite.services.databases import Databases
6from appwrite.id import ID
7 
8# ========== Configuration ==========
9SERIAL_PORT = "COM3"          
10BAUD_RATE = 115200
11 
12# ========== Appwrite Settings & Initialization ==========
13 
14APPWRITE_ENDPOINT = "https://cloud.appwrite.io/v1"
15APPWRITE_PROJECT_ID = "project_id"
16APPWRITE_API_KEY = "api_key"           
17APPWRITE_DATABASE_ID = "database_id"           
18APPWRITE_COLLECTION_ID = "collection_name"        
19 
20PATIENT_ID = "patient_001"                   
21 
22client = Client()
23client.set_endpoint(APPWRITE_ENDPOINT)
24client.set_project(APPWRITE_PROJECT_ID)
25client.set_key(APPWRITE_API_KEY)
26 
27databases = Databases(client)
28 
29# ========== Read steps from serial ==========
30def read_step_from_serial(serial_connection):
31 
32    if serial_connection.in_waiting:
33        line = serial_connection.readline().decode('utf-8', errors='ignore').strip()
34        if line.startswith("STEP:"):
35            try:
36                steps = int(line.split(":")[1])
37                return steps
38            except (IndexError, ValueError):
39                print(f"Data format error: {line}")
40                return None
41    return None
42 
43# ========== Upload data to Appwrite Cloud ==========
44def upload_step_count(steps):
45    try:
46        record = {
47            "patient_id": PATIENT_ID,
48            "steps": steps,
49            "timestamp": datetime.now(timezone.utc).isoformat()
50        }
51        
52        result = databases.create_document(
53            database_id=APPWRITE_DATABASE_ID,
54            collection_id=APPWRITE_COLLECTION_ID,
55            document_id=ID.unique(),
56            data=record
57        )
58        print(f"Uploaded: {steps} steps (Document ID: {result['$id']})")
59        return True
60    except Exception as e:
61        print(f"Upload failed: {e}")
62        return False
63 
64# ========== Main program ==========
65 
66if __name__ == "__main__":
67    try:
68        ser = serial.Serial(SERIAL_PORT, BAUD_RATE, timeout=1)
69        print(f"Serial port {SERIAL_PORT} opened, listening...")
70    except serial.SerialException as e:
71        print(f"Failed to open serial port {SERIAL_PORT}: {e}")
72 
73    try:
74        while True:
75            steps = read_step_from_serial(ser)
76            if steps is not None:
77                print(f"Received steps: {steps}")
78                upload_step_count(steps)
79            time.sleep(0.1) 
80    except KeyboardInterrupt:
81        print("\nProgram exited")
82    finally:
83        ser.close()

Arduino (Data Collection & Step Counter)

1#include <Wire.h>
2#include <MPU6050.h>
3 
4MPU6050 mpu;
5 
6// Step counter parameters
7const unsigned long MIN_STEP_INTERVAL = 300;   
8const float STEP_THRESHOLD = 0.15;             
9const float MIN_MAGNITUDE = 1.0;   
10 
11// Data upload parameters
12const unsigned long UPLOAD_INTERVAL = 5000;    
13unsigned long lastUploadTime = 0;
14 
15// State variables
16unsigned long lastStepTime = 0;
17int stepCount = 0;                              
18float lastMagnitude = 0;
19 
20// Sensor data
21float ax, ay, az;
22float magnitude = 0;
23 
24// ========== Step detection function ==========
25bool detectStep(float currentMagnitude, float previousMagnitude, unsigned long currentTime) {
26  // Check time interval
27  if (currentTime - lastStepTime < MIN_STEP_INTERVAL) {
28    return false;
29  }
30  
31  // Calculate change in magnitude
32  float change = fabs(currentMagnitude - previousMagnitude);
33  
34  // Apply threshold and magnitude range check
35  if (change >= STEP_THRESHOLD && 
36      currentMagnitude >= MIN_MAGNITUDE && 
37      currentMagnitude <= 3.0) {
38    return true;
39  }
40  return false;
41}
42 
43// ========== Data upload function ==========
44void sendStepData() {
45  // Send in simple text format, e.g. "STEP:25"
46  Serial.print("STEP:");
47  Serial.println(stepCount);
48}
49 
50void setup() {
51  Serial.begin(115200);
52  Wire.begin();
53  mpu.initialize();
54  
55  if (!mpu.testConnection()) {
56    Serial.println("MPU Connection Failed.");
57    while (1);
58  }
59  
60  lastUploadTime = millis();
61}
62 
63void loop() {
64  // Read raw data from sensor & Convert data to g
65  int16_t ax_raw, ay_raw, az_raw;
66  mpu.getAcceleration(&ax_raw, &ay_raw, &az_raw);
67  ax = ax_raw / 16384.0;
68  ay = ay_raw / 16384.0;
69  az = az_raw / 16384.0;
70  
71  // Compute resultant magnitude
72  magnitude = sqrt(ax*ax + ay*ay + az*az);
73  
74  unsigned long now = millis();
75  
76  // Step detection
77  if (detectStep(magnitude, lastMagnitude, now)) {
78    stepCount++;
79    lastStepTime = now;
80  }
81  lastMagnitude = magnitude;
82  
83  // Upload step count
84  if (now - lastUploadTime >= UPLOAD_INTERVAL) {
85    sendStepData();
86    lastUploadTime = now;
87  }
88  
89  delay(50);  
90}

Code for prototype (basic step counter & cloud connection)

Assembly

We installed the sensing system into a leg brace (with the fixation at the ankle joint removed to allow movement) and attached it to one side of the pedal, in order to synchronize the servo-assisted motion with the counting of the IMU sensor.

Software Development

Backend (Server): Appwrite Database Implementation

For the prototype, we implemented a simplified database architecture using Appwrite Cloud and focused on core functionality: exercise reps tracking and cloud synchronization.

The system utilizes 2 tables to store training session records and patient information. Both tables are indexed by patient ID, enabling retrieval of individual records.

Patients Info Collection: Stores minimal patient information including a unique patient ID, name, ward number, chemotherapy starting & ending time, and a cumulative exercise session counter that automatically increments with each completed session.
Training Sessions Collection: Records individual exercise sessions with details such as session ID, repetition count, duration, and timestamps.

Training Session (Python)

1    # Create the table 'TrainingSessions'
2    trainingTable = tablesDB.create_table(
3        database_id=anFlexDB.id,
4        table_id=ID.unique(),
5        name='TrainingSessions'
6    )
7 
8    # Define columns
9 
10    # patientId: string reference to patients.patientId
11    tablesDB.create_varchar_column(
12        database_id=trainingDatabase.id,
13        table_id=trainingTable.id,
14        key='patientId',
15        size=255,
16        required=True
17    )
18 
19    # sessionId: unique identifier (e.g., '20240120-P001-001')
20    tablesDB.create_varchar_column(
21        database_id=trainingDatabase.id,
22        table_id=trainingTable.id,
23        key='sessionId',
24        size=255,
25        required=True
26        # Uniqueness constraint is not explicitly provided in the API,
27        # but can be added separately if supported.
28    )
29 
30    # exerciseCount: integer (reps completed)
31    tablesDB.create_integer_column(
32        database_id=trainingDatabase.id,
33        table_id=trainingTable.id,
34        key='exerciseCount',
35        required=True
36    )
37 
38    # duration: integer (seconds)
39    tablesDB.create_integer_column(
40        database_id=trainingDatabase.id,
41        table_id=trainingTable.id,
42        key='duration',
43        required=True
44    )
45 
46    # completedAt: datetime
47    tablesDB.create_datetime_column(
48        database_id=trainingDatabase.id,
49        table_id=trainingTable.id,
50        key='completedAt',
51        required=True
52    )
53 
54    # createdAt: datetime
55    tablesDB.create_datetime_column(
56        database_id=trainingDatabase.id,
57        table_id=trainingTable.id,
58        key='createdAt',
59        required=True
60    )

Patient (Python)

1    # Create the 'Patients' table
2    patientTable = tablesDB.create_table(
3        database_id=anFlexDB.id,
4        table_id=ID.unique(),
5        name='Patients'
6    )
7 
8    # Define columns
9 
10    # patientId: unique identifier (e.g., 'P001')
11    tablesDB.create_varchar_column(
12        database_id=patientDatabase.id,
13        table_id=patientTable.id,
14        key='patientId',
15        size=255,
16        required=True
17    )
18 
19    # patientName: patient's full name
20    tablesDB.create_varchar_column(
21        database_id=patientDatabase.id,
22        table_id=patientTable.id,
23        key='patientName',
24        size=255,
25        required=True
26    )
27 
28    # wardNumber: ward identifier
29    tablesDB.create_varchar_column(
30        database_id=patientDatabase.id,
31        table_id=patientTable.id,
32        key='wardNumber',
33        size=50,
34        required=True
35    )
36 
37    # totalExerciseSessionCount: integer with default 0
38    tablesDB.create_integer_column(
39        database_id=patientDatabase.id,
40        table_id=patientTable.id,
41        key='totalExerciseSessionCount',
42        required=True,
43        default=0  # default value as specified
44    )
45 
46    # therapySessionStart: datetime
47    tablesDB.create_datetime_column(
48        database_id=patientDatabase.id,
49        table_id=patientTable.id,
50        key='therapySessionStart',
51        required=True
52    )
53 
54    # therapySessionEnd: datetime
55    tablesDB.create_datetime_column(
56        database_id=patientDatabase.id,
57        table_id=patientTable.id,
58        key='therapySessionEnd',
59        required=True
60    )

Frontend (Client): Data Visualization

Based on the data retrieved from Appwrite Cloud, the information is clearly visualized via a mobile app (designed for patients and their caregivers) and a web app (designed for medical workers).

The mobile application controls the device and provides intuitive visual feedback to help patients and caregivers monitor their exercise status, suggest training schedule within the prescribed chemotherapy schedule.

The web app provides medical staff with a centralized command center for monitoring patient compliance and managing chemotherapy progress. The main Dashboard is designed to highlight patients pending training (requiring intervention) sorted by their last training time. The Training Reports module offers a detailed tabular view for patient data through a structured list containing Name, Room Number, Hospitalization Time, and Latest Completion Time.

Project Delivery & Critical Reflection

Project Delivery and Demonstration

The prototype was presented to medical staff at Fudan University Shanghai Cancer Center for validation. The system successfully demonstrated the feasibility of automated ankle-pump assistance and remote monitoring.

The presentation at Fudan University Shanghai Cancer Center, and the in-depth discussions with healthcare professionals.

Critical Feedback - Security & Compliance

During the review, medical professionals highlighted a critical gap: Data Security and Regulatory Compliance. While the functional prototype worked, transmitting patient health data via cloud services (Appwrite) raised concerns regarding patient privacy and data encryption standards.

Future Improvement - Architecting for Trust

Acknowledging the critical feedback regarding data sovereignty and privacy, I conducted follow-up research on healthcare information security regulations in China. This led to the design of alternative technical architectures—prioritizing local data storage, access control (enhanced by audit log), and encryption—to ensure the system meets regulatory standards without compromising usability.

Local Storage

Encryption

Access Control

Self-hosting: deploy Appwrite with Docker on the hospital’s local server.
Data transfer: enable HTTPS across all data transfers.

Encrypt sensitive fields using the Chinese commercial cryptography standard SM4.

Enhanced tracking: add Python middleware to capture and retain audit logs.
Access management: integrate with the hospital information system for identity authentication.

Back

Project Overview

Problem Framing

System Architecture

Hardware Prototyping & Data Transfer

Mobile & Web Develoment

Project Delivery & Critical Reflection