KAI'S CAMERA TRIPOD REMOTE ADJUSTER

OVERVIEW

This lesson challenges 9th-10th grade experienced engineering students to design and build a camera tripod remote adjuster for Kai, a 16-year-old with a brachial plexus injury. Using the Smart Servo platform, students will follow the human-centered design process to create a solution that allows Kai to make precise adjustments to his camera setup despite limited arm mobility. Throughout the lesson, students will integrate engineering principles, CAD skills, and programming concepts while developing their ability to design for real human needs.

Client Profile

Name	About Me	My Challenge
Kai, 16	I'm a high school junior who loves photography and filmmaking. I have a brachial plexus injury from a motorcycle accident last year that limits the mobility and strength in my right arm and shoulder. Despite this, I'm determined to continue pursuing my passion for visual storytelling.	When setting up shots with my DSLR camera on a tripod, I struggle with making precise adjustments, especially when I need to change camera angles during filming. The standard tripod controls require fine motor control and strength that's difficult with my injury. I need a way to make smooth, controlled adjustments to my camera position without straining my affected arm.

Learning Objectives

Design and build a functional camera tripod remote adjuster that addresses specific user needs
Apply human-centered design principles to develop solutions for individuals with physical disabilities
Integrate digital input devices with servo motor control through Circuit Python programming
Design and fabricate mechanical components that effectively transfer servo motion to a camera tripod
Test and refine designs based on user feedback and performance criteria

MATERIALS NEEDED

Smart Servo units (1 per 2-3 students)
Adafruit Trinket M0 microcontrollers with Circuit Python 8.0
Assorted assistive input devices (AT Test Buttons, Jelly Bean Buttons, etc.)
LocLine flexible connectors and 10mm framing pieces
Bearings (605ZZ) and M5 screws/fasteners
Allen wrenches, screwdrivers, and LocLine pliers
3D printer (Bambu Lab A1 Mini recommended) with PLA filament
OnShape CAD software (free classroom license)
USB C programming cables
Spare MG956 servo motors for testing
Various tripods for testing designs (or 3D printed mockups)
Cardboard, foam core, and craft materials for initial prototyping

1. ENGAGE

How might we create assistive devices that enable people with physical limitations to pursue their creative passions?

Activity: "Experiencing Limited Mobility"

Simulation Exercise:
- Students work in pairs, with one student wearing an arm restriction (like an arm sling or mobility-limiting sleeve)
- The restricted student attempts to set up and adjust a camera tripod following a specific shot list
- The observing partner takes notes on specific challenges and pain points
Introduction to Kai's Challenge:
- Present Kai's profile and specific needs
- Show video examples of standard tripod operation
- Discuss how brachial plexus injuries affect movement and strength
- Highlight the importance of precise control for photography/videography
Smart Servo Introduction:
- Review the capabilities of the Smart Servo platform
- Demonstrate how servo motors can provide controlled rotational movement
- Explore different input methods that could be appropriate for Kai

Demo: Basic servo position control

import time
import board
import pwmio
import servo

# Create PWM output for the servo
pwm = pwmio.PWMOut(board.A2, duty_cycle=2 ** 15, frequency=50)
my_servo = servo.Servo(pwm)

# Move servo to different positions
while True:
    # Neutral position
    my_servo.angle = 90
    time.sleep(2)
    # 15 degrees left
    my_servo.angle = 75
    time.sleep(2)
    # 15 degrees right
    my_servo.angle = 105
    time.sleep(2)

Technical Checkpoints:

Students can identify key components of the Smart Servo system
Students understand how to control servo position using simple code

Understanding Checkpoints:

Students can articulate specific challenges related to Kai's condition
Students can describe how servo motion might help address these challenges

Connections

Connections to Standards	Connections to CAD Skills	Connections to HCD Skills
STEL 4S: Develop solutions with minimal negative environmental and social impact	CAD 2.3: Advanced Visualization - Complex views including sections	HCD #1: Problem Framing - Analyzing situations from multiple perspectives
STEL 7Z: Apply principles of human-centered design	CAD 1.2: Design Process - Following structured design processes	HCD #6: Stakeholder Dialogue - Gathering requirements and incorporating diverse feedback

2. EXPLORE

What are the specific movement requirements for effective camera tripod control, and how can we translate servo motion to meet these needs?

Activity: "Movement Analysis and Input Exploration"

