ISABELLA'S YARN HELPER

Key Concepts

Assistive Technology Design Principles:

1. User-Centered: The device must address Isabella's specific needs, not generic solutions
2. Accessible Control: Input methods must accommodate limited joint mobility
3. Adaptability: The device should adjust to different yarn types and tensions
4. Feedback: Visual or auditory signals help users understand device state
5. Mechanical Advantage: Using technology to reduce physical effort required

Programming Concepts:

1. Input Processing: Reading button or switch states
2. State Management: Tracking and changing modes of operation
3. Servo Control: Precise positioning based on user needs
4. Visual Feedback: Using LEDs to communicate device status

Activity: "Designing Isabella's Solution"

1. Define Requirements:
   • Students create a list of "must have" and "nice to have" features for Isabella's yarn helper
   • Requirements should include specific tension levels needed and control methods
2. Initial Design:
   • Teams create detailed sketches of their proposed solution
   • Sketches must include:
     • Position of the Smart Servo
     • Yarn path through the device
     • Control method (button placement)
     • Mounting or stabilizing features
     • LED feedback positioning
3. Pseudocode Development:
   • Students write pseudocode for their solution, focusing on:
     • How many tension settings will be available
     • How user inputs will change tension
     • What feedback the system will provide

Activity: "Prototype Development"

1. CAD Design and 3D Printing:
   • Students create CAD designs in OnShape for custom components:
     • Servo mounts or enclosures
     • Yarn guides or tension mechanisms
     • Button holders or mounting brackets
   • Export designs for 3D printing
2. Assembly and Integration:
   • Assemble mechanical components with the Smart Servo
   • Install input devices (buttons) in accessible positions
   • Test mechanical movement and stability
3. Programming and Refinement:
   • Students complete and upload their code to the Smart Servo:

# Isabella's Yarn Helper
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 - primary control and mode button
tension_button = DigitalInOut(board.D2)
tension_button.direction = Direction.INPUT
tension_button.pull = Pull.UP

mode_button = DigitalInOut(board.D4)
mode_button.direction = Direction.INPUT
mode_button.pull = Pull.UP

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

# Tension settings - tuned for different yarn weights
# [loose, medium-loose, medium, medium-tight, tight]
tension_positions = [20, 60, 90, 120, 160]  
tension_colors = [(0,0,255), (0,255,255), (0,255,0), (255,255,0), (255,0,0)]
current_tension = 2  # Start at medium tension

# Mode settings - different yarn feeding modes
modes = ["regular", "auto-feed"]  # Regular or pulsing for auto-feed
current_mode = 0

def display_tension():
    """Display current tension level with color"""
    pixel.fill(tension_colors[current_tension])
    
    # Also blink to indicate level
    for _ in range(current_tension + 1):
        pixel.brightness = 0.1
        time.sleep(0.1)
        pixel.brightness = 0.3
        time.sleep(0.1)

def change_tension():
    """Change to next tension level"""
    global current_tension
    current_tension = (current_tension + 1) % len(tension_positions)
    my_servo.angle = tension_positions[current_tension]
    display_tension()

def change_mode():
    """Toggle between regular and auto-feed modes"""
    global current_mode
    current_mode = (current_mode + 1) % len(modes)
    
    # Blink white to indicate mode change
    pixel.fill((255, 255, 255))
    time.sleep(0.5)
    display_tension()

# Initial setup
my_servo.angle = tension_positions[current_tension]
display_tension()

# Main loop
while True:
    # Check tension button
    if not tension_button.value:
        change_tension()
        time.sleep(0.5)  # Debounce
        
    # Check mode button
    if not mode_button.value:
        change_mode()
        time.sleep(0.5)  # Debounce
        
    # If in auto-feed mode, gently pulse the servo
    if modes[current_mode] == "auto-feed":
        current_pos = tension_positions[current_tension]
        # Small movements to help feed yarn
        my_servo.angle = current_pos - 5
        time.sleep(0.5)
        my_servo.angle = current_pos
        time.sleep(0.5)
        my_servo.angle = current_pos + 5
        time.sleep(0.5)
        my_servo.angle = current_pos
        time.sleep(0.5)
            

4. Refinement Through Testing:
   • Test the prototype with various yarn types
   • Measure the effectiveness of tension control
   • Evaluate the accessibility of controls for someone with limited joint mobility

Assessment: "Client Testing and Reflection"

1. User Testing Simulation:
   • Student teams trade prototypes and evaluate each other's designs
   • Students use the rubber band joint limitation method again while testing
   • Teams document strengths and areas for improvement in each design
2. Design Presentation:
   • Teams present their solutions to the class, explaining:
     • Key features and how they address Isabella's specific needs
     • Technical challenges they encountered and overcame
     • Testing results and future improvements
3. Reflection Discussion:
   • What was the most challenging aspect of designing for someone with joint limitations?
   • How did your understanding of Isabella's needs change during the design process?
   • What would you do differently if you could start over?

Assessment Rubric