DANIEL'S MICROSCOPE FOCUS ADJUSTER

This lesson challenges high school engineering students to design and build a precision microscope focus adjuster for Daniel, a 14-year-old with limited hand function. The project integrates digital design, physical computing, and human-centered design principles while addressing a real accessibility need in science education. Students will apply their knowledge of the Smart Servo platform to create a device that allows Daniel to make precise adjustments to a microscope focus knob using alternative input methods that accommodate his specific abilities.

Client Profile

Learning Objectives

• Apply the human-centered design process to develop an assistive technology solution for a user with specific physical needs
• Design and program a Smart Servo system that provides precise, controlled movement for microscope focus adjustment
• Create a customized input interface based on user requirements and physical abilities
• Optimize mechanical design for stability, precision, and ease of attachment/detachment
• Evaluate and refine the solution through iterative testing with feedback

Activity: "Understanding the Challenge"

1. Introduction to Client Profile:
   • Present Daniel's profile to the class, discussing his specific needs and challenges
   • Analyze the functional requirements of microscope focus adjustment (precision, force needed, range of motion)
   • Discuss the impact of limited hand function on educational participation
2. Microscope Exploration:
   • Divide students into teams of 3-4
   • Provide each team with a school microscope
   • Have students analyze the mechanics of the focus knobs:
     • Measure the diameter and height of both coarse and fine adjustment knobs
     • Determine the force required to turn each knob
     • Calculate how many degrees of rotation produce meaningful focus changes
     • Document the space available around the microscope for mounting a device
3. Simulation Experience:
   • Students attempt to use the microscope while wearing thick winter gloves or finger splints
   • Document the challenges encountered and potential workarounds
   • Discuss how this simulation differs from Daniel's actual experience

import time
import board
import pwmio
import servo
from digitalio import DigitalInOut, Direction, Pull

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

# Setup button
button = DigitalInOut(board.D2)
button.direction = Direction.INPUT
button.pull = Pull.UP

# Initial position
position = 90
my_servo.angle = position

while True:
    # When button is pressed, move servo slightly
    if not button.value:  # Button is pressed
        position = position + 5
        # Keep position within bounds
        if position > 180:
            position = 180
        my_servo.angle = position
        time.sleep(0.2)  # Debounce delay

Connections

Activity: "Technical Exploration"

1. Smart Servo Capabilities Analysis:
   • Investigate torque requirements for microscope focus knobs
   • Experiment with servo position control precision
   • Test different control inputs (buttons, switches, potentiometers)
   • Explore speed control options for precise adjustments
2. Input Interface Testing:
   • Students test different accessible input methods:
     • Single vs. dual button control
     • Pressure-sensitive inputs
     • Timed or momentary activation
   • Document which inputs might work best for Daniel's specific abilities
3. Mechanical Coupling Prototyping:
   • Design simple prototypes for connecting the servo to the microscope knob
   • Test different attachment mechanisms that allow for:
     • Secure connection during operation
     • Easy attachment/detachment without tools
     • Adaptability to different microscope models
   • Evaluate the stability and precision of each approach

# Fine Control Example: Using Two Buttons for Precision Movement
import time
import board
import pwmio
import servo
from digitalio import DigitalInOut, Direction, Pull

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

# Setup buttons
button_forward = DigitalInOut(board.D2)
button_forward.direction = Direction.INPUT
button_forward.pull = Pull.UP

button_backward = DigitalInOut(board.D3)
button_backward.direction = Direction.INPUT
button_backward.pull = Pull.UP

# Indicator LED
import neopixel
pixel = neopixel.NeoPixel(board.NEOPIXEL, 1)

# Initial position and movement settings
position = 90
my_servo.angle = position
increment = 2  # Small increments for fine control
fast_increment = 10  # Larger increments for coarse adjustment
long_press_time = 1.0  # seconds to detect long press