Tripod Movement Analysis:
- Teams analyze tripod mechanism movements (pan, tilt, rotation)
- Measure and document range of motion required for each movement
- Identify torque requirements and mechanical advantage needs
- Create diagrams of movement axes and potential servo integration points
Input Device Testing:
- Test various input devices (buttons, switches, potentiometers)
- Map input options to Kai's specific abilities and limitations
- Experiment with different control schemes (toggle, proportional, incremental)
- Document pros and cons of each approach
Servo Control Programming:
- Modify example code to test different control methods
- Experiment with speed and position control
- Create test program using button input to control servo movement
- Test precision control with small increment movements

Incremental movement with button control

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

# Set up buttons
button_left = DigitalInOut(board.D0)
button_left.direction = Direction.INPUT
button_left.pull = Pull.UP

button_right = DigitalInOut(board.D1)
button_right.direction = Direction.INPUT
button_right.pull = Pull.UP

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

# Initialize position
current_angle = 90
my_servo.angle = current_angle

# Small increment value for precise control
increment = 2

while True:
    # Check left button - decrease angle
    if button_left.value == False:  # Button pressed
        current_angle = max(0, current_angle - increment)
        my_servo.angle = current_angle
        time.sleep(0.2)  # Debounce delay
        
    # Check right button - increase angle
    if button_right.value == False:  # Button pressed
        current_angle = min(180, current_angle + increment)
        my_servo.angle = current_angle
        time.sleep(0.2)  # Debounce delay

Technical Checkpoints:

Teams can accurately measure and document tripod movement requirements
Teams successfully implement button-controlled servo movement
Students can modify code to adjust movement speed and increment size

Understanding Checkpoints:

Students can explain how their control scheme addresses Kai's specific needs
Students demonstrate understanding of mechanical requirements for tripod control

3. EXPLAIN

How can we translate user needs into specific design requirements and technical specifications?

Key Concepts

Mechanical Design Considerations

Torque Requirements: Camera tripod heads require specific torque for smooth movement without slipping
Gear Ratios: Using gear reduction to increase torque while maintaining precision
Mounting Solutions: Creating secure connections between servo and tripod without permanent modification
Material Selection: Choosing appropriate materials for strength, weight, and durability

Human Factors in Control Design

Cognitive Load: Designing intuitive controls that require minimal mental effort
Accessibility: Creating input mechanisms tailored to specific user capabilities
Feedback Systems: Incorporating visual feedback (LED) to indicate system status
Adaptability: Allowing for adjustment to accommodate changing user needs

Programming Concepts

State Management: Tracking current position and operation mode
Input Debouncing: Preventing false triggers from button presses
Speed Control: Implementing acceleration/deceleration for smooth movement
Multiple Control Modes: Programming different operation options based on user preference

Activity: "Design Requirements Document"

Define Performance Criteria:
- Teams develop specific, measurable requirements for their solutions
- Create criteria for mechanical performance (range of motion, precision, etc.)
- Define user interface requirements based on Kai's abilities
- Establish programming requirements for control logic
Develop Initial Concepts:
- Teams sketch at least three different mechanical approaches
- Create simple prototype models using cardboard or foam core
- Evaluate concepts against requirements
- Select most promising approach for further development
Technical Documentation:
- Document technical specifications including dimensions, materials, and components
- Create initial CAD sketches of mechanical components
- Develop pseudocode for control logic
- Identify potential challenges and solutions

Understanding Checkpoints:

Teams produce clear, specific design requirements documents
Students can justify design decisions based on client needs
Initial concept sketches show understanding of mechanical principles
Technical documentation includes appropriate specifications

4. ELABORATE

How can we transform our concepts into functional prototypes that meet our client's specific needs?

Extension Activity: "Prototype Development"

CAD Modeling:
- Create detailed CAD models of mechanical components using OnShape
- Design parts for 3D printing, considering printing limitations
- Incorporate mounting solutions for servo and tripod integration
- Generate technical drawings for fabrication
Component Fabrication:
- 3D print designed components
- Assemble mechanical systems with appropriate hardware
- Integrate servo motors and control electronics
- Test mechanical function before programming
Programming Implementation:
- Develop full control program based on pseudocode
- Implement input handling for selected control method
- Add visual feedback using Neopixel LED
- Test and debug control logic

Enhanced Control with LED Feedback

# Enhanced control with LED feedback
import time
import board
from digitalio import DigitalInOut, Direction, Pull
import pwmio
import servo
import neopixel

# Set up buttons
button_left = DigitalInOut(board.D0)
button_left.direction = Direction.INPUT
button_left.pull = Pull.UP

button_right = DigitalInOut(board.D1)
button_right.direction = Direction.INPUT
button_right.pull = Pull.UP

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

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

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

# Initialize position and mode
current_angle = 90
my_servo.angle = current_angle

