TYRELL'S TOOL GRIP STABILIZER

This engineering lesson challenges experienced 11-12th grade students to design and build a tool grip stabilizer for Tyrell, a 45-year-old professional who experiences hand tremors following an accident. Through the 5E model (Engage, Explore, Explain, Elaborate, Evaluate), students will apply human-centered design principles to develop a solution that helps Tyrell perform precision work despite his tremors. The project integrates engineering standards, CAD skills, and programming while emphasizing empathy and iterative design.

Client Profile

Learning Objectives

• Apply human-centered design principles to develop an assistive technology solution for a specific user need
• Design and fabricate a mechanical system that integrates with the Smart Servo to dampen unwanted movements
• Program the Smart Servo to detect and respond to tremor patterns using appropriate sensors
• Evaluate design effectiveness through quantitative measurements and user feedback
• Document the engineering process comprehensively, including design rationale and decision-making

Activity: "Experiencing Tremors"

1. Simulation Experience:
   • Students wear weighted gloves designed to simulate hand tremors
   • Working in pairs, students attempt precision tasks such as:
     • Threading a needle
     • Placing small components on a circuit board
     • Using calipers to measure small objects
     • Drawing a straight line or precise shape
   • Students document challenges faced and strategies attempted
2. Client Introduction:
   • Introduce Tyrell's profile and specific challenges
   • Discuss various causes of tremors and how they affect different professions
   • Watch video interviews with people experiencing similar challenges (if available)
   • Analyze existing solutions and their limitations
3. Engineering Challenge Framing:
   • Present the core challenge: designing a tool grip stabilizer that:
     • Actively counteracts unpredictable tremor movements
     • Allows intentional movements for precision work
     • Is customizable for different tools and tasks
     • Maintains user dignity and independence
   • Discuss the technical capabilities of the Smart Servo platform that might apply

import time
import board
import pwmio
import servo

pwm = pwmio.PWMOut(board.A2, duty_cycle=2 ** 15, frequency=50)
my_servo = servo.Servo(pwm)

# Demonstrate smooth movement
while True:
    for angle in range(0, 180, 5):  # 0 to 180 degrees in steps of 5
        my_servo.angle = angle
        time.sleep(0.05)
    for angle in range(180, 0, -5):  # 180 to 0 degrees in steps of 5
        my_servo.angle = angle
        time.sleep(0.05)

Checkpoints & Assessment

Connections

Activity: "Motion Analysis and Servo Response"

1. Setup Motion Detection:
   • Teams set up accelerometers connected to the Smart Servo's input
   • Record and analyze motion patterns:
     • Intentional movements (slow, deliberate, directional)
     • Simulated tremors (rapid, multi-directional, varying amplitude)
   • Use data logging to capture and visualize movement differences
2. Servo Response Experimentation:
   • Program the Smart Servo to respond differently to various inputs:
     • Immediate response to rapid changes (potential tremors)
     • Gradual response to sustained directional movement
   • Test response thresholds and timing
   • Document findings on servo behavior for different input patterns

import time
import board
import analogio
import pwmio
import servo
import neopixel

# Setup accelerometer on analog pin
accelerometer = analogio.AnalogIn(board.A0)

# Setup servo
pwm = pwmio.PWMOut(board.A2, duty_cycle=2 ** 15, frequency=50)
my_servo = servo.Servo(pwm)

# Setup neopixel for visual feedback
pixel = neopixel.NeoPixel(board.NEOPIXEL, 1)

# Variables for movement detection
previous_reading = 0
movement_threshold = 1000  # Adjust based on testing
rapid_change_count = 0

