OLIVIA'S PIANO PEDAL ASSISTANT

Key Concepts

In this phase, students will explore the principles of mechanical advantage, force transmission, and human-device interfaces that are essential for the piano pedal assistant. The key challenge is creating a system that:

1. Translates the rotary motion of the servo into appropriate linear motion for the pedal
2. Provides sufficient force multiplication to depress the pedal with the servo's available torque
3. Creates a control interface that matches Olivia's physical capabilities
4. Ensures consistent and reliable operation with appropriate timing

Activity: "Mechanical Design Workshop"

1. Force Translation Systems:
   • Introduce mechanical concepts for converting rotary to linear motion
   • Demonstrate leverage principles for force multiplication
   • Guide students in calculating required mechanical advantage
2. Interface Design Planning:
   • Analyze input device options for Olivia's specific capabilities
   • Design user interface with appropriate visual feedback using Neopixel
   • Create state diagrams for pedal control sequences
3. Design Sketching:
   • Students create detailed sketches of their proposed solutions
   • Technical drawings showing mechanical components and linkages
   • Preliminary CAD models of critical components

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

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

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

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

# Pedal states
PEDAL_UP = 0
PEDAL_DOWN = 1
pedal_state = PEDAL_UP

# Color feedback
READY_COLOR = (0, 10, 0)    # Dim green when ready
ACTIVE_COLOR = (0, 100, 0)  # Bright green when pedal is down

pixel.fill(READY_COLOR)

while True:
    # Check for button press (button.value is False when pressed)
    if button.value == False and pedal_state == PEDAL_UP:
        # Depress pedal
        pedal_servo.angle = 90
        pixel.fill(ACTIVE_COLOR)
        pedal_state = PEDAL_DOWN
        time.sleep(0.3)  # Debounce delay
        
    elif button.value == False and pedal_state == PEDAL_DOWN:
        # Release pedal
        pedal_servo.angle = 0
        pixel.fill(READY_COLOR)
        pedal_state = PEDAL_UP
        time.sleep(0.3)  # Debounce delay

Extension Activity: "Adaptive Design Enhancements"

1. Adjustable Mounting System:
   • Design a universal mounting system that works with different piano models
   • Create adjustable components for variable pedal positions
   • Implement quick-release mechanisms for easy installation and removal
2. Advanced Programming Features:
   • Add multiple control modes to accommodate different musical needs
   • Implement timing variations for different playing styles
   • Create presets for common pedaling patterns
3. Fabrication and Assembly:
   • 3D print designed components
   • Assemble mechanical linkages using LocLine and structural components
   • Integrate Smart Servo with mechanical systems

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

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

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

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

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

# System modes
MODE_TOGGLE = 0      # Press once to engage, again to release
MODE_MOMENTARY = 1   # Hold to engage, release to disengage
MODE_AUTO = 2        # Automatic timed patterns
current_mode = MODE_TOGGLE

# Mode colors
MODE_COLORS = [
    (0, 0, 100),     # Blue for toggle mode
    (100, 0, 100),   # Purple for momentary mode
    (100, 50, 0)     # Orange for auto mode
]

# Pedal state
pedal_engaged = False
last_button_state = True  # Pulled up when not pressed

# Auto mode variables
auto_pattern = [1, 0, 1, 0, 1, 1, 0]  # Example pattern (1=down, 0=up)
pattern_index = 0
last_pattern_time = 0
pattern_interval = 0.8  # seconds between pattern steps

# Update the pixel to show current mode
pixel.fill(MODE_COLORS[current_mode])

def toggle_mode():
    global current_mode
    current_mode = (current_mode + 1) % 3
    pixel.fill(MODE_COLORS[current_mode])
    return

while True:
    # Check for mode button press
    if mode_button.value == False:
        toggle_mode()
        time.sleep(0.3)  # Debounce
    
    # Handle pedal control based on current mode
    if current_mode == MODE_TOGGLE:
        # Toggle mode - press once to engage, again to disengage
        if action_button.value == False and last_button_state == True:
            pedal_engaged = not pedal_engaged
            pedal_servo.angle = 90 if pedal_engaged else 0
        last_button_state = action_button.value
            
    elif current_mode == MODE_MOMENTARY:
        # Momentary mode - hold to engage, release to disengage
        if action_button.value == False:
            pedal_servo.angle = 90
            pedal_engaged = True
        else:
            pedal_servo.angle = 0
            pedal_engaged = False
            
    elif current_mode == MODE_AUTO:
        # Auto pattern mode - follow preprogrammed pattern
        current_time = time.monotonic()
        if current_time - last_pattern_time >= pattern_interval:
            # Time to move to next step in pattern
            pedal_engaged = bool(auto_pattern[pattern_index])
            pedal_servo.angle = 90 if pedal_engaged else 0
            pattern_index = (pattern_index + 1) % len(auto_pattern)
            last_pattern_time = current_time
    
    # Brief pause in loop
    time.sleep(0.05)

Assessment Criteria

Students will evaluate their piano pedal assistant designs based on:

1. Functionality: Does the device reliably control the piano pedal with appropriate timing and pressure?
2. Usability: Is the solution easy for Olivia to use given her specific capabilities?
3. Versatility: Can the solution adapt to different pianos and playing conditions?
4. Durability: Will the solution withstand regular use in musical settings?
5. Aesthetics: Is the design visually appropriate for use in performance settings?

Activity: "Performance Evaluation"

1. User Testing Simulation:
   • Test the pedal assistant with sample musical pieces requiring different pedaling techniques
   • Evaluate consistency of operation across multiple trials
   • Collect data on timing accuracy and reliability
2. Peer Review:
   • Teams present their solutions to other groups
   • Structured feedback session with evaluation rubric
   • Identify strengths and opportunities for improvement
3. Reflection and Documentation:
   • Students document their design process in digital portfolios
   • Create user manuals for their piano pedal assistants
   • Record video demonstrations showing their solution in action

Assessment Rubric