while True:
    # Fine forward adjustment
    if not button_forward.value:
        start_time = time.monotonic()
        # Wait to see if it's a long press
        time.sleep(0.2)  # Initial debounce
        
        # Check if button is still pressed after debounce
        if not button_forward.value:
            # Monitor for long press
            while not button_forward.value:
                if time.monotonic() - start_time > long_press_time:
                    # Long press detected - use larger increment
                    position = position + fast_increment
                    if position > 180:
                        position = 180
                    my_servo.angle = position
                    pixel.fill((0, 255, 0))  # Green for fast mode
                    time.sleep(0.2)
                    break
                time.sleep(0.1)
            
            # If it wasn't a long press, use small increment
            if time.monotonic() - start_time <= long_press_time:
                position = position + increment
                if position > 180:
                    position = 180
                my_servo.angle = position
                pixel.fill((0, 0, 255))  # Blue for precision mode
        
        # Wait for button release
        while not button_forward.value:
            time.sleep(0.1)
        
        pixel.fill((0, 0, 0))  # Turn off LED
    
    # Similar logic for backward button
    if not button_backward.value:
        # (Code similar to above but decrementing position)
        # ...
    
    time.sleep(0.05)  # Small delay to prevent CPU hogging

Key Concepts

Precision Control in Assistive Technology
When designing assistive technology for precision tasks like microscope focus adjustment, several key principles must be considered:

1. Input/Output Ratio: The relationship between user input and device output must be calibrated for the user's abilities. For Daniel, who has limited hand function, we need to transform broad, low-precision movements he can make into fine, high-precision adjustments.
2. Modes of Operation: Effective assistive devices often provide multiple modes:
   • Fine adjustment mode (small, precise movements)
   • Coarse adjustment mode (larger, faster movements)
   • Variable speed control based on input duration or pressure
3. Feedback Mechanisms: Users need clear feedback about the system's operation:
   • Visual feedback (LED indicators for mode, direction)
   • Tactile feedback (resistance, detents)
   • Auditory feedback (beeps or clicks)
4. Mechanical Stability: Precision devices require stable mounting to prevent unwanted movement:
   • Secure attachment to fixed surfaces
   • Balanced force application
   • Vibration damping
5. Universal Design Principles: The solution should be:
   • Flexible (adaptable to different microscope models)
   • Simple to attach/detach (independence in setup)
   • Intuitive to operate (minimal cognitive load)

Activity: "Control System Design"

1. Precision Programming Exploration:
   • Students analyze the sample code for fine/coarse control
   • Identify ways to improve precision control through code modification
   • Implement a control algorithm that:
     • Provides smooth, consistent movement
     • Offers multiple speed options
     • Uses LED feedback to indicate current mode
2. Interface Design Sketching:
   • Based on their understanding of Daniel's abilities, students sketch interface designs
   • Focus on ergonomic placement of inputs
   • Consider mounting solutions that minimize setup complexity
3. Technical Documentation Draft:
   • Students create initial documentation explaining:
     • How their system works
     • Installation and setup procedures
     • Operating instructions written for Daniel

Extension Activity: "Advanced System Integration"

1. Mechanical Optimization:
   • Refine the attachment mechanism using 3D printing
   • Design custom adapters for different microscope models
   • Implement a quick-release system for easy attachment/detachment
   • Use CAD to optimize the mechanical design for:
     • Strength
     • Weight
     • Material efficiency
     • Ease of manufacturing
2. Enhanced Control Features:
   • Program memory positions for frequently used magnifications
   • Add auto-calibration routine for different microscope models
   • Implement a "home" function to return to a starting position
   • Create a sleep mode to conserve battery when not in use
3. User Experience Refinement:
   • Create a customized control layout based on Daniel's preferences
   • Design a mounting system that doesn't interfere with microscope use
   • Add visual indicators (using the Neopixel LED) for:
     • Current mode (fine/coarse adjustment)
     • Direction of movement
     • When limits are reached