# Control modes: 0 = Fine adjust (2 degrees), 1 = Medium adjust (5 degrees)
mode = 0
increments = [2, 5]  # Adjustment increments for different modes

# Colors for different modes
mode_colors = [(0, 0, 255), (0, 255, 0)]  # Blue for fine, Green for medium

# Update LED to show current mode
pixel.fill(mode_colors[mode])

last_mode_press_time = time.monotonic()
debounce_time = 0.3

while True:
    current_time = time.monotonic()
    
    # Check mode button
    if mode_button.value == False and (current_time - last_mode_press_time) > debounce_time:
        mode = (mode + 1) % len(increments)
        pixel.fill(mode_colors[mode])
        last_mode_press_time = current_time
    
    # Check left button - decrease angle
    if button_left.value == False:
        current_angle = max(0, current_angle - increments[mode])
        my_servo.angle = current_angle
        # Briefly flash LED when button pressed
        pixel.fill((255, 255, 255))
        time.sleep(0.05)
        pixel.fill(mode_colors[mode])
        time.sleep(0.15)  # Debounce delay
        
    # Check right button - increase angle
    if button_right.value == False:
        current_angle = min(180, current_angle + increments[mode])
        my_servo.angle = current_angle
        # Briefly flash LED when button pressed
        pixel.fill((255, 255, 255))
        time.sleep(0.05)
        pixel.fill(mode_colors[mode])
        time.sleep(0.15)  # Debounce delay

Integration and Testing:
- Assemble complete prototype with all components
- Test function with actual camera tripod
- Document performance against requirements
- Identify areas for improvement

Application Checkpoints:

CAD models are properly designed for 3D printing
Mechanical components successfully interface with tripod and servo
Control program correctly implements required functionality
Prototype meets key performance requirements

Connections to Standards	Connections to CAD Skills	Connections to HCD Skills
STEL 4S: Develop solutions with minimal negative environmental and social impact	CAD 2.3: Advanced Visualization - Complex views including sections	HCD #1: Problem Framing - Analyzing situations from multiple perspectives
STEL 7Z: Apply principles of human-centered design	CAD 1.2: Design Process - Following structured design processes	HCD #6: Stakeholder Dialogue - Gathering requirements and incorporating diverse feedback

5. EVALUATE

How well does our solution meet the needs of our client, and how can we improve it?

Assessment Criteria

Students will evaluate their solutions against two primary criteria:

Technical Performance: How well the device meets the specified mechanical and control requirements
User Experience: How effectively the solution addresses Kai's specific needs

Activity: "User Testing Simulation"

Peer Testing:
- Teams exchange prototypes for testing by other groups
- Testers use arm restrictions to simulate Kai's condition
- Document ease of use, effectiveness, and areas for improvement
- Provide constructive feedback to design teams
Self-Assessment:
- Teams evaluate their own designs against requirements
- Document strengths and weaknesses of their approach
- Propose specific improvements for next iteration
- Create presentation summarizing design process and outcomes
Reflection and Documentation:
- Complete design journals documenting the entire process
- Create user manual for the final device
- Prepare final presentation including demonstration video
- Discuss ethical considerations and broader applications

Assessment Rubric

Criteria	Level 1	Level 2	Level 3	Level 4
Functionality	Device provides basic movement but lacks precision or reliability	Device functions as intended with minor limitations	Device meets all functional requirements with good reliability	Device exceeds functional requirements with exceptional precision and reliability
Human-Centered Design	Limited consideration of user needs; minimal user testing	Basic consideration of user needs; some user testing conducted	Clear focus on user needs throughout design process; thorough user testing	Exceptional incorporation of user needs; extensive testing with simulated conditions
Technical Implementation	Basic servo control with limited programming features	Functional servo control with standard programming features	Well-implemented servo control with additional features like visual feedback	Advanced servo control with multiple modes, adaptive features, and optimized code
Mechanical Design	Basic mechanical design with limited consideration of forces and materials	Functional mechanical design with adequate consideration of forces and materials	Well-executed mechanical design with appropriate material selection and force management	Innovative mechanical design with excellent material choices, optimized force management, and refined aesthetics
Documentation & Communication	Basic documentation of process and results	Clear documentation with organized presentation of process and results	Comprehensive documentation with well-structured presentation of all aspects	Exceptional documentation with professional-quality presentation and instructional materials

Evaluation Checkpoints:

Teams have thoroughly tested their prototypes with simulated conditions
Self-assessment documents identify specific strengths and areas for improvement
User manuals clearly explain how to operate and maintain the device
Final presentations effectively communicate the design process and decisions
Students can articulate how their solution addresses Kai's specific needs