DAMIAN'S BOARD GAME SPINNER

Key Concepts

Human-Centered Design Approach

For this challenge, we must center Damian's specific needs in our design process. Remember that Damian has limited finger dexterity but can press large buttons. Our solution needs to allow him to independently trigger a game spinner without requiring fine motor control. Additionally, the solution should be adaptable to different board games since Damian enjoys a variety of games with his family and friends.

System Components

The smart servo spinner system has several key components to consider:

1. Input Method: Large, easy-to-press buttons that Damian can comfortably use
2. Control Logic: Programming that determines how the spinner behaves when activated
3. Spinning Mechanism: The servo motor that provides the rotational movement
4. Visual Indicator: Using the Neopixel LED to provide feedback on system state
5. Mounting System: How the device attaches to different game boards
6. Pointer Design: The physical indicator that shows the spin result

Technical Considerations

• Random vs. Controlled Rotation: Should the spinner rotate a random amount each time or should it have fixed positions?
• Speed and Duration: How fast should the spinner rotate and for how long?
• Visual Feedback: How can we use the LED to communicate the spinner's status?
• Adaptability: How can we design a mounting system that works with different game boards?
• Durability: How can we ensure the system is sturdy enough for regular use?

Activity: "Design Specification Development"

1. Client Requirements Analysis:
   • Review Damian's needs and constraints
   • Create a list of "must-have" and "nice-to-have" features
   • Develop specific criteria for success (e.g., button size, spinner visibility)
2. System Design Planning:
   • Create detailed sketches of potential solutions
   • Identify key components and their relationships
   • Develop pseudocode for the spinner's behavior
3. CAD Model Development:
   • Begin designing components in OnShape
   • Create a virtual assembly to test fit and function
   • Prepare files for 3D printing

Extension Activity: "Functional Prototype Development"

1. Component Fabrication:
   • 3D print designed components
   • Assemble mounting system using LocLine and framing pieces
   • Integrate servo and controls into the physical prototype
2. Programming Implementation:
   • Refine spinner behavior based on earlier experiments
   • Create efficient, commented code that meets design specifications
   • Implement random number generation for unpredictable spin results
   • Add advanced features like different spinning modes or visual effects
3. Adaptability Testing:
   • Test the prototype with multiple board games
   • Document adjustments needed for different game layouts
   • Refine mounting system for quick game changes

# Advanced spinner implementation with randomization and multiple modes
import time
import board
import neopixel
import random
from digitalio import DigitalInOut, Direction, Pull
import pwmio
import servo

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

# Second button for mode switching (optional)
mode_button = DigitalInOut(board.D3)
mode_button.direction = Direction.INPUT
mode_button.pull = Pull.UP

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

# Setup Neopixel
pixel = neopixel.NeoPixel(board.NEOPIXEL, 1)
pixel.brightness = 0.3

# Variables
spinning = False
current_mode = 0  # 0: Random, 1: Sectors (like 1-6 for dice)
modes = ["Random", "Sectors"]
sectors = 6  # Number of equal sectors (can be adjusted for different games)
start_time = 0
spin_time = 0
last_button_state = True
mode_button_last = True

# Color constants
READY_COLOR = (0, 0, 255)  # Blue
SPINNING_COLOR = (0, 255, 0)  # Green
DONE_COLOR = (255, 165, 0)  # Orange

# Indicator we're ready
pixel.fill(READY_COLOR)

while True:
    # Mode button handling
    if mode_button.value == False and mode_button_last == True:
        current_mode = (current_mode + 1) % len(modes)
        print(f"Mode changed to: {modes[current_mode]}")
        
        # Visual feedback for mode change
        for _ in range(current_mode + 1):
            pixel.fill((255, 0, 0))  # Red flash for mode indicator
            time.sleep(0.1)
            pixel.fill((0, 0, 0))
            time.sleep(0.1)
        
        pixel.fill(READY_COLOR)  # Back to ready state
        time.sleep(0.5)  # Debounce
    
    mode_button_last = mode_button.value
    
    # Spin button handling with debounce
    button_state = button.value
    if button_state == False and last_button_state == True and not spinning:
        spinning = True
        start_time = time.monotonic()
        spin_time = random.uniform(2.0, 4.0)  # Random spin duration
        
        if current_mode == 0:  # Random mode
            final_angle = random.uniform(0, 180)  # Random final position
        else:  # Sectors mode
            sector = random.randint(0, sectors - 1)
            sector_size = 180 / sectors
            final_angle = sector * sector_size + sector_size/2  # Middle of sector
        
        # Visual feedback - spinning
        pixel.fill(SPINNING_COLOR)
    
    last_button_state = button_state
    
    if spinning:
        elapsed = time.monotonic() - start_time
        
        if elapsed < spin_time:
            # Calculate spin position with slowing down effect
            progress = elapsed / spin_time
            # Start fast, end slow (ease-out function)
            ease_factor = 1 - (1 - progress) ** 2
            
            # For continuous spinning effect with slowing
            spins = 3 * (1 - ease_factor)  # Number of complete revolutions
            angle = ((spins % 1) * 360) % 180
            
            # Gradually move toward final position
            if elapsed > spin_time * 0.7:  # Last 30% of spin time
                blend_factor = (elapsed - spin_time * 0.7) / (spin_time * 0.3)
                angle = angle * (1 - blend_factor) + final_angle * blend_factor
                
            my_servo.angle = angle
            
        else:
            # Ensure final position is precise
            my_servo.angle = final_angle
            spinning = False
            
            # Visual feedback - done
            pixel.fill(DONE_COLOR)
            time.sleep(1.0)
            pixel.fill(READY_COLOR)  # Ready for next spin

Assessment Criteria

Students will evaluate their solutions based on both technical performance and user-centered design principles. The assessment will focus on three key areas:

1. Functionality: Does the spinner reliably perform when activated by Damian's specified input method? Does it provide clear visual feedback? Is the spinning mechanism appropriately random or controlled based on game requirements?
2. Usability: Is the solution easy for Damian to use independently? Does it accommodate his limited finger dexterity? Is the button size and placement optimized for his abilities?
3. Adaptability: Can the solution be used with multiple board games? Is it easy to adjust or reposition? Does it maintain stability during use?

Activity: "Client Testing Simulation"

1. User Testing Preparation:
   • Create testing scenarios that simulate Damian's abilities and game preferences
   • Develop evaluation rubrics based on design criteria
   • Assign team members to play different roles (Damian, observer, data collector)
2. Testing Protocol:
   • Test each solution with at least three different board games
   • Document success rates, challenges, and observations
   • Collect feedback from the "Damian" perspective
3. Design Review and Reflection:
   • Conduct team design reviews
   • Identify strengths and opportunities for improvement
   • Create action plans for refinement
   • Document the design journey and lessons learned

Assessment Rubric

Final Reflection Questions

1. How did focusing on Damian's specific needs influence your design decisions?
2. What surprised you most about the challenges of creating an accessible game spinner?
3. How might your solution be adapted for users with different abilities?
4. What would you change or improve if you had more time or resources?
5. How has this project changed your understanding of assistive technology?