while True:
    current_reading = accelerometer.value
    
    # Calculate change from previous reading
    change = abs(current_reading - previous_reading)
    
    # Detect rapid changes (potential tremors)
    if change > movement_threshold:
        rapid_change_count += 1
        pixel.fill((255, 0, 0))  # Red indicates detected tremor
    else:
        if rapid_change_count > 0:
            rapid_change_count -= 1
        pixel.fill((0, 255, 0))  # Green indicates stable
    
    # Apply dampening if tremor detected
    if rapid_change_count > 5:
        # Hold servo in stable position
        my_servo.angle = 90
    else:
        # Allow movement based on position (simplified)
        position = accelerometer.value // 182  # Scale to 0-180
        my_servo.angle = position
    
    previous_reading = current_reading
    time.sleep(0.05)

3. Mechanical Concepts Exploration:
   • Experiment with different mechanical systems to counteract tremors:
     • Inertial dampening (adding strategic weight)
     • Flexible mounting (using LocLine with varying rigidity)
     • Counterbalancing mechanisms
   • Create quick prototypes to test each approach
   • Document effectiveness of each approach

Checkpoints & Assessment

import time
import board
import analogio
import digitalio
import pwmio
import servo
import neopixel
import array
import math

# Setup hardware
accelerometer = analogio.AnalogIn(board.A0)
mode_button = digitalio.DigitalInOut(board.D2)
mode_button.direction = digitalio.Direction.INPUT
mode_button.pull = digitalio.Pull.UP

pwm = pwmio.PWMOut(board.A2, duty_cycle=2 ** 15, frequency=50)
my_servo = servo.Servo(pwm)
pixel = neopixel.NeoPixel(board.NEOPIXEL, 1)

# Configuration variables
sensitivity_levels = [500, 1000, 2000]  # Low, Medium, High thresholds
current_sensitivity = 1  # Default to medium
stabilization_modes = ["off", "adaptive", "locked"]
current_mode = 1  # Default to adaptive
history_buffer_size = 20
reading_history = array.array('H', [32767] * history_buffer_size)
last_button_state = True
button_debounce_time = 0

# Colors for different modes
mode_colors = [(0, 0, 0), (0, 64, 255), (255, 64, 0)]  # Off, Adaptive, Locked

def calculate_average(buffer):
    return sum(buffer) // len(buffer)

def calculate_variance(buffer, average):
    sum_squares = sum([(x - average) ** 2 for x in buffer])
    return sum_squares // len(buffer)

while True:
    current_time = time.monotonic()
    
    # Button handling for mode changes
    button_state = mode_button.value
    if not button_state and last_button_state and current_time - button_debounce_time > 0.3:
        button_debounce_time = current_time
        current_mode = (current_mode + 1) % len(stabilization_modes)
        pixel.fill(mode_colors[current_mode])
    last_button_state = button_state
    
    # Shift new reading into history buffer
    reading_history.pop(0)
    reading_history.append(accelerometer.value)
    
    # Calculate statistics
    avg = calculate_average(reading_history)
    variance = calculate_variance(reading_history, avg)
    
    # Determine if tremor is present
    tremor_detected = variance > sensitivity_levels[current_sensitivity]
    
    # Apply appropriate stabilization based on mode
    if stabilization_modes[current_mode] == "off":
        # Pass through movement directly
        position = (accelerometer.value // 182)  # Scale to 0-180
        my_servo.angle = position
        
    elif stabilization_modes[current_mode] == "adaptive":
        if tremor_detected:
            # Use moving average for smoothing during tremors
            position = avg // 182
            my_servo.angle = position
            # Pulse the LED to indicate active stabilization
            intensity = int((math.sin(current_time * 10) + 1) * 127)
            pixel.fill((0, intensity, 255-intensity))
        else:
            # Direct response when no tremor detected
            position = accelerometer.value // 182
            my_servo.angle = position
            pixel.fill(mode_colors[current_mode])
            
    elif stabilization_modes[current_mode] == "locked":
        if tremor_detected:
            # Hold position steady during tremors
            pass  # Maintain last position
        else:
            # Only update position when steady
            position = accelerometer.value // 182
            my_servo.angle = position
    
    time.sleep(0.05)