import time
import board
import pwmio
import servo
from digitalio import DigitalInOut, Direction, Pull
import neopixel

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

# Setup buttons
button_up = DigitalInOut(board.D2)
button_up.direction = Direction.INPUT
button_up.pull = Pull.UP

button_down = DigitalInOut(board.D3)
button_down.direction = Direction.INPUT
button_down.pull = Pull.UP

# Mode switch
mode_switch = DigitalInOut(board.D4)
mode_switch.direction = Direction.INPUT
mode_switch.pull = Pull.UP

# Indicator LED
pixel = neopixel.NeoPixel(board.NEOPIXEL, 1)

# Mode settings
FINE_MODE = 0
COARSE_MODE = 1
MEMORY_MODE = 2
current_mode = FINE_MODE

# Memory positions (simulating three common focus positions)
memory_positions = [45, 90, 135]
memory_index = 0

# Initial position
position = 90
my_servo.angle = position

# Speed settings
fine_increment = 1
coarse_increment = 5

# Colors for different modes
fine_color = (0, 0, 255)  # Blue
coarse_color = (0, 255, 0)  # Green
memory_color = (255, 0, 255)  # Purple

# Set initial color based on mode
pixel.fill(fine_color)

# Track last button states
last_up = True
last_down = True
last_mode = True

def update_position(new_position):
    """Update servo position with bounds checking"""
    global position
    position = max(0, min(180, new_position))
    my_servo.angle = position
    
    # Visual feedback based on position
    if position <= 45:
        # Near minimum - show partially red
        intensity = int((45 - position) / 45 * 255)
        if current_mode == FINE_MODE:
            pixel.fill((intensity, 0, 255 - intensity))
        elif current_mode == COARSE_MODE:
            pixel.fill((intensity, 255 - intensity, 0))
    elif position >= 135:
        # Near maximum - show partially red
        intensity = int((position - 135) / 45 * 255)
        if current_mode == FINE_MODE:
            pixel.fill((intensity, 0, 255 - intensity))
        elif current_mode == COARSE_MODE:
            pixel.fill((intensity, 255 - intensity, 0))
    else:
        # Normal range - show mode color
        if current_mode == FINE_MODE:
            pixel.fill(fine_color)
        elif current_mode == COARSE_MODE:
            pixel.fill(coarse_color)
        elif current_mode == MEMORY_MODE:
            pixel.fill(memory_color)

while True:
    # Check for mode switch press (detect change)
    if last_mode and not mode_switch.value:
        # Button was just pressed
        current_mode = (current_mode + 1) % 3
        
        # Visual feedback for mode change
        if current_mode == FINE_MODE:
            pixel.fill(fine_color)
        elif current_mode == COARSE_MODE:
            pixel.fill(coarse_color)
        elif current_mode == MEMORY_MODE:
            pixel.fill(memory_color)
        
        # Debounce
        time.sleep(0.2)
    
    # Up button logic
    if last_up and not button_up.value:
        if current_mode == FINE_MODE:
            update_position(position + fine_increment)
        elif current_mode == COARSE_MODE:
            update_position(position + coarse_increment)
        elif current_mode == MEMORY_MODE:
            # Go to next memory position
            memory_index = (memory_index + 1) % len(memory_positions)
            update_position(memory_positions[memory_index])
        
        # Debounce
        time.sleep(0.1)
    
    # Down button logic
    if last_down and not button_down.value:
        if current_mode == FINE_MODE:
            update_position(position - fine_increment)
        elif current_mode == COARSE_MODE:
            update_position(position - coarse_increment)
        elif current_mode == MEMORY_MODE:
            # Go to previous memory position
            memory_index = (memory_index - 1) % len(memory_positions)
            update_position(memory_positions[memory_index])
        
        # Debounce
        time.sleep(0.1)
    
    # Update button states
    last_up = button_up.value
    last_down = button_down.value
    last_mode = mode_switch.value
    
    # Small delay to prevent CPU hogging
    time.sleep(0.05)