Bespoke Robot Society - User contributions [en]

User talk:John

2025-10-12T23:35:22Z

John: Created page with "== Hi == I'm John McCardle, founder and BDFL of Bespoke Robot Society"

== Hi ==

I'm John McCardle, founder and BDFL of Bespoke Robot Society

Category:Raspberry Pi

2025-10-12T22:53:20Z

John: Created blank page

Category:MCU

2025-10-12T22:46:40Z

John: Created blank page

BRS Differential Drive Robot Control Board

2025-10-11T20:32:49Z

John:

{{PCB
| name = BRS Differential Drive Robot Control Board
| image = BRS_DDRCB.png
| purpose = Integrated motor control and sensor interface for differential drive robots
| type = Through-Hole (THT) / Surface-Mount (SMT variant planned)
| microcontroller = [[Raspberry Pi Pico]] or compatible 40-pin boards
| components = {{TB6612FNG}}, {{MP1584}}, {{LM393}}, nRF24L01 header, MPU6050 header, sensor expansion
| layers = 2-layer PCB
| cost = $5-10 for 5 PCBs (JLCPCB) + ~$10-15 components
| gerbers = [https://github.com/Bespoke-Robot-Society/simplebot/blob/master/diffdrive_robot_microcontroller_board--tht_Gerber.zip GitHub Repository]
| repository = [https://github.com/Bespoke-Robot-Society/simplebot GitHub - SimpleBot]
}}

The '''BRS Differential Drive Robot Control Board''' is a custom PCB designed for [[SimpleBot]] and other small differential drive robots. It integrates all electronics needed for motor control, power regulation, optical odometry, and sensor expansion onto a single compact board.

== Overview ==

This PCB was designed with BRS's core mission in mind: '''lower the barrier to entry''' for robotics. The through-hole version uses only THT (through-hole technology) components, making it ideal for:

* Educational environments (schools, workshops)
* Beginners learning to solder
* Rapid prototyping without specialized equipment
* Easy component replacement and repair

A surface-mount variant is planned for more compact builds and higher-volume production.

== Key Features ==

=== Integrated Components ===

* '''[[Raspberry Pi Pico]] Socket''' - 40-pin header for any Pico-compatible board
* '''Motor Driver''' - [[TB6612FNG]] module socket or external H-bridge header
* '''Power Regulation''' - [[MP1584]] buck converter (6V → 3.3V)
* '''Optical Encoders''' - [[LM393]]-based comparator circuit for wheel encoders
* '''Expansion Headers''':
** nRF24L01 2.4 GHz radio (SPI)
** MPU6050 IMU (I²C)
** 4× sensor headers (3.3V + GND + GPIO)
** Analog expansion (3× ADC pins)
** Digital expansion (GPIOs)

=== Design Philosophy ===

* '''Through-Hole First''' - Easy to solder for beginners
* '''Modular''' - Use standard breakout modules where possible
* '''Expandable''' - Room for additional sensors and features
* '''Repairable''' - Socketed components can be replaced
* '''Open Source''' - Full schematics and KiCad files available

== Schematic ==

The PCB is organized into functional sections:

=== Power Section ===

[[File:PCB_power.png|thumb|300px|Power regulation section]]

The power section converts 6V from 4× AA batteries to regulated 3.3V:

* '''Input''': 4.5V – 6.5V from battery pack (via power switch)
* '''Buck Converter''': [[MP1584]] module provides 3.3V at up to 3A
* '''Important''': Buck converter must be pre-tuned to 3.3V BEFORE soldering to PCB

The power switch should be wired to disconnect batteries when USB is connected, preventing back-feeding.

=== Microcontroller Section ===

40-pin socket for [[Raspberry Pi Pico]] or compatible boards:
* Raspberry Pi Pico (official or clone)
* Raspberry Pi Pico W (adds Wi-Fi)
* Raspberry Pi Pico 2 / 2W (RP2350-based)

The socket allows easy replacement if the Pico is damaged, and permits swapping between different Pico variants.

=== Motor Control Section ===

[[File:PCB_motor.png|thumb|300px|Motor driver section]]

Two options for motor control:

==== Option 1: TB6612FNG Module (Standard) ====

* Solder [[TB6612FNG]] breakout module directly to PCB
* Controls two TT motors independently
* PWM speed control via Pico GPIOs
* Direction control via logic pins

==== Option 2: External H-Bridge (Advanced) ====

* Install 2×5 DuPont header underneath TB6612FNG footprint
* Provides PWM, direction, and logic signals to external H-bridge
* Allows use of higher-power motor drivers
* '''Same Python code works''' - control signals are identical

This flexibility allows SimpleBot to be upgraded to more powerful motors without redesigning electronics or software.

=== Optical Encoder Section ===

[[File:PCB_Optoencoder.png|thumb|300px|Optical encoder circuit]]

The odometry section uses [[LM393]] dual comparator to convert analog encoder signals to digital pulses:

* '''Per Channel''':
** 1× IR LED (emitter)
** 1× Photoresistor (detector)
** Voltage divider resistors
** Comparator output to Pico GPIO

* '''Function''':
# LED shines through slotted encoder wheel
# Photoresistor detects light/dark transitions
# LM393 converts analog voltage to clean digital pulses
# Pico counts pulses using interrupts
# Software calculates distance traveled

This provides '''optical odometry''' for dead reckoning and position tracking.

=== Expansion Headers ===

==== nRF24L01 Radio (SPI) ====

* 2.4 GHz wireless communication
* SPI interface (SCK, MOSI, MISO, CS)
* Range: 10-100m depending on antenna and environment
* Use cases: Remote control, swarm robotics, telemetry

==== MPU6050 IMU (I²C) ====

* 3-axis accelerometer + 3-axis gyroscope
* I²C interface (SDA, SCL)
* Heading estimation, tilt detection, dynamic balancing

==== Sensor Headers (4×) ====

Each header provides:
* 3.3V power
* Ground
* GPIO pin from Pico

Use for:
* Additional line sensors
* Ultrasonic distance sensors
* Bump switches
* Custom sensors

==== Analog/Digital Expansion ====

* '''Analog Header''': 3× ADC pins for custom analog sensors
* '''Digital Header''': Multiple GPIO pins for digital I/O

== PCB Layout ==

=== Top View ===
[[File:PCB_front.png|thumb|300px|PCB top side (component placement)]]

The top side contains:
* All component footprints
* Module sockets (Pico, TB6612FNG, MP1584)
* Expansion headers
* Power and motor terminals

=== Bottom View ===
[[File:PCB_back.png|thumb|300px|PCB bottom side (traces and ground plane)]]

The bottom side contains:
* Signal traces
* Ground plane (for noise reduction and current return)
* Minimal components (optional pull-up resistors)

=== All Layers ===
[[File:PCB_all_layers.png|thumb|300px|Complete PCB stack-up]]

The 2-layer design uses:
* '''Top Layer''': Signal routing and power traces
* '''Bottom Layer''': Ground plane + additional signal routing

== Bill of Materials ==

{| class="wikitable"
! Component !! Description !! Qty !! Notes
|-
| colspan="4" style="background-color: #e0e0e0; font-weight: bold;" | '''Modules'''
|-
| [[Raspberry Pi Pico]] || Microcontroller board || 1 || Or Pico W for Wi-Fi
|-
| [[TB6612FNG]] Module || Dual H-bridge motor driver || 1 || Or external H-bridge
|-
| [[MP1584]] Module || Buck converter || 1 || Pre-tune to 3.3V!
|-
| colspan="4" style="background-color: #e0e0e0; font-weight: bold;" | '''ICs'''
|-
| [[LM393]] || Dual comparator IC || 1 || DIP-8 package
|-
| colspan="4" style="background-color: #e0e0e0; font-weight: bold;" | '''Passive Components'''
|-
| Resistors || Various values for encoders and pull-ups || ~10 || See schematic
|-
| IR LEDs || Encoder emitters (940nm) || 2 || Through-hole
|-
| Photoresistors || Encoder detectors || 2 || Through-hole
|-
| colspan="4" style="background-color: #e0e0e0; font-weight: bold;" | '''Connectors'''
|-
| 40-pin header || Pico socket || 2 || Female, 2×20
|-
| Motor terminals || Screw terminals or header || 2 || 2-pin each
|-
| Power terminals || Battery input || 1 || 2-pin screw terminal
|-
| Sensor headers || Expansion connections || 4 || 3-pin male header
|-
| colspan="4" style="background-color: #e0e0e0; font-weight: bold;" | '''Optional'''
|-
| nRF24L01 header || Radio module socket || 1 || 2×4 female header
|-
| MPU6050 header || IMU socket || 1 || 2×4 female header
|-
| DuPont header || External H-bridge || 1 || 2×5 male header
|}

Full BOM with part numbers and suppliers available in the [https://github.com/Bespoke-Robot-Society/simplebot GitHub repository].

== Assembly Guide ==

=== Assembly Order ===

# '''Pre-tune buck converter''' to 3.3V (CRITICAL!)
# Install low-profile components (resistors, ICs)
# Install sockets and headers
# Install modules (buck converter, TB6612FNG)
# Test voltage output before connecting Pico
# Insert Pico into socket
# Connect motors and sensors
# Upload code and test!

Full step-by-step assembly instructions: [[SimpleBot PCB Guide]] or [https://github.com/Bespoke-Robot-Society/simplebot/blob/master/PCB_GUIDE.md GitHub version]

=== Critical Steps ===

==== 1. Buck Converter Adjustment ====

'''DO THIS FIRST''':
# Connect multimeter to buck converter output
# Apply power to buck converter input
# Adjust potentiometer to exactly 3.3V
# Verify voltage is stable
# ONLY THEN solder to PCB

'''Failure to do this can damage your Pico!'''

==== 2. Test Before Connecting Pico ====

After soldering the buck converter:
# Apply battery power (do NOT connect Pico yet)
# Verify 3.3V on all power rails
# Check for shorts with multimeter
# Only after confirming correct voltage, insert Pico

== Manufacturing Files ==

=== Gerber Files ===

Ready-to-manufacture Gerber files available:
* '''[https://github.com/Bespoke-Robot-Society/simplebot/blob/master/diffdrive_robot_microcontroller_board--tht_Gerber.zip Through-Hole Version]''' - Beginner-friendly THT components
* SMT version (coming soon) - Compact surface-mount design

=== PCB Specifications ===

* '''Dimensions''': ~90mm × 70mm (approximate)
* '''Layers''': 2-layer PCB
* '''Thickness''': 1.6mm (standard)
* '''Material''': FR-4
* '''Surface Finish''': HASL or ENIG
* '''Min Trace/Space''': 0.3mm / 0.3mm
* '''Min Drill''': 0.8mm

=== Ordering ===

Upload the Gerber ZIP file to any PCB manufacturer:
* '''JLCPCB''' - ~$2 for 5 PCBs + shipping
* '''PCBWay''' - ~$5 for 5 PCBs + shipping
* '''OSH Park''' - ~$20 for 3 PCBs (US-based, high quality)
* '''Seeed Studio''' - ~$5 for 5 PCBs + shipping

Manufacturing typically takes 2-5 days + shipping time.

== Design Files ==

The PCB was designed in '''KiCad''' (open-source EDA software):

* '''Schematic''': Full circuit diagram in KiCad format
* '''PCB Layout''': Complete board design with traces and copper pours
* '''Gerber Files''': Manufacturing-ready outputs
* '''Bill of Materials''': Component list with part numbers

All files available in the [https://github.com/Bespoke-Robot-Society/simplebot GitHub repository] under open-source license.

== Usage in Projects ==

=== SimpleBot ===

This PCB was designed specifically for [[SimpleBot]], but the design is generic enough for any differential drive robot with:
* Two DC motors
* Wheel encoders
* Line sensors or similar digital/analog sensors
* Battery power (4.5V – 6.5V input)

=== Other Robots ===

The modular design makes this PCB suitable for:
* Line-following robots
* Maze-solving robots
* Dead-reckoning navigation platforms
* Educational robotics projects
* Small autonomous vehicles

== Variations ==

=== External H-Bridge Variant ===

Install the 2×5 DuPont header instead of TB6612FNG module to use external motor drivers:
* '''L298N''' - Lower efficiency but higher current
* '''BTS7960''' - Much higher current (43A!) for large motors
* '''Cytron MD30C''' - High power with heat sink

Same Pico code works with all drivers - only change is physical wiring.

=== Custom Sensor Configurations ===

Use the sensor headers for:
* Additional line sensors (6-8 sensor arrays)
* Ultrasonic sensors (HC-SR04)
* IR distance sensors (Sharp GP2Y0A)
* Bump switches
* Servo motor control

=== Future Variants ===

* '''SMT Version''' - All surface-mount components for compact design
* '''High-Power Version''' - Integrated high-current motor driver
* '''All-in-One Version''' - Integrated sensors (no external modules)

== See Also ==

* [[SimpleBot]] - Robot using this PCB
* [[Raspberry Pi Pico]] - Microcontroller platform
* [[TB6612FNG]] - Motor driver
* [[MP1584]] - Buck converter
* [[LM393]] - Comparator IC
* [[PCB Design]] - General PCB design guide
* [[KiCad]] - PCB design software tutorial

== Resources ==

* [https://github.com/Bespoke-Robot-Society/simplebot GitHub Repository] - Design files, Gerbers, BOM
* [https://github.com/Bespoke-Robot-Society/simplebot/blob/master/PCB_GUIDE.md PCB Assembly Guide] - Detailed assembly instructions
* [[Soldering Guide]] - Learn through-hole soldering techniques

[[Category:PCB]]
[[Category:Motor Control]]
[[Category:Robot Electronics]]

File:BRS DDRCB.png

2025-10-11T20:32:35Z

John:

SimpleBot

2025-10-11T20:29:15Z

John: /* Design Goals */

{{Robot
| name = SimpleBot
| image = simplebot.jpeg
| caption = SimpleBot - BRS's first robot design
| use_case = Educational robot for learning line following, optical odometry, and basic robotics
| microcontroller = [[Raspberry Pi Pico]] or [[Raspberry Pi Pico W]]
| sensors = 2× [[Infrared Line Detector]], 2× Optical Encoders (custom), optional [[MPU6050]] IMU, optional nRF24L01 radio
| power = 4× AA batteries (6V nominal) via [[MP1584]] buck converter (3.3V output)
| pcb = [[BRS Differential Drive Robot Control Board]] (through-hole assembly)
| cost = '''Under $20''' (with batteries)
| repository = [https://github.com/Bespoke-Robot-Society/simplebot GitHub Repository]
}}

'''SimpleBot''' is the Bespoke Robot Society's original robot design, created for students, educators, and cost-conscious makers. It's a fully functional {{Wikipedia|Differential_wheeled_robot|differential drive robot}} that demonstrates core robotics concepts including motor control, sensor integration, and autonomous navigation.

== Design Goals ==

SimpleBot was designed with BRS's core mission in mind:

* '''Enable Real-World Use Cases''' - SimpleBot is a demonstrator for dead reckoning and line maze problems, required study for all entry-level roboticists.
* '''Design and build custom robots''' - 3D-printed chassis with modular sensor mounts
* '''Lower the barrier to entry''' - Under $20 total cost with Optical odometry and line following sensors included.
* '''Teach robotics fundamentals''' - Every component serves an educational purpose

== Overview ==

SimpleBot is based on commonly available "Arduino Smart Car" components (motors, wheels, battery holder) combined with a custom 3D-printed chassis and optional custom PCB. The robot can be built three ways:

# '''Breadboard Version''' - Wire everything on a breadboard (fastest to prototype)
# '''Protoboard Version''' - Solder components to perfboard (more permanent)
# '''Custom PCB Version''' - Use the [[BRS Differential Drive Robot Control Board]] (most compact)

All three versions run the same code and have identical functionality.

== Capabilities ==

=== Line Following ===
Two [[Infrared Line Detector|infrared line detectors]] mounted under the chassis track a black line on a white surface (or vice versa). The robot adjusts its motor speeds to stay centered on the line.

=== Optical Odometry ===
Custom encoder circuits use LEDs and photoresistors to count pulses from slotted wheels attached to the motors. This allows the robot to measure distance traveled and perform [[dead reckoning]].

=== Motor Control ===
The [[TB6612FNG]] dual H-bridge provides independent speed and direction control for both wheels via PWM signals from the Pico.

=== Expansion Ready ===
The PCB includes headers for:
* '''MPU6050''' 6-axis IMU (accelerometer + gyroscope) via I²C
* '''nRF24L01''' 2.4 GHz radio module via SPI
* '''4× sensor headers''' for additional sensors (3.3V + GND + GPIO)
* '''Analog/digital breakout headers''' for custom additions

== Hardware ==

=== Base Components ===

{| class="wikitable"
! Component !! Description !! Qty !! Est. Cost
|-
| Arduino Smart Car Kit || 2× TT motors with wheels, encoder discs, battery holder, power switch, caster wheel || 1 || $6
|-
| [[Raspberry Pi Pico]] || Microcontroller board (or Pico W for Wi-Fi) || 1 || $4
|-
| [[TB6612FNG]] Module || Dual H-bridge motor driver || 1 || $3
|-
| [[MP1584]] Module || Buck converter (6V → 3.3V) || 1 || $1
|-
| [[Infrared Line Detector]] || Line following sensors || 2 || $1
|-
| [[LM393]] IC || Dual comparator for optical encoders || 1 || $0.25
|-
| Resistors, LEDs, photoresistors || Encoder circuit components || Set || $1
|-
| 4× AA Batteries || Power supply (1.5V each = 6V total) || 4 || $2
|-
| 3D Printed Parts || Chassis, motor mounts, sensor mounts || Set || $2 (filament)
|-
| '''Total''' || || || '''~$20'''
|}

=== PCB Options ===

* '''[[BRS Differential Drive Robot Control Board]]''' (Through-Hole) - $5-10 for 5 PCBs from JLCPCB, ~$5 in components
* '''Breadboard/Perfboard''' - Cheaper but less compact

== Mechanical Design ==

SimpleBot uses a modular 3D-printed chassis with several key features:

=== Chassis Modules ===

* '''Main Chassis Plate''' - Central platform with mounting points for all modules
* '''Battery Block''' - Secures 4× AA battery holder with velcro strap retention
* '''Caster Assembly''' - Front-mounted caster wheel with adjustable height
* '''Motor Mounts''' - Dovetail attachment system for easy motor positioning
* '''Sensor Rail''' - Underside mounting for adjustable line sensors

All STL files and the FreeCAD source are available in the [https://github.com/Bespoke-Robot-Society/simplebot GitHub repository].

=== Assembly ===

See the detailed [[SimpleBot Assembly Guide]] (or [https://github.com/Bespoke-Robot-Society/simplebot/blob/master/ASSEMBLY_GUIDE.md GitHub version]) for step-by-step mechanical assembly instructions with images.

== Electronics ==

=== Circuit Design ===

The electronics integrate:
* Power regulation (6V battery → 3.3V via buck converter)
* Motor control (TB6612FNG dual H-bridge)
* Optical encoder circuits (LM393 comparators)
* Sensor interfaces (line detectors, IMU, radio)
* GPIO expansion (analog and digital headers)

=== PCB Design ===

See the detailed [[SimpleBot PCB Guide]] (or [https://github.com/Bespoke-Robot-Society/simplebot/blob/master/PCB_GUIDE.md GitHub version]) for:
* Full schematic
* PCB layout views
* Component placement
* Assembly instructions
* Gerber files for manufacturing

The PCB uses '''through-hole components''' for easy hand-soldering, making it ideal for educational builds and beginners.

== Software ==

SimpleBot runs '''MicroPython''' on the [[Raspberry Pi Pico]], making it accessible to beginners while providing full control over hardware.

=== Programming ===

# Install [https://thonny.org/ Thonny IDE] or use any MicroPython-compatible editor
# Connect Pico via USB
# Copy Python files from the repository to the Pico
# Edit configuration for your specific hardware
# Run and test!

=== Code Structure ===

The SimpleBot code is organized into modular files:
* '''motor.py''' - Motor control class with PWM speed control
* '''encoder.py''' - Optical encoder pulse counting
* '''line_sensor.py''' - Line detector interface
* '''robot.py''' - High-level robot control (drive forward, turn, etc.)
* '''main.py''' - Main program loop

=== Example Code ===

<syntaxhighlight lang="python">
from robot import SimpleBot
import time

# Initialize robot
bot = SimpleBot()

# Drive forward 30cm using odometry
bot.drive_distance(30) # cm

# Follow a line
while True:
left, right = bot.read_line_sensors()

if not left and not right:
bot.forward(speed=50) # Both on white - go straight
elif left:
bot.turn_right(speed=40) # Left on line - turn right
elif right:
bot.turn_left(speed=40) # Right on line - turn left

time.sleep(0.01)
</syntaxhighlight>

Full code examples available in the [https://github.com/Bespoke-Robot-Society/simplebot GitHub repository].

== Build Paths ==

Choose the path that matches your skill level and available resources:

=== Path 1: Buy Everything (Easiest) ===

'''Best for:''' Complete beginners, classrooms

# Purchase all components from the bill of materials
# 3D print the chassis parts (or use a print service)
# Order the pre-assembled PCB (or use breadboard)
# Follow assembly guide
# Upload code and go!

'''Time:''' 2-4 hours assembly + printing time

=== Path 2: Solder It Yourself (Learning) ===

'''Best for:''' Learning electronics, gaining soldering experience

# Purchase components and blank PCB
# Order Gerber files from JLCPCB (~$2 for 5 PCBs)
# Learn through-hole soldering techniques
# Assemble PCB step by step
# Integrate into 3D-printed chassis
# Upload code and test!

'''Time:''' 4-8 hours including soldering practice

=== Path 3: Design Your Own (Advanced) ===

'''Best for:''' Experienced makers, custom requirements

# Use SimpleBot as a reference design
# Modify the FreeCAD chassis for your needs
# Adapt the PCB design in KiCad
# Add custom sensors or actuators
# Create your own robot variant!

'''Time:''' Unlimited - this is your custom project!

== Learning Outcomes ==

Building and programming SimpleBot teaches:

=== 3D Printing ===
* Printing functional mechanical parts
* Working with heat-set inserts
* Designing for printability

=== Electronics ===
* Motor control with H-bridges
* Sensor interfacing (analog and digital)
* Power regulation with buck converters
* PCB assembly (through-hole soldering)

=== Software ===
* MicroPython programming
* PWM for motor speed control
* Interrupt-driven encoder counting
* Sensor polling and decision making
* PID control (optional advanced topic)

=== Robotics Concepts ===
* Differential drive kinematics
* Optical odometry for position tracking
* Line following algorithms
* Dead reckoning navigation
* Sensor fusion (with IMU)

== Variations ==

=== SimpleBot Mini ===
A smaller version designed to fit standard micromouse mazes (under development).

=== SimpleBot Pro ===
Enhanced version with additional sensors, faster motors, and ROS integration (future development).

=== Community Variants ===
See [[Build Logs:SimpleBot]] for community members' custom builds and modifications.

== Limitations ==

SimpleBot is designed as an educational platform, so it has intentional limitations:

* '''Speed''' - Deliberately slow for safety and learning
* '''Maze Size''' - Too large for standard micromouse mazes (see SimpleBot Mini)
* '''Terrain''' - Designed for flat, smooth surfaces only
* '''Line Following''' - Two-sensor configuration is simple but less robust than arrays

These limitations are features, not bugs - they provide opportunities for learning and improvement!

== Next Steps After Building SimpleBot ==

Once you've built and programmed SimpleBot, consider:

# '''Master line following''' - Optimize your code for speed and accuracy
# '''Add the IMU''' - Implement heading-based navigation
# '''Add the radio''' - Control remotely or implement swarm behavior
# '''Design custom sensors''' - Add ultrasonic, IR distance, or other sensors
# '''Build a maze''' - Create line-following challenges
# '''Modify the chassis''' - Add a pen holder for drawing robots
# '''Teach others''' - Document your build and help newcomers

== Resources ==

* '''[https://github.com/Bespoke-Robot-Society/simplebot GitHub Repository]''' - CAD files, code, PCB designs
* '''[[SimpleBot Assembly Guide]]''' - Step-by-step mechanical assembly
* '''[[SimpleBot PCB Guide]]''' - Electronics and PCB information
* '''[[Raspberry Pi Pico]]''' - Microcontroller documentation
* '''[[BRS Differential Drive Robot Control Board]]''' - PCB details

== See Also ==

* [[Differential Drive]] - Theory behind two-wheeled robots
* [[Optical Odometry]] - Measuring distance with encoders
* [[Line Following]] - Algorithms and techniques
* [[Motor Control]] - PWM and H-bridge operation
* [[3D Printing for Robotics]] - Designing and printing robot parts

== Community ==

Share your SimpleBot build:
* Post photos and videos on the [[Discord]]
* Create a [[Build Logs:SimpleBot|build log]] on the wiki
* Submit improvements via pull request on GitHub
* Help answer questions from new builders

[[Category:Robot]]
[[Category:Educational]]
[[Category:Line Following]]
[[Category:Differential Drive]]

SimpleBot

2025-10-11T20:27:27Z

John: /* Design Goals */

{{Robot
| name = SimpleBot
| image = simplebot.jpeg
| caption = SimpleBot - BRS's first robot design
| use_case = Educational robot for learning line following, optical odometry, and basic robotics
| microcontroller = [[Raspberry Pi Pico]] or [[Raspberry Pi Pico W]]
| sensors = 2× [[Infrared Line Detector]], 2× Optical Encoders (custom), optional [[MPU6050]] IMU, optional nRF24L01 radio
| power = 4× AA batteries (6V nominal) via [[MP1584]] buck converter (3.3V output)
| pcb = [[BRS Differential Drive Robot Control Board]] (through-hole assembly)
| cost = '''Under $20''' (with batteries)
| repository = [https://github.com/Bespoke-Robot-Society/simplebot GitHub Repository]
}}

'''SimpleBot''' is the Bespoke Robot Society's original robot design, created for students, educators, and cost-conscious makers. It's a fully functional {{Wikipedia|Differential_wheeled_robot|differential drive robot}} that demonstrates core robotics concepts including motor control, sensor integration, and autonomous navigation.

== Design Goals ==

SimpleBot was designed with BRS's core mission in mind:

* '''Optical odometry and line following''' - SimpleBot is a demonstrator for dead reckoning and line maze problems, required study for all entry-level roboticists.
* '''Design and build custom robots''' - 3D-printed chassis with modular sensor mounts
* '''Lower the barrier to entry''' - Under $20 total cost with all batteries included
* '''Teach robotics fundamentals''' - Every component serves an educational purpose

== Overview ==

SimpleBot is based on commonly available "Arduino Smart Car" components (motors, wheels, battery holder) combined with a custom 3D-printed chassis and optional custom PCB. The robot can be built three ways:

# '''Breadboard Version''' - Wire everything on a breadboard (fastest to prototype)
# '''Protoboard Version''' - Solder components to perfboard (more permanent)
# '''Custom PCB Version''' - Use the [[BRS Differential Drive Robot Control Board]] (most compact)

All three versions run the same code and have identical functionality.

== Capabilities ==

=== Line Following ===
Two [[Infrared Line Detector|infrared line detectors]] mounted under the chassis track a black line on a white surface (or vice versa). The robot adjusts its motor speeds to stay centered on the line.

=== Optical Odometry ===
Custom encoder circuits use LEDs and photoresistors to count pulses from slotted wheels attached to the motors. This allows the robot to measure distance traveled and perform [[dead reckoning]].

=== Motor Control ===
The [[TB6612FNG]] dual H-bridge provides independent speed and direction control for both wheels via PWM signals from the Pico.

=== Expansion Ready ===
The PCB includes headers for:
* '''MPU6050''' 6-axis IMU (accelerometer + gyroscope) via I²C
* '''nRF24L01''' 2.4 GHz radio module via SPI
* '''4× sensor headers''' for additional sensors (3.3V + GND + GPIO)
* '''Analog/digital breakout headers''' for custom additions

== Hardware ==

=== Base Components ===

{| class="wikitable"
! Component !! Description !! Qty !! Est. Cost
|-
| Arduino Smart Car Kit || 2× TT motors with wheels, encoder discs, battery holder, power switch, caster wheel || 1 || $6
|-
| [[Raspberry Pi Pico]] || Microcontroller board (or Pico W for Wi-Fi) || 1 || $4
|-
| [[TB6612FNG]] Module || Dual H-bridge motor driver || 1 || $3
|-
| [[MP1584]] Module || Buck converter (6V → 3.3V) || 1 || $1
|-
| [[Infrared Line Detector]] || Line following sensors || 2 || $1
|-
| [[LM393]] IC || Dual comparator for optical encoders || 1 || $0.25
|-
| Resistors, LEDs, photoresistors || Encoder circuit components || Set || $1
|-
| 4× AA Batteries || Power supply (1.5V each = 6V total) || 4 || $2
|-
| 3D Printed Parts || Chassis, motor mounts, sensor mounts || Set || $2 (filament)
|-
| '''Total''' || || || '''~$20'''
|}

=== PCB Options ===

* '''[[BRS Differential Drive Robot Control Board]]''' (Through-Hole) - $5-10 for 5 PCBs from JLCPCB, ~$5 in components
* '''Breadboard/Perfboard''' - Cheaper but less compact

== Mechanical Design ==

SimpleBot uses a modular 3D-printed chassis with several key features:

=== Chassis Modules ===

* '''Main Chassis Plate''' - Central platform with mounting points for all modules
* '''Battery Block''' - Secures 4× AA battery holder with velcro strap retention
* '''Caster Assembly''' - Front-mounted caster wheel with adjustable height
* '''Motor Mounts''' - Dovetail attachment system for easy motor positioning
* '''Sensor Rail''' - Underside mounting for adjustable line sensors

All STL files and the FreeCAD source are available in the [https://github.com/Bespoke-Robot-Society/simplebot GitHub repository].

=== Assembly ===

See the detailed [[SimpleBot Assembly Guide]] (or [https://github.com/Bespoke-Robot-Society/simplebot/blob/master/ASSEMBLY_GUIDE.md GitHub version]) for step-by-step mechanical assembly instructions with images.

== Electronics ==

=== Circuit Design ===

The electronics integrate:
* Power regulation (6V battery → 3.3V via buck converter)
* Motor control (TB6612FNG dual H-bridge)
* Optical encoder circuits (LM393 comparators)
* Sensor interfaces (line detectors, IMU, radio)
* GPIO expansion (analog and digital headers)

=== PCB Design ===

See the detailed [[SimpleBot PCB Guide]] (or [https://github.com/Bespoke-Robot-Society/simplebot/blob/master/PCB_GUIDE.md GitHub version]) for:
* Full schematic
* PCB layout views
* Component placement
* Assembly instructions
* Gerber files for manufacturing

The PCB uses '''through-hole components''' for easy hand-soldering, making it ideal for educational builds and beginners.

== Software ==

SimpleBot runs '''MicroPython''' on the [[Raspberry Pi Pico]], making it accessible to beginners while providing full control over hardware.

=== Programming ===

# Install [https://thonny.org/ Thonny IDE] or use any MicroPython-compatible editor
# Connect Pico via USB
# Copy Python files from the repository to the Pico
# Edit configuration for your specific hardware
# Run and test!

=== Code Structure ===

The SimpleBot code is organized into modular files:
* '''motor.py''' - Motor control class with PWM speed control
* '''encoder.py''' - Optical encoder pulse counting
* '''line_sensor.py''' - Line detector interface
* '''robot.py''' - High-level robot control (drive forward, turn, etc.)
* '''main.py''' - Main program loop

=== Example Code ===

<syntaxhighlight lang="python">
from robot import SimpleBot
import time

# Initialize robot
bot = SimpleBot()

# Drive forward 30cm using odometry
bot.drive_distance(30) # cm

# Follow a line
while True:
left, right = bot.read_line_sensors()

if not left and not right:
bot.forward(speed=50) # Both on white - go straight
elif left:
bot.turn_right(speed=40) # Left on line - turn right
elif right:
bot.turn_left(speed=40) # Right on line - turn left

time.sleep(0.01)
</syntaxhighlight>

Full code examples available in the [https://github.com/Bespoke-Robot-Society/simplebot GitHub repository].

== Build Paths ==

Choose the path that matches your skill level and available resources:

=== Path 1: Buy Everything (Easiest) ===

'''Best for:''' Complete beginners, classrooms

# Purchase all components from the bill of materials
# 3D print the chassis parts (or use a print service)
# Order the pre-assembled PCB (or use breadboard)
# Follow assembly guide
# Upload code and go!

'''Time:''' 2-4 hours assembly + printing time

=== Path 2: Solder It Yourself (Learning) ===

'''Best for:''' Learning electronics, gaining soldering experience

# Purchase components and blank PCB
# Order Gerber files from JLCPCB (~$2 for 5 PCBs)
# Learn through-hole soldering techniques
# Assemble PCB step by step
# Integrate into 3D-printed chassis
# Upload code and test!

'''Time:''' 4-8 hours including soldering practice

=== Path 3: Design Your Own (Advanced) ===

'''Best for:''' Experienced makers, custom requirements

# Use SimpleBot as a reference design
# Modify the FreeCAD chassis for your needs
# Adapt the PCB design in KiCad
# Add custom sensors or actuators
# Create your own robot variant!

'''Time:''' Unlimited - this is your custom project!

== Learning Outcomes ==

Building and programming SimpleBot teaches:

=== 3D Printing ===
* Printing functional mechanical parts
* Working with heat-set inserts
* Designing for printability

=== Electronics ===
* Motor control with H-bridges
* Sensor interfacing (analog and digital)
* Power regulation with buck converters
* PCB assembly (through-hole soldering)

=== Software ===
* MicroPython programming
* PWM for motor speed control
* Interrupt-driven encoder counting
* Sensor polling and decision making
* PID control (optional advanced topic)

=== Robotics Concepts ===
* Differential drive kinematics
* Optical odometry for position tracking
* Line following algorithms
* Dead reckoning navigation
* Sensor fusion (with IMU)

== Variations ==

=== SimpleBot Mini ===
A smaller version designed to fit standard micromouse mazes (under development).

=== SimpleBot Pro ===
Enhanced version with additional sensors, faster motors, and ROS integration (future development).

=== Community Variants ===
See [[Build Logs:SimpleBot]] for community members' custom builds and modifications.

== Limitations ==

SimpleBot is designed as an educational platform, so it has intentional limitations:

* '''Speed''' - Deliberately slow for safety and learning
* '''Maze Size''' - Too large for standard micromouse mazes (see SimpleBot Mini)
* '''Terrain''' - Designed for flat, smooth surfaces only
* '''Line Following''' - Two-sensor configuration is simple but less robust than arrays

These limitations are features, not bugs - they provide opportunities for learning and improvement!

== Next Steps After Building SimpleBot ==

Once you've built and programmed SimpleBot, consider:

# '''Master line following''' - Optimize your code for speed and accuracy
# '''Add the IMU''' - Implement heading-based navigation
# '''Add the radio''' - Control remotely or implement swarm behavior
# '''Design custom sensors''' - Add ultrasonic, IR distance, or other sensors
# '''Build a maze''' - Create line-following challenges
# '''Modify the chassis''' - Add a pen holder for drawing robots
# '''Teach others''' - Document your build and help newcomers

== Resources ==

* '''[https://github.com/Bespoke-Robot-Society/simplebot GitHub Repository]''' - CAD files, code, PCB designs
* '''[[SimpleBot Assembly Guide]]''' - Step-by-step mechanical assembly
* '''[[SimpleBot PCB Guide]]''' - Electronics and PCB information
* '''[[Raspberry Pi Pico]]''' - Microcontroller documentation
* '''[[BRS Differential Drive Robot Control Board]]''' - PCB details

== See Also ==

* [[Differential Drive]] - Theory behind two-wheeled robots
* [[Optical Odometry]] - Measuring distance with encoders
* [[Line Following]] - Algorithms and techniques
* [[Motor Control]] - PWM and H-bridge operation
* [[3D Printing for Robotics]] - Designing and printing robot parts

== Community ==

Share your SimpleBot build:
* Post photos and videos on the [[Discord]]
* Create a [[Build Logs:SimpleBot|build log]] on the wiki
* Submit improvements via pull request on GitHub
* Help answer questions from new builders

[[Category:Robot]]
[[Category:Educational]]
[[Category:Line Following]]
[[Category:Differential Drive]]

Sensor Interfacing

2025-10-11T20:16:48Z

John: Created page with "{{Tutorial |name=Sensor Interfacing |competency=Electronics |difficulty=Intermediate |time=4-6 hours |prerequisites=Electronics Fundamentals, MicroPython Basics, basic understanding of digital signals |materials=Microcontroller (Raspberry Pi Pico), breadboard, I2C sensor (MPU6050 IMU), analog sensor (photoresistor), digital sensor (IR line detector), 10kΩ resistors, jumper wires, multimeter, logic analyzer (optional but helpful) |next_steps=Add IMU or distan..."

{{Tutorial
|name=Sensor Interfacing
|competency=[[Electronics]]
|difficulty=Intermediate
|time=4-6 hours
|prerequisites=[[Electronics Fundamentals]], [[MicroPython Basics]], basic understanding of digital signals
|materials=Microcontroller (Raspberry Pi Pico), breadboard, I2C sensor (MPU6050 IMU), analog sensor (photoresistor), digital sensor (IR line detector), 10kΩ resistors, jumper wires, multimeter, logic analyzer (optional but helpful)
|next_steps=Add IMU or distance sensors to your robot, [[MicroPython Programming]], build advanced capabilities
}}

'''Sensor Interfacing''' teaches you how to connect and read sensors in robotics applications. You'll learn about communication protocols (I2C, SPI), analog sensors with ADC, pull-up resistors, and active HIGH/LOW logic. By the end of this tutorial, you'll be able to integrate new sensors into your robots and troubleshoot sensor communication issues.

This tutorial builds on [[Electronics Fundamentals]] and [[MicroPython Basics]] - you should understand voltage, digital signals, and basic Python programming.

== Why Sensor Interfacing Matters ==

Sensors are your robot's perception of the world:
* '''Vision''' - Detect lines, obstacles, colors (cameras, distance sensors)
* '''Motion''' - Measure acceleration, rotation, orientation (IMUs, gyroscopes)
* '''Position''' - Track wheel rotation, distance traveled (encoders, odometry)
* '''Environment''' - Detect light, temperature, sound (photoresistors, thermistors, microphones)

Without proper sensor interfacing, you cannot:
* Add new capabilities to your robot
* Debug sensor communication problems
* Select appropriate sensors for your application
* Understand sensor datasheets and specifications

== Part 1: Sensor Types and Outputs ==

=== Digital Sensors ===

'''Digital sensors''' output HIGH or LOW signals:

* '''Active HIGH''' - HIGH means "detected" (e.g., button pressed = HIGH)
* '''Active LOW''' - LOW means "detected" (e.g., [[Infrared Line Detector]] on black line = LOW)

'''Example: SimpleBot line sensors'''
* Output HIGH when no line (white surface reflects IR light)
* Output LOW when on line (black tape absorbs IR light)

'''Reading digital sensors:'''
<syntaxhighlight lang="python">
from machine import Pin

# Configure with pull-up resistor (sensor is active LOW)
sensor = Pin(10, Pin.IN, Pin.PULL_UP)

if sensor.value() == 0: # LOW = line detected
print("Line detected!")
else:
print("No line")
</syntaxhighlight>

=== Analog Sensors ===

'''Analog sensors''' output variable voltage:

* '''Photoresistor''' - Resistance changes with light (requires voltage divider)
* '''Temperature sensor''' - Voltage proportional to temperature
* '''Potentiometer''' - Voltage varies from 0V to Vcc
* '''Pressure sensor''' - Voltage indicates force

'''ADC (Analog-to-Digital Conversion)''' converts voltage to number:
* Raspberry Pi Pico: 12-bit ADC (0-4095) with 3.3V reference
* ESP32: 12-bit ADC (0-4095) with configurable reference
* Arduino Uno: 10-bit ADC (0-1023) with 5V reference

'''Reading analog sensors:'''
<syntaxhighlight lang="python">
from machine import ADC

# Configure ADC on GPIO26 (ADC0 on Raspberry Pi Pico)
sensor = ADC(26)

# Read raw ADC value (0-65535 on Pico using 16-bit conversion)
raw_value = sensor.read_u16()

# Convert to voltage (Pico uses 3.3V reference)
voltage = raw_value * 3.3 / 65535

print(f"ADC: {raw_value}, Voltage: {voltage:.2f}V")
</syntaxhighlight>

=== Communication Protocol Sensors ===

Advanced sensors use digital communication protocols:

* '''I2C''' - Two-wire bus, multiple devices, addresses (IMUs, distance sensors)
* '''SPI''' - Four-wire, high-speed, chip-select per device (displays, SD cards)
* '''UART''' - Two-wire, point-to-point (GPS modules, serial sensors)
* '''1-Wire''' - Single data wire (temperature sensors)

Most modern robot sensors use '''I2C''' because:
* Only 2 wires (SDA and SCL) for multiple devices
* Built-in addressing (up to 127 devices on one bus)
* Widely supported by microcontrollers
* Good for moderate-speed data (100 kHz - 400 kHz typical)

== Part 2: Pull-up and Pull-down Resistors ==

=== The Floating Input Problem ===

Digital inputs must be either HIGH or LOW - never '''floating''' (undefined):

* '''Floating input''' - Not connected to anything, voltage drifts randomly
* '''Symptom''' - Erratic readings, false triggers, unpredictable behavior
* '''Solution''' - Pull-up or pull-down resistor

=== Pull-up Resistors ===

'''Pull-up resistor''' connects input to HIGH voltage (3.3V or 5V):

<pre>
+3.3V
|
[10kΩ] ← Pull-up resistor
|
+------- Input Pin
|
[Switch] ← When closed, pulls to GND
|
GND
</pre>

'''Behavior:'''
* Switch open → Input = HIGH (pulled up by resistor)
* Switch closed → Input = LOW (connected to GND)

'''Default state: HIGH'''

'''Example: I2C communication requires pull-ups on SDA and SCL lines'''

=== Pull-down Resistors ===

'''Pull-down resistor''' connects input to LOW voltage (GND):

<pre>
+3.3V
|
[Switch] ← When closed, pulls to +3.3V
|
+------- Input Pin
|
[10kΩ] ← Pull-down resistor
|
GND
</pre>

'''Behavior:'''
* Switch open → Input = LOW (pulled down by resistor)
* Switch closed → Input = HIGH (connected to +3.3V)

'''Default state: LOW'''

=== Internal Pull-up/Pull-down ===

Most microcontrollers have '''internal pull-up/pull-down resistors''' (typically 10-50kΩ):

<syntaxhighlight lang="python">
from machine import Pin

# Enable internal pull-up
sensor_pull_up = Pin(10, Pin.IN, Pin.PULL_UP)

# Enable internal pull-down
sensor_pull_down = Pin(11, Pin.IN, Pin.PULL_DOWN)

# No pull resistor (floating - avoid this for digital inputs!)
sensor_floating = Pin(12, Pin.IN) # BAD PRACTICE
</syntaxhighlight>

'''When to use external pull-ups:'''
* I2C communication (typically 4.7kΩ or 10kΩ)
* Multiple devices sharing the same line
* When internal pull-up is too weak (long wires, high capacitance)

=== Resistor Value Selection ===

'''Typical values:'''
* '''10kΩ''' - General-purpose pull-up/pull-down
* '''4.7kΩ''' - I2C pull-ups (standard value)
* '''1kΩ''' - Strong pull-up for high-speed or long wires
* '''100kΩ''' - Weak pull-up to save power

'''Trade-offs:'''
* '''Lower resistance''' (1kΩ) - Stronger pull, faster signals, more power consumption
* '''Higher resistance''' (100kΩ) - Weaker pull, slower signals, less power consumption

'''Rule of thumb:''' 10kΩ works for most applications. Use 4.7kΩ for I2C.

== Part 3: I2C Communication ==

=== What is I2C? ===

'''I2C (Inter-Integrated Circuit)''' is a two-wire communication protocol:

* '''SDA''' - Serial Data (bidirectional data line)
* '''SCL''' - Serial Clock (clock signal from master)
* '''Plus''' - Ground (GND) and power (VCC)

'''Characteristics:'''
* Multi-master, multi-slave (but typically one master)
* 7-bit or 10-bit device addresses
* Speeds: 100 kHz (standard), 400 kHz (fast), up to 3.4 MHz (high-speed)
* Open-drain design requires pull-up resistors

=== I2C Device Addressing ===

Each I2C device has a unique '''7-bit address''' (0x00 - 0x7F):

'''Common sensor addresses:'''
* '''MPU6050 IMU''' - 0x68 (default) or 0x69 (alternate)
* '''VL53L0X distance sensor''' - 0x29
* '''BMP280 pressure sensor''' - 0x76 or 0x77
* '''OLED display (SSD1306)''' - 0x3C or 0x3D

'''Address conflicts:'''
If two sensors have the same address, you cannot use them on the same I2C bus (unless they have configurable addresses via ADR pin).

=== Wiring I2C Sensors ===

<pre>
Raspberry Pi Pico → MPU6050 IMU:
- GP0 (I2C0 SDA) → SDA
- GP1 (I2C0 SCL) → SCL
- 3.3V → VCC
- GND → GND

Pull-up resistors (4.7kΩ):
- SDA to 3.3V
- SCL to 3.3V

Note: Some breakout boards have built-in pull-ups
</pre>

'''Important:'''
* Use I2C-capable pins (check your microcontroller pinout)
* Raspberry Pi Pico has two I2C buses: I2C0 (GP0/GP1, GP4/GP5, etc.) and I2C1 (GP2/GP3, GP6/GP7, etc.)
* Add pull-up resistors if not present on breakout board

=== I2C Code Example: Scanning for Devices ===

<syntaxhighlight lang="python">
from machine import I2C, Pin

# Initialize I2C bus
i2c = I2C(0, scl=Pin(1), sda=Pin(0), freq=400000)

# Scan for devices
devices = i2c.scan()

if devices:
print(f"Found {len(devices)} I2C device(s):")
for device in devices:
print(f" - Address: 0x{device:02X}")
else:
print("No I2C devices found")
</syntaxhighlight>

'''Expected output (MPU6050 connected):'''
<pre>
Found 1 I2C device(s):
- Address: 0x68
</pre>

=== I2C Code Example: Reading MPU6050 IMU ===

<syntaxhighlight lang="python">
from machine import I2C, Pin
import time
import struct

class MPU6050:
"""Simple MPU6050 IMU driver"""

# I2C address
ADDR = 0x68

# Register addresses
PWR_MGMT_1 = 0x6B # Power management
ACCEL_XOUT_H = 0x3B # Accelerometer data start
GYRO_XOUT_H = 0x43 # Gyroscope data start

def __init__(self, i2c):
"""Initialize MPU6050 on given I2C bus"""
self.i2c = i2c

# Wake up sensor (clear sleep bit)
self.i2c.writeto_mem(self.ADDR, self.PWR_MGMT_1, b'\x00')
time.sleep_ms(100)

def read_accel(self):
"""Read accelerometer data (m/s²)

Returns:
Tuple (x, y, z) in m/s²
"""
# Read 6 bytes starting at ACCEL_XOUT_H
data = self.i2c.readfrom_mem(self.ADDR, self.ACCEL_XOUT_H, 6)

# Unpack as three 16-bit signed integers (big-endian)
ax, ay, az = struct.unpack('>hhh', data)

# Convert to m/s² (16384 LSB/g for default ±2g range)
scale = 9.81 / 16384
return (ax * scale, ay * scale, az * scale)

def read_gyro(self):
"""Read gyroscope data (deg/s)

Returns:
Tuple (x, y, z) in deg/s
"""
# Read 6 bytes starting at GYRO_XOUT_H
data = self.i2c.readfrom_mem(self.ADDR, self.GYRO_XOUT_H, 6)

# Unpack as three 16-bit signed integers (big-endian)
gx, gy, gz = struct.unpack('>hhh', data)

# Convert to deg/s (131 LSB/(deg/s) for default ±250 deg/s range)
scale = 1 / 131
return (gx * scale, gy * scale, gz * scale)

# Initialize I2C and sensor
i2c = I2C(0, scl=Pin(1), sda=Pin(0), freq=400000)
imu = MPU6050(i2c)

# Read sensor data
while True:
accel = imu.read_accel()
gyro = imu.read_gyro()

print(f"Accel: X={accel[0]:6.2f} Y={accel[1]:6.2f} Z={accel[2]:6.2f} m/s²")
print(f"Gyro: X={gyro[0]:6.2f} Y={gyro[1]:6.2f} Z={gyro[2]:6.2f} deg/s")
print()

time.sleep(0.5)
</syntaxhighlight>

=== I2C Troubleshooting ===

'''No devices found (empty scan):'''
* Check wiring (SDA, SCL, GND, VCC all connected)
* Verify power supply (3.3V or 5V depending on sensor)
* Check pull-up resistors (need 4.7kΩ on SDA and SCL)
* Try lower I2C frequency (100 kHz instead of 400 kHz)
* Verify I2C pins (use correct pins for your microcontroller)

'''OSError: [Errno 5] EIO (Input/Output Error):'''
* Wrong I2C address (use scan to find actual address)
* Sensor not responding (check power, try different sensor)
* Bus contention (multiple masters or short circuit)

'''Intermittent readings:'''
* Weak pull-up resistors (use 4.7kΩ or 2.2kΩ)
* Long wires (keep I2C wires <1 meter, preferably <30cm)
* EMI interference (route I2C wires away from motors)
* Bad connections (check breadboard connections)

== Part 4: Analog Sensors and ADC ==

=== Voltage Dividers for Resistive Sensors ===

Many sensors (photoresistors, thermistors, FSRs) are '''variable resistors'''. To read them, create a voltage divider:

<pre>
+3.3V
|
[R1] ← Fixed resistor (e.g., 10kΩ)
|
+------- ADC Input (Vout)
|
[Photoresistor] ← Variable resistor
|
GND

Vout = 3.3V × R_photo / (R1 + R_photo)
</pre>

'''How it works:'''
* Bright light → Photoresistor low resistance (~1kΩ) → Vout low
* Dark → Photoresistor high resistance (~100kΩ) → Vout high

=== Reading Analog Sensors ===

'''Example: Photoresistor for optical encoders (SimpleBot)'''

<syntaxhighlight lang="python">
from machine import ADC, Pin
import time

# Configure ADC on GP26 (ADC0)
photoresistor = ADC(26)

# Read continuously
while True:
# Read 16-bit value (0-65535)
raw = photoresistor.read_u16()

# Convert to voltage (3.3V reference)
voltage = raw * 3.3 / 65535

# Convert to percentage (0-100%)
percentage = raw / 655.35

print(f"Raw: {raw:5d} Voltage: {voltage:.2f}V Brightness: {percentage:.1f}%")
time.sleep(0.1)
</syntaxhighlight>

=== ADC Reference Voltage ===

'''Reference voltage''' is the maximum voltage the ADC can read:

* '''Raspberry Pi Pico''' - 3.3V reference (ADC input max 3.3V)
* '''ESP32''' - Configurable (0-3.3V typical, can be attenuated to read higher voltages)
* '''Arduino Uno''' - 5V reference (ADC input max 5V)

'''Critical warning:''' Exceeding ADC input voltage can damage your microcontroller!

'''Voltage divider for higher voltages:'''
To measure a 9V battery with a 3.3V ADC:

<pre>
+9V Battery
|
[20kΩ] ← R1
|
+------- ADC Input (Vout = 3V when battery = 9V)
|
[10kΩ] ← R2
|
GND

Vout = Vin × R2 / (R1 + R2) = 9V × 10kΩ / 30kΩ = 3V
</pre>

<syntaxhighlight lang="python">
# Read battery voltage (9V nominal, divided by 3)
adc = ADC(26)
raw = adc.read_u16()
divided_voltage = raw * 3.3 / 65535
actual_voltage = divided_voltage * 3 # Multiply by divider ratio
print(f"Battery: {actual_voltage:.2f}V")
</syntaxhighlight>

=== ADC Noise and Averaging ===

ADC readings contain noise. '''Averaging''' multiple readings improves stability:

<syntaxhighlight lang="python">
def read_adc_average(adc, samples=10):
"""Read ADC and return average of multiple samples

Args:
adc: ADC object
samples: Number of samples to average

Returns:
Average ADC value (0-65535)
"""
total = 0
for _ in range(samples):
total += adc.read_u16()
return total // samples

# Usage
adc = ADC(26)
averaged_value = read_adc_average(adc, samples=20)
print(f"Averaged ADC: {averaged_value}")
</syntaxhighlight>

=== Optical Encoders (SimpleBot Example) ===

SimpleBot uses '''optical encoders''' to measure wheel rotation:

* '''Slotted wheel''' attached to motor shaft
* '''LED''' shines through slots
* '''Photoresistor''' detects light pulses
* '''Count pulses''' to measure distance

<syntaxhighlight lang="python">
from machine import ADC
import time

# Configure optical encoder on ADC0
encoder = ADC(26)

# Threshold for detecting slot vs spoke
THRESHOLD = 30000 # Tune based on your setup

# Track state
pulse_count = 0
prev_state = False

while True:
# Read sensor
value = encoder.read_u16()

# Detect light (slot) or dark (spoke)
current_state = (value > THRESHOLD)

# Count rising edges (transition from dark to light)
if current_state and not prev_state:
pulse_count += 1
print(f"Pulse count: {pulse_count}")

prev_state = current_state
time.sleep(0.01) # Poll at 100 Hz
</syntaxhighlight>

'''Better approach:''' Use interrupts for faster, more reliable pulse counting (see advanced section).

== Part 5: SPI Communication ==

=== What is SPI? ===

'''SPI (Serial Peripheral Interface)''' is a four-wire communication protocol:

* '''MOSI''' - Master Out, Slave In (data from controller to device)
* '''MISO''' - Master In, Slave Out (data from device to controller)
* '''SCK''' - Serial Clock (clock signal from master)
* '''CS''' - Chip Select (one per device, active LOW)

'''Characteristics:'''
* Full-duplex (simultaneous send and receive)
* High speed (MHz range, faster than I2C)
* No addressing (use CS pin to select device)
* Requires one CS pin per device

'''Common SPI devices:'''
* SD cards
* TFT displays
* LoRa radio modules
* Flash memory chips
* ADC/DAC chips

=== Wiring SPI Devices ===

<pre>
Raspberry Pi Pico → SPI Device:
- GP18 (SPI0 SCK) → SCK
- GP19 (SPI0 MOSI) → MOSI
- GP16 (SPI0 MISO) → MISO
- GP17 (any GPIO) → CS
- 3.3V → VCC
- GND → GND

Multiple devices:
- Share SCK, MOSI, MISO
- Each device gets unique CS pin
</pre>

=== SPI Code Example: Reading an ID Register ===

<syntaxhighlight lang="python">
from machine import SPI, Pin

# Initialize SPI bus
spi = SPI(0, baudrate=1000000, polarity=0, phase=0,
sck=Pin(18), mosi=Pin(19), miso=Pin(16))

# Chip select pin
cs = Pin(17, Pin.OUT)
cs.value(1) # Deselect (CS is active LOW)

def read_device_id(register_addr):
"""Read device ID register via SPI

Args:
register_addr: Register address to read

Returns:
Register value
"""
cs.value(0) # Select device

# Write register address
spi.write(bytearray([register_addr]))

# Read response
response = spi.read(1)

cs.value(1) # Deselect device

return response[0]

# Example: Read ID register at 0x0F (common for many sensors)
device_id = read_device_id(0x0F)
print(f"Device ID: 0x{device_id:02X}")
</syntaxhighlight>

=== SPI vs I2C Comparison ===

{| class="wikitable"
! Feature !! I2C !! SPI
|-
| Wires || 2 (SDA, SCL) || 4 (MOSI, MISO, SCK, CS)
|-
| Speed || 100-400 kHz typical || 1-10 MHz typical
|-
| Addressing || 7-bit address || Chip Select pin
|-
| Multiple devices || Easy (shared bus) || Requires one CS pin per device
|-
| Complexity || Moderate || Simple hardware, more wiring
|-
| Power || Lower || Higher (faster switching)
|-
| Distance || <1m typical || <30cm typical
|}

'''When to use I2C:'''
* Multiple sensors with unique addresses
* Moderate data rates
* Fewer available GPIO pins

'''When to use SPI:'''
* High-speed data (displays, SD cards)
* Full-duplex communication needed
* Plenty of GPIO pins available

== Part 6: Debugging Sensor Communication ==

=== Logic Analyzer ===

A '''logic analyzer''' captures and displays digital signals:

* Shows timing of SDA, SCL, MOSI, MISO, etc.
* Decodes I2C, SPI, UART protocols automatically
* Essential for debugging communication issues

'''Affordable options:'''
* '''Saleae Logic clone''' ($10-20) - 8 channels, USB
* '''DSLogic Plus''' ($100) - 16 channels, high speed
* '''Oscilloscope with protocol decode''' ($200+) - Shows analog waveforms too

'''How to use:'''
1. Connect logic analyzer probes to I2C/SPI lines (SDA, SCL, etc.)
2. Connect ground to circuit ground
3. Capture communication sequence
4. Analyze timing, decode data, identify errors

=== I2C Debugging Checklist ===

If I2C communication fails:

1. '''Scan for devices''' - Does `i2c.scan()` find your sensor?
2. '''Check address''' - Is device address correct? (Some have alternate addresses)
3. '''Verify wiring''' - SDA, SCL, GND, VCC all connected?
4. '''Pull-up resistors''' - 4.7kΩ on SDA and SCL?
5. '''Power supply''' - Is sensor getting correct voltage (3.3V or 5V)?
6. '''Clock speed''' - Try lower frequency (100 kHz instead of 400 kHz)
7. '''Multiple masters''' - Only one device should control I2C bus
8. '''Cable length''' - Keep I2C wires short (<30cm preferred)

=== Common Sensor Problems ===

'''Sensor returns garbage data:'''
* Incorrect data format (check datasheet for byte order, signed/unsigned)
* Wrong register address
* Sensor needs initialization sequence
* Data needs calibration or offset correction

'''Sensor works then stops:'''
* Power supply voltage sag (motors drawing too much current)
* Loose connection (check breadboard contacts)
* Thermal shutdown (sensor overheating)
* EMI from motors (add capacitors, shield wires)

'''Readings are noisy or fluctuate:'''
* ADC noise (use averaging, add filter capacitor)
* EMI from motors (route sensor wires away from motor wires)
* Poor ground connection (ensure solid GND)
* Floating inputs (add pull-up/pull-down resistors)

=== Multimeter Debugging ===

Use a multimeter to check:

1. '''Power supply''' - Measure voltage at sensor VCC pin (should be 3.3V or 5V)
2. '''Ground continuity''' - Check continuity between sensor GND and microcontroller GND
3. '''Signal levels''' - Measure SDA/SCL when idle (should be pulled up to 3.3V/5V)
4. '''Analog sensor output''' - Measure voltage at ADC pin (should vary with sensor input)

== Part 7: Advanced Sensor Techniques ==

=== Interrupts for Fast Sensors ===

'''Polling''' (checking sensor in loop) is slow and wastes CPU time. '''Interrupts''' trigger code immediately when signal changes:

<syntaxhighlight lang="python">
from machine import Pin

# Global counter
pulse_count = 0

def encoder_interrupt(pin):
"""Called when encoder signal changes"""
global pulse_count
pulse_count += 1

# Configure encoder pin with interrupt
encoder_pin = Pin(10, Pin.IN, Pin.PULL_UP)
encoder_pin.irq(trigger=Pin.IRQ_RISING, handler=encoder_interrupt)

# Main loop can do other things
while True:
print(f"Pulses: {pulse_count}")
time.sleep(1)
</syntaxhighlight>

'''When to use interrupts:'''
* High-speed encoders (>100 Hz)
* Critical timing (missing a pulse matters)
* Freeing CPU for other tasks

'''When NOT to use interrupts:'''
* Slow sensors (<10 Hz) - polling is simpler
* Complex processing needed - interrupts should be fast
* Debugging (harder to troubleshoot)

=== Kalman Filters for Sensor Fusion ===

Combine multiple sensors for better accuracy:

* '''IMU + Encoders''' - Accurate position and orientation
* '''Camera + Distance sensor''' - 3D object localization
* '''GPS + IMU''' - Precise outdoor navigation

'''Kalman filter''' is an algorithm that optimally combines sensor data, accounting for noise and uncertainty. This is an advanced topic beyond this tutorial.

=== Low-Pass Filters for Noisy Sensors ===

'''Low-pass filter''' smooths noisy analog readings:

<syntaxhighlight lang="python">
class LowPassFilter:
"""Simple exponential moving average low-pass filter"""

def __init__(self, alpha=0.1):
"""Initialize filter

Args:
alpha: Smoothing factor (0-1). Lower = smoother but slower.
"""
self.alpha = alpha
self.value = None

def update(self, new_value):
"""Update filter with new reading

Args:
new_value: Latest sensor reading

Returns:
Filtered value
"""
if self.value is None:
self.value = new_value
else:
self.value = self.alpha * new_value + (1 - self.alpha) * self.value
return self.value

# Usage
filter = LowPassFilter(alpha=0.2)
adc = ADC(26)

while True:
raw = adc.read_u16()
filtered = filter.update(raw)
print(f"Raw: {raw:5d} Filtered: {filtered:5.0f}")
time.sleep(0.1)
</syntaxhighlight>

'''Alpha parameter:'''
* '''alpha = 1.0''' - No filtering (output = input)
* '''alpha = 0.5''' - Moderate filtering
* '''alpha = 0.1''' - Heavy filtering (smooth but slow response)

=== Sensor Calibration ===

Many sensors need calibration to convert raw values to real-world units:

'''Example: Calibrating a line sensor threshold'''

<syntaxhighlight lang="python">
from machine import Pin
import time

# Configure sensor
sensor = Pin(10, Pin.IN, Pin.PULL_UP)

# Calibration procedure
print("Calibration: Place sensor on WHITE surface")
time.sleep(3)
white_count = 0
for _ in range(100):
if sensor.value():
white_count += 1
time.sleep(0.01)
white_confidence = white_count / 100

print(f"White confidence: {white_confidence:.2f}")

print("Calibration: Place sensor on BLACK surface")
time.sleep(3)
black_count = 0
for _ in range(100):
if not sensor.value():
black_count += 1
time.sleep(0.01)
black_confidence = black_count / 100

print(f"Black confidence: {black_confidence:.2f}")

# Use calibrated thresholds
if white_confidence > 0.8 and black_confidence > 0.8:
print("Calibration successful!")
else:
print("Calibration failed - adjust potentiometer")
</syntaxhighlight>

== Part 8: Practical Skills Checklist ==

By now, you should be able to:

* ☐ Explain the difference between digital and analog sensors
* ☐ Configure pull-up/pull-down resistors for digital inputs
* ☐ Understand active HIGH vs active LOW logic
* ☐ Wire and read an I2C sensor (IMU, distance sensor)
* ☐ Scan for I2C devices and identify addresses
* ☐ Read analog sensors using ADC
* ☐ Create voltage dividers for resistive sensors
* ☐ Understand SPI communication basics
* ☐ Debug sensor communication issues with multimeter
* ☐ Implement averaging and filtering for noisy sensors
* ☐ Use interrupts for fast sensors (encoders)

If you can check most of these boxes, you're ready to add sensors to your robots!

== Part 9: Sensor Selection Guide ==

=== Choosing the Right Sensor ===

{| class="wikitable"
! Sensor Type !! Use Case !! Interface !! Cost !! Complexity
|-
| IR Line Detector || Line following || Digital || $0.50 || Beginner
|-
| Ultrasonic (HC-SR04) || Obstacle avoidance || Digital (trigger/echo) || $1-2 || Beginner
|-
| MPU6050 IMU || Tilt, acceleration, rotation || I2C || $2-5 || Intermediate
|-
| VL53L0X Distance || Precise distance (2m) || I2C || $3-8 || Intermediate
|-
| Optical Encoder || Wheel rotation, odometry || Analog or Digital || $1-3 || Intermediate
|-
| Camera (OV7670) || Vision, object detection || Complex (parallel/SPI) || $5-15 || Advanced
|-
| LIDAR (RPLidar) || 360° mapping || UART || $100+ || Advanced
|}

=== Sensor Interface Summary ===

* '''Digital (GPIO)''' - Simplest, on/off sensors
* '''Analog (ADC)''' - Variable sensors, requires voltage divider for resistive sensors
* '''I2C''' - Most common for IMU, distance, environmental sensors
* '''SPI''' - High-speed displays, SD cards, some sensors
* '''UART''' - GPS modules, some distance sensors
* '''PWM''' - Servo motors, some ultrasonic sensors (output)

== Next Steps ==

=== Add Sensors to Your Robot ===
* [[Capability:IMU Sensing]] - Add MPU6050 for tilt and rotation detection
* [[Capability:Time-of-Flight Sensing]] - Add VL53L0X for obstacle detection
* [[Capability:Encoder Sensing]] - Add quadrature encoders for precise odometry
* [[Capability:Ultrasonic Sensing]] - Add HC-SR04 for distance measurement

=== Build Advanced Projects ===
* [[SimpleBot]] - Build a robot that uses multiple sensor types
* [[Activity:Maze Solving]] - Use distance sensors to navigate mazes
* Create a self-balancing robot using IMU feedback

=== Learn More Electronics ===
* [[Motor Control Basics]] - Control actuators based on sensor feedback
* [[Electronics]] - Full electronics competency overview
* [[MicroPython Programming]] - Advanced sensor data processing

== Common Mistakes and Pitfalls ==

* '''Missing pull-up resistors''' - I2C won't work without pull-ups on SDA/SCL
* '''Floating inputs''' - Digital inputs without pull-up/pull-down give random readings
* '''Wrong voltage''' - Exceeding ADC input voltage (3.3V on Pico) damages microcontroller
* '''Incorrect I2C address''' - Check datasheet, some sensors have alternate addresses
* '''Mixed logic levels''' - 5V sensor output can damage 3.3V microcontroller (use level shifter)
* '''Long I2C wires''' - Keep I2C wires short (<30cm) to avoid communication errors
* '''No common ground''' - Sensor GND must connect to microcontroller GND
* '''Polling too slowly''' - Fast sensors (encoders) may miss pulses if polling is too slow

== Resources and Further Reading ==

=== BRS Wiki Pages ===
* [[Electronics Fundamentals]] - Prerequisite tutorial
* [[Motor Control Basics]] - Combine sensors with motors
* [[Capability:IMU Sensing]] - MPU6050 usage in robots
* [[Capability:Optical Odometry]] - Encoder implementation
* [[Infrared Line Detector]] - Line sensor details

=== External Resources ===
* [https://learn.sparkfun.com/tutorials/i2c SparkFun I2C Tutorial]
* [https://learn.sparkfun.com/tutorials/analog-to-digital-conversion SparkFun ADC Tutorial]
* [https://learn.adafruit.com/working-with-i2c-devices Adafruit I2C Guide]
* [https://www.nxp.com/docs/en/user-guide/UM10204.pdf I2C Specification] (PDF, official)

=== Datasheets ===
Reading datasheets is essential for sensor interfacing:
* Sensor address and register map
* Timing requirements
* Power supply specifications
* Communication protocol details

== See Also ==

* [[Electronics Fundamentals]] - Prerequisite tutorial
* [[Motor Control Basics]] - Actuator control
* [[MicroPython Programming]] - Advanced sensor programming
* [[Electronics]] - Full electronics competency overview
* [[Capabilities]] - Hardware abilities unlocked by sensors

[[Category:Tutorials]]
[[Category:Electronics]]
[[Category:Intermediate]]

Motor Control Basics

2025-10-11T20:16:34Z

John: Created page with "{{Tutorial |name=Motor Control Basics |competency=Electronics |difficulty=Intermediate |time=3-5 hours |prerequisites=Electronics Fundamentals, basic understanding of digital signals and PWM |materials=Breadboard, DC motor, motor driver module (TB6612FNG or L298N), microcontroller (Raspberry Pi Pico or Arduino), power supply (6-9V), jumper wires, multimeter |next_steps=SimpleBot assembly, build Capability:Differential Drive, Sensor Interfacing }} '''..."

{{Tutorial
|name=Motor Control Basics
|competency=[[Electronics]]
|difficulty=Intermediate
|time=3-5 hours
|prerequisites=[[Electronics Fundamentals]], basic understanding of digital signals and PWM
|materials=Breadboard, DC motor, motor driver module (TB6612FNG or L298N), microcontroller (Raspberry Pi Pico or Arduino), power supply (6-9V), jumper wires, multimeter
|next_steps=[[SimpleBot]] assembly, build [[Capability:Differential Drive]], [[Sensor Interfacing]]
}}

'''Motor Control Basics''' teaches you how to control DC motors in robotics applications. You'll learn about H-bridges, PWM speed control, motor driver ICs, and differential drive systems. By the end of this tutorial, you'll understand how SimpleBot controls its motors and be able to implement motor control in your own robots.

This tutorial builds on [[Electronics Fundamentals]] - you should understand voltage, current, PWM, and digital signals before proceeding.

== Why Motor Control Matters ==

Motors are the primary actuators in mobile robotics. Understanding motor control is essential for:
* '''Speed control''' - Make your robot go faster or slower
* '''Direction control''' - Forward, reverse, turning
* '''Precise motion''' - Differential drive, straight-line driving, rotation in place
* '''Energy efficiency''' - Maximize battery life with proper motor control
* '''Protection''' - Prevent damage to motors and electronics

Without proper motor control knowledge, you risk burning out motors, draining batteries rapidly, or damaging your microcontroller.

== Part 1: DC Motor Fundamentals ==

=== How DC Motors Work ===

A '''DC (Direct Current) motor''' converts electrical energy into rotational motion:

* Apply voltage across motor terminals → motor spins
* Higher voltage = faster speed (generally)
* Reverse polarity → motor spins in opposite direction

'''Key characteristics:'''
* '''No-load speed''' - Maximum RPM when nothing is attached to the shaft
* '''Stall current''' - Current drawn when motor is blocked (highest current)
* '''Operating voltage''' - Typical range (e.g., 3V-6V for hobby motors)
* '''Rated current''' - Typical current during normal operation
* '''Torque''' - Rotational force the motor can produce

=== Current Draw and Power ===

Motors draw '''variable current''' depending on load:

* '''No load''' - Minimum current (50-100mA typical for small motors)
* '''Normal operation''' - Moderate current (200-500mA typical)
* '''Stall''' (blocked shaft) - Maximum current (1-3A typical)
* '''Startup''' - Brief high current spike when starting

'''Example: SimpleBot TT Motor'''
* No-load current: ~60mA at 6V
* Normal operation: ~200mA at 6V
* Stall current: ~1.5A at 6V

'''Why this matters:'''
* You cannot power motors directly from microcontroller GPIO pins (typically limited to 10-20mA)
* Motors need dedicated power supply (not the 3.3V regulator powering your microcontroller)
* Motor drivers must handle stall current without overheating

=== Back-EMF (Electromotive Force) ===

When a motor spins, it acts as a generator and produces voltage in the opposite direction:

* '''Back-EMF''' increases with motor speed
* Can damage circuits when motor suddenly stops or reverses
* '''Protection required''': Diodes (flyback diodes) or motor driver ICs with built-in protection

'''What happens without protection:'''
# Motor spinning at full speed
# You cut power to motor
# Motor's inertia keeps it spinning briefly
# Motor generates voltage spike (back-EMF)
# Voltage spike can damage transistors, microcontrollers, or other components

'''Solution:''' Use motor driver ICs (like TB6612FNG) with built-in protection, or add flyback diodes across motor terminals.

== Part 2: H-Bridge Motor Drivers ==

=== What is an H-Bridge? ===

An '''H-bridge''' is a circuit that allows you to control motor direction by switching the polarity of voltage across the motor:

<pre>
+V
|
[SW1] [SW2]
| |
+--M--+ (Motor)
| |
[SW3] [SW4]
|
GND

Legend: SW = Switch, M = Motor, +V = Battery positive
</pre>

The circuit forms an "H" shape - hence the name.

=== H-Bridge Operation ===

By controlling four switches (typically transistors), you can control motor direction:

{| class="wikitable"
! SW1 !! SW2 !! SW3 !! SW4 !! Motor Action
|-
| OFF || ON || ON || OFF || Forward (current flows left-to-right)
|-
| ON || OFF || OFF || ON || Reverse (current flows right-to-left)
|-
| OFF || OFF || OFF || OFF || Coast (motor freewheels)
|-
| OFF || ON || OFF || ON || Brake (both terminals connected to +V)
|-
| ON || OFF || ON || OFF || Brake (both terminals connected to GND)
|-
| ON || ON || OFF || OFF || SHORT CIRCUIT! Never do this!
|}

'''Critical rule:''' Never turn on SW1 and SW3 at the same time, or SW2 and SW4 at the same time - this creates a short circuit from +V to GND!

=== Building an H-Bridge (Educational - Not Recommended) ===

You '''could''' build an H-bridge using discrete transistors (4× MOSFETs), but:

* Requires careful gate driver design
* No built-in protection
* Easy to make mistakes that destroy components
* Takes up significant board space

'''Better approach:''' Use integrated H-bridge driver ICs like the TB6612FNG, L298N, or DRV8833. These have built-in protection, current limiting, and thermal shutdown.

== Part 3: PWM Speed Control ==

=== How PWM Controls Motor Speed ===

'''PWM (Pulse Width Modulation)''' controls motor speed by rapidly switching power on and off:

* '''100% duty cycle''' - Always ON → full speed
* '''50% duty cycle''' - ON half the time → ~half speed
* '''25% duty cycle''' - ON quarter of the time → ~quarter speed
* '''0% duty cycle''' - Always OFF → motor stopped

The motor's inertia smooths out the pulses, resulting in variable speed.

=== PWM Frequency Selection ===

'''Typical PWM frequencies for motor control:'''
* '''1 kHz - 20 kHz''' - Most common range
* '''Too low''' (<100 Hz) - Motor produces audible whine, rough motion
* '''Too high''' (>50 kHz) - Switching losses in driver increase, less efficient

'''SimpleBot uses 1 kHz PWM''' - good balance between smoothness and efficiency.

=== PWM and Direction Control Combined ===

To control both speed and direction:

# Set direction using H-bridge control pins (IN1, IN2)
# Apply PWM signal to enable/PWM pin
# Result: Motor spins at variable speed in chosen direction

'''Example: TB6612FNG control'''
* Set AIN1=LOW, AIN2=HIGH → Forward direction
* Apply PWM to PWMA pin → Variable speed forward
* Change to AIN1=HIGH, AIN2=LOW → Reverse direction

=== Non-Linear Speed Response ===

Motor speed is '''not''' linearly proportional to PWM duty cycle:

* '''Below ~20% duty cycle''' - Motor may not turn at all (not enough torque to overcome friction)
* '''20-80% duty cycle''' - Approximately linear speed response
* '''80-100% duty cycle''' - Speed approaches maximum, less sensitivity to changes

'''Practical implication:''' You may need to calibrate motor control in software:
* Dead zone compensation (start at 25% instead of 0%)
* Speed mapping function (non-linear duty cycle to achieve linear speed)
* Different motors may need different calibration

== Part 4: Motor Driver ICs ==

=== The TB6612FNG Motor Driver ===

The '''TB6612FNG''' is SimpleBot's motor driver. It's a dual H-bridge driver that can control two DC motors independently.

'''Key specifications:'''
* Motor voltage: 4.5V - 13.5V
* Logic voltage: 2.7V - 5.5V (3.3V compatible!)
* Continuous current: 1.2A per channel
* Peak current: 3.2A per channel
* Low voltage drop: ~0.3V (very efficient)
* Built-in protection: Thermal shutdown, low-voltage detection

'''Control pins per motor:'''
* '''PWM''' - Speed control (PWM signal)
* '''IN1''' - Direction control bit 1
* '''IN2''' - Direction control bit 2
* '''STBY''' - Standby (must be HIGH to enable driver)

=== TB6612FNG Truth Table ===

For each motor (A or B):

{| class="wikitable"
! IN1 !! IN2 !! PWM !! Motor Output
|-
| LOW || HIGH || PWM || Forward (CCW)
|-
| HIGH || LOW || PWM || Reverse (CW)
|-
| LOW || LOW || any || Coast (freewheeling)
|-
| HIGH || HIGH || any || Brake (short brake)
|}

'''Brake vs Coast:'''
* '''Brake''' (IN1=HIGH, IN2=HIGH) - Motor terminals shorted together, motor stops quickly
* '''Coast''' (IN1=LOW, IN2=LOW) - Motor terminals disconnected, motor coasts to a stop

=== Wiring the TB6612FNG ===

<pre>
Raspberry Pi Pico → TB6612FNG:
- GP14 → AIN1 (Motor A direction bit 1)
- GP15 → AIN2 (Motor A direction bit 2)
- GP16 → PWMA (Motor A speed - PWM capable pin)
- GP17 → BIN1 (Motor B direction bit 1)
- GP18 → BIN2 (Motor B direction bit 2)
- GP19 → PWMB (Motor B speed - PWM capable pin)
- GP20 → STBY (Standby - enable driver)
- GND → GND (Logic ground)

Power Supply:
- 6V Battery (+) → VM (Motor power)
- 3.3V → VCC (Logic power from Pico)
- GND → GND (Power) (Shared ground)

Motors:
- Left Motor → AO1, AO2
- Right Motor → BO1, BO2
</pre>

'''Important:''' Logic ground (from Pico) and power ground (from battery) must be connected together!

=== Code Example: TB6612FNG Control (MicroPython) ===

<syntaxhighlight lang="python">
from machine import Pin, PWM

class Motor:
"""Control a single motor on TB6612FNG"""

def __init__(self, pwm_pin, in1_pin, in2_pin, freq=1000):
"""Initialize motor control pins

Args:
pwm_pin: GPIO pin number for PWM control
in1_pin: GPIO pin number for direction bit 1
in2_pin: GPIO pin number for direction bit 2
freq: PWM frequency in Hz (default 1000)
"""
self.pwm = PWM(Pin(pwm_pin))
self.pwm.freq(freq)
self.in1 = Pin(in1_pin, Pin.OUT)
self.in2 = Pin(in2_pin, Pin.OUT)

def forward(self, speed):
"""Drive motor forward at specified speed

Args:
speed: 0-65535 (0 = stopped, 65535 = full speed)
"""
self.in1.value(0)
self.in2.value(1)
self.pwm.duty_u16(speed)

def reverse(self, speed):
"""Drive motor reverse at specified speed

Args:
speed: 0-65535 (0 = stopped, 65535 = full speed)
"""
self.in1.value(1)
self.in2.value(0)
self.pwm.duty_u16(speed)

def brake(self):
"""Brake motor (short brake - stops quickly)"""
self.in1.value(1)
self.in2.value(1)
self.pwm.duty_u16(0)

def coast(self):
"""Coast motor (freewheeling - stops gradually)"""
self.in1.value(0)
self.in2.value(0)
self.pwm.duty_u16(0)

# Initialize standby pin
stby = Pin(20, Pin.OUT)
stby.value(1) # Enable motor driver

# Initialize motors
left_motor = Motor(pwm_pin=16, in1_pin=14, in2_pin=15)
right_motor = Motor(pwm_pin=19, in1_pin=17, in2_pin=18)

# Example: Drive forward at 50% speed
left_motor.forward(32768) # 50% of 65535
right_motor.forward(32768)

# Stop after 2 seconds
import time
time.sleep(2)
left_motor.brake()
right_motor.brake()
</syntaxhighlight>

=== Alternative: L298N Motor Driver ===

The '''L298N''' is an older, more common motor driver. It's less efficient than the TB6612FNG:

'''L298N characteristics:'''
* Voltage drop: 2-4V (vs 0.3V for TB6612FNG)
* Maximum voltage: 46V (good for larger motors)
* Continuous current: 2A per channel
* Larger size, generates more heat
* Often includes onboard voltage regulator

'''When to use L298N:'''
* Larger motors that need >1.2A continuous current
* Higher voltage motors (>13.5V)
* You already have one available

'''When to use TB6612FNG:'''
* Battery-powered robots (efficiency matters)
* Small to medium motors (<1A typical)
* Space-constrained designs
* 3.3V logic (no level shifters needed)

== Part 5: Differential Drive ==

=== What is Differential Drive? ===

'''Differential drive''' is a robot motion system using two independently-controlled wheels:

* '''Left wheel''' and '''right wheel''' on opposite sides of robot
* No steering mechanism - turns are created by speed differential
* Simple, effective, and commonly used in mobile robots

'''SimpleBot uses differential drive''' with two TT motors and wheels.

=== Differential Drive Motion Control ===

By varying the speed of left and right wheels, you can create different motions:

{| class="wikitable"
! Left Motor !! Right Motor !! Robot Motion
|-
| Forward 50% || Forward 50% || Straight forward
|-
| Reverse 50% || Reverse 50% || Straight reverse
|-
| Forward 100% || Forward 50% || Gentle turn right (arc)
|-
| Forward 50% || Forward 100% || Gentle turn left (arc)
|-
| Forward 50% || Stop || Sharp turn right
|-
| Forward 50% || Reverse 50% || Rotate clockwise (pivot turn)
|-
| Stop || Stop || Stopped
|}

'''Key insight:''' The difference in wheel speeds determines turn radius. Equal speeds = straight line.

=== Implementing Differential Drive ===

<syntaxhighlight lang="python">
class DifferentialDrive:
"""Differential drive robot control"""

def __init__(self, left_motor, right_motor):
"""Initialize with two Motor objects"""
self.left = left_motor
self.right = right_motor

def drive(self, left_speed, right_speed):
"""Drive with independent wheel speeds

Args:
left_speed: -65535 to 65535 (negative = reverse)
right_speed: -65535 to 65535 (negative = reverse)
"""
# Left motor
if left_speed > 0:
self.left.forward(left_speed)
elif left_speed < 0:
self.left.reverse(-left_speed)
else:
self.left.coast()

# Right motor
if right_speed > 0:
self.right.forward(right_speed)
elif right_speed < 0:
self.right.reverse(-right_speed)
else:
self.right.coast()

def forward(self, speed):
"""Drive straight forward"""
self.drive(speed, speed)

def reverse(self, speed):
"""Drive straight reverse"""
self.drive(-speed, -speed)

def turn_left(self, speed):
"""Turn left (arc) by slowing left wheel"""
self.drive(speed // 2, speed)

def turn_right(self, speed):
"""Turn right (arc) by slowing right wheel"""
self.drive(speed, speed // 2)

def rotate_left(self, speed):
"""Rotate left in place (pivot turn)"""
self.drive(-speed, speed)

def rotate_right(self, speed):
"""Rotate right in place (pivot turn)"""
self.drive(speed, -speed)

def stop(self):
"""Stop both motors"""
self.left.brake()
self.right.brake()

# Initialize differential drive
robot = DifferentialDrive(left_motor, right_motor)

# Drive straight forward at 50% speed
robot.forward(32768)
time.sleep(2)

# Turn right
robot.turn_right(32768)
time.sleep(1)

# Rotate in place
robot.rotate_left(32768)
time.sleep(1)

# Stop
robot.stop()
</syntaxhighlight>

=== Straight-Line Driving Challenge ===

'''Problem:''' Even with equal PWM duty cycles, motors rarely spin at exactly the same speed due to:
* Manufacturing tolerances
* Different friction in gearboxes
* Voltage drop differences
* Wheel diameter differences

'''Result:''' Robot drifts left or right instead of going straight.

'''Solutions:'''
1. '''Calibration''' - Measure actual wheel speeds, adjust PWM to compensate
2. '''Closed-loop control''' - Use encoders (see [[Capability:Optical Odometry]]) to measure and correct speed
3. '''Trim adjustment''' - Add offset to one motor's speed in software

'''Example: Simple trim adjustment'''
<syntaxhighlight lang="python">
# If robot drifts right, left motor is slower - add trim
LEFT_MOTOR_TRIM = 1.05 # Left motor needs 5% more power

def forward_with_trim(speed):
left_speed = int(speed * LEFT_MOTOR_TRIM)
right_speed = speed
robot.drive(left_speed, right_speed)
</syntaxhighlight>

=== Turn Radius Calculation ===

For a differential drive robot:

<math>R = \frac{L}{2} \times \frac{v_L + v_R}{v_R - v_L}</math>

Where:
* R = turn radius
* L = distance between wheels (track width)
* v_L = left wheel velocity
* v_R = right wheel velocity

'''Special cases:'''
* v_L = v_R → R = infinity (straight line)
* v_L = -v_R → R = 0 (rotation in place)
* v_L = 0 or v_R = 0 → R = L/2 (pivot around one wheel)

== Part 6: Power Management and Protection ==

=== Separate Power Supplies ===

'''Best practice:''' Use separate power for motors and logic:

* '''Motor power''' - Battery (6V, 9V, 12V depending on motors)
* '''Logic power''' - Regulated 3.3V or 5V from voltage regulator
* '''Shared ground''' - All grounds connected together

'''Why separate?'''
* Motors create voltage spikes and noise
* Motor current draw can cause voltage sag
* Microcontroller needs stable, clean voltage

'''SimpleBot power system:'''
* 4× AA batteries (6V) → MP1584 buck converter → 5V regulated
* 5V → Raspberry Pi Pico onboard regulator → 3.3V for microcontroller
* Battery 6V → TB6612FNG VM pin → Motor power
* 3.3V → TB6612FNG VCC pin → Logic power

=== Decoupling Capacitors ===

'''Always add capacitors:'''
* '''0.1µF ceramic capacitor''' near every IC's power pins (VCC to GND)
* '''100-1000µF electrolytic capacitor''' across motor power supply

'''Purpose:'''
* Filter high-frequency noise
* Provide local energy storage for current spikes
* Prevent voltage droops during motor startup

'''Placement matters:''' Place decoupling capacitors as close to IC power pins as possible.

=== Current Limiting ===

'''Protect your system:'''
* Use motor drivers rated above your motor's stall current
* Add fuses or resettable fuses (PTC) in power supply line
* Monitor battery voltage to prevent over-discharge

'''Example:'''
* SimpleBot TT motors: 1.5A stall current
* TB6612FNG rating: 1.2A continuous, 3.2A peak
* Result: Motors protected during brief stalls, but extended stalls will trigger thermal shutdown

=== Thermal Management ===

Motor drivers generate heat, especially at high currents:

* '''Heatsinks''' - Attach to motor driver IC if handling >1A continuously
* '''Airflow''' - Don't enclose motor driver in sealed box
* '''Thermal shutdown''' - Most modern drivers shut down automatically if overheating
* '''Duty cycle''' - If driver gets too hot, reduce motor duty cycle or add cooling

== Part 7: Troubleshooting Motor Control ==

=== Motor Not Spinning ===

Check:
1. Power supply connected? (Measure voltage at VM pin)
2. Standby pin enabled? (STBY = HIGH)
3. PWM signal present? (Use oscilloscope or LED on PWM pin)
4. Direction pins set correctly? (Not both HIGH or both LOW for some drivers)
5. Motor connected? (Check continuity of motor wires)
6. Driver overheated? (Let cool down, check for thermal shutdown)

=== Motor Spins Wrong Direction ===

Fix:
* Swap motor wire connections (AO1 ↔ AO2)
* Or swap IN1/IN2 control in software

=== Motors Work Individually But Not Together ===

Likely causes:
* Insufficient current from power supply (voltage sags when both motors run)
* Wiring error (check all ground connections)
* Shared PWM channel (each motor needs independent PWM)

=== Motors Run Erratically or Stall ===

Check:
* Battery voltage sufficient? (Use multimeter under load)
* Stall current within driver rating?
* Decoupling capacitors installed?
* Mechanical binding? (Wheels rubbing, gears jammed)

=== Robot Drives Straight But Won't Turn ===

Debug:
* Test each motor independently (forward, reverse, variable speed)
* Check that both motors are receiving different commands during turns
* Verify IN1/IN2 pins controlling direction correctly
* Ensure motors can reverse (not just stop)

=== Robot Veers to One Side ===

Solutions:
* Calibrate motor speeds (add trim adjustment)
* Check wheel diameter (uneven wheels cause drift)
* Use encoders for closed-loop speed control
* Verify both motors receiving same PWM value when driving straight

== Part 8: Advanced Topics ==

=== Motor Speed Measurement ===

To achieve precise speed control, measure actual motor speed:

* '''Optical encoders''' - Count pulses from slotted wheel (see [[Capability:Optical Odometry]])
* '''Hall effect sensors''' - Count magnet passes
* '''Back-EMF sensing''' - Measure motor's generated voltage when coasting

'''Why measure speed?'''
* Compensate for manufacturing differences
* Implement PID control for precise motion
* Measure distance traveled
* Detect wheel slip or stalls

=== PID Control for Motors ===

'''PID (Proportional-Integral-Derivative)''' control maintains consistent motor speed:

* Measure actual speed (using encoders)
* Compare to desired speed (setpoint)
* Calculate error and adjust PWM duty cycle
* Result: Motor maintains target speed despite varying load

'''Benefits:'''
* Straight-line driving without drift
* Consistent speed regardless of battery voltage
* Precise turns and rotations

This is an advanced topic - start with open-loop control (no feedback), then add encoders later.

=== Acceleration and Deceleration ===

Instant speed changes stress motors and can cause wheel slip. Instead, ramp speed gradually:

<syntaxhighlight lang="python">
def ramp_speed(motor, target_speed, steps=20, delay_ms=50):
"""Gradually increase motor speed to target

Args:
motor: Motor object
target_speed: Desired final speed (0-65535)
steps: Number of incremental steps
delay_ms: Delay between steps in milliseconds
"""
current_speed = 0
step_size = target_speed // steps

for i in range(steps):
current_speed += step_size
motor.forward(current_speed)
time.sleep_ms(delay_ms)

# Final step to exact target
motor.forward(target_speed)
</syntaxhighlight>

=== Regenerative Braking ===

Some motor drivers support '''regenerative braking''' - converting motor's kinetic energy back into electrical energy:

* Motor acts as generator when coasting
* Energy charges battery or dissipates in brake resistor
* More efficient than friction braking
* Requires specialized motor driver with regen support

Most hobby motor drivers (including TB6612FNG) use '''dynamic braking''' (short brake) instead - motor energy dissipates as heat in the motor and driver.

== Part 9: Practical Skills Checklist ==

By now, you should be able to:

* ☐ Explain how DC motors work and why they draw variable current
* ☐ Describe what back-EMF is and why protection is needed
* ☐ Understand how H-bridges enable direction control
* ☐ Explain how PWM controls motor speed
* ☐ Wire a TB6612FNG motor driver to a microcontroller and motors
* ☐ Write code to drive motors forward, reverse, and stop
* ☐ Implement differential drive motion (forward, turn, rotate)
* ☐ Troubleshoot common motor control problems
* ☐ Understand the importance of separate power supplies
* ☐ Calculate current requirements for motor selection

If you can check most of these boxes, you're ready to build robots with motor control!

== Next Steps ==

=== Build SimpleBot ===
Apply your motor control knowledge:
* [[SimpleBot]] - Complete robot build guide with TB6612FNG motor control
* [[SimpleBot:Line Following Implementation]] - Use motors to follow a line
* [[SimpleBot:Dead Reckoning Implementation]] - Combine motors with encoders for precise motion

=== Add Sensors ===
Combine motor control with sensing:
* [[Sensor Interfacing]] - Learn I2C, SPI, and analog sensors
* [[Capability:Optical Odometry]] - Measure wheel rotation for precise distance
* [[Capability:IMU Sensing]] - Add gyroscope for accurate turning

=== Expand Capabilities ===
* [[Capability:Differential Drive]] - Full documentation of this motion system
* [[Capability:Encoder Sensing]] - Closed-loop motor speed control
* Build your own custom robot with motor control

== Common Mistakes and Pitfalls ==

* '''Powering motors from microcontroller pins''' - GPIO pins cannot supply enough current; always use motor driver
* '''No standby pin control''' - TB6612FNG requires STBY=HIGH to enable; forgetting this means motors won't work
* '''Separate grounds''' - Logic ground and motor ground must be connected together
* '''Insufficient decoupling''' - Missing capacitors cause erratic behavior and voltage spikes
* '''Exceeding current rating''' - Using motors with stall current higher than driver rating damages driver
* '''No back-EMF protection''' - If building H-bridge from transistors, must add flyback diodes
* '''PWM frequency too low''' - Causes audible motor whine and rough motion
* '''Forgetting motor trim''' - Robots rarely drive perfectly straight without calibration

== Resources and Further Reading ==

=== BRS Wiki Pages ===
* [[TB6612FNG]] - Detailed motor driver specifications
* [[Electronics]] - Full electronics competency overview
* [[Capability:Differential Drive]] - Motion system documentation
* [[SimpleBot]] - Complete robot using motor control

=== External Resources ===
* [https://www.ti.com/lit/an/slva842/slva842.pdf TI Motor Driver Basics] (PDF)
* [https://learn.sparkfun.com/tutorials/motors-and-selecting-the-right-one SparkFun Motor Selection Guide]
* [https://www.pololu.com/docs/0J15 Pololu Motor Selection Guide]

== See Also ==

* [[Electronics Fundamentals]] - Prerequisite tutorial
* [[Sensor Interfacing]] - Next tutorial in electronics learning path
* [[Capability:Encoder Sensing]] - Measure motor speed
* [[Behavior:PID Control]] - Advanced motor speed regulation

[[Category:Tutorials]]
[[Category:Electronics]]
[[Category:Intermediate]]

3D Printing for Robotics

2025-10-11T20:16:14Z

John: Created page with "{{Tutorial |name=3D Printing for Robotics |competency=3D Printing |difficulty=Intermediate |time=6-8 hours (plus iterative design time) |prerequisites=3D Printing Basics, basic CAD Design knowledge |materials=FDM printer, PLA/PETG filament, calipers, test hardware (screws, nuts, bearings, motor shafts) |next_steps=CAD Design, design custom robot chassis, document implementation pages }} '''3D Printing for Robotics''' teaches you how to design and print f..."

{{Tutorial
|name=3D Printing for Robotics
|competency=[[3D Printing]]
|difficulty=Intermediate
|time=6-8 hours (plus iterative design time)
|prerequisites=[[3D Printing Basics]], basic [[CAD Design]] knowledge
|materials=FDM printer, PLA/PETG filament, calipers, test hardware (screws, nuts, bearings, motor shafts)
|next_steps=[[CAD Design]], design custom robot chassis, document implementation pages
}}

'''3D Printing for Robotics''' teaches you how to design and print functional mechanical parts that work reliably in robots. This is not about making pretty objects - it's about creating parts that hold motors, position sensors, transfer forces, and survive repeated use.

You'll learn the engineering principles specific to FDM printing: layer orientation for strength, designing tolerances for fit, minimizing supports, embedding hardware, and iterating quickly.

By the end of this tutorial, you'll be able to:
* Design parts that print successfully on the first try
* Choose print orientation for maximum strength
* Design holes, slots, and assemblies with correct tolerances
* Eliminate or minimize support material
* Embed hardware like nuts, bearings, and heat-set inserts
* Iterate designs efficiently based on test fits
* Design complete robot chassis from scratch

This tutorial assumes you've successfully printed parts designed by others (see [[3D Printing Basics]]) and have basic CAD modeling skills.

== Part 1: Design Principles for FDM ==

FDM printing has constraints that machined or molded parts don't have. Ignore these and your parts will fail.

=== Layer Orientation Determines Strength ===

FDM parts are '''anisotropic''' - strength varies dramatically with orientation:

* '''Layers parallel to force''' - Very strong (plastic material strength)
* '''Layers perpendicular to force''' - Weak (layers peel apart)

'''Example: Motor mount bracket'''
* '''Bad orientation''' - Mount hole on side, forces pull perpendicular to layers → bracket snaps
* '''Good orientation''' - Mount hole on top/bottom, forces compress layers together → strong

'''Rule of thumb:''' Orient parts so primary forces push '''along''' layers, not '''between''' layers.

=== The 45-Degree Rule ===

FDM cannot print in mid-air. Overhangs are limited:

* '''0-45° overhang''' - Prints fine, no support needed
* '''45-60° overhang''' - May print, depends on geometry and cooling
* '''>60° overhang''' - Requires support material

'''Horizontal holes''' are problematic:
* Top of hole is >45° overhang
* Solution: Orient part vertically, or accept support inside hole

'''Tear-drop holes''' - Flatten top of circular hole to avoid overhang
* Instead of perfect circle, use circle with flat top above centerline
* Maintains most of the circular opening without support

=== Minimum Feature Sizes ===

FDM has resolution limits:

* '''Minimum wall thickness''' - 2× nozzle diameter (0.8mm for 0.4mm nozzle)
** Thinner walls may not print reliably
* '''Minimum hole diameter''' - 1mm (smaller may close up or need drilling)
* '''Minimum gap''' - 0.4mm (0.2mm may fuse together)
* '''Minimum text height''' - 3mm for raised text, 1mm for engraved
* '''Finest detail''' - Limited by layer height and nozzle diameter

=== Bridging Capability ===

FDM can print horizontal spans between two support points:

* '''Short bridges''' (<20mm) - Usually successful
* '''Medium bridges''' (20-40mm) - May sag in middle
* '''Long bridges''' (>40mm) - Will fail without support

'''Design strategy:''' Add intermediate support pillars for long bridges.

== Part 2: Tolerances and Fit ==

Printed parts have dimensional variation. You must design for clearance.

=== Understanding Tolerance ===

'''Tolerance''' is the allowable variation from nominal dimension:

* '''FDM accuracy''' - Typically ±0.1-0.2mm (but varies by printer, material, settings)
* '''Holes print undersized''' - 0.1-0.2mm smaller than designed
* '''Shafts print oversized''' - 0.1-0.2mm larger than designed

'''Why?''' First layer squish, elephant's foot, material shrinkage, thermal expansion.

=== Design Clearances for Assemblies ===

When parts must fit together, add clearance:

{| class="wikitable"
! Fit Type !! Clearance !! Description !! Robotics Use
|-
| '''Interference fit''' || -0.1mm || Parts pressed together, stay tight || Bearing press-fits
|-
| '''Press fit''' || 0.0mm || Tight fit, may need mallet || Wheel hubs on shafts
|-
| '''Slip fit''' || +0.2mm || Parts slide together with friction || Hinges, sliding joints
|-
| '''Free fit''' || +0.5mm || Parts move freely, slight wobble || Rotating shafts in bearings
|-
| '''Loose fit''' || +0.8mm || Easy assembly, significant play || Clearance holes for screws
|}

'''Example: M3 screw (3.0mm nominal diameter)'''
* '''Threaded hole''' - Design 2.5mm, print will be ~2.6-2.7mm, tap with M3 tap
* '''Tight clearance''' - Design 3.2mm, allows screw to pass with minimal wobble
* '''Standard clearance''' - Design 3.5mm, easy assembly (most common)
* '''Loose clearance''' - Design 4.0mm, allows adjustment during assembly

=== Testing and Iterating Tolerances ===

Every printer is different. You must calibrate:

# '''Print a tolerance test piece'''
** Design: Rectangular block with holes of different sizes (3.0mm, 3.2mm, 3.5mm, 4.0mm)
** Test with M3 screw - which hole gives best fit?
# '''Print a shaft test piece'''
** Design: Cylinders of different diameters (3.0mm, 3.2mm, 3.5mm, 4.0mm)
** Test fit in holes - which combination gives desired fit?
# '''Document your printer's behavior'''
** "My printer needs +0.3mm for M3 clearance holes"
** "My printer needs -0.2mm for press-fit shafts"
# '''Apply corrections to future designs'''

'''Tip:''' Print a "hardware calibration kit" with holes for all common screws (M2, M2.5, M3, M4) and slots for nuts. Test once, use forever.

=== Designing Holes for Hardware ===

'''Screw clearance holes:'''
* M2 (2.0mm) → Design 2.3-2.5mm
* M2.5 (2.5mm) → Design 2.8-3.0mm
* M3 (3.0mm) → Design 3.3-3.5mm
* M4 (4.0mm) → Design 4.3-4.5mm

'''Hex nut pockets:'''
* M3 hex nut (5.5mm across flats) → Design 5.7-5.8mm hexagon
* M3 hex nut (2.4mm thick) → Design 2.5-2.6mm deep pocket

'''Bearing press-fits:'''
* 608 bearing (22mm OD) → Design 21.8-21.9mm hole
* Test fit and adjust by 0.1mm increments

== Part 3: Support Strategies ==

Supports waste time and material. Minimize them through smart design.

=== Designing to Avoid Supports ===

'''Strategy 1: Orient for Printability'''
* Rotate part so overhangs are <45°
* Sometimes compromises strength - weigh trade-offs

'''Strategy 2: Split Parts'''
* Design in two pieces that print flat
* Assemble with screws or glue after printing
* Example: Sensor bracket with 90° angle → print as two flat pieces, bolt together

'''Strategy 3: Add Chamfers'''
* Chamfer bottom edges of holes to reduce overhang angle
* 45° chamfer = no support needed

'''Strategy 4: Use Tear-Drop Holes'''
* Horizontal holes with flattened tops
* Maintains circular opening at bottom (where precision matters)

'''Strategy 5: Add Self-Supporting Features'''
* Design deliberate material under overhangs
* Example: Ribs, gussets, or small supports that become part of the design

=== When Supports Are Necessary ===

Some geometries require supports. Optimize them:

* '''Use tree supports''' (PrusaSlicer, Cura) - Less material, easier removal
* '''Support enforcers''' - Add supports only where critical
* '''Support blockers''' - Remove supports where they're not needed
* '''Support interface layers''' - Dense layer between support and part (better surface finish)
* '''Support Z-distance''' - 0.2mm gap allows easier removal

'''Design tip:''' Add small tabs or nubs on support surfaces - gives supports better attachment point and easier removal.

== Part 4: Embedding Hardware ==

Robots need metal hardware (screws, nuts, bearings) integrated into plastic parts.

=== Heat-Set Inserts ===

'''Heat-set inserts''' are brass threaded inserts melted into plastic:

* '''Advantages''': Strong, reusable threads (screws won't strip plastic)
* '''Installation''': Use soldering iron with special tip, heat insert, press into plastic
* '''Design''':
** Hole diameter: Insert OD + 0.1-0.2mm (e.g., M3 insert needs ~4.0-4.2mm hole)
** Hole depth: Insert length + 0.5mm (allows insert to sit flush or slightly recessed)
** Boss diameter: At least insert OD + 3mm (provides material for insert to grip)

'''Common sizes for robotics:'''
* M2.5 × 4mm length (small brackets, PCB standoffs)
* M3 × 5mm length (general purpose, most common)
* M4 × 6mm length (motor mounts, high-stress points)

=== Captive Nuts ===

'''Captive nuts''' are trapped in hexagonal pockets during printing:

* '''Design''':
** Hexagonal pocket: Nut size + 0.2mm across flats
** Pocket depth: Nut thickness + 0.1mm
** Pocket height above surface: At least 2 layer heights (0.4mm for 0.2mm layers)
* '''Installation''': Drop nut into pocket during print (pause print) or slide in from side
* '''Retention''': Hex shape prevents rotation, pocket prevents pull-out

'''Pause method:'''
# Slice model, note layer number where pocket roof starts
# Add pause command at that layer (G-code: M0 or M600)
# During print, insert nuts when printer pauses
# Resume print, plastic grows over nuts

'''Slide-in method:'''
# Design pocket open on one side
# Print complete
# Slide nut into pocket from side
# Optional: Add small plastic tab to block side opening after insertion

=== Press-Fit Bearings ===

Ball bearings provide smooth rotation for wheels and joints:

* '''Common types''':
** 608 bearing (skateboard bearing): 8mm ID, 22mm OD, 7mm thick
** 688 bearing (miniature): 8mm ID, 16mm OD, 5mm thick
** MR105 bearing: 5mm ID, 10mm OD, 4mm thick

* '''Design for press-fit''':
** Hole diameter: Bearing OD - 0.1 to -0.2mm (tight press fit)
** Hole depth: Bearing thickness + 0.5mm (bearing sits fully in)
** Chamfer entrance: 45° chamfer makes bearing easier to press in

* '''Installation''':
** Press bearing in by hand (may need light mallet)
** Use vise or arbor press for very tight fits
** Heat plastic slightly with hot air gun (easier press)

'''Design tip:''' Add a flange or stop surface so bearing doesn't press through.

=== Shaft Collars and Set Screws ===

Hold shafts in place without glue:

* '''Design''':
** Shaft hole: Shaft diameter + 0.1-0.2mm (slip fit)
** Perpendicular M3 threaded hole intersecting shaft hole
** Tighten M3 screw to pinch shaft

* '''Alternative: Split collar'''
** C-shaped collar wraps around shaft
** Bolt squeezes collar closed to grip shaft
** Allows shaft removal without loosening set screw

== Part 5: Designing Assemblies ==

Multi-part assemblies require careful planning.

=== Snap-Fit Joints ===

'''Snap-fits''' allow parts to click together without fasteners:

* '''Cantilever snap'''
** Flexible beam with hook at end
** Hook catches on mating part
** Requires TPU or thin PLA/PETG that flexes
** Design: Beam thickness 0.8-1.2mm, deflection ~10-20% of beam length

* '''Annular snap'''
** Ring of material compresses to fit through opening
** Expands back to original size inside
** Example: Bottle cap mechanism

'''Limitations:''' PLA is brittle - snap-fits can break after few cycles. PETG is better.

=== Living Hinges ===

'''Living hinges''' are flexible joints printed in one piece:

* '''Material''': PETG or TPU (PLA breaks after few flexes)
* '''Design''':
** Hinge thickness: 0.4-0.6mm (thin enough to flex)
** Hinge width: 5-10mm (distributes stress)
** Layer orientation: Layers perpendicular to hinge axis (allows flexing between layers)
* '''Print settings''':
** 100% infill in hinge area
** Slow print speed (better layer adhesion)

'''Robotics use:''' Gripper jaws, sensor covers, cable management clips

=== Bolted Assemblies ===

Most reliable for robotics:

* '''Through-bolts''' - Screw passes through both parts, nut on other side
** Advantage: Very strong, easy to assemble/disassemble
** Design: Clearance hole in both parts, hex nut pocket in one part

* '''Standoffs''' - Threaded spacers between parallel plates
** Common: M3 brass standoffs, various lengths
** Design: M3 clearance holes in both plates

* '''Threaded inserts''' (see above) - One part has insert, other has clearance hole
** Advantage: Reusable threads, no loose nuts

== Part 6: Strength and Structural Design ==

=== Understanding Anisotropic Strength ===

Test data (varies by material and settings):
* '''Tensile strength along layers''' - 40-60 MPa (very strong)
* '''Tensile strength between layers''' - 10-20 MPa (weak)
* '''Shear strength''' - 15-25 MPa (moderate)

'''Design implication:''' A part can be 3-5× stronger in one orientation than another.

=== Optimizing for Strength ===

'''Strategy 1: Perimeters Over Infill'''
* '''Weak''': 2 perimeters, 50% infill
* '''Strong''': 4 perimeters, 20% infill
* Outer walls carry most load; infill just prevents wall collapse

'''Strategy 2: Reinforce Stress Points'''
* Add fillets (rounded corners) to reduce stress concentration
* Typical fillet radius: 2-5mm
* Sharp corners crack under load

'''Strategy 3: Increase Wall Thickness'''
* Minimum 2.4mm (6 perimeters with 0.4mm nozzle) for structural parts
* Thicker = stronger, but diminishing returns above 4-5mm

'''Strategy 4: Add Ribs and Gussets'''
* Vertical ribs increase bending stiffness without much added weight
* 45° gussets strengthen right-angle joints
* Rib thickness: 1.2-2.0mm (3-5 perimeters)

=== Motor Mount Design Case Study ===

Requirements for [[SimpleBot]] motor mount:
* Hold DC motor securely
* Withstand motor vibration
* Resist torque from wheel contact
* Easy to print without supports

'''Design decisions:'''
# '''Layer orientation''' - Mount flat on bed, motor axis parallel to bed
** Forces compress layers together (strong direction)
# '''Motor pocket''' - Snug fit around motor body
** Designed diameter: Motor OD + 0.2mm (slip fit)
# '''Mounting holes''' - M3 clearance holes for bolting to chassis
** Through-bolts with nuts on other side (strong, removable)
# '''Reinforcement''' - Ribs connecting motor pocket to mounting points
** Distributes motor vibration, prevents cracking
# '''Avoiding supports''' - All angles <45° from vertical
** Motor pocket has flat bottom (prints on bed, no support needed)

'''Testing:'''
# Print first prototype
# Test fit motor - too tight? Increase pocket 0.2mm
# Bolt to chassis, run motor at full speed
# Inspect for cracks or flexing
# Iterate design if needed

== Part 7: Print Settings for Mechanical Parts ==

=== Layer Height Selection ===

* '''0.1mm''' - High detail, smooth surface (decorative parts)
** Slow, not necessary for most robotics parts
* '''0.2mm''' - Standard, good balance (most common)
** Use for general purpose parts
* '''0.3mm''' - Fast draft, rougher finish
** Use for large chassis parts, non-visible internals

=== Infill Strategy ===

* '''10-15%''' - Light parts, minimal load (sensor brackets, covers)
* '''20-30%''' - Standard structural parts (chassis, mounts)
* '''40-50%''' - High-stress parts (motor mounts, wheel hubs)
* '''100%''' - Small parts where mass doesn't matter (tiny gears, pins)

'''Infill pattern:'''
* '''Grid''' - Fast, simple
* '''Gyroid''' - Strong in all directions, recommended for structural parts
* '''Honeycomb''' - Strong, but slower to slice and print

=== Perimeter Count ===

* '''2 perimeters''' - Minimum for functional parts
* '''3 perimeters''' - Standard for robotics parts
* '''4+ perimeters''' - High-stress parts, thin walls

'''Rule:''' Wall thickness = perimeter count × line width (e.g., 3 perimeters × 0.4mm = 1.2mm wall)

=== Material Selection ===

* '''PLA''' - Easy printing, rigid, brittle
** Good for: Chassis, brackets, low-stress parts
** Bad for: High-impact parts, outdoor use, hot environments
* '''PETG''' - Moderate difficulty, strong, flexible
** Good for: Motor mounts, wheels, stressed parts, outdoor robots
** Bad for: Fine details (strings more than PLA)
* '''TPU''' - Difficult printing, rubber-like
** Good for: Tires, grippers, shock absorption
** Bad for: Structural parts (too flexible)

=== Support Interface Layers ===

When supports are unavoidable:
* Enable '''support interface layers''' (dense layer between support and part)
* Set '''interface layer count''' to 2-3
* Results in better surface finish where supports touch part

== Part 8: Iterative Design Process ==

Professional designers rarely get parts perfect on first try. Embrace iteration.

=== Rapid Prototyping Workflow ===

# '''Design initial version''' in CAD
** Use nominal dimensions, best-guess clearances
# '''Print at 150% speed, 0.3mm layers''' (fast draft mode)
** Quality doesn't matter for first test
# '''Test fit''' with actual hardware
** Measure with calipers, identify problems
# '''Adjust design''' based on measurements
** Holes too small? Increase 0.2mm. Too large? Decrease 0.1mm
# '''Print second version''' at normal settings
** Should be close to perfect
# '''Final tweaks''' if needed
** Usually just minor adjustments
# '''Print final version''' for documentation
** Take photos, measure, document design decisions

'''Time saved:''' Fast draft print in 1 hour vs. high-quality print in 3 hours. Get feedback 3× faster.

=== Design Validation Checklist ===

Before printing final version:
* ☐ All mounting holes have clearance (+0.3mm for M3)
* ☐ Hex nut pockets correct size (measure actual nut with calipers)
* ☐ Bearing press-fit dimensions calculated (bearing OD - 0.2mm)
* ☐ No overhangs >45° (or supports enabled)
* ☐ Minimum wall thickness 0.8mm (2 perimeters)
* ☐ Fillets on stress concentration points
* ☐ Layer orientation optimized for primary forces
* ☐ Parts split or oriented to avoid supports if possible

=== Documentation ===

When design is finalized:
* Export STL files for distribution
* Document design decisions (why you chose dimensions, orientations, materials)
* Create assembly guide if multi-part
* Share on [[SimpleBot]] wiki or create implementation page

== Part 9: Example Project - Custom Sensor Bracket ==

Let's design a bracket to mount an ultrasonic distance sensor ([[Capability:Ultrasonic Sensing]]) on SimpleBot.

=== Requirements Analysis ===

* '''Sensor:''' HC-SR04 ultrasonic sensor
** Dimensions: 45mm × 20mm × 15mm
** Mounting: 2× holes on either side (40mm spacing)
* '''Mounting position:''' Front of SimpleBot chassis
** Must clear existing line sensors
** Point forward for obstacle detection
* '''Constraints:'''
** Print without supports if possible
** Use M3 hardware (consistent with SimpleBot)
** Minimize material use

=== Design Process ===

'''Step 1: Sketch concept'''
* L-shaped bracket: Vertical face for sensor, horizontal face for mounting to chassis
* Sensor held with M3 screws through side holes
* Bracket mounts to chassis with 2× M3 screws

'''Step 2: CAD model'''
* '''Vertical face:''' 50mm × 25mm × 2mm thick
** 2× M3 clearance holes (3.5mm diameter, 40mm apart) for sensor mounting
** Center holes vertically on face
* '''Horizontal face:''' 50mm × 15mm × 2mm thick
** 2× M3 clearance holes (3.5mm diameter, 40mm apart) for chassis mounting
** Position 5mm from edge
* '''Connection:''' Vertical face perpendicular to horizontal face
** Add 5mm fillet for strength
** No overhang issues (prints flat on bed)

'''Step 3: Print orientation'''
* Lay horizontal face on bed (L-shape standing up)
* Vertical face prints without support (perpendicular = vertical walls)

'''Step 4: First print (fast draft)'''
* 0.3mm layer height, 150% speed
* Print time: 45 minutes
* Test fit sensor - holes align correctly
* Test fit to chassis - mounting holes correct

'''Step 5: Refinements'''
* Add 2mm clearance between sensor and vertical face (prevents pressure on sensor PCB)
* Increase horizontal face width to 20mm (more contact with chassis)
* Add small chamfer to mounting holes (easier screw insertion)

'''Step 6: Final print'''
* 0.2mm layer height, 3 perimeters, 20% infill
* PETG material (more durable than PLA)
* Print time: 1 hour 15 minutes

'''Step 7: Assembly'''
* Mount sensor to bracket with M3×10mm screws and nuts
* Mount bracket to chassis with M3×8mm screws
* Connect sensor wiring to microcontroller

'''Step 8: Documentation'''
* Take photos of assembled bracket
* Export STL file
* Create wiki page: [[SimpleBot:Ultrasonic Sensor Bracket]]
* Document design decisions and dimensions

== Part 10: Advanced Techniques Preview ==

Once you've mastered intermediate skills, explore:

=== Parametric Design ===
* Use variables in CAD instead of fixed dimensions
* Adjust one parameter (wheel diameter), entire assembly updates
* Example: Parametric chassis that scales to different motor sizes

=== Multi-Material Printing ===
* Dual-extruder printers can print rigid and flexible materials
* Example: Rigid wheel hub with TPU tire in one print

=== Topology Optimization ===
* Software removes material from non-stressed areas
* Creates organic-looking structures with minimal weight
* Requires advanced CAD software (Fusion 360 Generative Design)

=== Functional Gears and Mechanisms ===
* Print gears with proper involute tooth profiles
* Calculate gear ratios for speed reduction
* Design escapements, ratchets, and complex mechanisms

=== Composite Structures ===
* Embed carbon fiber rods or metal inserts during printing
* Creates parts stronger than solid plastic
* Requires printer pause and careful alignment

== Common Design Mistakes ==

* '''Ignoring layer orientation''' - Part snaps because forces pull layers apart
* '''Designing like metal parts''' - Sharp corners, thin walls, complex geometry that needs support
* '''Forgetting shrinkage''' - Holes too small, shafts too big
* '''Over-constraining assemblies''' - Parts can't fit together due to tolerance stack-up
* '''Skipping test prints''' - Wasting 6 hours on full-quality print that doesn't fit
* '''Using 100% infill''' - Wastes time and material, adds minimal strength
* '''Not adding fillets''' - Stress concentrations cause cracking
* '''Ignoring print direction visibility''' - Layer lines ugly on visible faces

== Design Patterns for Common Robotics Parts ==

=== Motor Mount ===
* Cylindrical pocket for motor body (motor OD + 0.2mm)
* Flat bottom of pocket (no support needed)
* M3 clearance holes aligned with motor mounting holes
* Ribs connecting motor to mounting points
* Layer orientation: Motor axis parallel to build plate

=== Wheel Hub ===
* Press-fit hole for motor shaft (shaft diameter - 0.1mm)
* Perpendicular M3 set screw to lock shaft
* Outer rim for tire attachment
* Spokes to reduce weight
* Print flat on bed (strongest direction for torque)

=== Sensor Bracket ===
* Flat mounting face perpendicular to sensor
* M3 clearance holes for sensor screws
* 45° angle support to chassis
* Thin walls (save material, print faster)

=== Cable Management Clip ===
* C-shaped clip with slight interference fit
* PETG material (flexes without breaking)
* Mounting hole or adhesive pad for attachment
* Layer orientation: Flex perpendicular to layers

=== Battery Holder ===
* Cavity for battery with 1-2mm clearance (easy insertion)
* Contact points for terminals
* Strap or clip to retain battery
* Ventilation holes (safety)

== Next Steps ==

=== Apply Your Skills ===
* '''Design custom parts for [[SimpleBot]]'''
** New sensor brackets for additional capabilities
** Modified chassis for different battery configurations
** Custom wheel designs for different terrains
* '''Document your designs''' as implementation pages
* '''Share STL files''' with the BRS community

=== Continue Learning ===
* '''[[CAD Design]]''' - Master parametric modeling
* '''[[Mechanics]]''' - Understand forces and structural analysis
* '''[[3D Printing]]''' - Explore advanced competency overview
* '''Advanced FDM Techniques''' (future tutorial) - Multi-material, optimization, complex mechanisms

=== Join the Community ===
* Share your designs on Printables, Thingiverse
* Get feedback on r/3Dprinting or r/functionalprint
* Contribute STL files to BRS robot repositories
* Create tutorials for techniques you discover

== Resources ==

=== Online Tools ===
* '''Fusion 360''' (free for hobbyists) - Parametric CAD with simulation
* '''FreeCAD''' (free, open-source) - Full-featured parametric CAD
* '''Onshape''' (free for public projects) - Cloud-based CAD
* '''Blender''' (free) - Organic modeling (less suitable for mechanical parts)

=== Reference Materials ===
* '''[https://www.prusa3d.com/page/print-quality-troubleshooting_464/ Prusa Print Quality Guide]'''
* '''[https://www.cnckitchen.com/ CNC Kitchen]''' - Engineering tests of printed parts
* '''[https://www.youtube.com/c/MakersMuseOriginals Maker's Muse]''' - 3D printing techniques
* '''[https://www.youtube.com/c/DesignPrototypeTest Design Prototype Test]''' - Functional design

=== Community ===
* '''Reddit r/functionalprint''' - Share functional designs
* '''Printables''' / '''Thingiverse''' - Download and share STL files
* '''BRS Discord''' (future) - Real-time help with designs

== See Also ==

* [[3D Printing]] - Full competency overview
* [[3D Printing Basics]] - Foundation tutorial
* [[CAD Design]] - Create models to print
* [[SimpleBot]] - Apply your skills to build robots
* [[Capabilities]] - Mechanical parts enable capabilities

[[Category:Tutorials]]
[[Category:3D Printing]]
[[Category:Intermediate]]

Mechanical Design

2025-10-11T20:15:59Z

John: Created page with "{{Tutorial |name=Mechanical Design |competency=Mechanics |difficulty=Beginner |time=3-5 hours (split across multiple sessions) |prerequisites=Basic familiarity with 3D printing and CAD software |materials=Calipers ($15-30), CAD software (FreeCAD or Fusion 360), ruler, existing robot parts to measure |next_steps=Design custom parts for your robot, study SimpleBot CAD files, Gear Ratio Calculation }} '''Mechanical Design''' is your introduction to designing 3D..."

{{Tutorial
|name=Mechanical Design
|competency=[[Mechanics]]
|difficulty=Beginner
|time=3-5 hours (split across multiple sessions)
|prerequisites=Basic familiarity with 3D printing and CAD software
|materials=Calipers ($15-30), CAD software (FreeCAD or Fusion 360), ruler, existing robot parts to measure
|next_steps=Design custom parts for your robot, study [[SimpleBot]] CAD files, [[Gear Ratio Calculation]]
}}

'''Mechanical Design''' is your introduction to designing 3D-printable robot parts using CAD (Computer-Aided Design) software. This tutorial covers the essential skills for creating mounts, brackets, and structural parts for robots like [[SimpleBot]].

By the end of this tutorial, you'll understand:
* How to measure existing components with calipers
* How to design parts that fit together (tolerances)
* How to design mounting holes and fastener clearances
* How to create assemblies with multiple parts
* How to design for 3D printing (overhangs, bridges, support)

This tutorial is '''hands-on'''. You'll design a sensor mount for [[SimpleBot]] as a practical example.

== Part 1: CAD Software Setup ==

=== Choosing CAD Software ===

For robotics, you need '''parametric CAD''' software that can create precise mechanical parts:

* '''FreeCAD''' (Free, open-source)
** Pros: Completely free, runs on Linux/Mac/Windows, extensible
** Cons: Steeper learning curve, less polished UI
** Best for: Open-source advocates, Linux users, learning fundamentals

* '''Fusion 360''' (Free for hobbyists, students, startups under $100k)
** Pros: Professional-grade, excellent tutorials, cloud storage
** Cons: Requires account, online-only, subscription after trial
** Best for: Beginners, professional workflow, collaboration

* '''OnShape''' (Free for public projects)
** Pros: Browser-based, collaborative, parametric
** Cons: Projects are public unless you pay
** Best for: Collaboration, Chromebook users

'''This tutorial uses FreeCAD''' (works on all platforms), but concepts apply to any CAD software.

=== Installing FreeCAD ===

# Download from [https://www.freecadweb.org/ FreeCAD.org]
# Install (Linux: use package manager, Windows/Mac: run installer)
# Launch FreeCAD and create a new document (File → New)
# Select '''Part Design''' workbench (dropdown at top)

'''Key FreeCAD concepts:'''
* '''Sketch''' - 2D drawing on a plane (constrained shapes)
* '''Pad''' - Extrude sketch into 3D solid (add material)
* '''Pocket''' - Cut sketch from 3D solid (remove material)
* '''Body''' - Container for features (one part = one body)

== Part 2: Measuring with Calipers ==

Before designing parts, you need accurate measurements. '''Digital calipers''' are essential.

=== Caliper Basics ===

Calipers measure:
* '''Outside dimensions''' - Outer diameter, width (large jaws)
* '''Inside dimensions''' - Inner diameter, hole size (small jaws)
* '''Depth''' - How deep a hole or recess is (depth probe)
* '''Step height''' - Difference in height between surfaces

'''Accuracy:''' Digital calipers measure to 0.01mm (0.0005 inches)

=== Measuring Technique ===

# '''Zero the calipers''' - Close jaws and press "zero" button
# '''Place part squarely''' - Jaws perpendicular to surface
# '''Gentle pressure''' - Don't squeeze too hard (deforms plastic)
# '''Read display''' - Switch between mm and inches with "mm/inch" button

'''Exercise:''' Measure these dimensions on your [[Infrared Line Detector]] sensor:
* Width of PCB
* Height of PCB
* Mounting hole diameter
* Distance between mounting holes (center-to-center)
* Height of sensor above PCB bottom

Write down measurements - you'll use them to design a mount!

=== Common Measurement Mistakes ===

* '''Tilted calipers''' - Jaws not perpendicular gives false reading
* '''Measuring over obstacles''' - Measure at narrowest point (not over screw heads)
* '''Forgetting to zero''' - Calipers drift; re-zero before each measurement
* '''Confusing inside/outside''' - Check which jaws you're using
* '''Rounding too aggressively''' - Keep 0.1mm precision, don't round to whole mm

== Part 3: Designing a Sensor Mount ==

Let's design a mount for an [[Infrared Line Detector]] sensor. This mount will:
* Hold the sensor at correct height (3-5mm from ground)
* Attach to SimpleBot chassis with M3 screws
* Keep sensor level and aligned

=== Step 1: Create a Sketch (Base Plate) ===

In FreeCAD Part Design workbench:

# Create a new '''Body''' (right-click Body in tree, select "Create body")
# Create a '''Sketch''' on XY plane
# Draw a '''rectangle''' - 30mm × 20mm (base plate for mount)
# '''Constrain dimensions''' - Select each edge, press "C" (constrain), enter value
# Close sketch (click "Close" in toolbar)

'''Tip:''' Press "V" then "F" to fit sketch to screen.

=== Step 2: Extrude Base Plate (Pad) ===

# Select the closed sketch
# Click '''Pad''' tool (extrude icon)
# Set length to 2mm (base plate thickness)
# Click OK

You now have a 30mm × 20mm × 2mm base plate!

=== Step 3: Add Mounting Holes for Chassis ===

The base plate needs holes to attach to the robot chassis with M3 screws.

# Select top face of base plate
# Create new '''Sketch''' on that face
# Draw two '''circles''' - 3.2mm diameter, 20mm apart horizontally, centered vertically
# Close sketch
# Select sketch and click '''Pocket''' tool (cut icon)
# Set depth to "Through All"
# Click OK

'''Why 3.2mm holes for M3 screws?'''
* M3 screw is 3.0mm diameter
* 0.2mm clearance (3D printing tolerance) = 3.2mm hole
* This allows screws to pass through freely ('''clearance hole''')

=== Step 4: Add Vertical Wall for Sensor ===

The sensor mounts vertically on a wall:

# Select front face of base plate
# Create new '''Sketch''' on that face
# Draw a '''rectangle''' - 25mm wide × 15mm tall
# Close sketch
# '''Pad''' forward 2mm (wall thickness)

Now you have a base plate with a vertical wall!

=== Step 5: Add Sensor Mounting Holes ===

The sensor PCB attaches to the wall with two M3 screws:

# Select front face of vertical wall
# Create new '''Sketch'''
# Measure your sensor: holes are (example) 20mm apart, 8mm from bottom
# Draw two '''circles''' - 2.8mm diameter, positioned to match sensor holes
# Close sketch
# '''Pocket''' depth "Through All"

'''Why 2.8mm holes for M3 screws in plastic?'''
* M3 screw is 3.0mm diameter
* '''Thread-forming screws''' cut threads in plastic as they're screwed in
* 2.8mm hole (0.2mm undersized) allows screw to cut threads tightly
* Alternative: Use 3.2mm holes and M3 nuts on backside

=== Step 6: Add Chamfers (Optional) ===

'''Chamfers''' are angled edges that improve appearance and printability:

# Select top edges of base plate
# Click '''Chamfer''' tool
# Set distance to 0.5mm
# Click OK

This removes sharp corners and helps the print look professional.

== Part 4: Design for 3D Printing ==

Not all CAD designs can be 3D printed successfully. Follow these rules:

=== Overhang Rule: 45-Degree Maximum ===

FDM printers struggle with overhangs steeper than 45 degrees:

* '''OK:''' Walls at 90 degrees (vertical), floors at 0 degrees (horizontal)
* '''OK:''' 45-degree chamfers and slopes
* '''NOT OK:''' Upside-down 45-degree slopes (use support)
* '''NOT OK:''' Horizontal holes (print vertically or use support)

'''Fix:''' Orient part so overhangs are under 45 degrees, or add supports.

=== Bridging Rule: Short Gaps Only ===

Printers can ''bridge'' gaps (print unsupported horizontal lines) up to ~20mm:

* '''OK:''' 10mm horizontal hole (bridges nicely)
* '''NOT OK:''' 50mm horizontal hole (sags in middle)

'''Fix:''' Keep bridged gaps under 20mm, or use support.

=== Minimum Feature Size ===

FDM printers have limits on small features:

* '''Minimum wall thickness:''' 1.2mm (2× nozzle diameter for 0.6mm nozzle)
* '''Minimum hole diameter:''' 2mm (smaller holes often close up)
* '''Minimum gap:''' 0.4mm (smaller gaps fuse together)

'''Fix:''' Make features at least 2mm thick for reliability.

=== Tolerances for Fit ===

3D printed parts shrink slightly and have rough surfaces. Add clearance:

* '''Press fit:''' 0.0 to 0.1mm clearance (tight, may need force)
* '''Sliding fit:''' 0.2 to 0.3mm clearance (moves smoothly)
* '''Loose fit:''' 0.5mm+ clearance (rattles slightly)

'''For our sensor mount:'''
* Chassis mounting holes: 3.2mm (clearance fit for M3 screws)
* Sensor mounting holes: 2.8mm (thread-forming fit)

== Part 5: Assemblies (Multiple Parts) ==

Real robots have many parts. CAD software can show how they fit together:

=== Creating an Assembly in FreeCAD ===

# Create new document
# Insert parts: File → Insert → Part (select your sensor mount .FCStd file)
# Insert sensor model (if available) or create a simple box to represent it
# Use '''Transform''' tool to position parts
# Add '''Constraints''' to lock parts in place

'''Assembly shows:'''
* Do parts collide or interfere?
* Are mounting holes aligned?
* Is sensor at correct height?

=== Common Assembly Mistakes ===

* '''Over-constrained:''' Too many screws in slotted holes (thermal expansion causes binding)
* '''Under-constrained:''' Part wobbles or shifts (add more screws or pins)
* '''Interference:''' Parts overlap (check clearances)
* '''Wire routing:''' No space for wires (leave gaps and channels)

== Part 6: Practical Design Exercise ==

Let's design a motor mount bracket for SimpleBot:

=== Requirements ===
* Mount a DC motor to acrylic chassis
* Motor diameter: 24mm (measure with calipers)
* Motor shaft length: 12mm (protrudes from motor)
* Chassis mounting: Two M3 screws, 20mm apart
* Motor output: Wheel must attach to shaft

=== Design Steps ===

# '''Sketch base plate''' - 30mm × 30mm × 3mm thick (stronger for motor vibration)
# '''Add motor clamp''' - Half-circle cutout 24.2mm diameter (0.2mm clearance)
## Pad walls on both sides to clamp motor
## Add M3 screw hole through walls to tighten clamp
# '''Add chassis mounting holes''' - Two 3.2mm holes, 20mm apart
# '''Add wire routing''' - Small channel for motor wires to exit
# '''Check clearances''' - Wheel must not hit chassis (leave 2mm gap)

=== Design Checklist ===

Before printing, verify:
* ☐ All holes are correct size (calipers + tolerance)
* ☐ Mounting points are spaced correctly (measure chassis)
* ☐ No overhangs steeper than 45 degrees (or add supports)
* ☐ Minimum wall thickness 1.2mm
* ☐ Clearance for moving parts (wheels, gears)
* ☐ Space for wires to route through
* ☐ Chamfers on sharp edges (optional, looks better)

== Part 7: Exporting for 3D Printing ==

=== Export STL File ===

# Select the '''Body''' in FreeCAD tree
# File → Export → Select "STL Mesh" format
# Save as "sensor_mount.stl"

'''STL''' (STereoLithography) is the universal format for 3D printing - it stores the outer shell as triangles.

=== Slicing (Preparing for Print) ===

Use slicer software (Cura, PrusaSlicer, etc.):

# Import STL file
# Orient part (flat side down, minimize supports)
# Set print settings:
## '''Layer height:''' 0.2mm (good balance of speed and quality)
## '''Infill:''' 20% (functional parts), 10% (decorative)
## '''Supports:''' Enable if overhangs exceed 45 degrees
## '''Material:''' PLA (easy), PETG (strong), ABS (heat-resistant)
# Slice and generate G-code
# Send to printer or save to SD card

=== Print Orientation ===

Orientation affects strength and quality:

* '''Best strength:''' Forces perpendicular to layers (layers resist shear poorly)
* '''Best quality:''' Curved surfaces horizontal (layers follow curve)
* '''Minimize supports:''' Flat side down, overhangs under 45 degrees

'''For sensor mount:''' Print base plate down (vertical wall prints nicely, no supports needed).

== Part 8: Iteration and Testing ==

First prints rarely fit perfectly. Iterate:

=== Test Fit ===

# Print part
# Test fit with real components (sensor, screws, chassis)
# Check for issues:
## Holes too tight? Increase diameter by 0.1-0.2mm
## Holes too loose? Decrease diameter by 0.1-0.2mm
## Part warps? Add thicker base or print slower

=== Common Print Issues and Fixes ===

{| class="wikitable"
! Issue !! Cause !! Fix
|-
| Warping (corners lift) || Uneven cooling || Add brim or raft, lower bed temp
|-
| Holes too small || Printer over-extrudes || Increase hole diameter by 0.2mm
|-
| Weak parts || Under-extruding || Increase flow rate or check filament
|-
| Rough surface || Too fast, too hot || Slow down print, lower nozzle temp
|-
| Supports stuck || Too close to part || Increase support gap in slicer
|}

=== Design Iteration Loop ===

# Design part in CAD
# Export STL and slice
# Print part
# Test fit and identify issues
# Modify CAD design (change dimensions)
# Repeat until perfect fit

'''Tip:''' Print small test sections first (just one mounting hole) to check fit before printing the entire part.

== Part 9: Advanced Techniques ==

Once you're comfortable with basic design:

=== Parametric Design ===

'''Parameters''' are variables you can change to update the entire design:

* Create a parameter "motor_diameter = 24mm"
* Use "motor_diameter + 0.2mm" for clamp hole size
* Change motor_diameter to 20mm → entire mount resizes!

'''In FreeCAD:''' Use Spreadsheet workbench to create parameters.

=== Fillets vs Chamfers ===

* '''Chamfer''' - Angled edge (45 degrees typical), easier to print
* '''Fillet''' - Rounded edge, stronger, looks better, slower to print

Use fillets for stress concentration areas (corners that bear load).

=== Threaded Holes ===

Instead of thread-forming screws, design threads into plastic:

* M3 thread = 3.0mm outer diameter, 0.5mm pitch
* Add '''Helix''' feature (spiral) and '''Subtract''' to cut threads
* Requires high resolution (0.1mm layers) to print clearly

'''Easier alternative:''' Use heat-set inserts (metal threaded inserts melted into plastic).

=== Assemblies with Motion ===

Design parts that move (hinges, gears, linkages):

* Add clearance for rotation (0.3mm radial clearance for shafts)
* Use '''Snap fits''' - flexible tabs that lock parts together
* Use '''Living hinges''' - thin flexible sections (0.3-0.5mm thick)

=== Library of Standard Parts ===

Don't redesign screws and nuts - import models:

* [https://grabcad.com/ GrabCAD] - Free CAD library
* [https://www.mcmaster.com/ McMaster-Carr] - CAD models for every fastener
* FreeCAD Fasteners Workbench - Built-in screw library

== Part 10: Studying Existing Designs ==

Learn from [[SimpleBot]] CAD files:

# Download SimpleBot repository (symlinked at ./simplebot/)
# Open FreeCAD files (.FCStd) in CAD software
# Study how parts fit together
# Measure features with '''Measure''' tool
# Modify and remix designs for your own robot

=== What to Look For ===

* '''Hole placements''' - How are mounting holes spaced?
* '''Tolerances''' - What clearances are used for screws and shafts?
* '''Wall thicknesses''' - How thick are structural parts?
* '''Assembly method''' - How do multiple parts attach?
* '''Wire routing''' - Where do wires pass through?

== Part 11: Design Principles for Robotics ==

=== Minimize Part Count ===

Fewer parts = faster assembly, fewer failures:

* Combine multiple features into one part (mount + bracket = one piece)
* Use snap fits instead of screws where appropriate
* Design parts to be 3D printable in one piece

=== Design for Assembly ===

Make parts easy to put together:

* Use '''alignment pins''' or '''tabs''' to position parts correctly
* Add '''chamfers''' to screw holes (guide screws in)
* Leave '''clearance''' for screwdriver or hex key access
* Print '''assembly instructions''' into parts (arrows, labels)

=== Design for Serviceability ===

Robots need maintenance and upgrades:

* Don't trap components inside (leave access holes)
* Use standard fasteners (M3 screws are common)
* Make fragile parts replaceable (separate wheel mounts from chassis)
* Route wires through channels or clips (prevent tangling)

=== Design for Strength ===

Identify stress points and reinforce them:

* '''Thin sections''' break easily (use minimum 2mm thickness)
* '''Sharp corners''' concentrate stress (add fillets)
* '''Cantilever beams''' need support (add ribs or gussets)
* '''Print orientation''' affects strength (layers are weak in shear)

== Part 12: Resources and Next Steps ==

=== Learn More CAD ===

* '''FreeCAD Tutorials''' - [https://www.freecadweb.org/wiki/Tutorials Official wiki tutorials]
* '''Fusion 360 Tutorials''' - [https://www.autodesk.com/products/fusion-360/learn Autodesk Learning]
* '''YouTube Channels''' - Maker's Muse, Teaching Tech, 3D Printing Nerd

=== Practice Projects ===

# Design a custom sensor mount for your robot
# Design a battery holder for 4× AA batteries
# Design a motor mount with gear reduction
# Design a robot arm with 2 servos
# Study and remix [[SimpleBot]] chassis

=== Advanced Topics ===

* [[Gear Ratio Calculation]] - Design gear trains for speed/torque
* [[Kinematics Tutorial]] - Calculate robot motion from wheel speeds
* [[Inverse Kinematics]] - Multi-DOF robot arm calculations
* [[FEA Tutorial]] - Simulate stress in parts (advanced)

=== Related Competencies ===

* '''[[3D Printing]]''' - Fabricate your designs
* '''[[Mechanics]]''' - Understand forces and motion
* '''[[Electronics]]''' - Design mounts for sensors and motors
* '''[[Soldering]]''' - Assemble electronics that mount to your parts

== Troubleshooting ==

=== CAD Issues ===

* '''Sketch won't close?''' Check for gaps or overlapping lines
* '''Can't pad sketch?''' Sketch must be fully constrained
* '''Part disappeared?''' Check if hidden (press "Space" to toggle visibility)
* '''Changes don't update?''' Press "F5" to recompute all features

=== Print Issues ===

* '''Parts don't fit?''' Add 0.2mm clearance for sliding fits
* '''Screw holes too tight?''' Increase diameter by 0.2mm
* '''Parts warp?''' Increase bed adhesion (brim, glue stick, hairspray)
* '''Supports won't remove?''' Increase support gap to 0.2mm

=== Design Issues ===

* '''Part too weak?''' Increase wall thickness or add ribs
* '''Motor vibration causes loosening?''' Add threadlocker or locknut
* '''Wires tangled?''' Add wire routing channels or clips
* '''Parts misaligned?''' Add alignment pins or reference surfaces

== Summary Checklist ==

By now, you should be able to:

* ☐ Measure parts accurately with calipers
* ☐ Create sketches and extrude them into 3D parts
* ☐ Design mounting holes with correct clearances
* ☐ Add chamfers and fillets to edges
* ☐ Export STL files for 3D printing
* ☐ Design for printability (overhangs, bridging, supports)
* ☐ Test fit parts and iterate designs
* ☐ Create assemblies with multiple parts
* ☐ Design for strength and serviceability

If you can check most of these boxes, you're ready to design custom parts for your robot!

== See Also ==

* [[Mechanics]] - Full competency overview
* [[SimpleBot]] - Apply your skills to build a robot
* [[3D Printing]] - Fabrication techniques for your designs
* [[Gear Ratio Calculation]] - Design gear trains
* [[Robotics Ontology]] - How mechanical design fits into BRS

[[Category:Tutorials]]
[[Category:Mechanics]]
[[Category:Beginner]]

Mechanics

2025-10-11T20:15:49Z

John: Created page with "{{Competency |name=Mechanics |description=Understanding what actuates and what is actuated, what the software models, and where the electronics signals end |difficulty_range=Beginner to Advanced |time_to_basic=1-3 weeks |essential_tools=Calipers, screwdriver set, hex keys, ruler |optional_tools=CAD software (FreeCAD, Fusion 360), torque wrench, 3D printer |beginner_tutorial=Mechanical Design |unlocks_basic=Capability:Differential Drive, [[Capability:Line Sensing]..."

{{Competency
|name=Mechanics
|description=Understanding what actuates and what is actuated, what the software models, and where the electronics signals end
|difficulty_range=Beginner to Advanced
|time_to_basic=1-3 weeks
|essential_tools=Calipers, screwdriver set, hex keys, ruler
|optional_tools=CAD software (FreeCAD, Fusion 360), torque wrench, 3D printer
|beginner_tutorial=[[Mechanical Design]]
|unlocks_basic=[[Capability:Differential Drive]], [[Capability:Line Sensing]]
|unlocks_advanced=[[Capability:Omni Drive]], [[Capability:Gripper Control]], [[Capability:Servo Control]]
}}

'''Mechanics''' is the competency of understanding physical motion, forces, and mechanical systems in robotics. Mechanics is where electronic signals become physical movement - motors spin wheels, servos rotate arms, and gears multiply force. It encompasses understanding kinematics (motion), dynamics (forces), power transmission, and structural design.

Mechanics is distinct from [[3D Printing]] (the fabrication technique) and [[CAD]] (the design software). This competency focuses on '''understanding''' mechanical systems: how they move, how forces propagate, and how to design mechanisms that work reliably.

== Why Mechanics Matters for Robotics ==

Mechanics is the body and muscles of a robot:
* '''Actuators''' convert electrical energy into motion (motors, servos, solenoids)
* '''Transmissions''' modify speed and force (gears, belts, linkages)
* '''Chassis''' provide structural support and mounting points
* '''Wheels and drive systems''' enable locomotion
* '''End effectors''' interact with the environment (grippers, arms, tools)

Without mechanics knowledge, you can't design effective robots, predict their behavior, or troubleshoot motion problems. The software can send perfect signals, and the electronics can deliver perfect power, but if the mechanics are wrong, the robot won't work.

== Skill Progression ==

=== Beginner (SimpleBot Level) ===

Skills you need to build and understand [[SimpleBot]]:

* '''Basic kinematics''' - Understand how wheels create motion, turning radius, velocity
* '''Differential drive''' - Two-wheel steering (forward, backward, turning)
* '''Motors''' - DC motor basics, direction control, speed control
* '''Wheels and traction''' - Wheel diameter, friction, slipping
* '''Center of mass''' - Weight distribution, stability, tipping
* '''Mechanical assembly''' - Using screws, nuts, standoffs, spacers
* '''Basic measurements''' - Using calipers, measuring wheel diameter, gear pitch

'''Unlocks''':
* [[Capability:Differential Drive]] (two-motor steering)
* [[Capability:Line Sensing]] (sensor positioning and alignment)
* [[Capability:Optical Odometry]] (encoder wheel mounting)

'''Tutorials''': [[Mechanical Design]], [[Motor Control Basics]]

'''At this level you can''':
* Build SimpleBot from parts or a kit
* Understand how differential drive works
* Mount sensors and motors to a chassis
* Troubleshoot basic mechanical issues (loose wheels, misaligned sensors)
* Calculate turning radius and basic motion planning

=== Intermediate (Expanding Capabilities) ===

Skills for designing more complex mechanisms:

* '''Gear ratios''' - Speed reduction, torque multiplication, efficiency
* '''Torque calculations''' - Motor torque, load torque, stall conditions
* '''Kinematics analysis''' - Forward kinematics, wheel velocities, robot velocity
* '''Structural design''' - Load paths, stress, strain, material selection
* '''Bearings and bushings''' - Reducing friction in rotating joints
* '''Belt and pulley systems''' - Timing belts, GT2 belts, tensioning
* '''Linkages''' - Four-bar linkages, parallel linkages, mechanical advantage

'''Unlocks''':
* [[Capability:Encoder Sensing]] (precise motion control)
* [[Capability:Servo Control]] (multi-axis arms)
* [[Capability:Omni Drive]] (holonomic motion with omni wheels or mecanum wheels)
* [[Capability:Gripper Control]] (claw mechanisms)

'''Tutorials''': [[Gear Ratio Calculation]], [[Kinematics Tutorial]]

'''At this level you can''':
* Select motors based on torque and speed requirements
* Design gear trains for speed reduction or torque multiplication
* Calculate robot velocity from wheel speeds and encoder counts
* Design custom mounts and brackets in CAD
* Integrate servos and multi-DOF mechanisms
* Troubleshoot binding, friction, and alignment issues

=== Advanced (Custom Designs) ===

Skills for designing robots from scratch:

* '''Inverse kinematics''' - Calculate joint angles for desired end effector position
* '''Dynamics''' - Forces, inertia, acceleration, momentum
* '''Motor selection''' - Match motor to application (torque-speed curves, efficiency)
* '''Mechanical advantage''' - Leverage, gear ratios, compound machines
* '''Finite element analysis''' - Simulate stress and deformation in parts
* '''Closed-loop control''' - PID control for position, velocity, torque
* '''Advanced drive systems''' - Omni wheels, mecanum wheels, swerve drive

'''Unlocks''':
* [[Capability:Robot Arm Control]] (multi-DOF inverse kinematics)
* [[Capability:Omni Drive]] (holonomic motion)
* [[Capability:Balancing]] (inverted pendulum, two-wheel balancing)
* Custom drive trains and locomotion systems

'''Tutorials''': [[Inverse Kinematics]], [[PID Control for Motors]]

'''At this level you can''':
* Design multi-DOF robot arms with IK solvers
* Optimize mechanical systems for efficiency and performance
* Perform stress analysis and select materials appropriately
* Design custom transmissions (gearboxes, differentials)
* Implement advanced control algorithms for mechanical systems
* Troubleshoot complex mechanical vibration and resonance issues

== Learning Paths ==

=== Path 1: SimpleBot Builder (Beginner) ===
# Start with [[Mechanical Design]] - Learn basic concepts and measurements
# Build [[SimpleBot]] - Hands-on experience with differential drive
# Experiment with wheel changes and sensor mounting
# Study [[Motor Control Basics]] - Understand motor behavior

'''Result''': You can build SimpleBot and understand how differential drive works.

=== Path 2: Mechanism Designer (Intermediate) ===
# Complete Path 1 (SimpleBot Builder)
# Study [[Gear Ratio Calculation]] - Learn about gear trains
# Study [[Kinematics Tutorial]] - Calculate velocities and motion
# Design a custom gripper or sensor mount in CAD
# Add encoders or servos to SimpleBot

'''Result''': You can design custom mechanical systems and calculate their behavior.

=== Path 3: Robot Architect (Advanced) ===
# Complete Path 2 (Mechanism Designer)
# Study [[Inverse Kinematics]] - Multi-DOF robot arms
# Study [[PID Control for Motors]] - Closed-loop position control
# Design a robot arm or custom drive system
# Implement inverse kinematics in software

'''Result''': You can design complex robots with multi-DOF mechanisms from scratch.

== Essential Concepts ==

=== Differential Drive ===

'''Differential drive''' is the simplest robot steering method - two independently-controlled wheels:

* '''Forward''' - Both wheels rotate forward at same speed
* '''Backward''' - Both wheels rotate backward at same speed
* '''Turn right''' - Left wheel faster than right wheel (or right wheel backward)
* '''Turn left''' - Right wheel faster than left wheel (or left wheel backward)
* '''Rotate in place''' - One wheel forward, one wheel backward

'''Turning radius''' depends on wheel speeds:
* Equal speeds = infinite turning radius (straight line)
* Opposite speeds = zero turning radius (rotate in place)
* Different speeds = turning radius between zero and infinity

'''SimpleBot uses differential drive''' with two DC motors and a caster wheel for balance.

=== Kinematics: Motion Without Forces ===

'''Kinematics''' describes motion without considering forces:

* '''Linear velocity''' (v) - Speed in a straight line (m/s or cm/s)
* '''Angular velocity''' (ω) - Rotational speed (rad/s or degrees/s)
* '''Wheel velocity''' - Linear velocity at wheel edge: v = ω × r (radius)

'''For differential drive robots:'''
* Robot velocity = average of left and right wheel velocities
* Robot turning rate = difference of left and right wheel velocities divided by wheel separation

'''Example:''' If left wheel is at 10 cm/s and right wheel is at 6 cm/s:
* Robot moves forward at (10 + 6) / 2 = 8 cm/s
* Robot turns right at (10 - 6) / wheel_separation rad/s

=== Dynamics: Forces and Torque ===

'''Dynamics''' describes motion considering forces:

* '''Force''' (F) - Push or pull measured in Newtons (N)
* '''Torque''' (τ) - Rotational force measured in N·m or oz-in
* '''Newton's Second Law''' - F = m × a (force = mass × acceleration)

'''For motors:'''
* Motor torque determines acceleration and maximum load
* '''Stall torque''' - Maximum torque when motor is not rotating
* '''Free-run speed''' - Maximum speed when motor has no load
* Operating point is between stall and free-run

'''Why this matters:'''
* Underpowered motor can't move the robot (insufficient torque)
* Oversized motor wastes battery and adds weight
* Steep ramps require more torque than flat ground

=== Gear Ratios and Mechanical Advantage ===

'''Gear ratio''' = Output teeth / Input teeth (or output speed / input speed)

* '''Speed reduction''' - Large gear ratio (e.g., 30:1) decreases speed, increases torque
* '''Speed increase''' - Small gear ratio (e.g., 1:2) increases speed, decreases torque
* '''Power is conserved''' (minus losses) - Speed × Torque is constant

'''Example:''' Motor with 100 oz-in torque at 300 RPM, 30:1 gearbox:
* Output torque ≈ 100 × 30 = 3000 oz-in
* Output speed = 300 / 30 = 10 RPM
* Power is approximately conserved (ignoring 5-10% friction losses)

'''Common applications:'''
* High-speed motors with gearboxes for robot wheels
* Servo motors have internal gearboxes for high torque
* Multi-stage gearboxes for extreme ratios (100:1, 200:1)

=== Center of Mass and Stability ===

'''Center of mass''' (COM) is the average position of all the robot's mass:

* Low COM = more stable (less likely to tip)
* High COM = less stable (easier to tip)
* COM should be centered between support points (wheels)

'''Stability rules:'''
* Robot tips when COM moves outside support polygon
* Add caster wheels to expand support polygon
* Keep heavy components (batteries, motors) low and centered
* SimpleBot uses front caster for three-point stability

=== Friction and Traction ===

'''Friction''' determines how much force wheels can transfer to the ground:

* '''Static friction''' - Maximum force before slipping starts
* '''Kinetic friction''' - Force during sliding (less than static)
* '''Coefficient of friction''' (μ) - Material property (rubber on wood ≈ 0.7)

'''Maximum force''' = μ × Normal force (weight on wheel)

'''Why this matters:'''
* Wheels slip if motor torque exceeds traction limit
* More weight on drive wheels = more traction
* Rubber wheels have better traction than plastic
* Encoders may give false readings if wheels slip

== Mechanical Design Principles ==

=== Tolerances for 3D Printing ===

3D printed parts need clearance for fit:

* '''Press fit''' - 0.0 to 0.1mm clearance (interference fit)
* '''Sliding fit''' - 0.2 to 0.3mm clearance
* '''Loose fit''' - 0.5mm or more clearance
* Horizontal holes print smaller than designed (add 0.2mm)
* Vertical holes print more accurately

=== Fasteners and Mounting ===

* '''M3 screws''' - Most common robot fastener (3mm diameter)
* '''Standoffs''' - Spacers to mount PCBs and separate layers
* '''Heat-set inserts''' - Metal threads in 3D printed parts
* '''Thread-forming screws''' - Cut threads directly into plastic (one-time use)

=== Material Selection ===

* '''PLA''' - Stiff, brittle, easy to print (good for prototypes)
* '''PETG''' - Flexible, strong, impact-resistant (good for functional parts)
* '''ABS''' - Strong, heat-resistant (hard to print)
* '''Acrylic''' - Laser-cut sheets for chassis (cheap, rigid)
* '''Aluminum''' - High strength-to-weight, machineable (expensive)

== Tools and Equipment ==

=== Essential Tools (Start Here) ===
* '''Calipers''' ($15-30) - Measure parts accurately (0.01mm precision)
* '''Screwdriver set''' ($10-20) - Phillips and flathead
* '''Hex key set''' ($5-15) - Allen wrenches for socket head screws
* '''Ruler''' ($5) - Quick measurements and alignment
* '''Pliers''' ($10) - Hold nuts, bend wire, grip small parts

=== Intermediate Tools ===
* '''CAD software''' (Free - $500/year) - FreeCAD (free), Fusion 360 (hobbyist free)
* '''3D printer''' ($200-500) - Print custom parts
* '''Drill and bits''' ($30-60) - Make holes in chassis
* '''File set''' ($10-20) - Clean up burrs and adjust fit

=== Advanced Tools ===
* '''Torque wrench''' ($30-100) - Precise fastener tightening
* '''Dial indicator''' ($20-50) - Measure runout and alignment
* '''Tap and die set''' ($20-40) - Create or repair threads
* '''Lathe or mill''' ($500+) - Machine custom metal parts

== Common Pitfalls ==

* '''Underpowered motors''' - Calculate required torque before selecting motors
* '''Wheel slippage''' - Encoders are useless if wheels slip on smooth surfaces
* '''Loose wheels''' - Vibration loosens set screws; use threadlocker
* '''Misaligned sensors''' - Line sensors must be parallel to ground and perpendicular to line
* '''Over-constrained assemblies''' - Too many attachment points cause binding
* '''Ignoring tolerances''' - 3D printed parts won't fit together without clearance
* '''Top-heavy designs''' - High center of mass causes tipping
* '''Ignoring wire routing''' - Wires get caught in wheels or mechanisms

== Tutorials and Resources ==

=== BRS Tutorials ===
* '''[[Mechanical Design]]''' (Beginner) - Design printable parts in CAD
* '''[[Motor Control Basics]]''' (Beginner) - How motors work with electronics
* '''[[Gear Ratio Calculation]]''' (Intermediate) - Speed/torque tradeoffs
* '''[[Kinematics Tutorial]]''' (Intermediate) - Calculate robot motion
* '''[[Inverse Kinematics]]''' (Advanced) - Multi-DOF robot arms

=== Component Pages ===
* [[SimpleBot]] - Example of differential drive design
* [[TB6612FNG]] - Motor driver specifications and torque limits
* [[Raspberry Pi Pico]] - Microcontroller GPIO for motor control

=== External Resources ===
* [https://www.youtube.com/@Lesics Lesics] - 3D animations of mechanical systems
* [https://www.engineersedge.com/ Engineers Edge] - Mechanical engineering calculators
* [https://www.machinedesign.com/ Machine Design] - Mechanical engineering magazine
* [https://grabcad.com/ GrabCAD] - CAD model library for reference

== Related Competencies ==

* '''[[Electronics]]''' - Provides power and signals to actuators
* '''[[Software]]''' - Sends commands to move mechanical systems
* '''[[3D Printing]]''' - Fabricates mechanical parts
* '''[[CAD]]''' - Designs mechanical parts and assemblies
* '''[[Soldering]]''' - Assembles electronics that control mechanics

== See Also ==

* [[Capabilities]] - Mechanical capabilities like differential drive, omni drive
* [[SimpleBot]] - Apply mechanics knowledge to build a differential drive robot
* [[Robotics Ontology]] - How mechanics fits into the BRS knowledge structure
* [[Activity:Line Following]] - Example activity requiring mechanical understanding

[[Category:Competencies]]
[[Category:Skills]]

MicroPython Programming

2025-10-11T20:15:32Z

John: Created page with "{{Tutorial |name=MicroPython Programming |competency=Software |difficulty=Intermediate |time=5-8 hours (split across multiple sessions) |prerequisites=MicroPython Basics, Electronics Fundamentals |materials=Raspberry Pi Pico, breadboard, motors with H-bridge (TB6612FNG), encoders, I2C sensor (optional: MPU6050 IMU) |next_steps=State Machine Design, Behavior:PID Control, SimpleBot advanced implementations }} '''MicroPython Programming''' builds on..."

{{Tutorial
|name=MicroPython Programming
|competency=[[Software]]
|difficulty=Intermediate
|time=5-8 hours (split across multiple sessions)
|prerequisites=[[MicroPython Basics]], [[Electronics Fundamentals]]
|materials=Raspberry Pi Pico, breadboard, motors with H-bridge (TB6612FNG), encoders, I2C sensor (optional: MPU6050 IMU)
|next_steps=[[State Machine Design]], [[Behavior:PID Control]], [[SimpleBot]] advanced implementations
}}

'''MicroPython Programming''' builds on [[MicroPython Basics]] to teach advanced techniques for robot control. This tutorial covers interrupts, PWM motor control, I2C communication, timers, and state machines - everything you need to build sophisticated robot behaviors.

By the end of this tutorial, you'll understand:
* Hardware interrupts for encoder counting
* PWM generation for precise motor speed control
* I2C communication for reading sensors (IMU example)
* Timers for non-blocking periodic tasks
* State machines for organizing complex behaviors
* Asynchronous programming with asyncio

This tutorial is '''hands-on''' and assumes you've completed [[MicroPython Basics]].

== Part 1: Hardware Interrupts ==

'''Interrupts''' let the microcontroller respond immediately to events without constantly checking (polling).

=== Why Use Interrupts? ===

'''Polling (inefficient):'''
<syntaxhighlight lang="python">
while True:
if encoder.value() == 1: # Constantly checking
count += 1
# Do other work
</syntaxhighlight>

'''Problem:''' If encoder pulse is brief, you might miss it while doing other work.

'''Interrupts (efficient):'''
<syntaxhighlight lang="python">
def encoder_callback(pin):
count += 1 # Runs immediately when encoder pulses

encoder.irq(trigger=Pin.IRQ_RISING, handler=encoder_callback)
# Do other work - encoder is counted automatically!
</syntaxhighlight>

'''Interrupt triggers a function''' when the event occurs, regardless of what the main loop is doing.

=== Basic Interrupt Example: Count Button Presses ===

<syntaxhighlight lang="python">
from machine import Pin
import time

press_count = 0

def button_callback(pin):
global press_count
press_count += 1

button = Pin(14, Pin.IN, Pin.PULL_UP)
button.irq(trigger=Pin.IRQ_FALLING, handler=button_callback)

while True:
print(f"Button pressed {press_count} times")
time.sleep(1)
</syntaxhighlight>

'''Explanation:'''
* '''Pin.IRQ_FALLING''' - Trigger when signal goes HIGH→LOW (button pressed)
* '''global press_count''' - Modify variable from interrupt handler
* Main loop can do other work while button presses are counted

=== Interrupt-Driven Encoder Counting ===

Optical encoders produce pulses as wheels rotate. Interrupts ensure no pulses are missed.

'''Single encoder (counts pulses):'''
<syntaxhighlight lang="python">
from machine import Pin
import time

encoder_count = 0

def encoder_callback(pin):
global encoder_count
encoder_count += 1

encoder = Pin(15, Pin.IN, Pin.PULL_UP)
encoder.irq(trigger=Pin.IRQ_RISING, handler=encoder_callback)

while True:
print(f"Encoder count: {encoder_count}")
time.sleep(0.5)
</syntaxhighlight>

'''Quadrature encoder (detects direction):'''

Quadrature encoders have two channels (A and B) that pulse 90° out of phase:
* A leads B → forward rotation
* B leads A → backward rotation

<syntaxhighlight lang="python">
from machine import Pin
import time

encoder_count = 0
encoder_a = Pin(15, Pin.IN, Pin.PULL_UP)
encoder_b = Pin(16, Pin.IN, Pin.PULL_UP)

def encoder_a_callback(pin):
global encoder_count
if encoder_b.value() == 1:
encoder_count += 1 # Forward
else:
encoder_count -= 1 # Backward

encoder_a.irq(trigger=Pin.IRQ_RISING, handler=encoder_a_callback)

while True:
print(f"Position: {encoder_count}")
time.sleep(0.5)
</syntaxhighlight>

'''Why quadrature encoding matters:'''
* SimpleBot's [[Capability:Optical Odometry]] uses encoder direction to track position
* Essential for [[Activity:Dead Reckoning]] and precise movement

=== Interrupt Best Practices ===

'''DO:'''
* Keep interrupt handlers SHORT and FAST
* Use global variables to pass data to main loop
* Use volatile flags to signal events

'''DON'T:'''
* Use '''time.sleep()''' in interrupt handlers (blocks everything!)
* Print in interrupt handlers (slow, can cause problems)
* Do complex calculations in interrupt handlers

'''Good pattern - minimal interrupt, main loop does work:'''
<syntaxhighlight lang="python">
encoder_flag = False

def encoder_callback(pin):
global encoder_flag
encoder_flag = True # Just set a flag

encoder.irq(trigger=Pin.IRQ_RISING, handler=encoder_callback)

while True:
if encoder_flag:
# Do complex processing here
calculate_position()
encoder_flag = False

# Other work
time.sleep(0.01)
</syntaxhighlight>

== Part 2: PWM (Pulse Width Modulation) ==

'''PWM''' controls motor speed by rapidly switching power on and off.

=== PWM Basics ===

* '''Frequency''' - How fast it switches (typically 1-20 kHz for motors)
* '''Duty cycle''' - Percentage of time it's ON (0% = stopped, 100% = full speed)

'''Example:'''
* 50% duty cycle = motor at half speed
* 75% duty cycle = motor at 75% speed

=== PWM on Raspberry Pi Pico ===

<syntaxhighlight lang="python">
from machine import Pin, PWM

# Create PWM object
motor_pwm = PWM(Pin(16))

# Set frequency (1 kHz)
motor_pwm.freq(1000)

# Set duty cycle (50% = 32768 out of 65535)
motor_pwm.duty_u16(32768)

# Other duty cycles:
motor_pwm.duty_u16(0) # 0% - stopped
motor_pwm.duty_u16(16384) # 25% - quarter speed
motor_pwm.duty_u16(49152) # 75% - three-quarter speed
motor_pwm.duty_u16(65535) # 100% - full speed
</syntaxhighlight>

'''Why duty_u16?'''
* '''u16''' = unsigned 16-bit integer (0-65535)
* Provides fine control (65536 different speed levels)
* Alternative: '''duty_ns(nanoseconds)''' for precise timing

=== Motor Control with H-Bridge ===

DC motors need an '''H-bridge''' to control direction and speed. Common chip: [[TB6612FNG]].

'''H-bridge control signals:'''
* '''IN1, IN2''' - Direction control for motor A (HIGH/LOW, LOW/HIGH)
* '''PWM''' - Speed control (duty cycle)

'''Motor control class:'''
<syntaxhighlight lang="python">
from machine import Pin, PWM

class Motor:
def __init__(self, in1_pin, in2_pin, pwm_pin):
self.in1 = Pin(in1_pin, Pin.OUT)
self.in2 = Pin(in2_pin, Pin.OUT)
self.pwm = PWM(Pin(pwm_pin))
self.pwm.freq(1000) # 1 kHz

def forward(self, speed):
"""Drive forward at speed (0-100)"""
self.in1.high()
self.in2.low()
duty = int(speed * 65535 / 100)
self.pwm.duty_u16(duty)

def backward(self, speed):
"""Drive backward at speed (0-100)"""
self.in1.low()
self.in2.high()
duty = int(speed * 65535 / 100)
self.pwm.duty_u16(duty)

def stop(self):
"""Stop motor (brake)"""
self.in1.low()
self.in2.low()
self.pwm.duty_u16(0)

# Example usage
motor_left = Motor(in1_pin=10, in2_pin=11, pwm_pin=12)
motor_right = Motor(in1_pin=13, in2_pin=14, pwm_pin=15)

motor_left.forward(75) # Left motor 75% forward
motor_right.forward(75) # Right motor 75% forward
time.sleep(2)
motor_left.stop()
motor_right.stop()
</syntaxhighlight>

=== Differential Drive Robot ===

'''Differential drive''' uses two independently controlled wheels:

<syntaxhighlight lang="python">
class DifferentialDrive:
def __init__(self, motor_left, motor_right):
self.left = motor_left
self.right = motor_right

def forward(self, speed=50):
self.left.forward(speed)
self.right.forward(speed)

def backward(self, speed=50):
self.left.backward(speed)
self.right.backward(speed)

def turn_left(self, speed=50):
self.left.backward(speed)
self.right.forward(speed)

def turn_right(self, speed=50):
self.left.forward(speed)
self.right.backward(speed)

def stop(self):
self.left.stop()
self.right.stop()

# Create robot
robot = DifferentialDrive(motor_left, motor_right)

# Drive in a square
robot.forward(50)
time.sleep(1)
robot.turn_left(50)
time.sleep(0.5)
robot.stop()
</syntaxhighlight>

This is the foundation of [[Capability:Differential Drive]]!

== Part 3: I2C Communication ==

'''I2C''' (Inter-Integrated Circuit) is a two-wire protocol for communicating with sensors.

=== I2C Basics ===

* '''SDA''' - Serial Data (bidirectional data line)
* '''SCL''' - Serial Clock (clock signal from controller)
* '''Addresses''' - Each device has a unique 7-bit address (e.g., 0x68)
* '''Multi-device''' - Multiple sensors on same two wires

=== I2C on Raspberry Pi Pico ===

Pico has two I2C buses (I2C0, I2C1):

<syntaxhighlight lang="python">
from machine import I2C, Pin

# I2C0 on pins 0 (SDA) and 1 (SCL)
i2c = I2C(0, scl=Pin(1), sda=Pin(0), freq=400000)

# Scan for devices
devices = i2c.scan()
print(f"I2C devices found: {[hex(d) for d in devices]}")
# Example output: ['0x68'] (MPU6050 IMU)
</syntaxhighlight>

=== Reading an IMU (MPU6050) ===

The MPU6050 is a popular 6-axis IMU (3-axis accelerometer + 3-axis gyroscope) used for [[Capability:IMU Sensing]].

'''Basic register reading:'''
<syntaxhighlight lang="python">
from machine import I2C, Pin
import struct
import time

MPU6050_ADDR = 0x68
PWR_MGMT_1 = 0x6B
ACCEL_XOUT_H = 0x3B

# Initialize I2C
i2c = I2C(0, scl=Pin(1), sda=Pin(0), freq=400000)

# Wake up MPU6050 (it starts in sleep mode)
i2c.writeto_mem(MPU6050_ADDR, PWR_MGMT_1, bytes([0]))

def read_accel():
"""Read accelerometer data (X, Y, Z)"""
data = i2c.readfrom_mem(MPU6050_ADDR, ACCEL_XOUT_H, 6)
ax, ay, az = struct.unpack('>3h', data) # Big-endian signed 16-bit

# Convert to g (gravity units)
# MPU6050 default range: ±2g, scale: 16384 LSB/g
ax_g = ax / 16384.0
ay_g = ay / 16384.0
az_g = az / 16384.0

return ax_g, ay_g, az_g

while True:
ax, ay, az = read_accel()
print(f"Accel X: {ax:.2f}g, Y: {ay:.2f}g, Z: {az:.2f}g")
time.sleep(0.1)
</syntaxhighlight>

'''Complete MPU6050 class:'''
<syntaxhighlight lang="python">
class MPU6050:
def __init__(self, i2c, addr=0x68):
self.i2c = i2c
self.addr = addr
# Wake up MPU6050
self.i2c.writeto_mem(self.addr, 0x6B, bytes([0]))

def read_accel(self):
data = self.i2c.readfrom_mem(self.addr, 0x3B, 6)
ax, ay, az = struct.unpack('>3h', data)
return ax / 16384.0, ay / 16384.0, az / 16384.0

def read_gyro(self):
data = self.i2c.readfrom_mem(self.addr, 0x43, 6)
gx, gy, gz = struct.unpack('>3h', data)
# Gyro scale: 131 LSB/°/s
return gx / 131.0, gy / 131.0, gz / 131.0

def read_temp(self):
data = self.i2c.readfrom_mem(self.addr, 0x41, 2)
temp_raw = struct.unpack('>h', data)[0]
return temp_raw / 340.0 + 36.53 # Convert to °C

# Usage
i2c = I2C(0, scl=Pin(1), sda=Pin(0), freq=400000)
imu = MPU6050(i2c)

while True:
ax, ay, az = imu.read_accel()
gx, gy, gz = imu.read_gyro()
temp = imu.read_temp()
print(f"Accel: {ax:.2f}, {ay:.2f}, {az:.2f} | Gyro: {gx:.1f}, {gy:.1f}, {gz:.1f} | Temp: {temp:.1f}°C")
time.sleep(0.1)
</syntaxhighlight>

'''Why I2C matters for robotics:'''
* Many sensors use I2C: IMU, magnetometer, time-of-flight, OLED display
* Two wires connect many devices (versus 1 wire per device with digital I/O)
* Libraries abstract complexity (you don't need to know every register)

== Part 4: Timers and Non-Blocking Code ==

=== The Problem with time.sleep() ===

'''Blocking code:'''
<syntaxhighlight lang="python">
while True:
motor.forward(50)
time.sleep(2) # Blocks for 2 seconds - can't do anything else!
motor.stop()
time.sleep(1)
</syntaxhighlight>

'''Problem:''' Can't read sensors or respond to events during sleep.

=== Solution 1: Time-Based Switching ===

<syntaxhighlight lang="python">
import time

state = "forward"
state_start_time = time.ticks_ms()

while True:
current_time = time.ticks_ms()
elapsed = time.ticks_diff(current_time, state_start_time)

if state == "forward":
motor.forward(50)
if elapsed > 2000: # 2 seconds
state = "stopped"
state_start_time = current_time

elif state == "stopped":
motor.stop()
if elapsed > 1000: # 1 second
state = "forward"
state_start_time = current_time

# Can read sensors and do other work here!
sensor_value = sensor.value()
print(f"Sensor: {sensor_value}")

time.sleep(0.01) # Small delay to avoid maxing CPU
</syntaxhighlight>

'''Key functions:'''
* '''time.ticks_ms()''' - Milliseconds since boot (wraps around after ~12 days)
* '''time.ticks_diff(new, old)''' - Time difference handling wraparound

=== Solution 2: Hardware Timers ===

Hardware timers trigger a callback periodically without blocking:

<syntaxhighlight lang="python">
from machine import Timer

led_state = False

def timer_callback(timer):
global led_state
led_state = not led_state
led.value(led_state)

# Create timer that fires every 500ms
timer = Timer(period=500, mode=Timer.PERIODIC, callback=timer_callback)

# Main loop is free to do other work!
while True:
sensor_value = sensor.value()
print(f"Sensor: {sensor_value}")
time.sleep(0.1)
</syntaxhighlight>

'''When to use timers:'''
* Periodic sensor readings (sample IMU every 10ms)
* Blinking status LEDs without blocking
* PID control loops (run every 20ms)

== Part 5: State Machines ==

'''State machines''' organize complex behaviors into discrete states with transitions.

=== Line Following State Machine ===

'''States:'''
* '''FORWARD''' - Both sensors on line
* '''TURN_LEFT''' - Right sensor lost line
* '''TURN_RIGHT''' - Left sensor lost line
* '''SEARCH''' - Both sensors lost line

'''Code:'''
<syntaxhighlight lang="python">
from machine import Pin
import time

# Sensors
sensor_left = Pin(14, Pin.IN, Pin.PULL_UP)
sensor_right = Pin(15, Pin.IN, Pin.PULL_UP)

# State machine
state = "FORWARD"

while True:
left = sensor_left.value()
right = sensor_right.value()

# State transitions
if left == 0 and right == 0:
state = "FORWARD"
elif left == 0 and right == 1:
state = "TURN_LEFT"
elif left == 1 and right == 0:
state = "TURN_RIGHT"
else:
state = "SEARCH"

# State actions
if state == "FORWARD":
robot.forward(50)
print("State: FORWARD")
elif state == "TURN_LEFT":
robot.turn_left(40)
print("State: TURN_LEFT")
elif state == "TURN_RIGHT":
robot.turn_right(40)
print("State: TURN_RIGHT")
elif state == "SEARCH":
robot.turn_left(30)
print("State: SEARCH")

time.sleep(0.01)
</syntaxhighlight>

=== Advanced State Machine with Timing ===

Add state entry/exit actions and timing:

<syntaxhighlight lang="python">
class StateMachine:
def __init__(self):
self.state = None
self.state_start_time = 0

def change_state(self, new_state):
if new_state != self.state:
self.exit_state(self.state)
self.state = new_state
self.state_start_time = time.ticks_ms()
self.enter_state(new_state)

def enter_state(self, state):
print(f"Enter state: {state}")
# State entry actions

def exit_state(self, state):
print(f"Exit state: {state}")
# State cleanup actions

def time_in_state(self):
return time.ticks_diff(time.ticks_ms(), self.state_start_time)

# Usage
sm = StateMachine()
sm.change_state("FORWARD")

while True:
# Determine next state based on sensors
if obstacle_detected:
sm.change_state("AVOID")
elif line_detected:
sm.change_state("FOLLOW")

# Execute state behavior
if sm.state == "FORWARD":
robot.forward(50)
elif sm.state == "AVOID":
robot.turn_left(50)
if sm.time_in_state() > 1000: # Turn for 1 second
sm.change_state("FORWARD")
</syntaxhighlight>

See [[State Machine Design]] for more advanced patterns.

== Part 6: Asynchronous Programming with asyncio ==

'''asyncio''' allows concurrent tasks without threads (lightweight, cooperative multitasking).

=== Basic asyncio Example ===

<syntaxhighlight lang="python">
import asyncio
from machine import Pin

led1 = Pin(16, Pin.OUT)
led2 = Pin(17, Pin.OUT)

async def blink_led1():
while True:
led1.toggle()
await asyncio.sleep(0.5) # Non-blocking sleep

async def blink_led2():
while True:
led2.toggle()
await asyncio.sleep(0.3) # Different rate

async def main():
# Run both tasks concurrently
await asyncio.gather(
blink_led1(),
blink_led2()
)

# Start event loop
asyncio.run(main())
</syntaxhighlight>

'''Both LEDs blink at different rates simultaneously!'''

=== Robot with Concurrent Sensor Reading and Motor Control ===

<syntaxhighlight lang="python">
import asyncio
from machine import Pin, I2C

sensor_data = {"distance": 0, "imu": (0, 0, 0)}

async def read_distance_sensor():
while True:
# Read I2C distance sensor
distance = read_distance() # Hypothetical function
sensor_data["distance"] = distance
await asyncio.sleep(0.1) # 10 Hz

async def read_imu():
while True:
# Read I2C IMU
ax, ay, az = imu.read_accel()
sensor_data["imu"] = (ax, ay, az)
await asyncio.sleep(0.01) # 100 Hz

async def motor_control():
while True:
# Use sensor data to control motors
if sensor_data["distance"] < 20:
robot.stop()
else:
robot.forward(50)
await asyncio.sleep(0.02) # 50 Hz control loop

async def main():
await asyncio.gather(
read_distance_sensor(),
read_imu(),
motor_control()
)

asyncio.run(main())
</syntaxhighlight>

'''Why asyncio is useful:'''
* Multiple sensors at different rates (IMU at 100 Hz, distance at 10 Hz)
* Motor control loop independent of sensor reading
* No blocking delays - everything runs "simultaneously"

== Part 7: Practical Example - Encoder-Based Odometry ==

Combine interrupts, PWM, and state machines for [[Activity:Dead Reckoning]]:

<syntaxhighlight lang="python">
from machine import Pin, PWM
import time
import math

class Odometry:
def __init__(self, encoder_left_pin, encoder_right_pin, wheel_diameter, wheel_base, counts_per_rev):
self.wheel_diameter = wheel_diameter # mm
self.wheel_base = wheel_base # mm
self.counts_per_rev = counts_per_rev

# Position
self.x = 0.0
self.y = 0.0
self.theta = 0.0 # Heading in radians

# Encoder counts
self.left_count = 0
self.right_count = 0

# Setup encoders with interrupts
self.encoder_left = Pin(encoder_left_pin, Pin.IN, Pin.PULL_UP)
self.encoder_right = Pin(encoder_right_pin, Pin.IN, Pin.PULL_UP)

self.encoder_left.irq(trigger=Pin.IRQ_RISING, handler=self.left_callback)
self.encoder_right.irq(trigger=Pin.IRQ_RISING, handler=self.right_callback)

def left_callback(self, pin):
self.left_count += 1

def right_callback(self, pin):
self.right_count += 1

def update(self):
# Calculate distance traveled by each wheel
mm_per_count = (math.pi * self.wheel_diameter) / self.counts_per_rev
left_distance = self.left_count * mm_per_count
right_distance = self.right_count * mm_per_count

# Reset counts
self.left_count = 0
self.right_count = 0

# Calculate robot movement
distance = (left_distance + right_distance) / 2.0
delta_theta = (right_distance - left_distance) / self.wheel_base

# Update position
self.theta += delta_theta
self.x += distance * math.cos(self.theta)
self.y += distance * math.sin(self.theta)

def get_position(self):
return self.x, self.y, self.theta

# Usage
odom = Odometry(
encoder_left_pin=15,
encoder_right_pin=16,
wheel_diameter=65, # mm
wheel_base=120, # mm
counts_per_rev=20 # Pulses per revolution
)

while True:
odom.update()
x, y, theta = odom.get_position()
print(f"Position: ({x:.1f}, {y:.1f}) mm, Heading: {math.degrees(theta):.1f}°")
time.sleep(0.1)
</syntaxhighlight>

This implements [[SimpleBot:Dead Reckoning Implementation]]!

== Part 8: Skills Checklist ==

By now, you should be able to:

* ☐ Use hardware interrupts for encoder counting
* ☐ Generate PWM signals for motor speed control
* ☐ Control motor direction with H-bridge (TB6612FNG)
* ☐ Implement differential drive robot class
* ☐ Communicate with I2C sensors (read IMU)
* ☐ Use timers for non-blocking periodic tasks
* ☐ Write non-blocking code with time.ticks_ms()
* ☐ Design state machines for robot behaviors
* ☐ Use asyncio for concurrent tasks
* ☐ Implement encoder-based odometry

If you can check most of these boxes, you can build advanced robot behaviors!

== Next Steps ==

=== Apply to Real Robots ===
* [[SimpleBot:Dead Reckoning Implementation]] - Encoder odometry
* [[SimpleBot:Line Following Implementation]] - State machine line follower
* Add IMU to SimpleBot for heading stabilization

=== Learn Advanced Techniques ===
* [[State Machine Design]] - Hierarchical state machines, event-driven design
* [[Behavior:PID Control]] - Closed-loop control for speed and position
* [[ROS Basics]] - Distributed robotics framework

=== Build New Capabilities ===
* [[Capability:Encoder Sensing]] - Precise wheel rotation measurement
* [[Capability:IMU Sensing]] - Orientation and acceleration
* [[Capability:Time-of-Flight Sensing]] - I2C distance measurement

== Common Intermediate Mistakes ==

* '''Modifying variables in interrupts without "global"''' - Forgot global declaration
* '''Long interrupt handlers''' - Causes missed interrupts and timing issues
* '''Ignoring PWM frequency effects''' - Too low = audible whine, too high = inefficient
* '''Not debouncing switches''' - Mechanical switches bounce, causing multiple counts
* '''Forgetting I2C pull-up resistors''' - I2C needs 4.7kΩ pull-ups on SDA and SCL
* '''Race conditions in asyncio''' - Shared variables need careful handling
* '''Integer overflow in encoder counts''' - Use 32-bit integers or reset periodically

== Debugging Advanced Programs ==

=== Logic Analyzer for I2C/SPI ===

Use a logic analyzer ($10-60) to visualize I2C communication:
* See SDA and SCL signals
* Decode I2C addresses and data
* Identify timing issues and protocol errors

=== Oscilloscope for PWM ===

Visualize PWM signals:
* Verify frequency and duty cycle
* Check for glitches or noise
* Measure rise/fall times

=== Print Timing Analysis ===

Measure execution time:
<syntaxhighlight lang="python">
start = time.ticks_us()
# Code to measure
expensive_function()
elapsed = time.ticks_diff(time.ticks_us(), start)
print(f"Execution time: {elapsed} µs")
</syntaxhighlight>

== Tools and Resources ==

=== Hardware ===
* '''Logic analyzer''' - $10-60 (Saleae-compatible clones work well)
* '''Oscilloscope''' - $100-400 (DSO150 or Rigol DS1054Z)
* '''I2C sensors''' - MPU6050 IMU ($3), VL53L0X distance ($5)
* '''Motor driver''' - TB6612FNG breakout board ($5-10)

=== Software ===
* '''MicroPython I2C library''' - Built-in, no installation needed
* '''Pulseview''' (Free) - Logic analyzer software
* '''mpremote''' (Free) - Command-line tool for MicroPython

=== External Resources ===
* [https://docs.micropython.org/en/latest/library/machine.html MicroPython machine module]
* [https://docs.micropython.org/en/latest/library/asyncio.html MicroPython asyncio]
* [https://learn.sparkfun.com/tutorials/i2c SparkFun I2C Tutorial]
* [https://invensense.tdk.com/products/motion-tracking/6-axis/mpu-6050/ MPU6050 Datasheet]

== See Also ==

* [[Software]] - Full software competency overview
* [[MicroPython Basics]] - Prerequisites for this tutorial
* [[State Machine Design]] - Advanced behavior organization
* [[SimpleBot]] - Apply these techniques to a real robot
* [[Behavior:PID Control]] - Closed-loop motor control

[[Category:Tutorials]]
[[Category:Software]]
[[Category:Intermediate]]

MicroPython Basics

2025-10-11T20:15:06Z

John: Created page with "{{Tutorial |name=MicroPython Basics |competency=Software |difficulty=Beginner |time=3-5 hours (split across multiple sessions) |prerequisites=None - complete beginner friendly |materials=Raspberry Pi Pico ($4), USB cable, computer with Thonny IDE (free), LED, resistor (220Ω), breadboard |next_steps=SimpleBot assembly, MicroPython Programming, Electronics Fundamentals }} '''MicroPython Basics''' is your introduction to programming microcontrollers for ro..."

{{Tutorial
|name=MicroPython Basics
|competency=[[Software]]
|difficulty=Beginner
|time=3-5 hours (split across multiple sessions)
|prerequisites=None - complete beginner friendly
|materials=Raspberry Pi Pico ($4), USB cable, computer with Thonny IDE (free), LED, resistor (220Ω), breadboard
|next_steps=[[SimpleBot]] assembly, [[MicroPython Programming]], [[Electronics Fundamentals]]
}}

'''MicroPython Basics''' is your introduction to programming microcontrollers for robotics. This tutorial covers everything you need to write your first robot program, from installing MicroPython to controlling GPIO pins.

By the end of this tutorial, you'll understand:
* What MicroPython is and why it's great for robotics
* How to install MicroPython on Raspberry Pi Pico
* How to use Thonny IDE and the REPL
* Python basics: variables, functions, loops, conditionals
* How to control LEDs and read buttons
* How to write simple robot programs

This tutorial is '''hands-on'''. You'll write and run code on real hardware.

== Part 1: What is MicroPython? ==

'''MicroPython''' is a version of Python designed for microcontrollers - tiny computers that control robots.

=== Why MicroPython for Robotics? ===

* '''Easy to learn''' - Python is one of the most beginner-friendly programming languages
* '''Interactive''' - Test code immediately with the REPL (Read-Eval-Print Loop)
* '''Fast development''' - Write code quickly without compiling
* '''Rich libraries''' - GPIO, PWM, I2C, SPI built in
* '''Low cost''' - Raspberry Pi Pico costs $4 and runs MicroPython perfectly

'''Comparison to other options:'''
* '''Arduino (C/C++)''' - Faster execution, larger community, but harder to learn
* '''Python on Raspberry Pi''' - Full Python ecosystem, but not real-time, more expensive
* '''MicroPython''' - Best balance of simplicity and capability for beginners

=== What is a Microcontroller? ===

A '''microcontroller''' is a tiny computer designed to control hardware:
* '''CPU''' - Processes instructions (runs your code)
* '''RAM''' - Temporary storage for variables (264 KB on Pico)
* '''Flash''' - Permanent storage for programs (2 MB on Pico)
* '''GPIO''' - General-Purpose Input/Output pins to connect sensors and motors

'''Raspberry Pi Pico''' specifications:
* Dual-core ARM Cortex-M0+ @ 133 MHz
* 264 KB RAM, 2 MB flash
* 26 GPIO pins (digital I/O, PWM, ADC, I2C, SPI, UART)
* USB for programming and power
* Costs $4

== Part 2: Installing MicroPython ==

=== Step 1: Download MicroPython Firmware ===

# Go to [https://micropython.org/download/rp2-pico/ MicroPython Downloads]
# Download the latest '''.uf2''' file (e.g., "rp2-pico-latest.uf2")
# Save it to your computer

=== Step 2: Flash MicroPython to Pico ===

# Hold the '''BOOTSEL''' button on Raspberry Pi Pico
# While holding BOOTSEL, plug USB cable into computer
# Release BOOTSEL button
# Pico appears as a USB drive named "RPI-RP2"
# Drag the '''.uf2''' file to the RPI-RP2 drive
# Pico automatically reboots with MicroPython installed!

'''Troubleshooting:'''
* '''RPI-RP2 drive doesn't appear?''' Make sure you're holding BOOTSEL ''before'' plugging in USB
* '''File won't copy?''' Try a different USB cable (some are power-only)
* '''Pico disconnects after copying?''' This is normal! It's rebooting with MicroPython

=== Step 3: Install Thonny IDE ===

'''Thonny''' is a beginner-friendly Python IDE with built-in MicroPython support.

# Download from [https://thonny.org/ thonny.org]
# Install Thonny (Windows: run installer, macOS: drag to Applications, Linux: apt install thonny)
# Open Thonny
# Click bottom-right corner where it says "Python" and select '''MicroPython (Raspberry Pi Pico)'''
# Connect Pico via USB - Thonny should detect it

'''You should see:'''
* A '''code editor''' (top half) - Write programs here
* A '''Shell/REPL''' (bottom half) - Interactive Python console

== Part 3: Your First MicroPython Program ==

=== The REPL (Interactive Shell) ===

The '''REPL''' (Read-Eval-Print Loop) lets you test Python code immediately:

# Type in the Shell (bottom half of Thonny)
# Press Enter
# See the result instantly

'''Try this:'''
<syntaxhighlight lang="python">
>>> print("Hello, Robot!")
Hello, Robot!

>>> 2 + 2
4

>>> name = "SimpleBot"
>>> print(f"My robot is {name}")
My robot is SimpleBot
</syntaxhighlight>

'''Why the REPL is amazing:'''
* Test sensor readings instantly
* Debug code by checking variable values
* Learn Python by experimenting

=== Blink the Onboard LED ===

Raspberry Pi Pico has an LED on pin 25 (the "onboard LED"). Let's blink it!

'''Type this in the REPL:'''
<syntaxhighlight lang="python">
>>> from machine import Pin
>>> import time
>>> led = Pin(25, Pin.OUT)
>>> led.on()
</syntaxhighlight>

The LED should turn ON!

'''Now turn it OFF:'''
<syntaxhighlight lang="python">
>>> led.off()
</syntaxhighlight>

'''Make it blink:'''
<syntaxhighlight lang="python">
>>> for i in range(10):
... led.toggle()
... time.sleep(0.5)
</syntaxhighlight>

Note: After typing "for i in range(10):", press Enter, then type the indented lines, then press Enter twice to run.

=== Write Your First Program ===

Now let's write a complete program in the editor (top half):

<syntaxhighlight lang="python">
from machine import Pin
import time

led = Pin(25, Pin.OUT)

while True:
led.toggle()
time.sleep(0.5)
</syntaxhighlight>

'''Run the program:'''
# Click the green "Run" button (or press F5)
# Thonny will ask "Where to save?" - choose '''MicroPython device'''
# Save as '''blink.py'''
# The LED blinks forever!

'''Stop the program:'''
* Click the red "Stop" button or press Ctrl+C

'''What this code does:'''
* '''from machine import Pin''' - Import Pin class for GPIO control
* '''import time''' - Import time module for delays
* '''led = Pin(25, Pin.OUT)''' - Configure pin 25 as output
* '''while True:''' - Loop forever
* '''led.toggle()''' - Switch LED state (on→off or off→on)
* '''time.sleep(0.5)''' - Wait 0.5 seconds

== Part 4: Python Basics for Robotics ==

=== Variables ===

Variables store values (sensor readings, motor speeds, states):

<syntaxhighlight lang="python">
# Numbers
speed = 100
distance = 15.5

# Strings (text)
robot_name = "SimpleBot"

# Booleans (True/False)
line_detected = True
obstacle_ahead = False
</syntaxhighlight>

=== Comments ===

Comments explain code (Python ignores them):

<syntaxhighlight lang="python">
# This is a comment
speed = 100 # Set motor speed to 100%
</syntaxhighlight>

=== Math Operations ===

<syntaxhighlight lang="python">
# Basic math
x = 10 + 5 # Addition: 15
y = 10 - 3 # Subtraction: 7
z = 10 * 2 # Multiplication: 20
w = 10 / 4 # Division: 2.5
q = 10 // 4 # Integer division: 2
r = 10 % 3 # Modulo (remainder): 1

# Comparisons (result is True or False)
10 > 5 # Greater than: True
10 < 5 # Less than: False
10 == 10 # Equal: True
10 != 5 # Not equal: True
</syntaxhighlight>

=== Conditionals (If/Else) ===

Make decisions based on sensor readings:

<syntaxhighlight lang="python">
from machine import Pin

sensor = Pin(14, Pin.IN, Pin.PULL_UP)

if sensor.value() == 0:
print("Line detected!")
else:
print("No line")
</syntaxhighlight>

'''Multiple conditions:'''
<syntaxhighlight lang="python">
sensor_left = Pin(14, Pin.IN, Pin.PULL_UP)
sensor_right = Pin(15, Pin.IN, Pin.PULL_UP)

if sensor_left.value() == 0 and sensor_right.value() == 0:
print("Both sensors on line")
elif sensor_left.value() == 0:
print("Left sensor on line")
elif sensor_right.value() == 0:
print("Right sensor on line")
else:
print("No line detected")
</syntaxhighlight>

=== Loops (While and For) ===

'''While loop''' - Repeat until condition is false:
<syntaxhighlight lang="python">
count = 0
while count < 10:
print(count)
count += 1 # Shorthand for count = count + 1
</syntaxhighlight>

'''Infinite loop''' - Robot main loop:
<syntaxhighlight lang="python">
while True:
# Read sensors
# Make decisions
# Control motors
time.sleep(0.01) # Small delay
</syntaxhighlight>

'''For loop''' - Repeat a specific number of times:
<syntaxhighlight lang="python">
for i in range(5):
print(i) # Prints 0, 1, 2, 3, 4

# Blink LED 10 times
for i in range(10):
led.toggle()
time.sleep(0.2)
</syntaxhighlight>

=== Functions ===

Functions organize code into reusable blocks:

<syntaxhighlight lang="python">
def blink_led(times, delay):
"""Blink LED a specific number of times"""
for i in range(times):
led.toggle()
time.sleep(delay)

# Call the function
blink_led(5, 0.3) # Blink 5 times, 0.3 second delay
blink_led(10, 0.1) # Blink 10 times, 0.1 second delay
</syntaxhighlight>

'''Functions with return values:'''
<syntaxhighlight lang="python">
def read_sensor():
"""Read sensor and return True if line detected"""
sensor = Pin(14, Pin.IN, Pin.PULL_UP)
return sensor.value() == 0 # Returns True or False

# Use the function
if read_sensor():
print("Line detected!")
</syntaxhighlight>

== Part 5: GPIO Control ==

'''GPIO''' (General-Purpose Input/Output) pins connect sensors and actuators to the microcontroller.

=== Digital Output (Control LED) ===

'''Wiring:'''
* LED long leg → GPIO pin 15
* LED short leg → 220Ω resistor → GND

'''Code:'''
<syntaxhighlight lang="python">
from machine import Pin

led = Pin(15, Pin.OUT)

led.on() # Turn LED on (pin = HIGH = 3.3V)
led.off() # Turn LED off (pin = LOW = 0V)
led.value(1) # Alternative: 1 = on, 0 = off
led.toggle() # Switch state
</syntaxhighlight>

=== Digital Input (Read Button) ===

'''Wiring:'''
* Button one side → GPIO pin 14
* Button other side → GND
* Internal pull-up resistor (no external resistor needed)

'''Code:'''
<syntaxhighlight lang="python">
from machine import Pin

button = Pin(14, Pin.IN, Pin.PULL_UP)

while True:
if button.value() == 0: # Button pressed (connects to GND = LOW)
print("Button pressed!")
else:
print("Button not pressed")
time.sleep(0.1)
</syntaxhighlight>

'''Why Pin.PULL_UP?'''
* Without pull-up, the input "floats" (undefined voltage) when button is not pressed
* Pull-up resistor connects input to 3.3V by default (HIGH)
* When button pressed, it connects to GND (LOW)
* This is an '''active LOW''' button (pressed = LOW)

=== Example: Button-Controlled LED ===

<syntaxhighlight lang="python">
from machine import Pin

button = Pin(14, Pin.IN, Pin.PULL_UP)
led = Pin(15, Pin.OUT)

while True:
if button.value() == 0: # Button pressed
led.on()
else:
led.off()
</syntaxhighlight>

'''Improvement: Toggle LED on button press'''
<syntaxhighlight lang="python">
from machine import Pin
import time

button = Pin(14, Pin.IN, Pin.PULL_UP)
led = Pin(15, Pin.OUT)

last_button_state = 1 # Not pressed initially

while True:
button_state = button.value()

# Detect button press (transition from HIGH to LOW)
if button_state == 0 and last_button_state == 1:
led.toggle()
time.sleep(0.2) # Debounce delay

last_button_state = button_state
time.sleep(0.01)
</syntaxhighlight>

== Part 6: Analog Input (Read Variable Voltage) ==

Some sensors output variable voltage (temperature, light, distance). Use ADC (Analog-to-Digital Converter) to read them.

=== Reading a Potentiometer ===

'''Wiring:'''
* Potentiometer middle pin → GPIO 26 (ADC0)
* Potentiometer left pin → 3.3V
* Potentiometer right pin → GND

'''Code:'''
<syntaxhighlight lang="python">
from machine import ADC, Pin
import time

pot = ADC(Pin(26)) # GPIO 26 is ADC0

while True:
value = pot.read_u16() # Read 16-bit value (0-65535)
voltage = value * 3.3 / 65535 # Convert to voltage
percent = value / 65535 * 100 # Convert to percentage

print(f"Value: {value}, Voltage: {voltage:.2f}V, Percent: {percent:.1f}%")
time.sleep(0.5)
</syntaxhighlight>

'''What this does:'''
* '''pot.read_u16()''' - Returns 0 (0V) to 65535 (3.3V)
* Turn potentiometer dial and watch the value change
* This is how robots read analog sensors (photoresistors, battery voltage)

=== Example: ADC-Controlled LED Brightness ===

'''Note:''' This requires PWM, which we'll cover in [[MicroPython Programming]]. For now, we'll use a simple threshold:

<syntaxhighlight lang="python">
from machine import ADC, Pin
import time

pot = ADC(Pin(26))
led = Pin(15, Pin.OUT)

while True:
value = pot.read_u16()

if value > 32768: # If pot is more than 50%
led.on()
else:
led.off()

time.sleep(0.1)
</syntaxhighlight>

== Part 7: Your First Robot Program ==

Let's combine everything into a simple robot behavior:

'''Scenario:''' A robot with two line sensors that follows a line.

'''Simplified hardware (for testing without a robot):'''
* 2 buttons represent line sensors (pressed = line detected)
* 2 LEDs represent motors (on = motor running)

'''Wiring:'''
* Button 1 (left sensor) → GPIO 14 → GND, with Pin.PULL_UP
* Button 2 (right sensor) → GPIO 15 → GND, with Pin.PULL_UP
* LED 1 (left motor) → GPIO 16 → 220Ω → GND
* LED 2 (right motor) → GPIO 17 → 220Ω → GND

'''Code:'''
<syntaxhighlight lang="python">
from machine import Pin
import time

# Sensors (buttons for testing)
sensor_left = Pin(14, Pin.IN, Pin.PULL_UP)
sensor_right = Pin(15, Pin.IN, Pin.PULL_UP)

# Motors (LEDs for testing)
motor_left = Pin(16, Pin.OUT)
motor_right = Pin(17, Pin.OUT)

def drive_forward():
motor_left.on()
motor_right.on()

def turn_left():
motor_left.off()
motor_right.on()

def turn_right():
motor_left.on()
motor_right.off()

def stop():
motor_left.off()
motor_right.off()

# Main loop
while True:
left = sensor_left.value()
right = sensor_right.value()

# Both sensors on line (both buttons pressed)
if left == 0 and right == 0:
drive_forward()
# Left sensor on line, right sensor off
elif left == 0 and right == 1:
turn_left()
# Right sensor on line, left sensor off
elif left == 1 and right == 0:
turn_right()
# Neither sensor on line
else:
stop()

time.sleep(0.01) # Small delay
</syntaxhighlight>

'''Try this:'''
* Press left button only → left LED off, right LED on (turning left)
* Press right button only → left LED on, right LED off (turning right)
* Press both buttons → both LEDs on (driving forward)
* Release both buttons → both LEDs off (stopped)

This is the foundation of [[Activity:Line Following]]!

== Part 8: Saving Programs to Pico ==

=== Where Code is Stored ===

* '''main.py''' - Runs automatically when Pico powers on
* '''Other .py files''' - Can be imported as modules

=== Create a Startup Program ===

# Write your code in Thonny
# Click "Save as..." and choose '''MicroPython device'''
# Name it '''main.py'''
# Disconnect Pico and reconnect it
# Your program runs automatically!

'''Tip:''' Add a delay at the start so you can interrupt it if needed:
<syntaxhighlight lang="python">
import time
time.sleep(2) # 2-second delay before starting
# Your code here
</syntaxhighlight>

=== Organize Code into Modules ===

You can split code into multiple files:

'''robot.py''' (on Pico):
<syntaxhighlight lang="python">
from machine import Pin

class Robot:
def __init__(self):
self.led = Pin(25, Pin.OUT)

def blink(self, times):
for i in range(times):
self.led.toggle()
time.sleep(0.2)
</syntaxhighlight>

'''main.py''' (on Pico):
<syntaxhighlight lang="python">
from robot import Robot

bot = Robot()
bot.blink(10)
</syntaxhighlight>

== Part 9: Debugging and Troubleshooting ==

=== Print Debugging ===

The most useful debugging technique is printing values:

<syntaxhighlight lang="python">
while True:
sensor_value = sensor.value()
print(f"Sensor: {sensor_value}") # See what the sensor reads

if sensor_value == 0:
motor.on()
print("Motor ON") # Confirm this branch executes
else:
motor.off()
print("Motor OFF")

time.sleep(0.1)
</syntaxhighlight>

=== LED Indicator Debugging ===

When you can't connect to serial console (robot is moving), use LED patterns:

<syntaxhighlight lang="python">
def indicate_error():
for i in range(5):
led.toggle()
time.sleep(0.1) # Fast blink = error

def indicate_success():
led.on()
time.sleep(1) # Long on = success
led.off()
</syntaxhighlight>

=== Common Errors ===

'''IndentationError:''' Python uses indentation (spaces/tabs) to group code:
<syntaxhighlight lang="python">
# Wrong - inconsistent indentation
if sensor.value() == 0:
motor.on()
led.on() # Error: too many spaces

# Correct - consistent indentation
if sensor.value() == 0:
motor.on()
led.on()
</syntaxhighlight>

'''NameError:''' Variable not defined:
<syntaxhighlight lang="python">
# Wrong
print(speed) # Error: speed not defined

# Correct
speed = 100
print(speed)
</syntaxhighlight>

'''AttributeError:''' Calling wrong method:
<syntaxhighlight lang="python">
# Wrong
led.turnon() # Error: no such method

# Correct
led.on()
</syntaxhighlight>

=== REPL Error Messages ===

Read error messages carefully - they tell you what's wrong:

<pre>
Traceback (most recent call last):
File "<stdin>", line 5, in <module>
NameError: name 'speed' is not defined
</pre>

* '''Line 5''' - Error is on line 5
* '''NameError''' - Variable name doesn't exist
* '''speed not defined''' - You forgot to create variable "speed"

== Part 10: Skills Checklist ==

By now, you should be able to:

* ☐ Install MicroPython on Raspberry Pi Pico
* ☐ Use Thonny IDE to write and run code
* ☐ Use the REPL to test code interactively
* ☐ Write Python variables, conditionals, loops, functions
* ☐ Control digital outputs (LEDs)
* ☐ Read digital inputs (buttons)
* ☐ Read analog inputs (potentiometer, sensors)
* ☐ Write a simple robot behavior (line following simulation)
* ☐ Save programs to Pico (main.py)
* ☐ Debug with print statements and LED indicators

If you can check most of these boxes, you're ready to program [[SimpleBot]]!

== Next Steps ==

=== Build SimpleBot ===
Apply your MicroPython knowledge to a real robot:
* [[SimpleBot]] - Full robot assembly guide
* [[SimpleBot:Line Following Implementation]] - Real line following code
* [[SimpleBot:Dead Reckoning Implementation]] - Encoder-based odometry

=== Learn More Programming ===
* [[MicroPython Programming]] - Interrupts, PWM, I2C, state machines
* [[State Machine Design]] - Organize complex behaviors
* [[Software]] - Full competency overview

=== Practice Projects ===
* '''Reaction timer''' - Press button, wait random time, LED lights, measure reaction
* '''Light tracker''' - Use photoresistor to control LED brightness
* '''Morse code''' - Blink LED in Morse code patterns
* '''Night light''' - Turn LED on when photoresistor detects darkness

== Common Beginner Mistakes ==

* '''Forgetting to import modules''' - Always '''from machine import Pin''' at the start
* '''Using time.sleep() in interrupts''' - Interrupts must be fast (no delays!)
* '''Not configuring pin mode''' - Always specify Pin.IN or Pin.OUT
* '''Forgetting pull-up/pull-down resistors''' - Digital inputs need them to avoid floating
* '''Mixing up HIGH/LOW logic''' - Check if sensor is active HIGH or active LOW
* '''Infinite loops without sleep''' - Always add small delay to avoid maxing out CPU

== Tools and Resources ==

=== Essential Software ===
* '''Thonny IDE''' (Free) - [https://thonny.org/ thonny.org]
* '''MicroPython Firmware''' (Free) - [https://micropython.org/download/rp2-pico/ micropython.org]

=== Hardware Needed ===
* '''Raspberry Pi Pico''' - $4 from [https://www.raspberrypi.com/products/raspberry-pi-pico/ Raspberry Pi]
* '''USB cable''' (micro USB) - $2-5
* '''Breadboard''' - $5-10
* '''Jumper wires''' - $5-10
* '''LEDs and resistors''' - $5-10 for assorted kit

=== External Resources ===
* [https://docs.micropython.org/en/latest/rp2/quickref.html MicroPython Quick Reference for Pico]
* [https://projects.raspberrypi.org/en/projects/getting-started-with-the-pico Raspberry Pi Pico Getting Started]
* [https://www.raspberrypi.com/documentation/microcontrollers/raspberry-pi-pico.html Raspberry Pi Pico Documentation]
* [https://docs.python.org/3/tutorial/ Python Tutorial] - Learn Python language

== See Also ==

* [[Software]] - Full software competency overview
* [[MicroPython Programming]] - Next tutorial in the learning path
* [[SimpleBot]] - Build a robot using MicroPython
* [[Electronics Fundamentals]] - Understand the hardware you're controlling

[[Category:Tutorials]]
[[Category:Software]]
[[Category:Beginner]]

Software

2025-10-11T20:14:50Z

John: Created page with "{{Competency |name=Software |description=Programming robots to perform tasks and managing their behavior |difficulty_range=Beginner to Advanced |time_to_basic=2-3 weeks |essential_tools=Text editor or IDE (Thonny), USB cable, microcontroller |optional_tools=Debugger, serial monitor, version control (Git) |beginner_tutorial=MicroPython Basics |unlocks_basic=All robot capabilities (software is required for every robot) |unlocks_advanced=Capability:IMU Sensing, Ca..."

{{Competency
|name=Software
|description=Programming robots to perform tasks and managing their behavior
|difficulty_range=Beginner to Advanced
|time_to_basic=2-3 weeks
|essential_tools=Text editor or IDE (Thonny), USB cable, microcontroller
|optional_tools=Debugger, serial monitor, version control (Git)
|beginner_tutorial=[[MicroPython Basics]]
|unlocks_basic=All robot capabilities (software is required for every robot)
|unlocks_advanced=[[Capability:IMU Sensing]], [[Capability:Camera Vision]], [[Activity:Autonomous Navigation]]
}}

'''Software''' is the competency of programming robots and managing their behavior. In robotics, software is the brain that coordinates sensors, actuators, and decision-making logic. It encompasses writing code, debugging programs, using libraries, and managing complex multi-process systems.

Software is distinct from [[Electronics]] (the hardware interface) and [[Mechanics]] (the physical structure). This competency focuses on '''programming''': writing algorithms, controlling hardware through code, and building intelligent behaviors.

== Why Software Matters for Robotics ==

Software brings robots to life:
* '''Sensors''' provide data, but software interprets it
* '''Actuators''' can move, but software decides when and how
* '''Behaviors''' emerge from code that combines sensing and action
* '''Intelligence''' comes from algorithms, state machines, and decision logic

Without software knowledge, you're limited to pre-programmed behaviors and cannot create custom robot capabilities.

== Skill Progression ==

=== Beginner (SimpleBot Level) ===

Skills you need to program [[SimpleBot]]:

* '''MicroPython basics''' - Variables, functions, loops, conditionals
* '''Flashing firmware''' - Install MicroPython on Raspberry Pi Pico
* '''Using an IDE''' - Write and upload code with Thonny
* '''REPL interaction''' - Interactive Python shell for testing
* '''GPIO control''' - Read sensors, control motors with digital I/O
* '''Simple programs''' - Blink LED, read button, control motor direction
* '''Debugging''' - Print statements, LED indicators, REPL error messages

'''Unlocks''':
* [[Capability:Line Sensing]] (read digital sensors)
* [[Capability:Differential Drive]] (control motor directions)
* [[Activity:Line Following]] (combine sensing + control in a loop)

'''Tutorials''': [[MicroPython Basics]], [[MicroPython Programming]]

'''At this level you can''':
* Write simple MicroPython programs for Raspberry Pi Pico
* Control LEDs, buttons, and motors with GPIO
* Read sensor values and make decisions based on them
* Debug basic program errors
* Implement simple robot behaviors (line following, obstacle detection)

=== Intermediate (Expanding Capabilities) ===

Skills for implementing complex robot behaviors:

* '''Interrupts''' - Hardware interrupts for encoder counting, timing-critical events
* '''PWM generation''' - Precise motor speed control, servo positioning
* '''Timers''' - Periodic tasks, non-blocking delays
* '''Communication protocols''' - I2C and SPI libraries for sensors
* '''State machines''' - Organize complex behaviors with states and transitions
* '''Sensor fusion''' - Combine multiple sensors for robust perception
* '''Asynchronous programming''' - Use asyncio for concurrent tasks
* '''Calibration''' - Tune sensor thresholds, motor speeds, PID parameters

'''Unlocks''':
* [[Capability:Encoder Sensing]] (interrupt-driven quadrature encoders)
* [[Capability:IMU Sensing]] (I2C communication with accelerometer/gyroscope)
* [[Capability:Time-of-Flight Sensing]] (I2C distance sensors)
* [[Activity:Dead Reckoning]] (encoder integration, coordinate tracking)
* [[Behavior:PID Control]] (closed-loop motor control)

'''Tutorials''': [[MicroPython Programming]], [[State Machine Design]]

'''At this level you can''':
* Implement interrupt-driven encoder counting
* Control motor speeds with PWM
* Read I2C and SPI sensors using libraries
* Design state machines for complex behaviors
* Write asynchronous code for concurrent tasks
* Calibrate sensors and tune control parameters
* Debug timing and concurrency issues

=== Advanced (Autonomous Systems) ===

Skills for building sophisticated autonomous robots:

* '''Computer vision''' - OpenCV for camera-based perception
* '''ROS (Robot Operating System)''' - Distributed system for complex robots
* '''Path planning''' - A*, Dijkstra, RRT algorithms
* '''SLAM''' - Simultaneous Localization and Mapping
* '''Multi-process systems''' - Separate processes for perception, planning, control
* '''Docker containers''' - Portable, reproducible software environments
* '''Real-time systems''' - Guarantee timing constraints for safety-critical tasks
* '''Machine learning''' - Neural networks for perception and control

'''Unlocks''':
* [[Capability:Camera Vision]] (image processing, object detection)
* [[Capability:LIDAR Sensing]] (point cloud processing)
* [[Activity:Autonomous Navigation]] (mapping, path planning, obstacle avoidance)
* [[Activity:Object Manipulation]] (vision-guided grasping)
* Multi-robot coordination and swarm behaviors

'''Tutorials''': [[ROS Basics]], [[OpenCV for Robotics]], [[Docker for Robots]]

'''At this level you can''':
* Build ROS-based systems with multiple nodes
* Implement computer vision algorithms with OpenCV
* Deploy robot software in Docker containers
* Design path planning and navigation algorithms
* Integrate machine learning models for perception
* Build real-time control systems
* Manage complex multi-process robotic systems

== Learning Paths ==

=== Path 1: MicroPython Beginner (SimpleBot) ===
# Start with [[MicroPython Basics]] - Learn Python, GPIO, and basic control
# Build [[SimpleBot]] - Apply programming to a real robot
# Complete [[MicroPython Programming]] - Learn interrupts, PWM, and I2C

'''Result''': You can program SimpleBot and implement basic robot behaviors.

=== Path 2: Embedded Systems Developer (Intermediate) ===
# Complete Path 1 (MicroPython Beginner)
# Study [[State Machine Design]] - Organize complex behaviors
# Implement [[Behavior:PID Control]] - Closed-loop motor control
# Add advanced sensors (IMU, encoders) to your robot

'''Result''': You can write sophisticated control algorithms and handle multiple sensors.

=== Path 3: Autonomous Robotics Engineer (Advanced) ===
# Complete Path 2 (Embedded Systems Developer)
# Learn [[ROS Basics]] - Distributed robotics framework
# Study [[OpenCV for Robotics]] - Computer vision for perception
# Build a robot with camera-based navigation

'''Result''': You can build autonomous robots with vision, mapping, and planning capabilities.

== Essential Concepts ==

=== Programming Fundamentals ===
* '''Variables''' - Store sensor readings, motor states, calculated values
* '''Functions''' - Organize code into reusable blocks (read_sensor, drive_forward)
* '''Loops''' - Repeat actions (while True: read sensors, decide, act)
* '''Conditionals''' - Make decisions (if line_detected: turn_left)

=== Hardware Control ===
* '''Digital I/O''' - Read HIGH/LOW from sensors, write HIGH/LOW to motors
* '''Analog I/O''' - Read variable voltages with ADC (battery level, photoresistor)
* '''PWM''' - Generate pulse-width modulation for motor speed, servo position
* '''Interrupts''' - Respond immediately to events (encoder pulse, button press)

=== Communication Protocols ===
* '''I2C''' - Communicate with sensors (IMU, distance sensor, OLED display)
* '''SPI''' - High-speed communication (SD card, some sensors)
* '''UART/Serial''' - Debug output, GPS modules, Bluetooth communication

=== Control Structures ===
* '''State machines''' - Organize behaviors with states (SEARCHING, FOLLOWING, TURNING)
* '''PID control''' - Closed-loop control for speed, position, line following
* '''Sensor fusion''' - Combine multiple sensors for robust measurements
* '''Event-driven programming''' - Respond to interrupts, timers, external events

=== Debugging Techniques ===
* '''Print debugging''' - Print sensor values, state transitions to serial console
* '''LED indicators''' - Visual feedback for program state (blinking patterns)
* '''REPL testing''' - Test functions interactively before running full program
* '''Oscilloscope/logic analyzer''' - Visualize PWM signals, I2C communication

== Tools and Equipment ==

=== Essential Tools (Start Here) ===
* '''Text editor or IDE''' (Free) - Thonny (recommended for beginners), VS Code, Mu Editor
* '''USB cable''' ($2-5) - Connect microcontroller to computer
* '''Microcontroller''' ($4-10) - Raspberry Pi Pico (MicroPython), ESP32, Arduino
* '''Serial terminal''' (Free, built into IDE) - View debug output, REPL interaction

=== Intermediate Tools ===
* '''Version control''' (Free) - Git and GitHub for code management
* '''Logic analyzer''' ($10-60) - Debug I2C, SPI, UART communication
* '''Oscilloscope''' ($100-400) - Visualize PWM, timing, analog signals
* '''Debugger''' ($10-50) - Hardware debugger for stepping through code

=== Advanced Tools ===
* '''Single-board computer''' ($35-100) - Raspberry Pi for ROS, OpenCV
* '''Development board''' ($50-200) - Jetson Nano for computer vision, neural networks
* '''Docker''' (Free) - Container platform for reproducible environments
* '''ROS''' (Free) - Robot Operating System for distributed robotics

== Common Pitfalls ==

* '''Blocking delays''' - Using time.sleep() prevents interrupt handling and responsiveness
* '''Floating-point errors''' - Use integers for encoder counts, careful with division
* '''Race conditions''' - Interrupts can modify variables during main loop calculations
* '''Uninitialized variables''' - Always initialize variables before using them
* '''Infinite loops without exit''' - Always include a way to stop or reset your program
* '''Ignoring hardware timing''' - I2C/SPI require specific timing, PWM frequency affects motors
* '''Memory leaks''' - MicroPython has limited RAM; avoid creating objects in tight loops

== Programming Environments ==

=== MicroPython (Beginner-Friendly) ===
* '''Platforms''': Raspberry Pi Pico, ESP32, PyBoard
* '''Pros''': Easy to learn, interactive REPL, extensive libraries
* '''Cons''': Slower than C/C++, limited RAM
* '''Best for''': SimpleBot, learning robotics, rapid prototyping

=== Arduino (C/C++) (Popular) ===
* '''Platforms''': Arduino Uno, Nano, Mega, ESP32, Teensy
* '''Pros''': Fast execution, huge community, extensive libraries
* '''Cons''': Steeper learning curve, less interactive
* '''Best for''': Performance-critical tasks, larger community support

=== Python on SBC (Advanced) ===
* '''Platforms''': Raspberry Pi, Jetson Nano, Rock Pi
* '''Pros''': Full Python ecosystem (NumPy, OpenCV, ROS), multitasking
* '''Cons''': Not real-time, more expensive hardware
* '''Best for''': Computer vision, ROS, complex algorithms

=== ROS (Robot Operating System) (Advanced) ===
* '''Platforms''': Linux on SBC (Raspberry Pi, Jetson, x86)
* '''Pros''': Distributed system, reusable nodes, rich ecosystem
* '''Cons''': Steep learning curve, complex setup
* '''Best for''': Multi-sensor robots, navigation, manipulation

== Tutorials and Resources ==

=== BRS Tutorials ===
* '''[[MicroPython Basics]]''' (Beginner) - Start here if you're new to programming
* '''[[MicroPython Programming]]''' (Intermediate) - Interrupts, PWM, I2C, state machines
* '''[[State Machine Design]]''' (Intermediate) - Organize complex behaviors
* '''[[ROS Basics]]''' (Advanced) - Distributed robotics framework
* '''[[OpenCV for Robotics]]''' (Advanced) - Computer vision for perception

=== Implementation Pages ===
* [[SimpleBot:Line Following Implementation]] - Complete MicroPython code
* [[SimpleBot:Dead Reckoning Implementation]] - Encoder counting and odometry

=== External Resources ===
* [https://docs.micropython.org/ MicroPython Documentation] - Official reference
* [https://projects.raspberrypi.org/en/projects/getting-started-with-the-pico Raspberry Pi Pico Guide] - Getting started
* [https://www.arduino.cc/reference/en/ Arduino Language Reference] - C/C++ for Arduino
* [https://wiki.ros.org/ROS/Tutorials ROS Tutorials] - Robot Operating System
* [https://docs.opencv.org/4.x/d6/d00/tutorial_py_root.html OpenCV Python Tutorials] - Computer vision

== Related Competencies ==

* '''[[Electronics]]''' - Understand the hardware that software controls
* '''[[Mechanics]]''' - Design the physical systems that software commands
* '''[[Soldering]]''' - Build the circuits that software interfaces with
* '''[[3D Printing]]''' - Create robot chassis to mount sensors and actuators

== Example Programs ==

=== Blink LED (Hello World) ===
<syntaxhighlight lang="python">
from machine import Pin
import time

led = Pin(25, Pin.OUT) # Raspberry Pi Pico onboard LED

while True:
led.toggle()
time.sleep(0.5) # 0.5 seconds
</syntaxhighlight>

=== Read Button, Control LED ===
<syntaxhighlight lang="python">
from machine import Pin

button = Pin(14, Pin.IN, Pin.PULL_UP) # Active LOW button
led = Pin(25, Pin.OUT)

while True:
if button.value() == 0: # Button pressed (LOW)
led.on()
else:
led.off()
</syntaxhighlight>

=== PWM Motor Speed Control ===
<syntaxhighlight lang="python">
from machine import Pin, PWM

motor_pwm = PWM(Pin(16))
motor_pwm.freq(1000) # 1 kHz PWM frequency

# 50% speed
motor_pwm.duty_u16(32768) # 50% of 65535 (16-bit)

# 75% speed
motor_pwm.duty_u16(49152) # 75% of 65535
</syntaxhighlight>

=== Interrupt-Driven Encoder ===
<syntaxhighlight lang="python">
from machine import Pin

encoder_count = 0

def encoder_callback(pin):
global encoder_count
encoder_count += 1

encoder = Pin(15, Pin.IN, Pin.PULL_UP)
encoder.irq(trigger=Pin.IRQ_RISING, handler=encoder_callback)

# Count pulses while doing other work
while True:
print(f"Count: {encoder_count}")
time.sleep(1)
</syntaxhighlight>

== See Also ==

* [[Capabilities]] - Software enables all robot capabilities
* [[Behaviors]] - Algorithms that software implements
* [[SimpleBot]] - Apply software knowledge to build a robot
* [[Robotics Ontology]] - How software fits into the BRS knowledge structure

[[Category:Competencies]]
[[Category:Skills]]

KiCad Tutorial

2025-10-11T20:14:29Z

John: Created page with "{{Tutorial |name=KiCad Tutorial |competency=PCB Design |difficulty=Beginner |time=3-6 hours (spread across multiple sessions) |prerequisites=Electronics Fundamentals - Understanding of circuits, components, schematics |materials=KiCad (free download), computer, practice project (LED breakout board) |next_steps=Design custom board for your robot, study SimpleBot PCB design, order boards from JLCPCB }} '''KiCad Tutorial''' is your complete guide to designing y..."

{{Tutorial
|name=KiCad Tutorial
|competency=[[PCB Design]]
|difficulty=Beginner
|time=3-6 hours (spread across multiple sessions)
|prerequisites=[[Electronics Fundamentals]] - Understanding of circuits, components, schematics
|materials=KiCad (free download), computer, practice project (LED breakout board)
|next_steps=Design custom board for your robot, study [[SimpleBot]] PCB design, order boards from JLCPCB
}}

'''KiCad Tutorial''' is your complete guide to designing your first printed circuit board (PCB) from start to finish. This tutorial walks you through KiCad, a free and powerful PCB design tool, using a simple LED breakout board project.

By the end of this tutorial, you'll:
* Install and configure KiCad
* Create a schematic with components and connections
* Assign footprints to components
* Layout a PCB with proper trace routing
* Generate Gerber files for manufacturing
* Order your PCB from an online manufacturer

This tutorial is '''hands-on'''. You'll design a complete, manufacturable PCB that you can order and assemble.

== Part 1: Installing KiCad ==

=== Download and Install ===

# Visit [https://www.kicad.org/download/ KiCad Downloads]
# Download the latest stable version for your operating system
# Run the installer (accept defaults)
# Launch KiCad

'''Note''': This tutorial uses KiCad 7.x or 8.x. Interface may differ slightly in older versions.

=== First Launch Setup ===

When you first launch KiCad:
# Select default library paths (click OK/Next)
# KiCad will download symbol and footprint libraries (this may take a few minutes)
# You'll see the KiCad project manager window

=== Understanding KiCad's Interface ===

KiCad has several tools (all launched from the project manager):
* '''Schematic Editor''' - Draw circuit diagrams
* '''Symbol Editor''' - Create/edit component symbols
* '''PCB Editor''' - Layout physical board
* '''Footprint Editor''' - Create/edit component footprints
* '''Gerber Viewer''' - Preview manufacturing files

'''Workflow''': Schematic → Footprint Assignment → PCB Layout → Gerber Export

== Part 2: Creating a New Project ==

=== Project: LED Breakout Board ===

We'll design a simple LED breakout board:
* '''Input''': 5V and GND via screw terminal
* '''Components''': Current-limiting resistor, LED, header pins for output
* '''Output''': LED indicator, 5V/GND headers for connecting to other boards

This teaches fundamental PCB design skills without overwhelming complexity.

=== Create the Project ===

# Click '''File → New Project'''
# Name it: <code>led_breakout</code>
# Choose a location to save it
# Click '''Create'''

You'll see two files created:
* <code>led_breakout.kicad_sch</code> - Schematic file
* <code>led_breakout.kicad_pcb</code> - PCB layout file

== Part 3: Schematic Design ==

=== Launch the Schematic Editor ===

# Double-click <code>led_breakout.kicad_sch</code> in the project manager
# You'll see a blank grid with a title block in the corner

=== Adding Components (Symbols) ===

We need these components:
* 1× LED
* 1× Resistor (220Ω)
* 1× Screw terminal (2-position)
* 1× Pin header (1×3, for 5V/LED/GND output)
* Power symbols (VCC, GND)

'''Adding the LED:'''
# Press '''A''' (Add symbol shortcut) or click the "Place Symbol" icon
# Type "LED" in the search box
# Select '''Device:LED''' from the list
# Click to place it on the schematic (middle of the grid)
# Press '''ESC''' to exit placement mode

'''Adding the resistor:'''
# Press '''A''' again
# Type "R" in the search box
# Select '''Device:R''' (resistor)
# Place it to the left of the LED
# Press '''ESC'''

'''Adding the screw terminal:'''
# Press '''A'''
# Type "screw terminal" or "conn_01x02"
# Select '''Connector:Screw_Terminal_01x02''' (2-position terminal)
# Place it on the far left
# Press '''ESC'''

'''Adding the output header:'''
# Press '''A'''
# Type "conn_01x03"
# Select '''Connector_Generic:Conn_01x03''' (3-pin header)
# Place it on the far right
# Press '''ESC'''

'''Adding power symbols:'''
# Press '''P''' (Power symbol shortcut)
# Type "VCC"
# Select '''power:VCC'''
# Place above the screw terminal
# Press '''P''' again
# Type "GND"
# Select '''power:GND'''
# Place below the screw terminal and near the LED

Your schematic should have: screw terminal (left) → resistor → LED → header (right), with VCC/GND symbols.

=== Connecting Components (Wiring) ===

Now connect the components with wires (nets):

# Press '''W''' (Wire tool) or click "Place Wire" icon
# Click on the screw terminal pin 1 (top pin)
# Click on the VCC symbol (creates a connection)
# Press '''ESC''' to exit wire mode

Repeat for all connections:
* Screw terminal pin 1 → VCC symbol
* Screw terminal pin 2 → GND symbol (bottom)
* VCC → Resistor pin 1 (left side)
* Resistor pin 2 (right side) → LED anode (top pin, triangle side)
* LED cathode (bottom pin, bar side) → GND
* VCC → Header pin 1
* LED anode → Header pin 2 (LED output)
* GND → Header pin 3

'''Tips:'''
* Wires connect when you click directly on a pin (pink circle appears)
* Press '''ESC''' to cancel wire placement
* Move components with '''M''' (grab and move)

=== Annotating Components ===

Components need unique reference designators (R1, D1, J1):

# Click '''Tools → Annotate Schematic'''
# Click '''Annotate''' button (uses defaults)
# Click '''Close'''

Your components now have designators:
* J1 (screw terminal)
* R1 (resistor)
* D1 (LED)
* J2 (header)

=== Setting Component Values ===

Assign values to resistor and LED:

# Hover over R1 and press '''V''' (Value shortcut)
# Type "220" (220 ohms)
# Press '''Enter'''
# Hover over D1 and press '''V'''
# Type "Red LED" or just "LED"
# Press '''Enter'''

=== Adding Title Block Information ===

# Click '''File → Page Settings'''
# Fill in:
** Title: "LED Breakout Board"
** Date: (auto-filled)
** Revision: "1.0"
** Company: (your name or "BRS")
# Click '''OK'''

=== Electrical Rules Check (ERC) ===

Check for errors before moving to PCB layout:

# Click '''Inspect → Electrical Rules Checker'''
# Click '''Run ERC'''
# Review any errors or warnings
# Fix errors (warnings about unused pins are usually OK)
# Click '''Close'''

'''Common errors:'''
* Unconnected pins - Make sure all wires connect to pins (pink circle at connection)
* Missing power flags - Can ignore for this simple circuit

=== Save Your Schematic ===

# Press '''Ctrl+S''' or click '''File → Save'''

Your schematic is complete! Next: assign footprints.

== Part 4: Footprint Assignment ==

=== Understanding Footprints ===

'''Schematic symbols''' show logical connections (how components connect).
'''Footprints''' show physical layout (where pads/holes are on the PCB).

Each component needs a footprint:
* LED → 5mm through-hole LED footprint
* Resistor → Axial resistor footprint
* Screw terminal → 5mm pitch screw terminal
* Header → 2.54mm pin header

=== Open Footprint Assignment Tool ===

# In schematic editor, click '''Tools → Assign Footprints'''
# You'll see a list of components on the left, libraries in the middle, footprints on the right

=== Assigning Footprints ===

For each component, select it (left column), then double-click the footprint (right column):

'''J1 (Screw Terminal):'''
# Select J1 in left column
# Middle column: scroll to '''TerminalBlock_Phoenix'''
# Right column: double-click '''TerminalBlock_Phoenix_MKDS-1,5-2_1x02_P5.00mm_Horizontal'''
# This is a 2-position, 5mm pitch screw terminal

'''R1 (Resistor):'''
# Select R1
# Middle column: scroll to '''Resistor_THT'''
# Right column: double-click '''R_Axial_DIN0207_L6.3mm_D2.5mm_P10.16mm_Horizontal'''
# This is a standard through-hole resistor footprint

'''D1 (LED):'''
# Select D1
# Middle column: scroll to '''LED_THT'''
# Right column: double-click '''LED_D5.0mm'''
# This is a standard 5mm LED footprint

'''J2 (Header):'''
# Select J2
# Middle column: scroll to '''Connector_PinHeader_2.54mm'''
# Right column: double-click '''PinHeader_1x03_P2.54mm_Vertical'''
# This is a 3-pin, 2.54mm pitch (0.1") header

=== Verify Assignments ===

All components should now have footprints listed in the left column. If any show "No Footprint", assign one.

# Click '''OK''' to save footprint assignments
# Close the footprint assignment window

=== Save and Update PCB ===

# In schematic editor, press '''Ctrl+S''' to save
# Click '''Tools → Update PCB from Schematic''' (or press '''F8''')
# Click '''Update PCB'''
# Click '''Close'''

This generates a netlist and sends it to the PCB editor.

== Part 5: PCB Layout ==

=== Open PCB Editor ===

# In project manager, double-click <code>led_breakout.kicad_pcb</code>
# You'll see a blank workspace

=== Import Components from Schematic ===

If you followed the "Update PCB from Schematic" step, components should already be imported. If not:

# In PCB editor, click '''Tools → Update PCB from Schematic'''
# Click '''Update PCB'''
# All components appear in a cluster near the origin

=== Setting Up the Board ===

Before placing components, set up the PCB:

'''Set design rules:'''
# Click '''File → Board Setup'''
# Left panel: click '''Constraints'''
# Set minimum values (for JLCPCB/PCBWay standard):
** Minimum Clearance: 0.2mm
** Minimum Track Width: 0.2mm
** Minimum Via Diameter: 0.8mm
** Minimum Via Drill: 0.4mm
# Click '''OK'''

'''Select layers:'''
For this beginner project, use 2 layers (F.Cu = top, B.Cu = bottom).

=== Drawing the Board Outline ===

Define the physical board shape:

# Select '''Edge.Cuts''' layer (dropdown in top toolbar)
# Click '''Draw a Rectangle''' tool (right toolbar)
# Click to start at (0, 0)
# Click to end at (40mm, 25mm) - creates a 40mm × 25mm rectangle
# This is your board outline

'''Tips:'''
* Grid helps with alignment (default 1mm is fine)
* Switch to '''mm''' units if needed (bottom status bar)

=== Placing Components ===

Arrange components logically on the board:

# Switch to '''F.Cu''' layer (top copper)
# Press '''M''' (move) and click a component to move it
# Press '''R''' while moving to rotate component

'''Suggested layout:'''
* J1 (screw terminal) - Left edge, centered vertically
* R1 (resistor) - Middle, horizontal orientation
* D1 (LED) - Right of resistor, vertical orientation
* J2 (header) - Right edge, vertical

'''Layout strategy:'''
* Inputs (screw terminal) on one side
* Outputs (header) on opposite side
* Flow left-to-right matches schematic

=== Routing Traces (Connecting Components) ===

'''Ratsnest lines''' (thin white lines) show which pads need to be connected.

# Select '''F.Cu''' layer
# Press '''X''' (Route tracks tool)
# Click on a pad to start a trace
# Follow the ratsnest line to the destination pad
# Click on destination pad to complete connection
# Press '''ESC''' to finish

Route all connections:
* J1 pin 1 → R1 left pad (this is the VCC net)
* R1 right pad → D1 anode (top pad)
* D1 cathode → J1 pin 2 (GND net)
* Branch VCC to J2 pin 1
* Branch LED anode to J2 pin 2
* Branch GND to J2 pin 3

'''Trace width:'''
* For this low-current circuit, default 0.25mm traces are fine
* To change: Press '''W''' while routing to cycle through widths

'''Tips:'''
* Route on F.Cu (top) layer when possible
* Use vias to switch layers if traces cross (press '''V''' while routing)
* Press '''/''' while routing to switch between 45° and free-angle modes

=== Adding a Ground Plane (Copper Pour) ===

A ground plane improves power distribution and reduces noise:

# Select '''F.Cu''' layer
# Press '''Ctrl+Shift+Z''' (Add filled zone tool) or click "Add Filled Zone" icon
# Click to start zone around the board edge
# Follow the board outline (click each corner)
# Double-click to close the zone
# In the dialog:
** Net: select '''GND'''
** Clearance: 0.3mm
** Minimum width: 0.2mm
# Click '''OK'''

The ground plane fills all unused copper with GND connection.

# Press '''B''' to rebuild all copper zones

Repeat for bottom layer (B.Cu) if desired (also connect to GND).

=== Adding Mounting Holes ===

Mounting holes let you attach the PCB to a chassis:

# Press '''Ctrl+Shift+A''' (Add footprint) or click "Add Footprint" icon
# Type "MountingHole"
# Select '''MountingHole:MountingHole_3.2mm_M3'''
# Place in four corners (inside the board outline)

Press '''ESC''' when done.

=== Adding Text (Silkscreen) ===

Add labels to identify the board:

# Select '''F.Silkscreen''' layer (front silkscreen)
# Press '''Ctrl+Shift+T''' (Add text) or click "Add Text" icon
# Type "LED Breakout v1.0"
# Click to place near top edge
# Press '''ESC'''

Add polarity labels:
* "+" near VCC connections
* "-" near GND connections
* "LED OUT" near J2 pin 2

'''Tips:'''
* Keep silkscreen text away from pads (0.5mm clearance)
* Use F.Silkscreen for top, B.Silkscreen for bottom

=== Design Rule Check (DRC) ===

Check for errors before manufacturing:

# Click '''Inspect → Design Rules Checker'''
# Click '''Run DRC'''
# Review errors and warnings:
** Errors (red) - Must fix
** Warnings (yellow) - Review, may be OK
# Fix any errors:
** Traces too close? Reroute with more spacing
** Unconnected nets? Route missing traces
# Re-run DRC until no errors
# Click '''Close'''

=== 3D Preview ===

View your board in 3D:

# Click '''View → 3D Viewer''' (or press '''Alt+3''')
# Rotate view with mouse (left-click drag)
# Inspect component placement and board appearance
# Close 3D viewer when satisfied

== Part 6: Generating Gerber Files ==

=== Understanding Gerber Files ===

'''Gerber files''' are the industry-standard format for PCB manufacturing. They describe:
* Copper layers (traces and pads)
* Soldermask (green coating)
* Silkscreen (white text)
* Board outline (cut shape)
* Drill holes

=== Exporting Gerbers ===

# In PCB editor, click '''File → Fabrication Outputs → Gerbers (.gbr)'''
# In the dialog:
** Output directory: <code>gerbers/</code>
** Layers to export: Check these:
*** F.Cu (front copper)
*** B.Cu (back copper)
*** F.Paste (front solder paste - optional)
*** B.Paste (back solder paste - optional)
*** F.Silkscreen (front silkscreen)
*** B.Silkscreen (back silkscreen)
*** F.Mask (front soldermask)
*** B.Mask (back soldermask)
*** Edge.Cuts (board outline)
** Format: 4.6, unit mm (defaults are fine)
** Check "Use Protel filename extensions" (JLCPCB/PCBWay prefer this)
# Click '''Plot'''
# Click '''Generate Drill Files'''
** Format: Excellon (default)
** Units: Millimeters
** Zeros: Decimal format
# Click '''Generate Drill File'''
# Click '''Close'''

You now have Gerber files in the <code>gerbers/</code> folder.

=== Zipping Gerber Files ===

Manufacturers need all Gerbers in a single ZIP file:

# Navigate to your project folder → <code>gerbers/</code> subfolder
# Select all .gbr and .drl files
# Right-click → Send to → Compressed (zipped) folder
# Name it: <code>led_breakout_gerbers.zip</code>

This ZIP file is ready to upload to a manufacturer.

== Part 7: Ordering Your PCB ==

=== Choosing a Manufacturer ===

Recommended beginner-friendly manufacturers:
* '''JLCPCB''' - $2 for 5 boards, fast shipping (1-2 weeks)
* '''PCBWay''' - Similar pricing, good quality
* '''OSH Park''' - USA-based, $5 per sq inch, purple boards

This tutorial uses JLCPCB (most popular for hobbyists).

=== Ordering from JLCPCB ===

# Visit [https://jlcpcb.com/ JLCPCB.com]
# Click '''Instant Quote'''
# Click '''Add Gerber File''' and upload <code>led_breakout_gerbers.zip</code>
# JLCPCB auto-detects settings:
** Size: 40mm × 25mm (from your board outline)
** Layers: 2
** Quantity: 5 boards (default minimum)
# Select options:
** PCB Color: Green (cheapest), or choose Blue/Red/Black (+$2)
** Surface Finish: HASL (default, fine for through-hole)
** PCB Thickness: 1.6mm (default)
# Review price (typically $2-5 for 5 boards)
# Add shipping (varies by location, $5-20)
# Click '''Save to Cart'''
# Checkout and pay

=== Waiting for Delivery ===

* Production: 1-3 days
* Shipping: 1-2 weeks (standard), 3-7 days (expedited)
* Tracking: Emailed when shipped

== Part 8: Assembling Your PCB ==

When your boards arrive:

=== Gather Components ===

Order components to match your design:
* 1× 220Ω resistor (1/4W through-hole)
* 1× 5mm red LED
* 1× 2-position 5mm screw terminal
* 1× 1×3 pin header (2.54mm pitch)

'''Where to buy:'''
* Mouser, Digikey (exact parts, fast shipping, minimum order fees)
* Amazon, eBay (component kits, slower shipping, no fees)

=== Soldering Components ===

Follow [[Soldering]] tutorial for technique. Assembly order:

# '''Resistor''' - Bend leads, insert, solder, trim
# '''LED''' - Mind polarity! Long leg = anode (+), short leg = cathode (-)
# '''Screw terminal''' - Insert, solder (requires more heat)
# '''Pin header''' - Insert, solder

=== Testing ===

# Connect 5V power supply to screw terminal (+ to top, - to bottom)
# LED should light up
# Measure voltage at header pins with multimeter:
** Pin 1: ~5V (VCC)
** Pin 2: ~2V (LED forward voltage)
** Pin 3: 0V (GND)

'''Troubleshooting:'''
* LED not lighting? Check polarity, test LED separately
* No voltage? Check solder joints for cold joints (dull, not shiny)
* Short circuit? Check for solder bridges between pads

== Part 9: Next Steps ==

Congratulations! You've designed, ordered, and assembled your first PCB. Next:

=== Design a Custom Board for Your Robot ===

Apply your skills to a real project:
* Design a sensor breakout board for [[SimpleBot]]
* Create a motor driver board
* Design a main board integrating MCU, sensors, and power

=== Study Existing Designs ===

Learn from production-quality PCBs:
* [[SimpleBot]] PCB design (files in <code>./simplebot/kicad/</code>)
** Study component placement strategy
** Observe trace routing and ground plane usage
** Note silkscreen labeling

=== Learn Advanced Techniques ===

Expand your PCB design skills:
* '''SMD components''' - Surface-mount devices for compact boards
* '''4-layer boards''' - Internal power and ground planes
* '''High-current traces''' - Calculate trace width for motor drivers
* '''Impedance control''' - High-speed signal integrity
* '''PCBA services''' - Let manufacturers assemble SMD boards

=== Share Your Design ===

Contribute to the BRS community:
* Document your PCB on the wiki
* Share KiCad files on GitHub
* Write an Implementation page
* Help others learn PCB design

== Common Beginner Mistakes ==

* '''Wrong footprint dimensions''' - Always verify footprints with calipers or datasheets before ordering
* '''Forgetting board outline''' - No Edge.Cuts layer = manufacturer can't cut your board
* '''Missing connections''' - Run DRC to find unrouted nets
* '''Traces too narrow''' - Use at least 0.2mm (wider for high current)
* '''No ground plane''' - Increases noise, makes routing harder
* '''Overlapping silkscreen''' - Text on pads won't print correctly
* '''Reversed component polarity''' - Double-check LED, capacitor, IC orientation
* '''Forgetting mounting holes''' - Can't attach board to chassis

== Troubleshooting Tips ==

* '''Ratsnest lines everywhere?''' Press '''N''' to show/hide ratsnest (airwires)
* '''Can't route a trace?''' Switch layers with '''V''' (via) or rearrange components
* '''DRC errors won't clear?''' Zoom in closely - errors are marked with small icons
* '''Gerber upload fails?''' Ensure Edge.Cuts layer is included (board outline)
* '''Board too expensive?''' Reduce size to <100mm × 100mm for cheapest pricing
* '''Components don't fit?''' Verify footprints - measure physical parts with calipers

== KiCad Keyboard Shortcuts Reference ==

=== Schematic Editor ===
* '''A''' - Add symbol (component)
* '''P''' - Add power symbol
* '''W''' - Wire (connect components)
* '''L''' - Label net (name wires)
* '''M''' - Move component
* '''R''' - Rotate component
* '''V''' - Edit value (resistor value, etc.)
* '''Ctrl+S''' - Save
* '''F8''' - Update PCB from schematic

=== PCB Editor ===
* '''M''' - Move component
* '''R''' - Rotate component
* '''X''' - Route track (trace)
* '''V''' - Add via (while routing)
* '''W''' - Change track width (while routing)
* '''/''' - Change routing mode (45° / free angle)
* '''Ctrl+Shift+Z''' - Add filled zone (copper pour)
* '''B''' - Rebuild all copper zones
* '''N''' - Toggle ratsnest display
* '''Alt+3''' - 3D viewer

== Tools and Resources ==

=== Essential Software ===
* '''KiCad''' (Free) - [https://www.kicad.org/download/ Download]
* '''PDF reader''' - View component datasheets

=== Component Suppliers ===
* '''Mouser''' - [https://www.mouser.com/ mouser.com] (USA)
* '''Digikey''' - [https://www.digikey.com/ digikey.com] (USA)
* '''LCSC''' - [https://www.lcsc.com/ lcsc.com] (China, cheap, slow shipping)

=== PCB Manufacturers ===
* '''JLCPCB''' - [https://jlcpcb.com/ jlcpcb.com] ($2 for 5 boards)
* '''PCBWay''' - [https://www.pcbway.com/ pcbway.com]
* '''OSH Park''' - [https://oshpark.com/ oshpark.com] (USA-based)

=== Learning Resources ===
* [https://docs.kicad.org/ KiCad Official Documentation]
* [https://www.youtube.com/c/Contextualelectronics Contextual Electronics] - KiCad video tutorials
* [https://www.youtube.com/playlist?list=PLy2022BX6EspFAKBCgRuEuzapuz_4aJCn Phil's Lab] - PCB design tutorials
* [https://www.eevblog.com/forum/kicad/ EEVblog KiCad Forum] - Community support

== Design Files for This Tutorial ==

If you want to compare your work or download a complete reference design:

* LED Breakout KiCad project (schematic, PCB, Gerbers)
* Available in BRS repository: <code>./pcb_examples/led_breakout/</code> (if created)

== Expanding Your Skills ==

After mastering this tutorial, try these progressively challenging projects:

=== Beginner+ ===
* '''Power indicator board''' - Add multiple LEDs, different colors
* '''Sensor breakout''' - IR sensor + headers
* '''Button array''' - 4 buttons + pull-up resistors + header

=== Intermediate ===
* '''Motor driver board''' - TB6612FNG IC + terminal blocks + logic inputs
* '''Voltage regulator board''' - LM7805 IC + capacitors + heatsink
* '''Sensor array''' - 4× IR sensors + multiplexer IC

=== Advanced ===
* '''Robot main board''' - MCU + sensors + motor driver + power (like SimpleBot)
* '''SMD practice board''' - Recreate LED breakout with 0805 resistor, SMD LED
* '''Programmable board''' - ESP32 module + USB-to-serial + sensors

== See Also ==

* [[PCB Design]] - Full competency overview
* [[Electronics]] - Understand circuits before designing PCBs
* [[Soldering]] - Assemble your PCBs after ordering
* [[SimpleBot]] - Study a production robot PCB design

[[Category:Tutorials]]
[[Category:PCB Design]]
[[Category:Beginner]]

PCB Design

2025-10-11T20:14:17Z

John: Created page with "{{Competency |name=PCB Design |description=Expressing electronics knowledge into custom circuit boards for professional, integrated robot designs |difficulty_range=Beginner to Advanced |time_to_basic=3-6 weeks |essential_tools=KiCad (free), PCB manufacturer account (JLCPCB, PCBWay) |optional_tools=Caliper for component measurements, PCB design rule checker |beginner_tutorial=KiCad Tutorial |unlocks_basic=Custom sensor breakout boards, simple robot PCBs |unlocks_advan..."

{{Competency
|name=PCB Design
|description=Expressing electronics knowledge into custom circuit boards for professional, integrated robot designs
|difficulty_range=Beginner to Advanced
|time_to_basic=3-6 weeks
|essential_tools=KiCad (free), PCB manufacturer account (JLCPCB, PCBWay)
|optional_tools=Caliper for component measurements, PCB design rule checker
|beginner_tutorial=[[KiCad Tutorial]]
|unlocks_basic=Custom sensor breakout boards, simple robot PCBs
|unlocks_advanced=Multi-layer integrated robot boards, motor controllers, high-speed designs
}}

'''PCB Design''' is the competency of translating circuit schematics and electronics knowledge into manufacturable printed circuit boards (PCBs). In robotics, custom PCBs transform breadboard prototypes into durable, compact, and professional designs. This competency specifically covers expressing goals and comprehension from [[Electronics]] into new custom boards and getting them assembled by a board house.

PCB design is distinct from [[Electronics]] (understanding how circuits work) and [[Soldering]] (assembling components onto boards). This competency focuses on '''designing''' the board itself: creating schematics, laying out traces, selecting footprints, and generating manufacturing files.

== Why PCB Design Matters for Robotics ==

Custom PCBs elevate your robot from prototype to production:
* '''Integration''' - Combine sensors, motor drivers, and microcontroller on one board
* '''Reliability''' - No loose breadboard connections or flying wires
* '''Compactness''' - Shrink your electronics to fit tight spaces
* '''Reproducibility''' - Order 5, 10, or 100 identical boards from manufacturers
* '''Professionalism''' - Clean, documented designs you can share or sell

Without PCB design skills, you're limited to pre-made modules and breadboards. With PCB design, you can create exactly the board your robot needs.

== Skill Progression ==

=== Beginner (First PCB) ===

Skills you need to design and order your first PCB:

* '''Schematic capture''' - Draw circuit diagrams in KiCad
* '''Component symbols''' - Find or create schematic symbols for parts
* '''Footprint assignment''' - Match components to their physical footprints
* '''PCB layout basics''' - Place components and route traces
* '''Design rules''' - Set trace width, clearance, via size
* '''Gerber generation''' - Export manufacturing files
* '''Ordering from manufacturers''' - Upload to JLCPCB/PCBWay, select options

'''Unlocks''':
* Simple breakout boards (sensor modules, connector adapters)
* Through-hole robot PCBs (like [[SimpleBot]] main board)
* LED circuits and indicator panels

'''Tutorials''': [[KiCad Tutorial]]

'''At this level you can''':
* Design simple 2-layer through-hole PCBs
* Order boards from online manufacturers
* Create breakout boards for sensors and modules
* Understand SimpleBot's PCB design

=== Intermediate (Production-Ready Designs) ===

Skills for designing robust, manufacturable PCBs:

* '''4-layer boards''' - Add internal power and ground planes
* '''SMD components''' - Use surface-mount devices for compact designs
* '''Trace width calculations''' - Calculate trace width for current capacity
* '''Component library management''' - Create custom symbols and footprints
* '''Design rule checks (DRC)''' - Catch errors before manufacturing
* '''Silkscreen design''' - Add labels, logos, version numbers
* '''Bill of Materials (BOM)''' - Generate parts lists for assembly
* '''PCB panelization''' - Arrange multiple boards on one panel

'''Unlocks''':
* Integrated robot main boards (MCU + sensors + motor drivers)
* Custom motor controller PCBs
* Power distribution boards with multiple voltage rails
* Compact sensor arrays

'''Tutorials''': Advanced KiCad techniques, PCB layout best practices

'''At this level you can''':
* Design compact, reliable robot PCBs
* Use SMD components to reduce board size
* Create production-ready designs with proper documentation
* Work with PCB assembly services (PCBA)

=== Advanced (High-Performance Designs) ===

Skills for specialized and high-performance PCBs:

* '''High-speed design''' - Controlled impedance, differential pairs, length matching
* '''Thermal management''' - Heat dissipation, thermal vias, copper pours
* '''EMI/EMC design''' - Shielding, filtering, grounding strategies
* '''RF design''' - Antenna design, impedance matching, transmission lines
* '''Flex and rigid-flex PCBs''' - Flexible circuits for moving parts
* '''PCB assembly optimization''' - Design for manufacturability (DFM)
* '''Multi-board systems''' - Stackable boards, connectors, modularity

'''Unlocks''':
* [[Capability:Camera Vision]] boards (high-speed data transfer)
* [[Capability:LIDAR Sensing]] controllers (motor drivers + high-bandwidth serial)
* Wireless communication boards (WiFi, Bluetooth, LoRa)
* Custom IMU boards with sensor fusion

'''At this level you can''':
* Design high-speed communication boards
* Create custom motor controllers with current sensing
* Design RF and antenna boards
* Optimize designs for cost-effective mass production

== Learning Paths ==

=== Path 1: First PCB Designer (Beginner) ===
# Complete [[Electronics Fundamentals]] - Understand circuits before designing PCBs
# Start with [[KiCad Tutorial]] - Design a simple LED or sensor breakout board
# Order your first PCB from JLCPCB (5 boards for $2 + shipping)
# Assemble and test your board

'''Result''': You can design simple 2-layer PCBs and order them from manufacturers.

=== Path 2: Robot PCB Designer (Intermediate) ===
# Complete Path 1 (First PCB Designer)
# Study [[SimpleBot]] PCB design (schematic and layout files)
# Design a custom breakout board for a sensor or module
# Learn SMD component soldering ([[Soldering]])
# Design a robot main board integrating MCU, sensors, and motor driver

'''Result''': You can design integrated robot PCBs with SMD components.

=== Path 3: Advanced PCB Designer ===
# Complete Path 2 (Robot PCB Designer)
# Study high-speed design principles (impedance control, signal integrity)
# Design a 4-layer board with internal power/ground planes
# Use PCB assembly services (PCBA) for SMD assembly
# Design a specialized board (motor controller, camera interface, RF module)

'''Result''': You can design production-ready, high-performance PCBs for any robot application.

== Essential Concepts ==

=== PCB Layers ===

PCBs are built from copper layers separated by insulating material:
* '''2-layer''' - Top and bottom copper (beginner level)
* '''4-layer''' - Top, bottom, and two internal layers (typically power and ground)
* '''6+ layers''' - High-speed designs, dense routing

'''Why more layers?'''
* Better power distribution (dedicated power planes)
* Reduced noise (solid ground plane)
* More routing space for complex designs

=== Trace Width and Current Capacity ===

Trace width determines how much current a trace can carry:
* '''Thin traces''' (0.2mm) - Signal traces, low current (<100mA)
* '''Medium traces''' (0.5mm) - General purpose (100mA - 500mA)
* '''Thick traces''' (1-2mm) - High current (1A - 3A)
* '''Copper pours''' - Very high current (5A+), heat dissipation

'''Rule of thumb''': 1mm trace width per 1A of current (for 1oz copper, typical PCB)

=== Vias ===

'''Vias''' are holes that connect copper layers:
* '''Through-hole vias''' - Connect all layers (most common)
* '''Blind vias''' - Connect outer layer to internal layer
* '''Buried vias''' - Connect internal layers only

Use vias to:
* Route traces to other layers
* Connect component pads to internal planes
* Improve heat dissipation (thermal vias)

=== Design Rules ===

Design rules ensure manufacturability:
* '''Minimum trace width''' - Typically 0.15mm - 0.2mm
* '''Minimum clearance''' - Gap between traces (typically 0.15mm - 0.2mm)
* '''Minimum via size''' - Drill diameter (typically 0.3mm)
* '''Soldermask expansion''' - Gap around pads for solder mask

Violating design rules = manufacturing errors or rejected boards

=== Footprints ===

'''Footprint''' = physical pad layout for a component:
* '''Through-hole''' - Holes for component leads (resistors, DIP ICs)
* '''SMD''' - Surface pads for surface-mount components (0805 resistors, QFN ICs)

Getting footprints right is critical:
* Wrong footprint = component doesn't fit
* Check datasheets for recommended footprints
* Test footprints with calipers before ordering

== PCB Design Workflow ==

=== Step 1: Schematic Design ===
# Start with a tested breadboard prototype
# Draw schematic in KiCad schematic editor
# Add component symbols from libraries
# Connect components with wires (nets)
# Add power symbols (VCC, GND)
# Annotate components (assign reference designators: R1, C2, U3)
# Run electrical rules check (ERC)

=== Step 2: Footprint Assignment ===
# Assign footprints to all components
# Verify footprints match physical parts (check datasheets)
# Create custom footprints if needed
# Generate netlist (connects schematic to PCB layout)

=== Step 3: PCB Layout ===
# Import netlist into PCB editor
# Define board outline (cut shape)
# Place components logically (MCU in center, connectors on edges)
# Route power traces first (wide traces for high current)
# Route signal traces
# Add ground plane (copper pour connected to GND)
# Add mounting holes for screws
# Design silkscreen labels (component names, polarity markers)

=== Step 4: Design Rule Check and Export ===
# Run design rule check (DRC) to find errors
# Fix all violations (spacing, trace width, unconnected nets)
# Generate Gerber files (manufacturing files)
# Generate drill files
# Optionally generate assembly files (BOM, pick-and-place)

=== Step 5: Manufacturing ===
# Upload Gerber files to manufacturer website
# Select options (board size, quantity, color, finish)
# Review preview and pricing
# Place order
# Wait 1-2 weeks for delivery

== Tools and Equipment ==

=== Essential Software ===
* '''KiCad''' (Free, open-source) - Full-featured PCB design suite
** Schematic editor
** PCB layout editor
** Footprint editor
** 3D viewer
** Available for Windows, Mac, Linux

=== Alternative Software ===
* '''Eagle''' (Free for hobbyists, limited board size) - Popular alternative
* '''EasyEDA''' (Free, web-based) - Integrated with JLCPCB ordering
* '''Altium Designer''' ($$$$) - Professional industry standard
* '''Fusion 360 Electronics''' (Subscription) - Integrated with CAD

'''BRS recommendation''': Use KiCad (free, powerful, no limitations)

=== Online PCB Manufacturers ===
* '''JLCPCB''' - $2 for 5 boards (100mm × 100mm), fast shipping, PCBA services
* '''PCBWay''' - Similar pricing, good quality, responsive support
* '''OSH Park''' - USA-based, purple boards, slower but high quality
* '''Seeed Studio''' - Fusion PCB service, good for prototypes

=== Physical Tools ===
* '''Caliper''' ($15-30) - Measure component dimensions for footprint verification
* '''PCB ruler''' ($5-10) - Check trace width and component spacing
* '''Magnifying glass''' ($10-20) - Inspect SMD pads and trace spacing

== Common Pitfalls ==

* '''Wrong footprints''' - Always verify footprints with datasheets and calipers before ordering
* '''Insufficient trace width''' - Narrow traces overheat and fail under high current
* '''Missing ground plane''' - Increases noise, poor power distribution
* '''No silkscreen labels''' - Difficult to assemble and debug without labels
* '''Ignoring DRC errors''' - "It'll probably work" usually means it won't
* '''Placing components too close''' - Difficult or impossible to solder
* '''Forgetting mounting holes''' - Can't attach board to robot chassis
* '''No decoupling capacitors''' - ICs behave erratically without local power filtering

== SimpleBot PCB Example ==

The [[SimpleBot]] main board is an excellent beginner-level PCB design:
* '''2-layer through-hole design''' - Easy to assemble with basic soldering skills
* '''Clear component layout''' - Components labeled and logically placed
* '''Designed in KiCad''' - Source files available in repository
* '''Motor driver integration''' - TB6612FNG motor driver IC
* '''Sensor headers''' - Connectors for line sensors and encoders
* '''Power regulation''' - MP1584 buck converter footprint

Study the SimpleBot PCB files to learn:
* How to layout a robot main board
* Component placement strategy
* Trace routing for power and signals
* Silkscreen labeling best practices

Files available at: `./simplebot/kicad/` (schematic and PCB layout)

== First PCB Project Ideas ==

Start with simple projects to build confidence:

=== Beginner Projects ===
* '''LED circuit board''' - Power LED, resistor, battery connector (learn basics)
* '''Sensor breakout board''' - IR sensor, headers, mounting holes (learn footprints)
* '''Power distribution board''' - Voltage regulator, capacitors, terminal blocks (learn power design)

=== Intermediate Projects ===
* '''Motor controller board''' - H-bridge IC, terminal blocks, logic inputs
* '''Sensor array board''' - Multiple IR sensors, multiplexer, single I2C output
* '''Robot main board''' - MCU, sensors, motor driver, power regulation (like SimpleBot)

=== Advanced Projects ===
* '''Custom IMU board''' - Accelerometer/gyro IC, level shifters, SMD components
* '''Camera interface board''' - High-speed serial, MIPI interface, impedance control
* '''Wireless module board''' - ESP32, antenna, RF design considerations

== Design for Manufacturing (DFM) ==

Make your boards easier to manufacture and assemble:

* '''Use standard components''' - Common resistor values, standard ICs
* '''Add test points''' - Pads for probing signals with multimeter/oscilloscope
* '''Label polarity''' - Mark + and - for electrolytic capacitors, diodes, connectors
* '''Add version number''' - Silkscreen text with version/date
* '''Include fiducial marks''' - Alignment marks for automated assembly
* '''Add mounting holes''' - 3mm or M3 holes in corners
* '''Keep components on one side''' - Easier assembly (both sides only if necessary)

== PCB Assembly Options ==

=== Hand Assembly (DIY) ===
* Solder components yourself
* Requires [[Soldering]] skills
* Cost: $0 (just your time)
* Best for: Through-hole, small quantities, learning

=== PCB Assembly Services (PCBA) ===
* Manufacturer assembles components onto PCB
* Requires BOM (bill of materials) and pick-and-place files
* Cost: Setup fee + component cost (economical for >10 boards)
* Best for: SMD components, production runs

'''Popular PCBA services''':
* JLCPCB Assembly - Large component library, economical for prototypes
* PCBWay Assembly - Good for custom components
* Seeed Studio - Fusion PCBA service

== Tutorials and Resources ==

=== BRS Tutorials ===
* '''[[KiCad Tutorial]]''' (Beginner) - Complete first PCB design walkthrough
* '''[[Electronics]]''' (Beginner to Advanced) - Understand circuits before designing PCBs
* '''[[Soldering]]''' (Beginner) - Assemble your PCBs after manufacturing

=== Component and Robot Pages ===
* [[SimpleBot]] - Study the PCB design (files in `./simplebot/kicad/`)
* [[TB6612FNG]] - Motor driver IC used in SimpleBot PCB
* [[Raspberry Pi Pico]] - Microcontroller footprint and pinout
* [[MP1584]] - Buck converter module for power regulation

=== External Resources ===
* [https://docs.kicad.org/ KiCad Official Documentation]
* [https://www.youtube.com/c/Contextualelectronics Contextual Electronics] - PCB design video tutorials
* [https://www.fedevel.com/welldoneblog/ Robert Feranec] - Professional PCB design tutorials
* [https://jlcpcb.com/capabilities/pcb-capabilities JLCPCB Capabilities] - Manufacturing specs and design rules
* [https://www.eevblog.com/ EEVblog] - Electronics and PCB design blog

== Related Competencies ==

* '''[[Electronics]]''' - Understand circuits before designing PCBs
* '''[[Soldering]]''' - Assemble components onto PCBs
* '''[[Software]]''' - Program the microcontrollers on your PCBs
* '''[[3D Printing]]''' - Design enclosures and mounts for your PCBs
* '''[[Mechanics]]''' - Integrate PCBs into robot chassis

== See Also ==

* [[Capabilities]] - Hardware abilities that custom PCBs enable
* [[SimpleBot]] - Example robot with custom PCB
* [[Robotics Ontology]] - How PCB design fits into the BRS knowledge structure

[[Category:Competencies]]
[[Category:Skills]]

Soldering Techniques

2025-10-11T20:13:54Z

John: Created page with "{{Tutorial |name=Soldering Techniques |competency=Soldering |difficulty=Intermediate |time=3-4 hours (practice) + 1 hour (theory) |prerequisites=Soldering Guide, experience soldering 50+ through-hole joints |materials=Temperature-controlled iron, solder, flux pen, tweezers, hot air station (optional), SMD practice board |next_steps=Custom sensor modules, PCB rework and repair, advanced motor driver assembly }} '''Soldering Techniques''' is the intermediate tutor..."

{{Tutorial
|name=Soldering Techniques
|competency=[[Soldering]]
|difficulty=Intermediate
|time=3-4 hours (practice) + 1 hour (theory)
|prerequisites=[[Soldering Guide]], experience soldering 50+ through-hole joints
|materials=Temperature-controlled iron, solder, flux pen, tweezers, hot air station (optional), SMD practice board
|next_steps=Custom sensor modules, PCB rework and repair, advanced motor driver assembly
}}

'''Soldering Techniques''' is the intermediate tutorial for surface-mount device (SMD) soldering, desoldering, and PCB rework. This tutorial covers techniques needed to assemble advanced robot PCBs, add SMD sensors, and repair damaged electronics.

By the end of this tutorial, you'll be able to:
* Hand-solder SMD resistors and capacitors (0805, 0603)
* Solder multi-pin SMD ICs using drag soldering technique
* Use hot air rework station to remove and replace SMD components
* Apply flux effectively for improved solder flow
* Desolder through-hole and SMD components without damaging PCBs
* Repair common PCB damage (lifted pads, broken traces)

This tutorial assumes you've completed [[Soldering Guide]] and are comfortable with through-hole soldering.

== Part 1: SMD Component Sizes ==

Surface-mount devices (SMD) are tiny components soldered directly to PCB pads (no through-holes).

=== Standard SMD Package Sizes ===

{| class="wikitable"
! Package !! Dimensions (mm) !! Difficulty !! Applications
|-
| '''1206''' || 3.2 × 1.6 || Easy || Beginner practice, power resistors
|-
| '''0805''' || 2.0 × 1.25 || Easy || Most common resistors/capacitors
|-
| '''0603''' || 1.6 × 0.8 || Moderate || High-density boards, standard SMD
|-
| '''0402''' || 1.0 × 0.5 || Hard || Very high density, requires magnification
|-
| '''0201''' || 0.6 × 0.3 || Very Hard || Specialized applications, microscope required
|}

'''Start with 0805''' - Large enough to handle with tweezers, small enough to develop technique.

=== IC Package Types ===

* '''SOIC''' (Small Outline IC) - 1.27mm pin pitch, relatively easy
* '''TSSOP''' (Thin Shrink Small Outline Package) - 0.65mm pitch, moderate difficulty
* '''QFP/TQFP''' (Quad Flat Pack) - 0.8mm to 0.5mm pitch, pins on all four sides
* '''QFN''' (Quad Flat No-leads) - Pads on bottom, requires hot air or reflow
* '''BGA''' (Ball Grid Array) - Solder balls on bottom, requires reflow or specialized rework

'''Start with SOIC or TSSOP''' for learning multi-pin IC soldering.

== Part 2: Essential SMD Tools ==

Beyond basic through-hole tools, SMD work requires:

=== Required Tools ===

* '''Fine-tip soldering iron''' - Chisel or conical tip (0.5-1.0mm)
* '''Tweezers''' - Fine-point or angled, non-magnetic preferred
* '''Flux pen''' - Essential for SMD work (no-clean or rosin flux)
* '''Magnifying glass or lamp''' - 2-10× magnification to see SMD components
* '''Fine solder''' - 0.5mm diameter (0.3mm for fine-pitch work)

=== Highly Recommended Tools ===

* '''Hot air rework station''' - Remove and replace SMD components ($$50-150)
* '''SMD practice board''' - Various package sizes for skill development ($10-20)
* '''Solder paste''' - Can be used with hot air instead of wire solder
* '''Anti-static mat and wrist strap''' - Protect sensitive ICs from ESD
* '''Kapton tape''' - Heat-resistant tape for masking

=== Professional Tools (Nice to Have) ===

* '''Stereo microscope''' - 10-20× magnification for fine-pitch work ($100-400)
* '''PCB preheater''' - Preheat board to reduce thermal stress ($50-200)
* '''Chip Quik low-temp solder''' - Ease removal of multi-pin ICs ($15-20)
* '''Vacuum pickup tool''' - Place tiny SMD components ($20-50)

== Part 3: Flux - The Secret Ingredient ==

Flux is even more critical for SMD work than through-hole.

=== What Flux Does ===

* '''Removes oxidation''' - Cleans metal surfaces for better wetting
* '''Improves heat transfer''' - Helps solder flow smoothly to small pads
* '''Prevents bridging''' - Solder flows to flux, making drag soldering possible
* '''Lowers surface tension''' - Allows solder to wet small SMD pads

=== Types of Flux ===

* '''Rosin flux''' (R) - Natural tree resin, mildly corrosive, common in solder cores
* '''No-clean flux''' (NC) - Leaves minimal residue, doesn't require cleaning
* '''Water-soluble flux''' (OA) - Most active, requires cleaning after soldering
* '''Tacky flux''' - Gel consistency, holds components in place while soldering

'''Recommendation''': No-clean flux pen for most SMD work (easy to apply, minimal cleanup).

=== Flux Application ===

# Apply small amount to pads before soldering
# Component will "snap" into alignment when heated (flux surface tension)
# Excess flux will smoke during soldering (normal)
# Clean residue if desired (isopropyl alcohol and brush)

'''Key principle''': When SMD soldering is difficult, add more flux!

== Part 4: SMD Resistor and Capacitor Soldering ==

The fundamental SMD technique applies to all two-terminal components.

=== The "Tack and Flow" Method ===

This is the standard approach for 0805/0603 components:

# '''Apply flux''' to both pads
# '''Tin one pad''' - Add small amount of solder to one pad
# '''Pick up component''' with tweezers (hold on sides, not ends)
# '''Position component''' on pads (alignment doesn't need to be perfect yet)
# '''Tack first side''' - Heat tinned pad, component will sink into solder
# '''Adjust alignment''' - Component will self-align if flux is present
# '''Solder second side''' - Apply iron and solder to opposite end
# '''Re-flow first side''' (optional) - Ensure good joint on both ends

=== Step-by-Step: 0805 Resistor ===

# Clean PCB pads with isopropyl alcohol
# Apply flux to both pads with flux pen
# Tin left pad: touch iron to pad, apply small amount of solder
# Pick up 0805 resistor with tweezers
# Position resistor on pads (approximately centered)
# Touch iron to left end of resistor while holding with tweezers
# Solder melts, component sinks into place
# Remove iron, hold steady 1-2 seconds
# Move iron to right end of resistor
# Apply solder wire to joint (iron touching both pad and component)
# Solder flows onto pad and component
# Remove iron and solder wire

'''Inspection''':
* Component aligned with pads (flux self-aligns if not forced)
* Solder visible on both ends (small fillet)
* No excess solder (shouldn't look like through-hole joint)

=== Common SMD Mistakes ===

'''Tombstoning''':
* Component stands on end (one side soldered before other)
* Prevention: Tack one side first, then solder opposite side
* If using hot air or reflow, ensure even heating

'''Insufficient solder''':
* Component appears to float above pad
* Add more solder - SMD joints are small but need wetting

'''Excess solder''':
* Large blob obscures component and pads
* Remove excess with solder wick

== Part 5: Multi-Pin IC Soldering (SOIC, TSSOP) ==

ICs with many pins use "drag soldering" technique.

=== Drag Soldering Method ===

Drag soldering uses flux and a flood of solder, then drags iron across pins to separate:

# '''Apply flux generously''' to all IC pads (this is critical!)
# '''Align IC''' on pads using tweezers
# '''Tack one corner pin''' - Hold IC with tweezers, solder one pin to secure IC
# '''Check alignment''' - IC should be centered on pads
# '''Tack opposite corner''' - Ensure IC doesn't shift
# '''Flood one side with solder''' - Apply solder liberally along pins (will create bridges)
# '''Drag iron across pins''' - Draw iron along pins with slight pressure
# '''Solder separates''' - Flux causes solder to "ball up" on individual pins
# '''Repeat for each side''' of IC
# '''Inspect for bridges''' - Look carefully between pins
# '''Remove bridges''' with solder wick if present

=== Why Drag Soldering Works ===

* '''Flux lowers surface tension''' - Solder prefers to ball up on pads rather than bridge
* '''Solder follows heat''' - Iron draws excess solder away from pins
* '''Much faster''' than soldering each pin individually
* '''Requires practice''' - Don't expect perfection on first attempt

=== Pin-by-Pin Alternative ===

For beginners, soldering each pin individually is slower but more controlled:

# Align and tack IC (corners first)
# Apply flux to all pins
# Touch iron to first pin and pad, apply small amount of solder
# Move to next pin, repeat
# Inspect for bridges after each side

=== Inspecting IC Solder Joints ===

Use magnifying glass to check:
* All pins have solder fillet (not dry or unsoldered)
* No bridges between adjacent pins (continuity test with multimeter if unsure)
* IC is aligned with pads (no pins floating off pads)

== Part 6: Hot Air Rework ==

Hot air stations remove and replace SMD components with heated air.

=== Hot Air Station Basics ===

* '''Temperature''' - 300-380°C for lead-free (adjust based on component size)
* '''Air flow''' - Low for small components (blown away by high flow), medium for ICs
* '''Nozzle''' - Use smallest nozzle that covers component

=== Removing SMD Components ===

# '''Apply flux''' around component
# '''Set temperature''' - 350°C for small passives, 380°C for ICs
# '''Set air flow''' - Low-medium to avoid blowing away components
# '''Heat component''' - Hold nozzle 10-20mm above component
# '''Watch solder melt''' - Solder will become shiny when molten
# '''Lift with tweezers''' - Gently tug component; if not free, heat more
# '''Clean pads''' - Remove old solder with wick or iron while still hot

=== Installing SMD Components with Hot Air ===

# '''Clean and tin pads''' (small amount of solder on each pad)
# '''Apply flux''' to pads
# '''Position component''' with tweezers
# '''Heat with hot air''' - Hold nozzle above component
# '''Solder melts''' - Component will self-align (flux surface tension)
# '''Remove heat''' when component settles into position
# '''Hold steady''' 2-3 seconds while cooling

=== Hot Air Safety ===

* '''Protect adjacent components''' - Use Kapton tape or aluminum foil shield
* '''Don't overheat''' - Plastic connectors and components can melt
* '''Burns''' - Hot air nozzle is extremely hot; never touch during or immediately after use
* '''Airflow''' - Don't direct at nearby components (can blow them off board)

== Part 7: Advanced Desoldering Techniques ==

=== Solder Wick Mastery ===

Solder wick (braid) removes excess solder effectively when used correctly:

# '''Cut fresh wick''' - Used/saturated wick doesn't absorb well
# '''Apply flux''' to wick and target solder
# '''Press wick firmly''' onto solder with iron tip
# '''Wait for solder to melt''' - Wicks into braid by capillary action
# '''Remove iron and wick together''' - Solder solidifies in wick
# '''Repeat if needed''' with fresh wick section

'''Advanced tip''': Pre-tin the wick with solder for better heat transfer, then use to remove solder.

=== Desoldering Pump Technique ===

Also called "solder sucker" - mechanical vacuum device:

# '''Heat solder joint''' until fully molten
# '''Cock pump''' spring mechanism
# '''Position tip''' close to molten solder (not touching iron)
# '''Press button''' - Creates vacuum, sucks solder into pump
# '''Clean pump chamber''' regularly (dump out collected solder)

Works best for through-hole components; less effective for SMD.

=== Removing Through-Hole ICs ===

Multi-pin through-hole ICs require special technique:

'''Method 1: Chip Quik low-temp solder'''
# Add Chip Quik (low-melt) solder to all pins
# Heat all pins with iron - Chip Quik stays molten longer
# Gently pull IC while heating multiple pins
# IC releases when all pins are molten

'''Method 2: Pin-by-pin'''
# Heat one pin, push component from other side
# Heat next pin, push component
# Alternate sides to avoid bending IC
# Requires patience - 20-30 pins takes time

'''Method 3: Cut and remove'''
# Cut IC body with cutters (destroy IC)
# Remove pins individually from PCB
# Clean holes with desoldering pump or wick
# Use when IC is already damaged

=== Removing Stubborn SMD Components ===

Some SMD parts are difficult to remove with hot air alone:

* '''Large thermal mass''' - Ground planes conduct heat away; use preheater or higher temperature
* '''Lead-free solder''' - Higher melting point; ensure hot air reaches 380°C
* '''Multiple rows of pins''' - QFP, QFN require flux and patience
* '''Adhesive''' - Some components glued in addition to soldering; may need force

== Part 8: Repairing PCB Damage ==

Mistakes and accidents cause PCB damage. Here's how to fix common issues:

=== Lifted Pad ===

Pad separated from PCB (adhesive failed from heat or force):

# '''Identify trace connection''' - Where does the pad connect?
# '''Scrape soldermask''' from trace near damaged pad
# '''Solder component directly to trace''' - Bypass lifted pad
# '''Reinforce with wire''' (if needed) - Jumper from component to nearby pad/via
# '''Test continuity''' - Verify connection with multimeter

=== Broken Trace ===

Copper trace cut or damaged:

# '''Expose trace ends''' - Scrape soldermask on both sides of break
# '''Solder jumper wire''' across break - 30AWG wire works well
# '''Secure with glue''' (optional) - CA glue or epoxy to prevent stress
# '''Test continuity''' - Verify repair with multimeter

=== Missing Pad ===

Pad completely removed from PCB:

# '''Find nearest via or pad''' on same net
# '''Run jumper wire''' from component to via/pad
# '''Secure component''' with CA glue (won't have mechanical strength from pad)
# '''Test connection''' with multimeter

=== Bridged Pins Under IC ===

Solder bridge you can't access:

# '''Add flux''' around IC
# '''Re-flow with hot air''' - Heat IC until solder melts
# '''Flux should separate bridge''' (surface tension pulls solder to individual pins)
# '''Alternative''': Remove IC, clean pads with wick, reinstall IC

== Part 9: Practice Projects ==

Build skills with these progressive exercises:

=== Exercise 1: SMD Resistors (0805 → 0603) ===

'''Materials''': SMD practice board or breakout board, 0805 and 0603 resistors

# Solder 10× 0805 resistors using tack-and-flow method
# Inspect each joint - proper alignment? Solder on both ends?
# Solder 10× 0603 resistors (smaller, requires more precision)
# Remove and replace 5× resistors with hot air (if available)

'''Goal''': Consistent SMD joints, confidence with small components.

=== Exercise 2: SOIC IC (8-pin or 16-pin) ===

'''Materials''': SOIC practice board, 8-pin or 16-pin SOIC chip

# Apply flux to all pads
# Align and tack IC (opposite corners)
# Drag solder one side of IC
# Inspect for bridges
# Remove bridges with solder wick if present
# Repeat for remaining sides

'''Goal''': Successful drag soldering with no bridges.

=== Exercise 3: SMD Motor Driver Assembly ===

'''Materials''': TB6612FNG breakout board kit (SparkFun, Adafruit) or similar

# Assemble complete SMD board from kit
# Includes various SMD component sizes and IC
# Demonstrates real-world application
# Test functionality when complete

'''Goal''': Fully functional assembled board.

=== Exercise 4: Desoldering and Rework ===

'''Materials''': Old/broken PCB or previous practice boards

# Remove 10× SMD components with hot air
# Remove 10× SMD components with iron and tweezers
# Remove through-hole IC with Chip Quik or pin-by-pin
# Clean pads with solder wick
# Reinstall components

'''Goal''': Proficiency with removal and replacement.

== Part 10: Quality Control ==

=== Visual Inspection ===

Inspect SMD joints under magnification:
* ☐ Solder visible on all component ends/pins
* ☐ No bridges between adjacent pins
* ☐ Components aligned with pads (not crooked)
* ☐ No excess solder obscuring component markings
* ☐ No missing joints (all pins soldered)

=== Electrical Testing ===

* '''Continuity''' - Test connections with multimeter
* '''No shorts''' - Check adjacent pins for bridges
* '''Power rails''' - Verify no shorts between power and ground
* '''Functional test''' - Power up board and test operation

=== Common SMD Defects ===

* '''Dry joint''' - Solder didn't wet pad or component
* '''Insufficient solder''' - Joint looks weak or incomplete
* '''Bridging''' - Adjacent pins connected by solder
* '''Tombstoning''' - Component standing on end
* '''Misalignment''' - Component not centered on pads
* '''Cold joint''' - Dull, grainy appearance

== Part 11: Real-World Applications ==

=== Motor Driver Boards ===

Many advanced motor drivers use SMD components:
* TB6612FNG breakout (SparkFun)
* DRV8833 (Pololu, Adafruit)
* TMC2209 stepper drivers

'''Skills required''':
* 0805 resistors and capacitors
* SOIC or TSSOP motor driver IC
* Through-hole terminal blocks

=== Sensor Modules ===

Custom sensor breakout boards:
* IMU sensors (MPU6050, BNO055)
* Time-of-flight sensors (VL53L0X)
* Optical encoders

'''Skills required''':
* Fine-pitch SMD (0603 or smaller)
* I2C pull-up resistors
* Decoupling capacitors near IC

=== Robot PCBs ===

Complete robot control boards combine through-hole and SMD:
* Microcontroller (QFP or QFN package)
* Power regulation (SMD buck converters)
* Sensor headers (through-hole)
* Motor terminals (through-hole)

== Part 12: Troubleshooting ==

=== Problem: Component Won't Stay in Place ===
* '''Cause''': Insufficient flux or solder on first pad
* '''Fix''': Apply flux, re-tin pad with more solder, try again

=== Problem: Solder Bridges Keep Forming ===
* '''Cause''': Too much solder or insufficient flux
* '''Fix''': Use less solder, apply more flux, use solder wick to remove excess

=== Problem: Component Floats Off Pads When Heated ===
* '''Cause''': Solder on both pads melts simultaneously (hot air or reflow)
* '''Fix''': Use tack-and-flow method (iron) instead, or hold component with tweezers during reflow

=== Problem: Can't See What I'm Doing ===
* '''Cause''': Components too small for unaided vision
* '''Fix''': Use magnifying lamp (2-10×) or microscope for 0603 and smaller

=== Problem: Lifted Pad ===
* '''Cause''': Excessive heat or force during soldering/desoldering
* '''Fix''': Solder to trace instead (see Part 8)

=== Problem: IC Pins Not Aligned with Pads ===
* '''Cause''': IC shifted while tacking corner pins
* '''Fix''': Re-heat corner pins, reposition IC with tweezers while molten

== Part 13: Skills Checklist ==

By now, you should be able to:

* ☐ Hand-solder 0805 SMD components consistently
* ☐ Hand-solder 0603 SMD components with magnification
* ☐ Use flux effectively to improve solder flow
* ☐ Drag solder SOIC or TSSOP ICs without bridges
* ☐ Remove SMD components with hot air station
* ☐ Install SMD components with hot air
* ☐ Remove excess solder with solder wick
* ☐ Repair lifted pads and broken traces
* ☐ Inspect SMD joints under magnification
* ☐ Test assembled boards for shorts and continuity

If you can check most of these boxes, you're ready for advanced SMD assembly projects!

== Next Steps ==

=== Advanced Projects ===
* Design and assemble custom sensor modules
* Build SMD motor driver board from scratch
* Rework and repair commercial electronics
* Assemble fine-pitch (0.5mm) QFP chips

=== Advanced Learning ===
* Reflow soldering (oven or hot plate)
* Solder paste stencils and application
* BGA rework and X-ray inspection
* IPC-A-610 certification (industry soldering standard)

=== BRS Applications ===
* Add IMU sensor breakout to SimpleBot
* Build custom motor driver with current sensing
* Design integrated robot PCB with SMD components

== Common Intermediate Mistakes ==

* '''Insufficient flux for SMD''' - Add more flux than you think you need
* '''Hot air too close''' - Hold nozzle 10-20mm above, not touching component
* '''Rushing drag soldering''' - Take time to apply flux generously first
* '''Wrong hot air temperature''' - Too low = won't melt, too high = damaged components
* '''Excess force on SMD components''' - Lift pads easily; use heat, not force
* '''Not checking for bridges''' - Always inspect multi-pin ICs under magnification

== Tools and Resources ==

=== Recommended Purchases for Intermediate Work ===
* '''Hot air station''' - 858D or QuickO T12 ($50-100)
* '''Fine-tip soldering iron''' - 0.5-1.0mm chisel or cone tip ($10-20)
* '''Flux pen''' - Kester 951 or MG Chemicals ($5-10)
* '''Fine tweezers''' - ESD-safe, fine point ($10-20)
* '''SMD practice board''' - Various package sizes ($10-20)
* '''Magnifying lamp''' - 5-10× magnification with light ($30-60)

'''Total additional budget''': $120-250 (beyond beginner tools)

=== External Resources ===
* [https://www.youtube.com/watch?v=5uiroWBkdFY Pace: SMD Soldering] (video)
* [https://www.youtube.com/watch?v=pdGSFc7VjBE Pace: Drag Soldering] (video)
* [https://www.youtube.com/watch?v=nS0bEuYPJoA Pace: Hot Air Rework] (video)
* [https://www.sparkfun.com/tutorials/96 SparkFun: SMD Soldering Tutorial]
* [https://www.ipc.org/ipc-a-610 IPC-A-610] - Industry standard for solder joint quality

== See Also ==

* [[Soldering]] - Full competency overview
* [[Soldering Guide]] - Beginner tutorial (prerequisite)
* [[PCB Design]] - Design boards you'll assemble with these techniques
* [[Electronics]] - Understanding what you're soldering and why

[[Category:Tutorials]]
[[Category:Soldering]]
[[Category:Intermediate]]

Soldering Guide

2025-10-11T20:13:45Z

John: Created page with "{{Tutorial |name=Soldering Guide |competency=Soldering |difficulty=Beginner |time=1-2 hours (practice) + 30 minutes (theory) |prerequisites=None - complete beginner friendly |materials=Soldering iron ($20-50), lead-free solder, safety glasses, ventilation, practice kit or perfboard |next_steps=SimpleBot PCB assembly, Soldering Techniques }} '''Soldering Guide''' is your introduction to the hands-on technique of joining electronic components with molten metal..."

{{Tutorial
|name=Soldering Guide
|competency=[[Soldering]]
|difficulty=Beginner
|time=1-2 hours (practice) + 30 minutes (theory)
|prerequisites=None - complete beginner friendly
|materials=Soldering iron ($20-50), lead-free solder, safety glasses, ventilation, practice kit or perfboard
|next_steps=[[SimpleBot]] PCB assembly, [[Soldering Techniques]]
}}

'''Soldering Guide''' is your introduction to the hands-on technique of joining electronic components with molten metal. This tutorial covers everything you need to safely and successfully solder through-hole components for [[SimpleBot]] and other BRS robots.

By the end of this tutorial, you'll be able to:
* Set up and safely operate a soldering iron
* Create reliable solder joints on through-hole components
* Recognize good joints vs cold joints vs bridges
* Solder wires to terminals and pads
* Troubleshoot common soldering problems

This tutorial is '''hands-on'''. Plan to spend 1-2 hours practicing before attempting your first real PCB.

== Part 1: Safety First ==

Soldering involves high temperatures and fumes. Before you start:

=== Essential Safety Rules ===

# '''Wear safety glasses''' - Solder can spatter, component leads fly when clipped
# '''Ventilate your workspace''' - Work near open window or use fume extractor
# '''Never touch the iron tip''' - Reaches 300-400°C (572-752°F)
# '''Use a proper iron stand''' - Never lay hot iron on desk
# '''Keep flammable materials away''' - No paper, plastic, or fabric near hot iron
# '''Wash hands after soldering''' - Especially important with leaded solder
# '''Never leave hot iron unattended''' - Turn off or unplug when leaving

=== Understanding the Hazards ===

* '''Burns''' - Iron tip can cause instant, serious injury; handle only by the insulated grip
* '''Fumes''' - Flux produces irritating smoke containing rosin or other compounds
* '''Lead exposure''' - Traditional 60/40 solder contains lead; use lead-free or handle carefully
* '''Fire''' - Hot iron can ignite paper, plastic, sponges left in contact
* '''Eye injury''' - Clipped component leads can fly across room at high speed

'''If you get burned''': Cool immediately under cold running water for 10+ minutes. Seek medical attention for serious burns.

== Part 2: Tools and Materials ==

=== Soldering Iron Selection ===

You need a temperature-controlled soldering iron for electronics work:

'''Recommended irons ($20-50)''':
* '''Hakko FX-888D''' ($90) - Industry standard, very reliable
* '''Pinecil''' ($30) - Portable, USB-C powered, excellent value
* '''TS100''' ($50) - Portable, battery-compatible
* '''Weller WLC100''' ($40) - Basic analog temperature control

'''Avoid''':
* Non-temperature-controlled irons (too hot, damage components)
* High-wattage soldering guns (too powerful for electronics)
* Ultra-cheap irons under $15 (unreliable temperature, poor tips)

'''Tip selection''': Start with a chisel or cone tip (1-2mm). Avoid fine needle tips for beginners.

=== Solder Selection ===

* '''Lead-free solder''' (SAC305: 96.5% Sn, 3% Ag, 0.5% Cu) - Recommended, melts at 217°C
* '''Leaded solder''' (60/40: 60% Sn, 40% Pb) - Easier for beginners, melts at 183°C, but contains lead
* '''Diameter''' - 0.8mm for most electronics work (0.5mm for fine-pitch, 1.0mm for larger joints)
* '''Flux core''' - All electronic solder has rosin flux core (essential for good flow)

'''For learning''': Leaded solder is easier to work with (lower temperature, better flow). Use lead-free for production projects. Wash hands after handling either type.

=== Additional Essential Tools ===

* '''Solder stand''' - Holds hot iron safely
* '''Brass wool or wet sponge''' - Clean iron tip (brass wool better, doesn't cool tip)
* '''Safety glasses''' - Protect eyes from solder spatter and flying leads
* '''Wire cutters''' - Flush-cut type for trimming component leads
* '''Practice board''' - Perfboard or through-hole practice kit

=== Helpful But Not Essential ===

* '''Helping hands''' - Third hand with alligator clips to hold work
* '''Magnifying glass''' - Inspect joints for defects
* '''Solder wick''' - Braided copper removes excess solder
* '''Flux pen''' - Extra flux improves difficult joints
* '''Desoldering pump''' - Sucks up molten solder for removal

== Part 3: Iron Setup and Maintenance ==

=== First Time Setup ===

# '''Read iron manual''' - Temperature settings vary by model
# '''Install tip''' - Most irons come with tip installed; tighten securely
# '''Set temperature''' - 350°C (662°F) for lead-free, 320°C (608°F) for leaded
# '''Place in stand''' - Secure stand location away from flammable materials

=== Tinning the Tip (Critical Step!) ===

'''Tinning''' means coating the tip with a thin layer of solder. This:
* Protects tip from oxidation
* Improves heat transfer to joints
* Extends tip lifetime

'''Tinning procedure:'''
# Heat iron to working temperature (2-3 minutes)
# Clean tip on brass wool or damp sponge
# Immediately apply solder to tip - should melt and coat tip surface
# Wipe excess on brass wool, leaving thin shiny coating
# Tip should be shiny silver, not black or brown

'''Re-tin every 3-5 joints''' to maintain performance. Always tin before turning off iron.

=== Tip Cleaning ===

Clean tip before every joint:
* '''Brass wool''' (preferred) - Wipe tip, doesn't cool it down
* '''Damp sponge''' - Wipe tip, cools it temporarily (recovers quickly)

Never use file, sandpaper, or abrasive - damages tip plating!

=== Tip Maintenance ===

* '''Oxidation''' - Black or brown crusty coating prevents heat transfer
* '''Prevention''' - Keep tip tinned at all times, clean frequently
* '''Recovery''' - Use tip cleaner/activator (Hakko FS-100) or replace tip

'''When to replace tip''':
* Pitting or holes in plating (copper core visible)
* Can't maintain tinning even after cleaning
* Tips are consumable ($5-10) and last 6-12 months with proper care

== Part 4: Making Your First Solder Joint ==

=== The Basic Technique ===

Creating a solder joint has four steps:

# '''Heat the joint''' (not the solder)
# '''Apply solder to the joint''' (not the iron)
# '''Wait for solder to flow''' (1-2 seconds)
# '''Remove iron and hold steady''' (2-3 seconds while cooling)

=== Step-by-Step: Through-Hole Resistor ===

'''Setup:'''
* Insert resistor leads through perfboard holes
* Bend leads slightly on bottom to hold in place
* Position board so you can access solder side

'''Soldering:'''
# Clean and tin iron tip
# Touch iron to both pad and component lead (contact both!)
# Wait 0.5-1 second for heat transfer
# Apply solder wire to the junction of pad and lead (not to iron tip)
# Solder should melt and flow smoothly around lead and onto pad
# Remove solder wire (joint should have small amount of solder)
# Remove iron (total contact time 2-3 seconds)
# Hold component steady for 2-3 seconds while solder solidifies
# Solder changes from shiny-liquid to matte-solid when cooled

'''What you should see:'''
* Solder flows smoothly onto pad and up component lead
* Forms concave "fillet" shape (like volcano)
* Shiny, smooth surface after cooling
* No excess solder (blob) or insufficient solder (barely wetting)

=== Common Mistakes (And How to Fix Them) ===

'''Mistake 1: Cold Joint'''
* '''Appearance''': Dull, grainy, crystalline surface
* '''Cause''': Insufficient heat - solder didn't flow properly
* '''Fix''': Re-heat joint until solder melts and flows smoothly

'''Mistake 2: Too Much Solder'''
* '''Appearance''': Large blob obscuring pad and lead
* '''Fix''': Remove excess with solder wick (see Part 7)

'''Mistake 3: Disturbed Joint'''
* '''Appearance''': Cracks, irregular surface
* '''Cause''': Component moved before solder fully solidified
* '''Fix''': Re-heat until solder melts, hold steady while cooling

'''Mistake 4: Insufficient Solder'''
* '''Appearance''': Solder barely touches pad or lead, no fillet
* '''Fix''': Re-heat and add more solder

'''Mistake 5: Solder Won't Flow'''
* '''Cause''': Dirty/oxidized surfaces or insufficient heat
* '''Fix''': Clean surfaces, increase temperature 10-20°C, use flux

== Part 5: Recognizing Good Solder Joints ==

=== The "Ideal" Solder Joint ===

A properly made through-hole solder joint has:

# '''Shiny surface''' - Smooth, reflective (not dull or grainy)
# '''Concave fillet''' - Solder flows up lead in smooth curve (volcano shape)
# '''Complete wetting''' - Solder visibly adheres to both pad and lead
# '''Appropriate amount''' - Enough to form fillet, not a blob
# '''Pad fully covered''' - No exposed copper on pad
# '''Lead well-coated''' - Solder flows partway up component lead

=== Visual Inspection Checklist ===

Examine each joint under magnification if possible:

☐ '''Shiny, not dull''' - Indicates proper temperature and flow<br>
☐ '''Concave fillet''' - Not ball-shaped or flat<br>
☐ '''No cracks''' - Joint wasn't disturbed while cooling<br>
☐ '''No bridges''' - Adjacent pads not connected by solder<br>
☐ '''Pad visible''' - Can see solder flowed onto pad<br>
☐ '''Lead visible''' - Can see solder flowed up lead

=== Bad Joint Examples ===

'''Cold joint''':
* Dull, grainy, crystalline appearance
* Solder didn't flow properly at temperature
* Poor electrical connection, may fail intermittently
* Fix: Re-heat until solder melts and flows smoothly

'''Insufficient solder''':
* Pad or lead not fully wetted
* May look like solder "balled up" instead of flowing
* Poor mechanical strength
* Fix: Add more solder while heating

'''Excess solder''':
* Large blob, can't see pad or lead
* Wastes solder, may hide defects underneath
* Fix: Remove excess with solder wick

'''Solder bridge''':
* Unwanted solder connection between adjacent pads
* Causes short circuit
* Fix: Remove with solder wick or carefully with iron

== Part 6: Wire Soldering ==

Robots need soldered wire connections for motors, batteries, and sensors.

=== Soldering Stranded Wire to Terminal ===

Stranded wire (multiple thin strands) is flexible but requires tinning:

# '''Strip insulation''' - Remove 3-4mm (just enough to fit in terminal)
# '''Twist strands together''' - All strands aligned, no fraying
# '''Tin the wire''' - Heat wire end, apply solder until solder wicks into strands
# '''Position in terminal''' - Insert tinned wire into terminal hole or pad
# '''Solder joint''' - Heat terminal and wire, add solder if needed (wire may have enough)
# '''Hold steady''' - Wait 2-3 seconds for solder to solidify
# '''Tug test''' - Gently pull wire - should not come loose

=== Why Tinning Matters ===

Untinned stranded wire:
* Individual strands don't all make contact
* Strands can fray and short to adjacent terminals
* Difficult to insert into terminal holes

Tinned stranded wire:
* Behaves like solid wire (all strands bonded)
* Easy to insert into holes
* All strands make electrical contact

=== Soldering Solid Wire ===

Solid core wire (single thick strand) doesn't require tinning:
# Strip 3-4mm insulation
# Insert wire into terminal or wrap around post
# Heat wire and terminal together
# Apply solder - flows onto wire and terminal
# Hold steady while cooling

== Part 7: Desoldering Basics ==

Mistakes happen. You need to remove solder or components sometimes.

=== Desoldering with Solder Wick (Braid) ===

Solder wick is braided copper wire that absorbs molten solder:

# Place wick on top of unwanted solder
# Press hot iron tip onto wick (heats solder through wick)
# Solder melts and wicks into braid by capillary action
# Remove iron and wick together (solder solidifies in wick)
# Cut off used section of wick, repeat if needed

'''Tips:'''
* Apply flux to wick for better solder absorption
* Press firmly - good contact needed for heat transfer
* Fresh wick works better than saturated wick

=== Desoldering with Solder Sucker (Pump) ===

Solder sucker is spring-loaded vacuum pump:

# Heat solder joint until molten
# Position sucker tip near molten solder
# Press sucker button - creates vacuum, sucks up solder
# Clean sucker tip before next use

'''Tips:'''
* Position sucker before pressing button (solder solidifies quickly)
* May need multiple attempts for large joints
* Works best on through-hole joints

=== Removing Through-Hole Components ===

# Heat one lead, pull component gently (don't force!)
# Heat other lead, pull gently
# Alternate heating leads until component releases
# Alternative: Use solder wick or sucker to remove all solder first, then pull component

'''Warning''': Excessive force can lift pads (damage PCB). Heat sufficiently before pulling.

== Part 8: Practice Exercises ==

Before attempting SimpleBot PCB assembly, practice these exercises:

=== Exercise 1: Basic Through-Hole (20-30 joints) ===

'''Materials''': Perfboard, 10-15 resistors, solder

# Insert resistors in perfboard (space them out)
# Solder one lead of each resistor
# Inspect each joint - shiny? Concave fillet?
# Solder second lead of each resistor
# Inspect all joints

'''Goal''': Consistent, shiny joints with proper fillet shape.

=== Exercise 2: Wire Soldering (5-10 wires) ===

'''Materials''': Stranded wire, terminal blocks or pads

# Cut 5 wire pieces (5cm each)
# Strip and tin each wire
# Solder wires to terminals or pads
# Tug test each wire

'''Goal''': Secure wire connections that don't pull loose.

=== Exercise 3: Close-Pitched Joints (IC Socket) ===

'''Materials''': Perfboard, IC socket (14-pin or 16-pin)

# Insert IC socket in perfboard
# Solder all pins (pay attention to spacing)
# Inspect for solder bridges between adjacent pins
# Use wick to remove any bridges

'''Goal''': All pins soldered without bridges.

=== Exercise 4: Desoldering Practice ===

'''Materials''': Previously soldered perfboard, solder wick or sucker

# Remove 5 resistors using solder wick
# Remove 5 resistors using solder sucker (if available)
# Inspect pads - should be clean and intact

'''Goal''': Remove components without damaging pads.

== Part 9: SimpleBot PCB Assembly ==

You're now ready to assemble the [[SimpleBot]] PCB!

=== Component Order (Solder Shortest First) ===

# '''Resistors''' - Flat against board, solder from bottom
# '''Capacitors''' - Watch polarity on electrolytic capacitors
# '''IC sockets''' - Notch indicates pin 1 direction
# '''Headers''' - Hold straight while soldering first pin
# '''Terminal blocks''' - Large joints, may need more heat
# '''Inspect''' - Check every joint before continuing

=== SimpleBot-Specific Tips ===

* '''Motor terminals''' - Large joints require higher heat and more solder
* '''Power connector''' - Double-check polarity before soldering
* '''Pin headers''' - Tack one pin first, adjust if crooked, then solder rest
* '''IC orientation''' - Notch or dot indicates pin 1

Full assembly guide: [[SimpleBot:PCB Assembly]]

== Part 10: Troubleshooting ==

=== Problem: Solder Won't Melt ===
* '''Cause''': Temperature too low
* '''Fix''': Increase iron temperature 10-20°C

=== Problem: Solder Balls Up Instead of Flowing ===
* '''Cause''': Oxidized surfaces or insufficient flux
* '''Fix''': Clean surfaces with brass wool, apply flux, increase heat

=== Problem: Iron Tip is Black/Brown ===
* '''Cause''': Oxidized tip (not tinned properly)
* '''Fix''': Clean with brass wool, immediately tin with fresh solder

=== Problem: Joint Looks Good But Fails Electrically ===
* '''Cause''': Cold joint - solder didn't bond despite appearance
* '''Fix''': Re-heat joint until solder melts and flows smoothly

=== Problem: Component Gets Too Hot ===
* '''Cause''': Taking too long to solder (heat soaking component)
* '''Fix''': Work faster (2-3 seconds per joint), use higher temperature for faster heat transfer

=== Problem: Lifted Pad ===
* '''Cause''': Excessive force or heat damaged adhesive between pad and PCB
* '''Fix''': Solder component lead directly to trace (requires scraping soldermask), or use jumper wire

== Part 11: Skills Checklist ==

By now, you should be able to:

* ☐ Set up soldering iron and set appropriate temperature
* ☐ Tin the iron tip before and during work
* ☐ Make shiny through-hole solder joints
* ☐ Recognize good joints vs cold joints
* ☐ Solder stranded wire (strip, tin, solder)
* ☐ Identify and remove solder bridges
* ☐ Remove components with solder wick or sucker
* ☐ Trim component leads flush with joint
* ☐ Inspect joints with magnification
* ☐ Work safely (glasses, ventilation, iron stand)

If you can check all these boxes, you're ready to assemble [[SimpleBot]]!

== Next Steps ==

=== Build SimpleBot ===
Apply your soldering skills:
* [[SimpleBot]] - Full robot build guide
* [[SimpleBot:PCB Assembly]] - Detailed soldering instructions for SimpleBot PCB

=== Learn Advanced Techniques ===
* [[Soldering Techniques]] - SMD soldering, hot air rework, desoldering
* [[Soldering]] - Full competency overview with intermediate and advanced topics

=== Continue Practicing ===
* Electronics kits from SparkFun, Adafruit, or Digikey
* Solder practice boards (IC trainer boards, SMD practice boards)
* Dead electronics for desoldering practice

== Common Beginner Mistakes ==

* '''Not tinning the tip''' - Single biggest cause of poor results; tin frequently!
* '''Temperature too low''' - Solder doesn't flow; increase 10-20°C
* '''Not cleaning tip''' - Wipe on brass wool before every joint
* '''Applying solder to iron instead of joint''' - Prevents proper wetting
* '''Pulling on component before solder solidifies''' - Creates disturbed joint
* '''Using too much solder''' - More is not better; use just enough for fillet
* '''Insufficient heat time''' - Solder needs time to flow; don't rush
* '''Working without ventilation''' - Flux fumes are irritating; open window or use fan

== Tips for Success ==

* '''Practice first''' - 20-30 practice joints before real PCB
* '''Good lighting''' - See what you're doing (magnification helps too)
* '''Comfortable position''' - Steady hands require comfortable posture
* '''Take breaks''' - Hand fatigue leads to mistakes
* '''Inspect as you go''' - Catch problems early
* '''Don't rush''' - Speed comes with practice; focus on quality first
* '''Ask for help''' - Show your joints to experienced solderers for feedback

== Tools and Resources ==

=== Recommended Purchases for Beginners ===
* '''Soldering iron''' - Pinecil ($30) or Hakko FX-888D ($90)
* '''Solder''' - 0.8mm lead-free SAC305 ($10-15 for 50g)
* '''Safety glasses''' - Any ANSI-rated glasses ($5-10)
* '''Brass wool''' - Hakko 599B tip cleaner ($5)
* '''Practice kit''' - Through-hole soldering practice board ($10-20)

'''Total budget''': $60-150

=== External Resources ===
* [https://www.sparkfun.com/tutorials/106 SparkFun: How to Solder - Through-Hole]
* [https://www.youtube.com/watch?v=QKbJxytERvg Pace: Basic Soldering Lesson 1] (video)
* [https://www.youtube.com/watch?v=vIT4ra6Mo0s EEVblog: Soldering Tutorial] (video)
* [https://www.ifixit.com/Guide/How+to+Solder+and+Desolder+Connections/750 iFixit: Soldering Guide]

== See Also ==

* [[Soldering]] - Full competency overview
* [[Soldering Techniques]] - Intermediate tutorial (SMD, hot air rework)
* [[SimpleBot]] - Apply your skills to build a robot
* [[Electronics]] - Understanding what you're soldering and why

[[Category:Tutorials]]
[[Category:Soldering]]
[[Category:Beginner]]

Soldering

2025-10-11T20:13:13Z

John: Created page with "{{Competency |name=Soldering |description=The hands-on technique of joining electronic components to circuit boards |difficulty_range=Beginner to Advanced |time_to_basic=1-2 days |essential_tools=Soldering iron ($20-50), lead-free solder, safety glasses, ventilation |optional_tools=Helping hands, solder wick, flux pen, hot air station |beginner_tutorial=Soldering Guide |unlocks_basic=SimpleBot PCB assembly, basic electronics repair |unlocks_advanced=SMD assembly,..."

{{Competency
|name=Soldering
|description=The hands-on technique of joining electronic components to circuit boards
|difficulty_range=Beginner to Advanced
|time_to_basic=1-2 days
|essential_tools=Soldering iron ($20-50), lead-free solder, safety glasses, ventilation
|optional_tools=Helping hands, solder wick, flux pen, hot air station
|beginner_tutorial=[[Soldering Guide]]
|unlocks_basic=[[SimpleBot]] PCB assembly, basic electronics repair
|unlocks_advanced=SMD assembly, PCB rework, custom sensor modules
}}

'''Soldering''' is the competency of physically joining electronic components to circuit boards using molten metal. In robotics, soldering is essential for assembling PCBs, connecting sensors and motors, and creating permanent electrical connections that withstand vibration and movement.

Soldering is distinct from [[Electronics]] (understanding circuits and components) and [[PCB Design]] (creating circuit board layouts). This competency focuses on the '''hands-on fabrication technique''': heating the iron, forming good joints, avoiding cold solder and bridges, and safely working with molten metal.

== Why Soldering Matters for Robotics ==

Robots need permanent electrical connections:
* '''PCB assembly''' - Attach components to circuit boards (SimpleBot PCB, motor driver boards)
* '''Wire connections''' - Secure wires to connectors and components
* '''Sensor modules''' - Build custom sensors and breakout boards
* '''Repair''' - Fix broken connections, replace damaged components

Without soldering skills, you're limited to breadboards and pre-assembled modules. Soldering unlocks:
* Building robots with custom PCBs
* Creating robust connections that survive robot movement
* Repairing damaged electronics
* Designing and fabricating your own sensor modules

== Skill Progression ==

=== Beginner (SimpleBot Level) ===

Skills you need to assemble [[SimpleBot]] PCB:

* '''Safety fundamentals''' - Eye protection, ventilation, burn prevention
* '''Iron temperature control''' - Set appropriate temperature (300-350°C for lead-free)
* '''Tinning the tip''' - Keep the tip coated with fresh solder
* '''Through-hole soldering''' - Insert component leads, solder from bottom
* '''Solder joint inspection''' - Recognize good joints vs cold joints vs bridges
* '''Wire soldering''' - Strip insulation, tin wire, solder to terminal
* '''Basic desoldering''' - Remove excess solder with solder sucker or wick

'''Unlocks''':
* [[SimpleBot]] PCB assembly (resistors, capacitors, headers, motor terminals)
* Basic sensor module assembly
* Wire-to-board connections for motors and batteries

'''Tutorials''': [[Soldering Guide]]

'''At this level you can''':
* Assemble through-hole PCB kits
* Solder headers and terminals to breakout boards
* Create secure wire connections
* Troubleshoot basic soldering issues

=== Intermediate (SMD and Rework) ===

Skills for advanced PCB assembly and repair:

* '''SMD hand soldering''' - 0805/0603 resistors and capacitors with iron and tweezers
* '''Hot air rework''' - Remove and replace SMD components with hot air
* '''Flux usage''' - Apply flux for better solder flow and heat transfer
* '''Desoldering techniques''' - Solder wick, solder sucker, hot air removal
* '''Component rework''' - Replace damaged ICs and connectors
* '''Drag soldering''' - Efficiently solder multi-pin ICs
* '''Solder paste application''' - Apply paste for reflow or hot air soldering

'''Unlocks''':
* Hand-assembly of SMD PCBs (motor drivers, sensor boards)
* Repair of existing electronics (broken traces, lifted pads, damaged components)
* Custom sensor modules with SMD components
* Prototype boards with mixed through-hole and SMD

'''Tutorials''': [[Soldering Techniques]]

'''At this level you can''':
* Hand-solder SMD components down to 0603 size
* Rework and repair PCBs with hot air and desoldering tools
* Replace damaged connectors and ICs
* Assemble custom sensor modules

=== Advanced (Fine-Pitch and Production) ===

Skills for complex assemblies and production-quality work:

* '''Fine-pitch SMD''' - 0402 components, TQFP, QFN packages (0.5mm pitch or finer)
* '''Reflow soldering''' - Use reflow oven or hot plate for solder paste assembly
* '''BGA rework''' - Ball grid array component removal and replacement
* '''Microscope work''' - Solder under magnification for fine-pitch components
* '''Thermal management''' - Preheat boards, manage heat-sensitive components
* '''Quality control''' - Inspect joints with microscope, identify defects
* '''Production techniques''' - Efficient workflows, jigs, and fixtures

'''Unlocks''':
* Complete PCB assembly for complex robots
* Reflow soldering for production quantities
* Repair of laptop/phone electronics (fine-pitch work)
* Custom high-density sensor arrays

'''Tutorials''': Advanced soldering resources (external)

'''At this level you can''':
* Assemble any PCB design, regardless of component density
* Rework complex multi-layer boards
* Set up production soldering workflows
* Troubleshoot and repair professional electronics

== Learning Paths ==

=== Path 1: SimpleBot Builder (Beginner) ===
# Read [[Soldering Guide]] - Learn safety, technique, and practice on scrap
# Practice on perfboard or practice kit (20-30 joints to build muscle memory)
# Assemble [[SimpleBot]] PCB - Through-hole components only
# Inspect joints and fix any cold solder or bridges

'''Result''': You can confidently assemble through-hole PCBs for robotics projects.

=== Path 2: SMD Assembler (Intermediate) ===
# Complete Path 1 (SimpleBot Builder)
# Study [[Soldering Techniques]] - SMD soldering and hot air rework
# Practice SMD soldering on breakout boards (start with 0805, work down to 0603)
# Assemble an SMD motor driver or sensor board
# Learn desoldering with solder wick and hot air

'''Result''': You can hand-assemble SMD boards and perform PCB rework.

=== Path 3: Production Assembly (Advanced) ===
# Complete Path 2 (SMD Assembler)
# Learn reflow soldering (hot plate or reflow oven)
# Practice fine-pitch soldering (TQFP, QFN) under microscope
# Set up efficient workflows with jigs and fixtures
# Study IPC-A-610 soldering standards

'''Result''': You can assemble production-quality PCBs and manage complex assemblies.

== Essential Concepts ==

=== Good Solder Joint Characteristics ===

A proper solder joint has:
* '''Shiny appearance''' - Smooth, reflective surface (not dull or grainy)
* '''Concave fillet''' - Solder flows up the lead in a smooth curve (volcano shape)
* '''Complete wetting''' - Solder adheres to both pad and component lead
* '''No excess solder''' - Just enough to form a fillet (not a blob)
* '''No cold joint''' - Solder flowed properly at temperature (not crystalline)

=== Temperature Control ===

* '''Lead solder''' (60/40 Sn/Pb) - Melts at 183°C, work at 300-330°C
* '''Lead-free solder''' (SAC305, 96.5/3.0/0.5 Sn/Ag/Cu) - Melts at 217°C, work at 320-370°C
* '''Too cold''' - Solder doesn't flow, forms cold joints
* '''Too hot''' - Damages components, lifts pads, oxidizes tip faster

=== Heat Transfer ===

Good solder joints require heating both the pad and the component lead:
# Touch iron tip to pad and lead simultaneously
# Apply solder to the joint (not the iron tip)
# Solder flows toward heat - if it balls up, increase heat or clean surfaces
# Remove iron after solder flows smoothly around joint (1-3 seconds)

=== Flux ===

Flux is the "secret ingredient" that makes soldering work:
* '''Removes oxidation''' - Cleans metal surfaces for better wetting
* '''Improves heat transfer''' - Helps solder flow smoothly
* '''Prevents oxidation''' - Protects joint while hot
* '''Types''': Rosin (mildly corrosive, common), No-clean (low residue), Water-soluble (requires cleaning)

Most solder has a flux core, but additional flux improves results on difficult joints.

=== Common Soldering Defects ===

* '''Cold joint''' - Dull, grainy appearance; solder didn't flow properly (re-heat to fix)
* '''Solder bridge''' - Unwanted connection between adjacent pads (remove with solder wick)
* '''Insufficient solder''' - Joint doesn't fully wet pad or lead (add more solder)
* '''Excess solder''' - Large blob that may hide defects (remove excess with wick)
* '''Lifted pad''' - Pad separated from PCB due to excessive heat or force (difficult repair)
* '''Tombstoning''' - SMD component stands on end (one side heated before the other)

== Tools and Equipment ==

=== Essential Tools (Start Here) ===

* '''Soldering iron''' ($20-50) - Temperature-controlled preferred (Hakko FX-888D, Pinecil, TS100)
* '''Solder''' ($10-15) - 0.8mm diameter lead-free (SAC305) or 60/40 leaded for practice
* '''Safety glasses''' ($5-10) - Protect eyes from solder spatter
* '''Solder stand''' ($5-10) - Safe place to rest hot iron
* '''Brass wool or sponge''' ($5) - Clean iron tip
* '''Wire cutters''' ($10-15) - Trim component leads after soldering
* '''Ventilation''' (free-$50) - Work near open window or use fume extractor fan

'''Total beginner budget''': $50-100

=== Intermediate Tools ===

* '''Helping hands''' ($10-30) - Third hand to hold PCBs and wires
* '''Solder wick''' ($5-10) - Braided copper removes excess solder
* '''Desoldering pump''' ($5-15) - Suck up molten solder
* '''Flux pen''' ($5-10) - Apply extra flux for difficult joints
* '''Tip cleaner''' ($5-10) - Brass wool more effective than wet sponge
* '''Magnifying lamp''' ($20-50) - Inspect joints and work with small components
* '''Tweezers''' ($5-15) - Place and hold SMD components

'''Total intermediate budget''': $50-150 (plus beginner tools)

=== Advanced Tools ===

* '''Hot air rework station''' ($50-150) - Remove and replace SMD components
* '''Soldering microscope''' ($100-400) - 10-20× magnification for fine-pitch work
* '''Reflow oven or hot plate''' ($50-300) - Solder paste assembly
* '''Chip Quik or low-temp solder''' ($10-20) - Ease removal of multi-pin ICs
* '''PCB vise''' ($20-50) - Secure PCBs for rework
* '''Temperature-controlled preheater''' ($50-200) - Preheat boards for large components

'''Total advanced budget''': $300-1000+ (plus beginner and intermediate tools)

== Safety Considerations ==

Soldering involves high temperatures and fumes:

* '''Burns''' - Soldering irons reach 300-400°C; tip can cause instant injury
* '''Eye protection''' - Solder spatter and clipped component leads can fly
* '''Fumes''' - Flux produces irritating smoke; work with ventilation
* '''Lead exposure''' - Use lead-free solder or wash hands after handling leaded solder
* '''Fire hazard''' - Iron can ignite paper, plastic, fabric; use metal stand

'''Safety rules''':
# Always wear safety glasses
# Work in ventilated area (fume extractor or open window)
# Never leave hot iron unattended
# Use soldering iron stand when not actively soldering
# Keep flammable materials away from work area
# Wash hands after soldering (especially with leaded solder)

== Component-Specific Techniques ==

=== Through-Hole Components (Resistors, Capacitors, Headers) ===

# Insert component leads through holes from top side
# Bend leads slightly on bottom to hold component in place
# Solder from bottom side: heat pad and lead together, apply solder
# Trim excess lead flush with solder joint

'''SimpleBot PCB assembly uses through-hole components throughout.'''

=== Wire Soldering ===

# Strip 2-3mm of insulation from wire
# Tin the wire: heat wire, apply small amount of solder
# Position tinned wire in terminal or pad
# Heat wire and terminal together, add solder if needed
# Hold steady until solder solidifies (1-2 seconds)

=== SMD Resistors and Capacitors ===

# Apply flux to pads
# Tin one pad with small amount of solder
# Place component on pads with tweezers, heat tinned pad to tack in place
# Solder opposite end: heat pad and component, apply solder
# Re-flow first side if needed to ensure good joint

=== IC Chips (Through-Hole) ===

# Use IC socket if possible (avoids heat damage, allows replacement)
# If soldering directly: insert IC, tack opposite corners first
# Solder all pins quickly (avoid prolonged heating)
# Inspect for bridges between adjacent pins

=== IC Chips (SMD) ===

# Align IC with pads, tack one corner pin
# Apply flux generously to all pins
# Use drag soldering: draw iron tip across pins with small amount of solder on tip
# Solder bridges across pins, then draw iron to separate
# Alternative: Solder each pin individually with fine-tip iron

== Common Pitfalls ==

* '''Not tinning the tip''' - Oxidized tip won't transfer heat; tin tip before every few joints
* '''Too much solder''' - Obscures defects and wastes material; use just enough to form fillet
* '''Moving joint before solidification''' - Creates cold joint; hold steady 1-2 seconds
* '''Heating component instead of joint''' - Apply heat to pad and lead, not component body
* '''Dirty or oxidized surfaces''' - Clean with flux or abrasive before soldering
* '''Wrong temperature''' - Too cold = cold joints, too hot = lifted pads and damaged components
* '''Poor ventilation''' - Flux fumes are irritating; always work with airflow

== Practice Recommendations ==

Before attempting SimpleBot PCB assembly:

=== Beginner Practice (1-2 hours) ===
# Practice on perfboard or scrap PCB: solder 20-30 through-hole resistor leads
# Inspect each joint: shiny? Concave fillet? No cold joints?
# Practice wire soldering: solder stranded wire to terminal blocks
# Desolder practice: remove components with solder wick or sucker

=== Intermediate Practice (2-4 hours) ===
# Hand-solder 0805 SMD resistors/capacitors (practice kit or breakout board)
# Practice hot air rework: remove and replace SMD components
# Work down to 0603 components once comfortable with 0805
# Practice drag soldering on SOIC or TQFP chips

=== Quality Check ===
Use magnifying glass to inspect joints:
* No cold joints (dull, grainy appearance)
* No bridges between adjacent pins
* Complete wetting on pad and lead
* Shiny, smooth surface

== Tutorials and Resources ==

=== BRS Tutorials ===
* '''[[Soldering Guide]]''' (Beginner) - Start here for through-hole soldering fundamentals
* '''[[Soldering Techniques]]''' (Intermediate) - SMD soldering, desoldering, rework

=== Implementation Pages ===
* [[SimpleBot]] - Through-hole PCB assembly guide
* [[SimpleBot:PCB Assembly]] - Step-by-step SimpleBot soldering instructions

=== External Resources ===
* [https://www.sparkfun.com/tutorials/106 SparkFun: How to Solder]
* [https://www.youtube.com/watch?v=QKbJxytERvg Pace: Basic Soldering] (video)
* [https://www.youtube.com/watch?v=5uiroWBkdFY Pace: SMD Soldering] (video)
* [https://www.ipc.org/ipc-a-610 IPC-A-610] - Industry standard for soldering quality

== Related Competencies ==

* '''[[Electronics]]''' - Understand circuits and components before soldering them
* '''[[PCB Design]]''' - Design circuit boards that you'll assemble with soldering
* '''[[Mechanics]]''' - Mechanical assembly often requires soldered wire connections
* '''[[3D Printing]]''' - Print jigs and fixtures for holding PCBs during soldering

== See Also ==

* [[SimpleBot]] - Apply soldering skills to build a robot
* [[Capabilities]] - Hardware abilities that require soldered assemblies
* [[Robotics Ontology]] - How soldering fits into BRS knowledge structure

[[Category:Competencies]]
[[Category:Skills]]

3D Printing Basics

2025-10-11T20:12:53Z

John: Created page with "{{Tutorial |name=3D Printing Basics |competency=3D Printing |difficulty=Beginner |time=4-6 hours (spread over multiple sessions) |prerequisites=None - complete beginner friendly |materials=FDM 3D printer, PLA filament (1kg), slicer software (free), spatula, flush cutters |next_steps=SimpleBot assembly, 3D Printing for Robotics, CAD Design }} '''3D Printing Basics''' is your complete introduction to fabricating robot parts using FDM (Fused Deposition Mode..."

{{Tutorial
|name=3D Printing Basics
|competency=[[3D Printing]]
|difficulty=Beginner
|time=4-6 hours (spread over multiple sessions)
|prerequisites=None - complete beginner friendly
|materials=FDM 3D printer, PLA filament (1kg), slicer software (free), spatula, flush cutters
|next_steps=[[SimpleBot]] assembly, [[3D Printing for Robotics]], [[CAD Design]]
}}

'''3D Printing Basics''' is your complete introduction to fabricating robot parts using FDM (Fused Deposition Modeling) 3D printing. This tutorial takes you from unboxing a printer to successfully printing [[SimpleBot]] components.

By the end of this tutorial, you'll be able to:
* Set up and calibrate your 3D printer
* Use slicer software to prepare models for printing
* Successfully print your first parts
* Troubleshoot common failures
* Print all components for SimpleBot
* Post-process and assemble printed parts

This tutorial is '''completely hands-on'''. You'll need a working FDM printer (recommendations below) and basic tools.

== What You'll Need ==

=== Required Equipment ===
* '''3D Printer''' - FDM printer with minimum 180×180×180mm build volume
** Recommended: Creality Ender 3 V2 ($200-250), Prusa Mini+ ($400), Artillery Genius ($300)
* '''PLA Filament''' - 1kg spool, 1.75mm diameter ($15-25)
** Color doesn't matter functionally, but white/black are easiest to see layer quality
* '''Slicer Software''' - Free software to convert models to printer instructions
** Recommended: PrusaSlicer (works with any printer, not just Prusa)
** Alternative: Cura (more beginner-friendly interface)
* '''Computer''' - Windows, Mac, or Linux to run slicer software

=== Required Tools ===
* '''Spatula or scraper''' ($5-10) - Remove prints from bed (often included with printer)
* '''Flush cutters''' ($5-10) - Remove supports and clean up prints
* '''Isopropyl alcohol''' 70-90% ($5) - Clean print bed

=== Helpful But Optional ===
* '''Calipers''' ($15-30) - Measure prints to check accuracy
* '''Needle files''' ($10-20) - Clean up holes and edges
* '''Glue stick''' ($2) - Extra bed adhesion for difficult prints
* '''Filament storage container''' ($10-20) - Keep filament dry

== Part 1: Understanding Your 3D Printer ==

=== FDM Printer Anatomy ===

Your printer has these key components:

* '''Print bed''' (heated platform) - Where the part is built
** Heats to 50-100°C to prevent warping
** Must be level and clean for adhesion
* '''Hot end''' (extruder nozzle) - Melts and deposits plastic
** Heats to 180-220°C for PLA
** Nozzle is typically 0.4mm diameter
* '''Extruder''' (filament feeder) - Pushes filament into hot end
** Bowden tube (tube between feeder and hot end) or direct drive (feeder mounted on hot end)
* '''Motion system''' - Moves hot end in XYZ axes
** Belts, stepper motors, linear rails
* '''Controller board''' - Computer that runs the printer
** Reads G-code files from SD card or USB
* '''Display''' - Interface to control printer
** Start prints, adjust temperature, move axes

=== First Time Setup (Assembly) ===

Most budget printers require some assembly. Follow manufacturer instructions, but key steps:

# '''Attach gantry to base''' - Usually pre-assembled, just bolt together
# '''Install print bed''' - Connect heated bed power and thermistor
# '''Run cables''' - Route wires neatly, use cable clips
# '''Install bowden tube''' - Push into fittings on extruder and hot end
# '''Verify motion''' - Manually move axes (power off) - should move smoothly with no binding
# '''Check wiring''' - Loose wires can cause fires! Verify all connections tight

'''Safety check before first power-on:'''
* ☐ All screws tight (especially bed and gantry)
* ☐ Belts tensioned (not too loose, not too tight)
* ☐ Wires secured, not touching hot end or bed
* ☐ No shipping zip ties or packing material left on moving parts

=== First Power On ===

# Plug in printer and turn on power switch
# Display should light up with home screen
# '''DO NOT start a print yet!''' - Must level bed first

Navigate the menu:
* Most printers use a rotary knob (turn to move, press to select)
* Find the temperature display - should show room temperature (~20-25°C)
* Find the axis movement controls - you'll need these for bed leveling

== Part 2: Bed Leveling (Most Critical Step) ==

'''Bed leveling''' is the single most important step for successful prints. The nozzle must be exactly the right distance from the bed across the entire surface.

=== Why Bed Leveling Matters ===

* '''Too close''' - Nozzle drags through plastic, clogs, scrapes bed
* '''Too far''' - Plastic doesn't stick, print fails in first layer
* '''Uneven''' - Works on one side, fails on other side

You must level the bed:
* When you first set up the printer
* After moving the printer
* Periodically (every 5-10 prints) to maintain accuracy

=== Manual Bed Leveling Procedure ===

You'll need:
* A piece of paper (printer paper works fine)
* 10-15 minutes of patience

'''Steps:'''

# '''Home all axes''' - Use printer menu: Prepare → Auto Home
** Nozzle moves to home position (usually front-left corner)
# '''Disable steppers''' - Menu: Prepare → Disable Steppers
** Now you can manually move the hot end
# '''Heat the nozzle''' (optional but recommended) - Menu: Prepare → Preheat PLA
** Bed and nozzle expand when hot; level when hot for best accuracy
# '''Position nozzle over first corner''' - Manually move hot end to front-left, just above bed
# '''Adjust bed corner knob''' - Turn knob under bed while sliding paper between nozzle and bed
** '''Goal''': Paper should slide with slight friction (like writing on paper)
** Too loose? Tighten knob (turn clockwise)
** Too tight? Loosen knob (turn counter-clockwise)
# '''Repeat for all four corners''' - Front-left, front-right, back-right, back-left
# '''Check center of bed''' - Move nozzle to center, test with paper
** If center is different from corners, repeat the process
# '''Iterate''' - Go around all corners again. Adjusting one corner affects others slightly

'''Target feeling:''' Paper should slide with noticeable resistance but not tear. You should feel the nozzle just barely touching through the paper.

'''Tip:''' Some people describe it as "dragging paper over a wooden table" feeling.

=== Auto Bed Leveling (If Your Printer Has It) ===

Higher-end printers (Prusa, some Creality models) have automatic bed leveling:

# Attach probe or ensure sensor is working
# Menu: Prepare → Auto Bed Leveling or similar
# Printer probes multiple points on bed
# Creates a mesh to compensate for unevenness

'''Note:''' Even with auto bed leveling, you still need to set the initial Z-offset (nozzle-to-bed distance).

== Part 3: Loading Filament ==

=== Preparing Filament ===

# Remove filament from sealed bag (if new)
# Inspect filament end - should be cleanly cut (if not, use flush cutters to cut at angle)
# Note the diameter: 1.75mm (most common) or 2.85mm (some printers)

=== Loading Procedure ===

# '''Heat the nozzle''' - Menu: Prepare → Preheat PLA (nozzle to ~200°C)
# '''Wait for temperature''' - Display shows current and target temp
# '''Release extruder tension''' - Squeeze lever or loosen spring on extruder
# '''Insert filament''' - Push filament into extruder hole
** For Bowden tube systems: Push until it comes out the hot end (may take 30-50cm)
** For direct drive: Push until it comes out the nozzle (just a few cm)
# '''Extrude some plastic''' - Menu: Prepare → Move Axis → Extruder → Move 10mm
** Plastic should flow freely from nozzle
** If not, increase temperature by 5-10°C and try again
# '''Check extrusion''' - Plastic should come out smooth and consistent, not bubbly or clumpy

'''Tip:''' Have paper towel ready to wipe excess plastic from nozzle.

=== Unloading Filament ===

# '''Heat nozzle''' to printing temperature (~200°C for PLA)
# '''Retract filament''' - Menu: Prepare → Move Axis → Extruder → Move -10mm
** Or squeeze extruder lever and pull filament out manually
# '''Store filament''' - Wind onto spool, secure end with clip or tape

'''Why store properly?''' PLA absorbs moisture from air, which causes print quality issues (bubbling, poor layer adhesion).

== Part 4: Your First Print - Calibration Cube ==

=== Getting the STL File ===

A calibration cube is a simple 20mm × 20mm × 20mm cube used to test printer accuracy.

# Search online: "20mm calibration cube STL"
# Download from Thingiverse, Printables, or similar site
# Save to your computer (file will be named something like `calibration_cube.stl`)

=== Introduction to Slicer Software ===

'''Slicer software''' converts 3D models (STL files) into instructions (G-code) for your printer.

# Download and install PrusaSlicer: https://www.prusa3d.com/prusaslicer/
# Launch PrusaSlicer
# First-time setup wizard:
** Select your printer manufacturer (or Generic for non-listed printers)
** Select your printer model (if listed) or closest match
** Select filament type: PLA
** Complete wizard

=== Importing and Slicing the Cube ===

# '''Import STL''' - File → Import → Import STL/OBJ, select calibration cube
# '''Position model''' - Should automatically be on center of bed
** If not: Right-click model → Center
# '''Check scale''' - Model should be 20mm × 20mm × 20mm (verify in right panel)
# '''Configure print settings''' (right panel):
** '''Layer height''': 0.2mm (good balance of speed and quality)
** '''Infill''': 20% (sufficient for test)
** '''Supports''': None (cube doesn't need them)
** '''Brim''': Yes (helps adhesion for first print)
# '''Slice''' - Click "Slice now" button (bottom right)
# '''Review preview''':
** Click "Preview" button (bottom right)
** Use slider to see layer by layer
** Check that first layer looks good (should be solid, covering bed area)
# '''Export G-code''' - Click "Export G-code" button
** Save to SD card or USB drive

=== Print Settings Explained ===

* '''Layer height''' (0.2mm) - Thickness of each layer
** Smaller = smoother, slower (0.1mm for high detail)
** Larger = faster, rougher (0.3mm for draft prints)
* '''Infill''' (20%) - Internal structure density
** Higher = stronger, heavier, slower (30-50% for structural parts)
** Lower = lighter, faster (10-15% for non-structural parts)
* '''Perimeters''' (2-3) - Number of outer wall layers
** More = stronger, better surface finish
* '''Brim''' - Extra layer around base (helps adhesion, easy to remove)
* '''Raft''' - Platform under entire part (use for difficult adhesion, wastes material)
* '''Supports''' - Temporary structures to hold overhangs (remove after printing)

=== Starting the Print ===

# '''Insert SD card''' into printer
# '''Clean the bed''' - Wipe with isopropyl alcohol, let dry
# '''Verify bed level''' - Do a final check with paper if uncertain
# '''Start print''' - Menu: Print from SD → select G-code file
# '''Watch the first layer''' - This is critical!

=== Watching the First Layer ===

Stand and watch the entire first layer print. This determines success:

'''Good first layer:'''
* Plastic is squished slightly onto bed (not round, slightly flat)
* Lines are touching each other with no gaps
* Plastic is not being pushed around by nozzle
* Print is adhering firmly to bed

'''Bad first layer (stop and restart):'''
* Lines are round (nozzle too high - adjust bed lower)
* Nozzle drags through plastic (too low - raise bed)
* Gaps between lines (too high)
* Plastic not sticking to bed (bed too cold, dirty, or not level)

'''If first layer fails:''' Stop the print, adjust bed leveling, clean bed, try again.

'''If first layer succeeds:''' You can leave it to print! Check back periodically.

=== Print Complete ===

When print finishes:
# '''Let bed cool''' - Print will often pop off on its own as bed cools
# '''Gently flex bed''' (if removable spring steel sheet) - Print pops off
# '''Use spatula''' - Slide under edge of print, pry gently
# '''Remove brim''' - Use flush cutters or hands to remove brim material

Inspect your cube:
* Measure with calipers: Should be close to 20mm × 20mm × 20mm (±0.2mm is good)
* Check corners: Should be square and sharp
* Check walls: Should be solid and smooth

Congratulations on your first successful print!

== Part 5: Troubleshooting Common First Print Problems ==

=== Print Not Sticking to Bed ===

'''Causes and solutions:'''
* '''Bed not level''' - Re-level bed, nozzle should be slightly closer
* '''Bed too cold''' - Increase bed temperature by 5-10°C (try 65°C for PLA)
* '''Bed dirty''' - Clean with isopropyl alcohol
* '''Nozzle too far''' - Lower bed (turn corner knobs clockwise)
* '''First layer too fast''' - Slow down first layer speed in slicer (50% of normal)

'''Extra help:''' Apply glue stick to bed for difficult adhesion.

=== Lines Not Touching (Gaps in First Layer) ===

'''Cause:''' Nozzle too far from bed

'''Solution:''' Adjust bed level - turn corner knobs clockwise to bring bed closer to nozzle.

=== Nozzle Dragging/Scraping ===

'''Cause:''' Nozzle too close to bed

'''Solution:''' Adjust bed level - turn corner knobs counter-clockwise to lower bed away from nozzle.

=== Print Warping (Corners Lifting) ===

'''Causes and solutions:'''
* '''Bed too cold''' - Increase bed temperature
* '''Rapid cooling''' - Close windows, avoid drafts
* '''Poor adhesion''' - Clean bed, use brim or raft
* '''Part geometry''' - Large flat parts warp more (add brim or mouse ears at corners)

=== Stringing (Thin Strings Between Parts) ===

'''Causes and solutions:'''
* '''Nozzle too hot''' - Reduce temperature by 5°C
* '''Retraction too low''' - Increase retraction distance in slicer (5-6mm for Bowden)
* '''Print too slow''' - Increase print speed slightly

=== Layer Shifting (Print Offset Mid-Print) ===

'''Causes and solutions:'''
* '''Belts too loose''' - Tighten belts (should twang like guitar string when plucked)
* '''Speed too high''' - Reduce print speed
* '''Mechanical binding''' - Check that axes move freely, lubricate if needed

=== Under-Extrusion (Gaps in Walls) ===

'''Causes and solutions:'''
* '''Nozzle partially clogged''' - Perform cold pull cleaning
* '''Temperature too low''' - Increase by 5-10°C
* '''Filament diameter wrong''' - Verify slicer is set to 1.75mm (or 2.85mm if that's what you have)
* '''Extruder gear slipping''' - Tighten extruder tension spring

== Part 6: Printing SimpleBot Components ==

Now that you've successfully printed a calibration cube, you're ready for real robot parts!

=== Downloading SimpleBot STL Files ===

# Navigate to SimpleBot repository (linked from [[SimpleBot]] wiki page)
# Go to the `stl/` or `3d_models/` directory
# Download all STL files:
** Chassis base and top
** Motor mounts (left and right)
** Wheel hubs (2×)
** Sensor bracket
** Battery holder
** Any other structural components

=== Print Order Recommendation ===

Start with smallest parts first to gain confidence:

# '''Sensor bracket''' (~1 hour) - Small, simple, good practice
# '''Wheel hubs''' (30-45 min each) - Small, verify fit with motor shaft
# '''Motor mounts''' (~2 hours each) - Test holes fit motors correctly
# '''Chassis base''' (~4-6 hours) - Large, important part
# '''Chassis top''' (~3-5 hours) - Can print while assembling other parts

=== Slicer Settings for SimpleBot Parts ===

'''General settings:'''
* '''Layer height''': 0.2mm (good balance)
* '''Infill''': 20% (sufficient for most parts)
* '''Perimeters''': 3 (strong outer walls)
* '''Supports''': Usually not needed (parts designed to print without supports)
* '''Brim''': Use for large parts (chassis) to prevent warping

'''Part-specific notes:'''
* '''Chassis''' - Large flat part, definitely use brim
* '''Motor mounts''' - Check hole sizes (may need to adjust scale if motors don't fit)
* '''Wheel hubs''' - Verify fit on motor shaft (may need light sanding)
* '''Sensor bracket''' - Ensure mounting holes align with sensors

=== Print Time Estimates ===

Total print time for all SimpleBot parts: '''15-20 hours'''

* Sensor bracket: 1 hour
* Wheel hubs (2×): 1.5 hours
* Motor mounts (2×): 4 hours
* Chassis base: 5 hours
* Chassis top: 4 hours
* Misc brackets: 2 hours

You can print multiple small parts simultaneously to save time.

=== Quality Check After Printing ===

For each part:
* ☐ Verify dimensions with calipers (compare to CAD file or assembly guide)
* ☐ Check mounting holes - screws should fit (M3 typically)
* ☐ Test fit with hardware - motors, sensors, PCB
* ☐ Remove supports (if any) and clean up edges
* ☐ Light sanding if parts don't fit together smoothly

== Part 7: Post-Processing Robot Parts ==

=== Removing Supports ===

If you printed parts with supports:
# Use flush cutters to clip large support structures
# Break away remaining supports by hand
# Use needle file or sandpaper to smooth support scars
# Check that surfaces are flat where parts mate

=== Cleaning Up Holes ===

Printed holes are often slightly undersized:

* '''Clearance holes (screws pass through)''':
** Use drill bit slightly larger than screw diameter
** Drill by hand (twist drill bit with fingers) or with drill
** Test fit frequently - don't remove too much material
* '''Press-fit holes (bearings, nuts)''':
** May need light sanding with sandpaper wrapped around dowel
** Test fit frequently - goal is snug fit
* '''Threaded holes''':
** Drill/print undersized (M3 screw needs 2.5mm hole)
** Use tap to cut threads
** Or just drive screw directly into plastic (works for low-stress applications)

=== Fitting Parts Together ===

Test assembly before final build:
# Dry-fit all parts (no glue, no screws)
# Identify any interference or misalignment
# Sand or file problem areas
# Re-test until smooth assembly

=== Optional Finishing ===

For a polished look:
* '''Sanding''' - Progressive grits (120 → 220 → 400) for smooth surface
* '''Primer and paint''' - Automotive filler primer hides layer lines
* '''Clear coat''' - Protects finish and adds shine

Not necessary for functional robot parts, but makes them look professional.

== Part 8: Assembling SimpleBot with Printed Parts ==

Once all parts are printed and cleaned up:

# Follow [[SimpleBot]] assembly guide
# Key steps:
** Mount motors into motor mounts using M3 screws
** Attach wheel hubs to motor shafts (may need small set screws)
** Mount PCB and electronics to chassis base
** Attach sensor bracket at front of chassis
** Mount line sensors to bracket
** Connect wiring according to schematic
** Attach chassis top
** Insert batteries

'''Tip:''' Take photos during assembly to help with troubleshooting later.

== Part 9: Maintenance and Care ==

=== Printer Maintenance ===

After every print:
* Remove print from bed
* Clean bed with isopropyl alcohol
* Inspect nozzle for plastic buildup (wipe with paper towel when hot)

Weekly (if printing frequently):
* Check belt tension
* Lubricate linear rods/rails with machine oil
* Check all screws for tightness (vibration loosens them)

Monthly:
* Re-level bed
* Check extruder gear for wear
* Clean fans and heat sinks

=== Filament Storage ===

PLA absorbs moisture from air, which causes:
* Bubbling during extrusion
* Poor layer adhesion
* Brittle prints

'''Storage solution:'''
* Keep filament in sealed container with silica gel desiccant
* Some hobbyists use vacuum-sealed bags
* If filament gets wet, dry in oven at 40-50°C for 4-6 hours (or use filament dryer)

=== Replacing Nozzles ===

Nozzles wear out after 100-500 hours of printing:
* Abrasive filaments (carbon fiber, wood fill) wear fastest
* Symptoms: Under-extrusion, inconsistent extrusion
* Replacement: Heat to 200°C, unscrew old nozzle, screw in new one

Keep spare 0.4mm nozzles on hand ($1-2 each in bulk).

== Next Steps ==

=== Continue Your 3D Printing Journey ===
* '''[[3D Printing for Robotics]]''' (Intermediate) - Learn to design custom parts for FDM printing
* '''[[CAD Design]]''' (Intermediate) - Create your own robot parts from scratch
* '''[[3D Printing]]''' (Competency Overview) - Explore intermediate and advanced techniques

=== Build With Your New Skill ===
* '''[[SimpleBot]]''' - Complete your robot assembly
* '''[[SimpleBot:Line Following Implementation]]''' - Get SimpleBot following lines
* '''[[SimpleBot:Dead Reckoning Implementation]]''' - Implement odometry navigation

=== Expand Your Capabilities ===
* Print custom sensor mounts for new capabilities
* Design brackets for additional electronics
* Create custom wheels for different surfaces
* Build entirely new robot chassis designs

== Common Beginner Questions ==

=== Q: How do I know if my printer is working correctly? ===
'''A:''' Print a calibration cube and measure it. If dimensions are within 0.2mm of 20mm × 20mm × 20mm, your printer is well-calibrated.

=== Q: My print failed. What do I do? ===
'''A:''' Identify the failure mode:
* Failed first layer → Bed leveling issue
* Warped corners → Bed temperature or adhesion issue
* Spaghetti mess → Lost adhesion mid-print, clean bed and re-level
* Layer shifting → Belt tension or mechanical issue
* Under-extrusion → Temperature, clog, or extruder issue

=== Q: How long does filament last? ===
'''A:''' 1kg of PLA prints approximately:
* 50-100 calibration cubes
* 3-4 complete SimpleBot chassis sets
* 10-20 smaller parts (brackets, mounts)

=== Q: Can I leave prints running overnight? ===
'''A:''' Generally yes, but:
* Watch the first layer before leaving
* Ensure printer is on stable surface, away from flammable materials
* Some hobbyists use fire-resistant enclosures for peace of mind
* Consider cheap WiFi camera to monitor remotely

=== Q: What if screws/motors don't fit printed parts? ===
'''A:''' Common issue due to printer tolerances:
* Holes too small → Drill them slightly larger
* Holes too large → Print at 101-102% scale, or use larger screws
* Shaft loose → Wrap with tape or print at 99% scale

=== Q: Do I need supports for SimpleBot parts? ===
'''A:''' SimpleBot parts are designed to print without supports when properly oriented. If your slicer suggests supports, check the part orientation in the slicer.

== Troubleshooting Resources ==

* '''Teaching Tech Calibration''': https://teachingtechyt.github.io/calibration.html
* '''Simplify3D Print Quality Guide''': https://www.simplify3d.com/support/print-quality-troubleshooting/
* '''Reddit r/FixMyPrint''': Community help for print issues
* '''3D Printing Discord servers''': Real-time help from experienced users

== See Also ==

* [[3D Printing]] - Full competency overview
* [[SimpleBot]] - Build your first robot with printed parts
* [[3D Printing for Robotics]] - Next tutorial in the learning path
* [[CAD Design]] - Design your own parts to print

[[Category:Tutorials]]
[[Category:3D Printing]]
[[Category:Beginner]]

3D Printing

2025-10-11T20:12:29Z

John: Created page with "{{Competency |name=3D Printing |description=Creating mechanical parts from plastic filament using FDM printing |difficulty_range=Beginner to Advanced |time_to_basic=1-2 weeks |essential_tools=FDM 3D printer ($200-400), PLA filament, slicer software |optional_tools=Calipers, flush cutters, deburring tool, adhesives |beginner_tutorial=3D Printing Basics |unlocks_basic=Custom chassis, sensor mounts, brackets, wheels |unlocks_advanced=Complex assemblies, living hinges, p..."

{{Competency
|name=3D Printing
|description=Creating mechanical parts from plastic filament using FDM printing
|difficulty_range=Beginner to Advanced
|time_to_basic=1-2 weeks
|essential_tools=FDM 3D printer ($200-400), PLA filament, slicer software
|optional_tools=Calipers, flush cutters, deburring tool, adhesives
|beginner_tutorial=[[3D Printing Basics]]
|unlocks_basic=Custom chassis, sensor mounts, brackets, wheels
|unlocks_advanced=Complex assemblies, living hinges, parametric designs, embedded hardware
}}

'''3D Printing''' is the competency of fabricating mechanical parts from digital designs using additive manufacturing. In robotics, 3D printing is the most accessible and affordable way to create custom chassis, brackets, sensor mounts, wheels, and structural components.

This competency focuses specifically on '''FDM (Fused Deposition Modeling)''' printing - the cheapest and most common technology for hobbyist robotics. It's about the '''hands-on technique''' of turning digital CAD files into physical parts that work on real robots.

3D Printing is distinct from [[CAD Design]] (creating the digital models) and [[Mechanics]] (understanding mechanical principles). This competency focuses on the '''fabrication process itself''': preparing models for printing, selecting settings, troubleshooting failures, and finishing parts.

== Why 3D Printing Matters for Robotics ==

3D printing revolutionized hobbyist robotics by eliminating barriers to custom mechanical design:

* '''Affordability''' - Print custom parts for pennies instead of machining for dollars
* '''Rapid iteration''' - Redesign and reprint in hours, not weeks
* '''Complex geometry''' - Create shapes impossible to machine or cut
* '''No tooling''' - No need for mills, lathes, or specialized equipment
* '''On-demand manufacturing''' - Print what you need, when you need it

Before accessible 3D printing, hobbyists were limited to:
* Off-the-shelf kits with fixed designs
* Simple laser-cut acrylic plates
* Hand-cutting/drilling materials with limited precision
* Expensive machine shop services

Now, anyone with a $200-400 printer can create professional-quality robot parts at home.

== Skill Progression ==

=== Beginner (SimpleBot Level) ===

Skills you need to print and assemble [[SimpleBot]] parts:

* '''Operating a printer''' - Bed leveling, loading filament, starting prints
* '''Using slicer software''' - Import STL, basic settings, generate G-code
* '''Print preparation''' - Bed adhesion, first layer success
* '''Basic troubleshooting''' - Warping, layer adhesion, stringing
* '''Post-processing''' - Removing supports, cleaning up prints, basic finishing
* '''Assembly''' - Inserting hardware (screws, nuts, bearings) into printed parts

'''Unlocks''':
* Print SimpleBot chassis from provided STL files
* Print sensor brackets and motor mounts
* Print wheels and structural components
* Assemble printed parts into working robots

'''Tutorials''': [[3D Printing Basics]]

'''At this level you can''':
* Print designs created by others (download STL files)
* Successfully produce functional parts for your robot
* Troubleshoot common print failures
* Assemble printed parts with hardware

=== Intermediate (Custom Robot Parts) ===

Skills for designing and printing custom robot parts:

* '''Design for FDM''' - Layer orientation, overhangs, support requirements
* '''Tolerances and fit''' - Designing holes, slots, and assemblies that fit together
* '''Print orientation''' - Choosing optimal orientation for strength and printability
* '''Support strategies''' - When to use supports, how to minimize them
* '''Advanced slicing''' - Variable layer height, infill patterns, perimeters
* '''Material selection''' - PLA vs PETG vs TPU for different applications
* '''Embedded hardware''' - Designing parts with captive nuts, heat-set inserts, bearings
* '''Iterative design''' - Measuring, adjusting, reprinting efficiently

'''Unlocks''':
* Design custom chassis for your robot concept
* Create mounting brackets for non-standard sensors
* Design wheel hubs, motor mounts, and gearing
* Print functional assemblies (hinges, latches, sliding parts)
* Adapt designs for different motors/sensors/components

'''Tutorials''': [[3D Printing for Robotics]]

'''At this level you can''':
* Design parts from scratch that print successfully
* Modify existing designs to fit your needs
* Choose optimal print settings for different applications
* Design multi-part assemblies that fit together
* Troubleshoot dimensional accuracy issues

=== Advanced (Complex Mechanical Systems) ===

Skills for professional-grade printed mechanisms:

* '''Parametric design''' - Use variables to create adjustable designs
* '''Living hinges''' - Print flexible joints in rigid materials
* '''Gear design''' - Print functional gears, belts, pulleys
* '''Multi-material printing''' - Combining rigid and flexible materials
* '''Thread design''' - Print functional threads for screws and bolts
* '''Strength optimization''' - Anisotropy, layer lines, infill strategies for load-bearing parts
* '''Tolerance stacks''' - Managing precision in complex assemblies
* '''Material properties''' - Engineering plastics (nylon, polycarbonate, carbon fiber composites)
* '''Surface finishing''' - Vapor smoothing, sanding, painting, coating

'''Unlocks''':
* Gripper mechanisms with printed flexures
* Custom gearboxes and drivetrains
* Ball bearing races and sliding mechanisms
* Snap-fit enclosures and latches
* Load-bearing structural components

'''Tutorials''': [[Advanced FDM Techniques]] (stub)

'''At this level you can''':
* Design complex mechanisms entirely in plastic
* Replace machined metal parts with optimized prints
* Create production-quality assemblies
* Push the limits of FDM technology
* Teach others 3D printing for robotics

== Learning Paths ==

=== Path 1: SimpleBot Builder (Beginner) ===
# Get a working FDM printer (Creality Ender 3, Prusa Mini, or similar)
# Complete [[3D Printing Basics]] - First successful print
# Download SimpleBot STL files from the repository
# Print all SimpleBot parts (chassis, motor mounts, wheels, brackets)
# Assemble [[SimpleBot]] using your printed parts

'''Result''': You can print robot parts designed by others and assemble them into working robots.

=== Path 2: Custom Parts Designer (Intermediate) ===
# Complete Path 1 (SimpleBot Builder)
# Learn basic [[CAD Design]] (FreeCAD, Fusion 360, or Onshape)
# Study [[3D Printing for Robotics]] - Design principles for FDM
# Design a custom sensor mount for SimpleBot
# Iterate on the design (measure, adjust, reprint)
# Document your design as an implementation page

'''Result''': You can design custom parts that integrate with existing robots.

=== Path 3: Mechanism Designer (Advanced) ===
# Complete Path 2 (Custom Parts Designer)
# Design a complete custom robot chassis from scratch
# Incorporate complex features (living hinges, embedded nuts, snap fits)
# Design multi-part assemblies (gripper, articulated arm, gearbox)
# Test and iterate on mechanical performance
# Share your design with the community

'''Result''': You can design complete robots and complex mechanisms using 3D printing.

== Essential Concepts ==

=== FDM Process Basics ===

'''Fused Deposition Modeling''' works by:
# '''Heating''' plastic filament (typically 190-220°C for PLA)
# '''Extruding''' melted plastic through a nozzle (typically 0.4mm)
# '''Depositing''' plastic in layers (typically 0.1-0.3mm thick)
# '''Building up''' layers to create 3D objects

Key parameters:
* '''Layer height''' - Thinner = smoother, slower; thicker = faster, rougher
* '''Nozzle temperature''' - Too hot = stringing; too cold = poor adhesion
* '''Bed temperature''' - Prevents warping (60°C for PLA, 80°C for PETG)
* '''Print speed''' - Faster = more failures; slower = higher quality

=== Material Selection for Robotics ===

* '''PLA (Polylactic Acid)''' - Best for beginners
** Easy to print, low warping, no fumes
** Rigid but brittle
** Good for chassis, brackets, non-load-bearing parts
** '''Weakness''': Low temperature resistance (softens >60°C)

* '''PETG (Polyethylene Terephthalate Glycol)''' - Durable upgrade
** Slightly harder to print than PLA
** Flexible and impact-resistant
** Good for wheels, motor mounts, stressed parts
** '''Weakness''': Prone to stringing

* '''TPU (Thermoplastic Polyurethane)''' - Flexible rubber-like
** Difficult to print (requires direct drive or slow speeds)
** Excellent for tires, grips, shock absorption
** '''Weakness''': Cannot be load-bearing

'''For SimpleBot''': PLA is sufficient for all parts. Upgrade to PETG for motor mounts and wheels if you want better durability.

=== Layer Orientation and Strength ===

FDM parts are '''anisotropic''' - strength depends on orientation:

* '''Strongest''': Load parallel to layers
* '''Weakest''': Load perpendicular to layers (layers can separate)

'''Example''': A motor mount bracket should be oriented so forces push along layers, not pulling layers apart.

This is critical for robotics - a poorly oriented print can fail under load even with 100% infill.

=== Overhangs and Supports ===

FDM cannot print in mid-air. '''Overhangs''' are angles that extend beyond the previous layer:

* '''<45° overhang''' - Usually prints fine without support
* '''45-70° overhang''' - May need support depending on geometry
* '''>70° overhang''' - Definitely needs support

'''Bridging''' - Horizontal spans between two points (printer can do short bridges <20mm)

'''Supports''' are temporary structures that hold up overhangs during printing. They must be removed after printing, leaving marks on the surface.

'''Design strategy''': Orient parts to minimize supports (faster, cleaner, stronger).

=== Tolerances and Fit ===

Printed parts have dimensional variation:

* '''Typical accuracy''': ±0.2mm (but varies by printer, material, settings)
* '''Holes print smaller''' - Add 0.2-0.3mm to hole diameters
* '''Shafts print larger''' - Subtract 0.2-0.3mm from shaft diameters

'''Clearance fits''' for robotics:
* '''Press fit''' - 0.0mm clearance (part pressed in, stays tight)
* '''Slip fit''' - 0.2mm clearance (parts slide together with friction)
* '''Free fit''' - 0.5mm clearance (parts move freely, some wobble)

'''Example''': For an M3 screw (3.0mm nominal):
* '''Threaded hole''' - print 2.5mm, tap with M3 tap
* '''Clearance hole''' - print 3.3-3.5mm (screw passes through freely)

== Print Preparation and Settings ==

=== Slicing Software ===

'''Slicers''' convert STL files to G-code (printer instructions):

* '''PrusaSlicer''' (free, open-source, excellent defaults)
* '''Cura''' (free, user-friendly, widely used)
* '''Simplify3D''' (paid, advanced features)

All slicers allow you to adjust:
* Layer height, infill density, perimeters
* Support generation and placement
* Print speed, temperature, retraction
* Bed adhesion (brim, raft, skirt)

=== Critical First Layer ===

The '''first layer''' determines success or failure:

* '''Bed leveling''' - Nozzle must be exactly the right distance from bed
** Too close = nozzle drags, clogs
** Too far = poor adhesion, warping
* '''Bed adhesion''' - Clean bed, appropriate temperature
* '''First layer speed''' - Slower than normal (50% of print speed)
* '''First layer height''' - Slightly thicker than other layers (0.2mm is common)

'''Tip''': Watch the entire first layer. If it's not perfect, stop and restart.

=== Support Settings ===

When supports are needed:
* '''Support type''' - Grid, lines, or tree supports
* '''Support density''' - 10-20% typical (more = harder to remove)
* '''Support Z-distance''' - Gap between support and part (0.2mm typical)
* '''Support interface''' - Dense layer between support and part (easier removal, better surface)

'''Tip''': Use support blockers/enforcers to add supports only where needed.

=== Infill Strategies ===

'''Infill''' is the internal structure (not visible on outside):

* '''Infill density''' - 10-20% for most robotics parts (saves time and material)
* '''Infill pattern''' - Grid, gyroid, honeycomb (gyroid is strong and fast)
* '''Perimeters''' - 3-4 walls typical (outside strength comes from perimeters, not infill)

'''For structural parts''': 30-50% infill + 4 perimeters is stronger than 100% infill + 2 perimeters.

== Common Pitfalls ==

* '''Skipping bed leveling''' - Single most common cause of failure. Level the bed every time.
* '''Ignoring first layer problems''' - A bad first layer never gets better. Stop and restart.
* '''Wrong temperature''' - Too cold = poor adhesion between layers (weak parts). Too hot = stringing, oozing.
* '''Insufficient perimeters''' - Thin walls with high infill are weaker than thick walls with low infill.
* '''Poor orientation''' - Printing with load perpendicular to layers = weak parts that snap.
* '''Overusing supports''' - Supports waste time and material. Reorient parts to avoid them when possible.
* '''Ignoring tolerances''' - Holes too small, shafts too big. Always test fit and adjust.
* '''Wet filament''' - PLA absorbs moisture from air, causes bubbling and poor prints. Store in dry boxes.

== Post-Processing Techniques ==

=== Support Removal ===
* Use flush cutters to clip away supports
* Pliers for larger support structures
* Deburring tool or knife for cleaning up nubs
* Sandpaper for smoothing support scars

=== Hardware Insertion ===
* '''Heat-set inserts''' - Brass threaded inserts melted into plastic (strong, reusable threads)
* '''Captive nuts''' - Design hexagonal pockets for nuts to drop into
* '''Press-fit bearings''' - Print undersized holes, press bearings in for tight fit
* '''Tapping threads''' - Drill/print undersized hole, cut threads with tap

=== Finishing ===
* '''Sanding''' - Progressive grits (80 → 220 → 400) for smooth surface
* '''Acetone vapor''' - ABS only (PLA doesn't respond)
* '''Primer + paint''' - Automotive primer fills layer lines
* '''Clear coat''' - Protects paint, adds gloss

== Tools and Equipment ==

=== Essential Tools (Start Here) ===
* '''FDM 3D Printer''' ($200-400) - Creality Ender 3, Prusa Mini, Artillery Sidewinder
* '''PLA filament''' ($15-25/kg) - White, black, or colorful
* '''Slicer software''' (free) - PrusaSlicer or Cura
* '''Flush cutters''' ($5-10) - Remove supports and clean up prints
* '''Spatula/scraper''' ($5-10) - Remove prints from bed

=== Intermediate Tools ===
* '''Calipers''' ($15-30) - Measure parts and check tolerances
* '''Deburring tool''' ($5-10) - Clean up edges and holes
* '''Needle files''' ($10-20) - Fine-tune printed holes and slots
* '''Isopropyl alcohol''' ($5-10) - Clean print bed for adhesion
* '''Extra nozzles''' ($10-20) - 0.4mm spares, plus 0.6mm for faster prints

=== Advanced Tools ===
* '''Heat-set insert tips''' ($20-40) - For soldering iron
* '''Filament dryer''' ($30-60) - Keep filament moisture-free
* '''Different materials''' ($20-30/kg) - PETG, TPU for specialized parts
* '''Spare parts kit''' ($20-40) - Nozzles, hot end parts, belts, fans

== Printer Recommendations for Robotics ==

=== Budget Entry ($200-300) ===
* '''Creality Ender 3 V2''' - Most popular beginner printer, huge community
* '''Artillery Genius''' - Quieter, faster out-of-box experience

=== Mid-Range ($400-600) ===
* '''Prusa Mini+''' - Excellent reliability, open-source, great support
* '''Creality CR-10 Smart''' - Larger build volume (300×300mm)

=== Premium ($800-1200) ===
* '''Prusa i3 MK4''' - Best-in-class, auto bed leveling, filament sensor
* '''Bambu Lab P1S''' - Extremely fast, enclosed, multi-material capable

'''For SimpleBot''': Any printer with 180×180×180mm build volume works. Ender 3 is excellent value.

== Tutorials and Resources ==

=== BRS Tutorials ===
* '''[[3D Printing Basics]]''' (Beginner) - Your first print to assembled robot
* '''[[3D Printing for Robotics]]''' (Intermediate) - Design principles for functional parts
* '''[[CAD Design]]''' (Intermediate) - Create your own designs

=== Robot Pages ===
* [[SimpleBot]] - All parts are 3D printed (download STLs from repository)
* [[SimpleBot:Chassis Design]] - Design decisions for SimpleBot chassis

=== External Resources ===
* [https://www.prusa3d.com/learn/ Prusa Learning] - Comprehensive 3D printing guides
* [https://www.youtube.com/c/MakersMuseOriginals Maker's Muse] - YouTube channel on 3D printing
* [https://teachingtechyt.github.io/calibration.html Teaching Tech Calibration] - Printer calibration guide
* [https://www.youtube.com/c/CNCKitchen CNC Kitchen] - Engineering analysis of 3D printed parts

== Related Competencies ==

* '''[[CAD Design]]''' - Create the digital models to print (prerequisite for custom designs)
* '''[[Mechanics]]''' - Understand forces, motion, and structural principles
* '''[[Electronics]]''' - Design parts that house and protect electronics
* '''[[Soldering]]''' - Insert heat-set inserts with soldering iron
* '''[[Assembly]]''' - Put printed parts together with hardware

== How 3D Printing Enables Capabilities ==

3D printing doesn't directly create [[Capabilities]] (which require sensors or actuators), but it '''enables''' capabilities by providing the mechanical structure:

* '''Chassis''' - Provides rigid structure for mounting electronics and motors
* '''Sensor mounts''' - Position [[Capability:Line Sensing]], [[Capability:Ultrasonic Sensing]], etc. at correct angles and heights
* '''Motor mounts''' - Secure motors for [[Capability:Differential Drive]], [[Capability:Omni Drive]]
* '''Wheel hubs''' - Connect wheels to motor shafts (custom diameters for different odometry needs)
* '''Brackets and standoffs''' - Organize electronics, prevent shorts, provide cable management
* '''Enclosures''' - Protect electronics from impacts and debris

Every capability needs mechanical support - 3D printing makes that support custom-fittable to your exact hardware.

== See Also ==

* [[SimpleBot]] - A robot designed around 3D printed parts
* [[CAD Design]] - Create models to print
* [[Robotics Ontology]] - How fabrication fits into the BRS knowledge structure
* [[Capabilities]] - What 3D printed parts enable

[[Category:Competencies]]
[[Category:Skills]]

Electronics Fundamentals

2025-10-11T19:50:51Z

John: Created page with "{{Tutorial |name=Electronics Fundamentals |competency=Electronics |difficulty=Beginner |time=2-4 hours (split across multiple sessions) |prerequisites=None - complete beginner friendly |materials=Multimeter ($15-30), breadboard, LED, resistor (220Ω), 9V battery or power supply |next_steps=SimpleBot assembly, Motor Control Basics, Sensor Interfacing }} '''Electronics Fundamentals''' is your introduction to understanding circuits, components, and electron..."

{{Tutorial
|name=Electronics Fundamentals
|competency=[[Electronics]]
|difficulty=Beginner
|time=2-4 hours (split across multiple sessions)
|prerequisites=None - complete beginner friendly
|materials=Multimeter ($15-30), breadboard, LED, resistor (220Ω), 9V battery or power supply
|next_steps=[[SimpleBot]] assembly, [[Motor Control Basics]], [[Sensor Interfacing]]
}}

'''Electronics Fundamentals''' is your introduction to understanding circuits, components, and electronic systems for robotics. This tutorial covers the essential knowledge you need to build and understand [[SimpleBot]] and other BRS robots.

By the end of this tutorial, you'll understand:
* How to read schematics
* What voltage, current, and resistance mean
* How to use a multimeter
* How digital and analog signals work
* How to prototype circuits on a breadboard

This tutorial is '''hands-on'''. You'll need a multimeter and a few basic components to follow along.

== Part 1: Understanding Voltage, Current, and Resistance ==

=== The Water Analogy ===

Electricity is invisible, so we use analogies to understand it. The water pipe analogy is the most common:

* '''Voltage (V)''' - Water pressure in the pipes
** Higher voltage = more "push" on electrons
** Measured in volts (V)
** Example: A 9V battery pushes harder than a 3V battery

* '''Current (I)''' - Flow rate of water through the pipe
** Higher current = more electrons flowing per second
** Measured in amperes or amps (A)
** Example: An LED draws 20mA (0.02A), a motor draws 200mA (0.2A)

* '''Resistance (R)''' - Size of the pipe (restriction to flow)
** Higher resistance = harder for current to flow
** Measured in ohms (Ω)
** Example: A resistor limits current flow

=== Ohm's Law: The Fundamental Equation ===

The relationship between voltage, current, and resistance is:

<math>V = I \times R</math>

'''Examples:'''
* If voltage = 9V and resistance = 450Ω, then current = 9V / 450Ω = 0.02A = 20mA
* If current = 0.5A and resistance = 10Ω, then voltage = 0.5A × 10Ω = 5V

'''Why this matters for robotics:'''
* LEDs need current-limiting resistors (too much current burns them out)
* Motors draw variable current depending on load
* You need to calculate wire thickness based on current

=== Power: Energy Consumption ===

Power is how much energy is consumed per second:

<math>P = V \times I</math>

'''Examples:'''
* If voltage = 5V and current = 0.1A, then power = 5V × 0.1A = 0.5W
* A 9V battery powering a 200mA motor consumes 9V × 0.2A = 1.8W

'''Why this matters for robotics:'''
* Battery life depends on power consumption
* Components have maximum power ratings (exceed them and they overheat)
* More power = shorter battery life or bigger batteries needed

== Part 2: Using a Multimeter ==

A '''multimeter''' is your most important electronics tool. It measures voltage, current, resistance, and continuity.

=== Multimeter Basics ===

Most multimeters have these modes:
* '''V⎓''' or '''DCV''' - DC voltage (what robots use)
* '''V~''' or '''ACV''' - AC voltage (wall power - not used in robotics)
* '''A⎓''' or '''DCA''' - DC current
* '''Ω''' - Resistance
* '''Diode symbol''' or '''Continuity''' - Beeps when circuit is complete

=== Measuring Voltage ===

Voltage is measured '''in parallel''' (multimeter probes touch two points in the circuit):

# Set multimeter to DC voltage mode (20V range for 9V battery)
# Touch red probe to positive (+) terminal
# Touch black probe to negative (-) terminal
# Read the voltage on display

'''Exercise:''' Measure a 9V battery. It should read 9V (or slightly higher if fresh, slightly lower if used).

'''Common mistake:''' Probes reversed? You'll see a negative voltage (-9V). No damage, just flip the probes.

=== Measuring Resistance ===

Resistance is measured '''with power OFF''' (multimeter sends its own small current):

# Set multimeter to resistance mode (2kΩ range for 220Ω resistor)
# Touch probes to both ends of resistor (polarity doesn't matter)
# Read the resistance on display

'''Exercise:''' Measure a 220Ω resistor. You should read approximately 220Ω (resistors have tolerance, typically ±5%).

=== Measuring Continuity ===

Continuity mode checks if there's a complete circuit (useful for finding broken wires):

# Set multimeter to continuity mode (diode symbol or speaker icon)
# Touch probes to two points in the circuit
# If it beeps, there's a complete circuit (low resistance path)
# If silent, the circuit is open (broken wire or no connection)

'''Exercise:''' Touch the probes together - it should beep. Separate them - it should be silent.

=== Measuring Current ===

Current is measured '''in series''' (multimeter becomes part of the circuit). '''Warning:''' Most multimeters have a fuse that blows if you exceed the current limit!

# Set multimeter to DC current mode (200mA range for LED)
# '''Break the circuit''' and insert multimeter in series
# Current flows through the multimeter
# Read the current on display

'''For beginners:''' Skip current measurement until you're comfortable with voltage and resistance. It's easy to blow the fuse.

== Part 3: Reading Resistor Color Codes ==

Resistors use colored bands to indicate resistance value:

{| class="wikitable"
! Band 1 !! Band 2 !! Band 3 (Multiplier) !! Band 4 (Tolerance)
|-
| First digit || Second digit || Number of zeros || Accuracy
|-
| Red = 2 || Red = 2 || Red = ×100 || Gold = ±5%
|-
| colspan="4" | '''Result: 22 × 100 = 2200Ω = 2.2kΩ, ±5%'''
|}

'''Color code:'''
* Black = 0, Brown = 1, Red = 2, Orange = 3, Yellow = 4
* Green = 5, Blue = 6, Violet = 7, Gray = 8, White = 9

'''Common resistor values in robotics:'''
* '''220Ω''' (red-red-brown) - LED current limiting
* '''1kΩ''' (brown-black-red) - Pull-up/pull-down resistors
* '''10kΩ''' (brown-black-orange) - General-purpose pull-up/pull-down

'''Tip:''' Use your multimeter to verify resistor values if you can't read the bands!

== Part 4: Breadboards and Prototyping ==

A '''breadboard''' lets you build circuits without soldering. It has internal connections:

* '''Horizontal rows''' (in the middle) - 5 holes connected together
* '''Vertical rails''' (on the sides) - Entire column connected (for power and ground)

=== Breadboard Anatomy ===

<pre>
+ Rail (Red) [Connected vertically]
- Rail (Blue) [Connected vertically]
====================================
Row 1: a b c d e f g h i j [a-b-c-d-e connected, f-g-h-i-j connected]
Row 2: a b c d e f g h i j
...
</pre>

=== Building Your First Circuit: LED + Resistor ===

'''Goal:''' Light an LED using a 9V battery and resistor.

'''Why the resistor?''' LEDs need about 20mA of current. Without a resistor, they draw too much current and burn out. The resistor "limits" the current to a safe level.

'''Calculating resistor value:'''
* LED needs 20mA (0.02A) at 2V forward voltage
* Battery provides 9V
* Voltage across resistor = 9V - 2V = 7V
* Ohm's Law: R = V / I = 7V / 0.02A = 350Ω
* Use 220Ω or 470Ω resistor (standard values close to 350Ω)

'''Wiring:'''
# Insert 9V battery clip into breadboard (+red to + rail, -black to - rail)
# Insert resistor from + rail to row 1
# Insert LED long leg (anode, +) into row 1, short leg (cathode, -) to - rail
# LED should light up!

'''Troubleshooting:'''
* LED not lighting? Check polarity (long leg = +, short leg = -)
* LED very dim? Battery might be dead
* LED too bright/hot? Resistor value too small

== Part 5: Digital Signals (HIGH and LOW) ==

Robots use '''digital signals''' - voltage is either HIGH or LOW:

* '''HIGH''' (logic 1) - Voltage is at the supply level (3.3V or 5V)
* '''LOW''' (logic 0) - Voltage is at ground (0V)

'''Example:''' A microcontroller GPIO pin can be set HIGH (3.3V) or LOW (0V) to turn an LED on or off.

=== Pull-up and Pull-down Resistors ===

Digital inputs need to be either HIGH or LOW - never '''floating''' (undefined). Pull-up/pull-down resistors set the default state:

* '''Pull-up resistor''' - Connects input to HIGH voltage (default HIGH, button press = LOW)
* '''Pull-down resistor''' - Connects input to LOW voltage (default LOW, button press = HIGH)

'''Why this matters for robots:'''
* [[Infrared Line Detector]] sensors use pull-up resistors (output LOW when line detected)
* Button inputs need pull-up or pull-down resistors to avoid erratic behavior

'''Typical value:''' 10kΩ (not too strong to waste power, not too weak to be unreliable)

=== Active HIGH vs Active LOW ===

Components can be triggered by HIGH or LOW signals:

* '''Active HIGH''' - HIGH signal activates the component (LED turns on when pin is HIGH)
* '''Active LOW''' - LOW signal activates the component (LED turns on when pin is LOW)

'''Example:''' SimpleBot's [[Infrared Line Detector]] sensors are '''active LOW''':
* Output HIGH (3.3V) when no line detected (white surface)
* Output LOW (0V) when line detected (black tape)

This is important when writing software - you need to know which logic level means "detected"!

== Part 6: Analog Signals (Variable Voltage) ==

Not all signals are digital (HIGH/LOW). '''Analog signals''' have variable voltage:

* '''Temperature sensor''' - Voltage increases with temperature
* '''Potentiometer''' (dial) - Voltage varies from 0V to supply voltage
* '''Photoresistor''' - Resistance changes with light level

=== Analog-to-Digital Conversion (ADC) ===

Microcontrollers use '''ADC''' to convert analog voltage to a number:

* '''10-bit ADC''' (Raspberry Pi Pico) - 1024 possible values (0-1023)
* '''12-bit ADC''' (ESP32) - 4096 possible values (0-4095)

'''Example:''' If ADC reads 512 on a 10-bit ADC with 3.3V reference:
* 512 / 1024 = 0.5 (50% of maximum)
* Voltage = 0.5 × 3.3V = 1.65V

'''Why this matters for robots:'''
* [[Capability:Optical Odometry]] uses photoresistors (analog signal indicates wheel position)
* Battery voltage monitoring uses ADC to measure remaining charge

== Part 7: PWM (Pulse Width Modulation) ==

'''PWM''' is a way to simulate analog voltage using rapid digital pulses:

* HIGH for 50% of the time, LOW for 50% = equivalent to half voltage
* HIGH for 75% of the time, LOW for 25% = equivalent to 75% voltage

'''Duty cycle''' = percentage of time signal is HIGH

'''Why this matters for robots:'''
* '''Motor speed control''' - 50% duty cycle = half speed, 100% = full speed
* '''LED brightness''' - 25% duty cycle = dim, 100% = full brightness

'''Frequency:''' PWM typically runs at 1kHz - 20kHz (too fast to see flickering)

== Part 8: Reading Schematics ==

'''Schematics''' are circuit diagrams using standard symbols:

{| class="wikitable"
! Component !! Symbol Description
|-
| '''Resistor''' || Zigzag line (US) or rectangle (European)
|-
| '''LED''' || Triangle with arrows pointing out
|-
| '''Battery''' || Long line (+) and short line (-)
|-
| '''Ground''' || Three horizontal lines or triangle pointing down
|-
| '''Switch''' || Gap with movable connector
|-
| '''Motor''' || Circle with M inside
|-
| '''IC (chip)''' || Rectangle with pin numbers
|}

'''Example schematic: LED circuit'''
<pre>
+9V ----[220Ω]----[LED]---- GND

Legend: [220Ω] = resistor, [LED] = LED, GND = ground
</pre>

'''Reading tips:'''
* Trace the path from + to - (current flows from positive to negative)
* Components in '''series''' (one after another) share the same current
* Components in '''parallel''' (side-by-side) share the same voltage
* Ground symbol (⏚) means 0V reference point

== Part 9: Practical Skills Checklist ==

By now, you should be able to:

* ☐ Explain voltage, current, resistance, and power
* ☐ Use Ohm's Law to calculate voltage, current, or resistance
* ☐ Measure voltage with a multimeter
* ☐ Measure resistance with a multimeter
* ☐ Check continuity with a multimeter
* ☐ Read resistor color codes (or use multimeter to verify)
* ☐ Build a simple LED circuit on a breadboard
* ☐ Understand digital signals (HIGH/LOW)
* ☐ Explain what pull-up/pull-down resistors do
* ☐ Understand what PWM is and why it's used
* ☐ Read simple schematics

If you can check most of these boxes, you're ready to build [[SimpleBot]]!

== Next Steps ==

=== Build SimpleBot ===
You now have the foundational knowledge to understand SimpleBot's electronics:
* [[SimpleBot]] - Full robot build guide
* [[SimpleBot:Line Following Implementation]] - Sensor wiring and code
* [[SimpleBot:Dead Reckoning Implementation]] - Encoder wiring and code

=== Learn More Electronics ===
* [[Motor Control Basics]] - PWM, H-bridges, motor drivers
* [[Sensor Interfacing]] - I2C, SPI, analog sensors
* [[Electronics]] - Full competency overview with intermediate and advanced topics

=== Hands-on Practice ===
* Buy an electronics kit ($20-40) with assorted components
* Build classic circuits: blinking LED, button-controlled LED, photoresistor nightlight
* Use a breadboard to prototype before soldering

== Common Beginner Mistakes ==

* '''Using voltage mode to measure current''' - This shorts the circuit and can blow the multimeter fuse or damage components
* '''Measuring resistance with power ON''' - Gives incorrect readings and can damage the multimeter
* '''Forgetting current-limiting resistors for LEDs''' - LEDs burn out instantly
* '''Reversing polarity''' - Some components (LEDs, electrolytic capacitors, ICs) are polarity-sensitive and can be damaged
* '''Confusing mA and A''' - 200mA = 0.2A, not 200A! (Off by 1000×)
* '''Breadboard wiring errors''' - Double-check that components are in the same row to be connected

== Troubleshooting Tips ==

* '''Circuit not working?''' Check continuity with multimeter (is everything connected?)
* '''Component hot?''' It's drawing too much current - check for short circuits or wrong resistor values
* '''Inconsistent behavior?''' Check for floating inputs (add pull-up/pull-down resistors)
* '''Multimeter shows 0V everywhere?''' Battery is dead or not connected
* '''Can't read resistor colors?''' Use multimeter to measure resistance directly

== Tools and Resources ==

=== Recommended First Purchases ===
* '''Multimeter''' - $15-30 (any basic model works, look for DC voltage, resistance, continuity)
* '''Breadboard''' - $5-10 (get a full-size 830-point breadboard)
* '''Jumper wire kit''' - $5-10 (includes various lengths)
* '''Electronics component kit''' - $20-40 (resistors, LEDs, capacitors, transistors)

=== External Resources ===
* [https://learn.sparkfun.com/tutorials/voltage-current-resistance-and-ohms-law SparkFun: Ohm's Law]
* [https://learn.sparkfun.com/tutorials/how-to-use-a-multimeter SparkFun: How to Use a Multimeter]
* [https://learn.sparkfun.com/tutorials/how-to-use-a-breadboard SparkFun: How to Use a Breadboard]
* [https://www.allaboutcircuits.com/textbook/ All About Circuits] - Free electronics textbook

== See Also ==

* [[Electronics]] - Full competency overview
* [[SimpleBot]] - Apply your knowledge to build a robot
* [[Motor Control Basics]] - Next tutorial in the electronics learning path
* [[Sensor Interfacing]] - Intermediate electronics tutorial

[[Category:Tutorials]]
[[Category:Electronics]]
[[Category:Beginner]]

Electronics

2025-10-11T19:50:37Z

John: Created page with "{{Competency |name=Electronics |description=Understanding the exchange of signals and power between mechanical components and software instructions |difficulty_range=Beginner to Advanced |time_to_basic=2-4 weeks |essential_tools=Multimeter, breadboard, jumper wires, wire strippers |optional_tools=Oscilloscope, logic analyzer, power supply, component kit |beginner_tutorial=Electronics Fundamentals |unlocks_basic=Capability:Line Sensing, Capability:Differential D..."

{{Competency
|name=Electronics
|description=Understanding the exchange of signals and power between mechanical components and software instructions
|difficulty_range=Beginner to Advanced
|time_to_basic=2-4 weeks
|essential_tools=Multimeter, breadboard, jumper wires, wire strippers
|optional_tools=Oscilloscope, logic analyzer, power supply, component kit
|beginner_tutorial=[[Electronics Fundamentals]]
|unlocks_basic=[[Capability:Line Sensing]], [[Capability:Differential Drive]]
|unlocks_advanced=[[Capability:IMU Sensing]], [[Capability:Camera Vision]], [[Capability:LIDAR Sensing]]
}}

'''Electronics''' is the competency of understanding circuits, components, sensors, and actuators. In robotics, electronics is the bridge between the physical world ([[Mechanics]]) and the digital world ([[Software]]). It encompasses reading schematics, selecting components, understanding power distribution, and interfacing sensors and actuators with microcontrollers.

Electronics is distinct from [[Soldering]] (the hands-on technique of joining components) and [[PCB Design]] (creating custom circuit boards). This competency focuses on '''understanding''' electronic systems: how they work, how to analyze them, and how to design them.

== Why Electronics Matters for Robotics ==

Electronics is the nervous system of a robot:
* '''Sensors''' convert physical phenomena (light, distance, motion) into electrical signals
* '''Microcontrollers''' process those signals and make decisions
* '''Actuators''' convert electrical signals back into physical motion
* '''Power systems''' distribute energy throughout the robot

Without electronics knowledge, you're limited to pre-built modules and can't troubleshoot problems, expand capabilities, or design custom solutions.

== Skill Progression ==

=== Beginner (SimpleBot Level) ===

Skills you need to build and understand [[SimpleBot]]:

* '''Reading schematics''' - Understand circuit diagrams, recognize symbols
* '''Component identification''' - Resistors, capacitors, diodes, transistors, ICs
* '''Using a multimeter''' - Measure voltage, current, resistance, continuity
* '''Breadboarding''' - Prototype circuits without soldering
* '''Power concepts''' - Voltage, current, power, batteries, regulators
* '''Digital I/O''' - HIGH/LOW signals, pull-up/pull-down resistors, active HIGH/LOW
* '''PWM basics''' - Pulse-width modulation for motor speed control

'''Unlocks''':
* [[Capability:Line Sensing]] (IR reflectance sensors)
* [[Capability:Differential Drive]] (DC motors + H-bridge)
* [[Capability:Optical Odometry]] (LED + photoresistor encoders)

'''Tutorials''': [[Electronics Fundamentals]], [[Motor Control Basics]]

'''At this level you can''':
* Build SimpleBot from a kit or pre-selected components
* Understand how sensors and motors work
* Troubleshoot basic wiring issues
* Use pre-built breakout boards and modules

=== Intermediate (Expanding Capabilities) ===

Skills for adding new sensors and capabilities to your robot:

* '''Component selection''' - Read datasheets, understand specifications, choose parts
* '''Communication protocols''' - I2C, SPI, UART/serial
* '''Analog sensors''' - ADC (analog-to-digital conversion), voltage dividers, reference voltages
* '''Logic levels''' - 3.3V vs 5V, level shifters, voltage translation
* '''Circuit design''' - Design sensor circuits, filtering, signal conditioning
* '''Interrupts''' - Hardware interrupts for encoders and timing-critical sensors
* '''Power distribution''' - Multiple voltage rails, current requirements, wire gauge selection

'''Unlocks''':
* [[Capability:IMU Sensing]] (I2C accelerometer/gyroscope modules)
* [[Capability:Encoder Sensing]] (interrupt-driven quadrature encoders)
* [[Capability:Time-of-Flight Sensing]] (I2C distance sensors)
* [[Capability:Ultrasonic Sensing]] (trigger/echo timing)
* [[Capability:Bump Sensing]] (switch debouncing)

'''Tutorials''': [[Sensor Interfacing]], [[Motor Control Basics]]

'''At this level you can''':
* Select and integrate new sensors into your robot
* Design custom sensor circuits
* Interface 5V and 3.3V components safely
* Debug communication issues with I2C and SPI
* Calculate power requirements for your robot

=== Advanced (Custom Designs) ===

Skills for designing robots from scratch:

* '''PCB layout and design''' - Design custom boards (see [[PCB Design]])
* '''Power supply design''' - Buck/boost converters, LDOs, power sequencing
* '''Signal integrity''' - Noise reduction, grounding, decoupling capacitors
* '''High-speed communication''' - SPI timing, I2C clock stretching, UART baud rates
* '''Motor driver selection''' - H-bridge specifications, current sensing, thermal management
* '''EMI/EMC considerations''' - Electromagnetic interference, shielding, filtering
* '''Analog circuit design''' - Op-amps, filters, amplifiers for custom sensors

'''Unlocks''':
* [[Capability:Camera Vision]] (high-speed data transfer, power management)
* [[Capability:LIDAR Sensing]] (motor control, high-bandwidth serial)
* [[Capability:Servo Control]] (PWM generation, power distribution)
* Custom PCB designs for integrated robots

'''Tutorials''': [[KiCad Tutorial]], [[PCB Design]]

'''At this level you can''':
* Design custom PCBs for your robots
* Select and integrate motor drivers and power systems
* Design custom sensor circuits and signal conditioning
* Troubleshoot complex electrical issues
* Optimize power efficiency and thermal performance

== Learning Paths ==

=== Path 1: SimpleBot Builder (Beginner) ===
# Start with [[Electronics Fundamentals]] - Learn to read schematics and use a multimeter
# Build [[SimpleBot]] - Hands-on experience with sensors, motors, and microcontrollers
# Complete [[Motor Control Basics]] - Understand PWM and H-bridges

'''Result''': You can build SimpleBot and understand how it works electrically.

=== Path 2: Capability Expander (Intermediate) ===
# Complete Path 1 (SimpleBot Builder)
# Study [[Sensor Interfacing]] - Learn I2C, SPI, and analog sensors
# Add a new sensor to SimpleBot (IMU, distance sensor, or encoders)
# Document your work as an Implementation page

'''Result''': You can expand SimpleBot with new capabilities and troubleshoot sensor issues.

=== Path 3: Robot Designer (Advanced) ===
# Complete Path 2 (Capability Expander)
# Learn [[PCB Design]] and [[KiCad Tutorial]]
# Design a custom PCB for your robot
# Order boards and assemble them

'''Result''': You can design robots from scratch with custom electronics.

== Essential Concepts ==

=== Voltage, Current, and Power ===
* '''Voltage''' (V) - Electrical "pressure" that pushes electrons
* '''Current''' (A) - Flow rate of electrons
* '''Power''' (W) - Energy consumption rate: P = V × I
* '''Ohm's Law''' - V = I × R (voltage = current × resistance)

=== Digital Signals ===
* '''Logic levels''' - HIGH (typically 3.3V or 5V) and LOW (0V)
* '''Pull-up/pull-down resistors''' - Set default state when input is floating
* '''Active HIGH vs Active LOW''' - Does HIGH or LOW trigger the action?

=== Analog Signals ===
* '''ADC''' (Analog-to-Digital Converter) - Convert continuous voltage to discrete number
* '''Resolution''' - 10-bit ADC = 1024 possible values (0-1023)
* '''Reference voltage''' - Maximum voltage the ADC can read

=== Communication Protocols ===
* '''I2C''' - Two-wire bus, multiple devices, addresses
* '''SPI''' - Four-wire, high-speed, chip-select per device
* '''UART/Serial''' - Two-wire, point-to-point, baud rate

=== Power Systems ===
* '''Voltage regulators''' - Convert one voltage to another (buck, boost, LDO)
* '''Decoupling capacitors''' - Filter noise near ICs
* '''Wire gauge''' - Thicker wire for higher current

== Tools and Equipment ==

=== Essential Tools (Start Here) ===
* '''Multimeter''' ($15-30) - Measure voltage, current, resistance, continuity
* '''Breadboard''' ($5-10) - Prototype circuits without soldering
* '''Jumper wires''' ($5-10) - Connect components on breadboard
* '''Wire strippers''' ($10-20) - Remove insulation from wires
* '''Component kit''' ($20-40) - Assorted resistors, capacitors, LEDs, transistors

=== Intermediate Tools ===
* '''Power supply''' ($30-80) - Variable voltage and current limiting
* '''Logic analyzer''' ($10-60) - Debug I2C, SPI, UART communication
* '''Helping hands''' ($10-20) - Hold components while working

=== Advanced Tools ===
* '''Oscilloscope''' ($100-400) - Visualize signals and timing
* '''Function generator''' ($50-200) - Generate test signals
* '''Hot air station''' ($50-150) - SMD component rework

== Common Pitfalls ==

* '''Mixing 5V and 3.3V logic''' - Can damage 3.3V microcontrollers! Use level shifters
* '''Floating inputs''' - Digital inputs without pull-up/pull-down resistors can cause erratic behavior
* '''Insufficient decoupling''' - Every IC needs a 0.1µF capacitor near its power pins
* '''Underpowered supplies''' - Motors draw large current spikes; use appropriate power sources
* '''Reversed polarity''' - Always double-check battery/power connections before powering on
* '''Overlooking current limits''' - Exceeding GPIO current limits can damage microcontrollers

== Tutorials and Resources ==

=== BRS Tutorials ===
* '''[[Electronics Fundamentals]]''' (Beginner) - Start here if you're new to electronics
* '''[[Motor Control Basics]]''' (Beginner) - PWM, H-bridges, speed control
* '''[[Sensor Interfacing]]''' (Intermediate) - I2C, SPI, analog sensors

=== Component Pages ===
* [[Raspberry Pi Pico]] - Microcontroller specifications and GPIO
* [[TB6612FNG]] - Motor driver IC details
* [[Infrared Line Detector]] - Line sensor module explanation
* [[MP1584]] - Buck converter for power regulation

=== External Resources ===
* [https://learn.sparkfun.com/tutorials SparkFun Electronics Tutorials]
* [https://www.allaboutcircuits.com/ All About Circuits] - Comprehensive electronics theory
* [https://www.eevblog.com/ EEVblog] - Electronics engineering video blog

== Related Competencies ==

* '''[[Soldering]]''' - Join components to create circuits (hands-on fabrication)
* '''[[PCB Design]]''' - Design custom circuit boards (advanced electronics)
* '''[[Software]]''' - Program microcontrollers to control electronics
* '''[[Mechanics]]''' - Understand the physical systems that electronics control
* '''[[3D Printing]]''' - Create chassis and mounts for electronic components

== See Also ==

* [[Capabilities]] - Hardware abilities that electronics enable
* [[SimpleBot]] - Apply electronics knowledge to build a robot
* [[Robotics Ontology]] - How electronics fits into the BRS knowledge structure

[[Category:Competencies]]
[[Category:Skills]]

Template:Tutorial

2025-10-11T19:49:53Z

John: Created page with "<noinclude> This template creates an info box for tutorial pages. == Usage == <pre> {{Tutorial |name=Soldering Guide |competency=Soldering |difficulty=Beginner |time=1-2 hours |prerequisites=None |materials=Soldering iron, solder, practice kit |next_steps=SimpleBot assembly, Soldering Techniques }} </pre> == Parameters == * '''name''' - Name of the tutorial * '''competency''' - Parent competency (linked) * '''difficulty''' - Beginner, Intermediate, or Advan..."

<noinclude>
This template creates an info box for tutorial pages.

== Usage ==
<pre>
{{Tutorial
|name=Soldering Guide
|competency=[[Soldering]]
|difficulty=Beginner
|time=1-2 hours
|prerequisites=None
|materials=Soldering iron, solder, practice kit
|next_steps=[[SimpleBot]] assembly, [[Soldering Techniques]]
}}
</pre>

== Parameters ==
* '''name''' - Name of the tutorial
* '''competency''' - Parent competency (linked)
* '''difficulty''' - Beginner, Intermediate, or Advanced
* '''time''' - Estimated completion time
* '''prerequisites''' - Required prior knowledge/skills
* '''materials''' - Tools and materials needed
* '''next_steps''' - What to do after completing this tutorial

</noinclude><includeonly>{| class="wikitable" style="float: right; margin-left: 15px; width: 320px; border: 2px solid #2196F3; background-color: #f0f8ff;"
! colspan="2" style="text-align: center; font-size: 120%; background-color: #2196F3; color: white;" | {{{name}}}
|-
! style="width: 40%; background-color: #e3f2fd;" | Competency
| {{{competency}}}
|-
! style="background-color: #e3f2fd;" | Difficulty
| {{{difficulty}}}
|-
! style="background-color: #e3f2fd;" | Time Required
| {{{time}}}
|-
! style="background-color: #e3f2fd;" | Prerequisites
| {{{prerequisites}}}
|-
! style="background-color: #e3f2fd;" | Materials Needed
| {{{materials}}}
|-
! style="background-color: #e3f2fd;" | Next Steps
| {{{next_steps}}}
|}</includeonly>

Template:Competency

2025-10-11T19:49:16Z

John: Created page with "<noinclude> This template creates an info box for competency pages. == Usage == <pre> {{Competency |name=Electronics |description=Understanding circuits, components, and electronic systems |difficulty_range=Beginner to Advanced |time_to_basic=2-4 weeks |essential_tools=Multimeter, breadboard, wire strippers |optional_tools=Oscilloscope, logic analyzer |beginner_tutorial=Electronics Fundamentals |unlocks_basic=Capability:Line Sensing, Capability:Differential Dr..."

<noinclude>
This template creates an info box for competency pages.

== Usage ==
<pre>
{{Competency
|name=Electronics
|description=Understanding circuits, components, and electronic systems
|difficulty_range=Beginner to Advanced
|time_to_basic=2-4 weeks
|essential_tools=Multimeter, breadboard, wire strippers
|optional_tools=Oscilloscope, logic analyzer
|beginner_tutorial=[[Electronics Fundamentals]]
|unlocks_basic=[[Capability:Line Sensing]], [[Capability:Differential Drive]]
|unlocks_advanced=[[Capability:IMU Sensing]], [[Capability:Camera Vision]]
}}
</pre>

== Parameters ==
* '''name''' - Name of the competency
* '''description''' - One-sentence description
* '''difficulty_range''' - Skill range (e.g., "Beginner to Advanced")
* '''time_to_basic''' - Time to reach basic proficiency
* '''essential_tools''' - Minimum required tools
* '''optional_tools''' - Nice-to-have tools
* '''beginner_tutorial''' - Link to get-started tutorial
* '''unlocks_basic''' - Beginner-level capabilities unlocked
* '''unlocks_advanced''' - Advanced capabilities unlocked

</noinclude><includeonly>{| class="wikitable" style="float: right; margin-left: 15px; width: 350px; border: 2px solid #4CAF50; background-color: #f9fff9;"
! colspan="2" style="text-align: center; font-size: 120%; background-color: #4CAF50; color: white;" | {{{name}}}
|-
| colspan="2" style="text-align: center; font-style: italic; padding: 10px;" | {{{description}}}
|-
! style="width: 40%; background-color: #e8f5e9;" | Difficulty Range
| {{{difficulty_range}}}
|-
! style="background-color: #e8f5e9;" | Time to Basic
| {{{time_to_basic}}}
|-
! style="background-color: #e8f5e9;" | Essential Tools
| {{{essential_tools}}}
|-
! style="background-color: #e8f5e9;" | Optional Tools
| {{{optional_tools|''None''}}}
|-
! style="background-color: #e8f5e9;" | Get Started
| {{{beginner_tutorial}}}
|-
! style="background-color: #e8f5e9;" | Unlocks (Basic)
| {{{unlocks_basic}}}
|-
! style="background-color: #e8f5e9;" | Unlocks (Advanced)
| {{{unlocks_advanced|''Various advanced capabilities''}}}
|}</includeonly>

Main Page

2025-10-11T17:31:32Z

John: /* About */

__NOTOC__
{| style="width: 100%; background-color: #f0f0f0; border: 1px solid #aaa; padding: 20px; margin-bottom: 20px;"
|-
| style="text-align: center; font-size: 150%; font-weight: bold;" | Welcome to the Bespoke Robot Society
|-
| style="text-align: center; font-size: 110%; padding-top: 10px;" | Building robots that work. Open source. Low cost. For everyone.
|}

== Our Mission ==

Our mission is to '''lower the barrier to robotics''': to create a world where building a robot to execute real-world tasks in your home or workplace is as simple as assembling a PC today. The plans and software for these robots '''must''' be open-source, or automation of daily tasks will be locked behind a paywall.

At the Bespoke Robot Society, we believe you should build your own robot that is exactly what you want it to be. But that's far too difficult today for beginners, and starting from scratch leaves far too much to be done. So '''start with one of our designs''', duplicate it exactly or use it as the starting point to your own designs. '''That's the power of open source.'''

We are at the beginning of our journey. Join us.

----

== Featured Robot: SimpleBot ==

{| style="width: 100%; border: 2px solid #4CAF50; background-color: #f9fff9; padding: 15px; margin: 20px 0;"
|-
| style="width: 300px; vertical-align: top; padding-right: 20px;" |
[[File:simplebot.jpeg|300px|link=SimpleBot]]
| style="vertical-align: top;" |
=== [[SimpleBot]] - Your First Robot ===

'''SimpleBot''' is BRS's original robot design: a low-cost, educational differential drive robot that demonstrates core robotics concepts without compromising on capability.

'''What it does:'''
* Line following with infrared sensors
* Optical odometry (measures distance traveled)
* Motor control with PWM speed adjustment
* Ready for expansion (IMU, radio, additional sensors)

'''What you'll learn:'''
* 3D printing for robot chassis
* Through-hole soldering (optional PCB kit)
* MicroPython programming
* Motor control and sensor interfacing
* Dead reckoning and navigation

'''Cost: Under $20''' (including batteries)

'''[[SimpleBot|→ Build SimpleBot]]''' | '''[https://github.com/Bespoke-Robot-Society/simplebot GitHub Repository]'''
|}

----

== Core Competencies ==

The Society organizes robotics knowledge into '''Core Competencies''' - the individual skills required to go from a pile of parts to a robot completing a task. Our goal is to provide step-by-step instructions for each skill, or open-source methods to outsource that task.

{| class="wikitable" style="width: 100%;"
! style="width: 20%; background-color: #e6f3ff;" | Competency
! style="width: 60%; background-color: #e6f3ff;" | Description
! style="width: 20%; background-color: #e6f3ff;" | Get Started
|-
| '''[[3D Printing]]'''
| Design and manufacture custom plastic parts for robot chassis and mounting systems
| [[3D Printing Basics]]
|-
| '''[[Electronics]]'''
| Understand circuits, components, sensors, and actuators; design and assemble electronic systems
| [[Electronics Fundamentals]]
|-
| '''[[Soldering]]'''
| Join electronic components to create functional circuits; through-hole and surface-mount techniques
| [[Soldering Guide]]
|-
| '''[[PCB Design]]'''
| Design custom printed circuit boards to integrate electronics into compact, reliable packages
| [[KiCad Tutorial]]
|-
| '''[[Software]]'''
| Program microcontrollers and single-board computers to control robot behavior
| [[MicroPython Basics]]
|-
| '''[[Mechanics]]'''
| Apply mechanical engineering principles to robot motion, structure, and tool interfaces
| [[Mechanical Design]]
|}

----

== Wiki Structure ==

=== Robots ===
Complete robot designs with full documentation, code, and CAD files:
* '''[[SimpleBot]]''' - Differential drive robot with line following and odometry
* More robots coming soon...

=== Components ===
Detailed references for electronic components, sensors, and modules:
* '''Microcontrollers''': [[Raspberry Pi Pico]], [[ESP32]], [[Arduino]]
* '''Motor Drivers''': [[TB6612FNG]], [[L298N]]
* '''Sensors''': [[Infrared Line Detector]], [[MPU6050]]
* '''Power''': [[MP1584]], [[Battery Management]]

=== Skills & Tutorials ===
Step-by-step guides for building and programming robots:
* [[3D Printing for Robotics]]
* [[Soldering Techniques]]
* [[MicroPython Programming]]
* [[Motor Control Basics]]
* [[Sensor Interfacing]]

=== Build Logs ===
Community members document their robot builds:
* [[Build Logs:Overview|View All Build Logs]]
* [[Build Logs:SimpleBot|SimpleBot Builds]]

----

== Recent Updates ==

'''2025-10:''' SimpleBot CAD v1.0 released with improved sensor mounting and modular chassis design

'''2025-10:''' SimpleBot review units shipped - first robots in the hands of testers

'''2025-01:''' SimpleBot PCB design finalized (through-hole version for easy assembly)

'''2024-09:''' SimpleBot prototype tested - successful line following and odometry demonstrations

----

== Get Involved ==

The Bespoke Robot Society is a collaborative effort. Here's how you can participate:

* '''[[Discord]]''' - Real-time chat, questions, and project discussions
* '''[[GitHub|GitHub Organization]]''' - Contribute code, CAD files, and documentation
* '''[[Mailing List]]''' - Monthly updates and announcements
* '''[[Contributing|Contribute to the Wiki]]''' - Share your knowledge and document your builds

=== Membership ===

BRS has no dues, no formal membership requirements, and no gatekeeping. If you're building robots and contributing to the community, you're a member. See [[Bespoke_Robot_Society:About#Structure_of_Membership|membership structure]] for informal titles based on contribution level.

----

== About ==

Learn more about the Bespoke Robot Society:
* [[Bespoke_Robot_Society:About|Mission Statement and Structure]]
* [[Bespoke_Robot_Society:Battlebots_Are_Not_Robots|Philosophy: Battlebots Are Not Robots]]
* [[Bespoke_Robot_Society:Beyond_Toys|Philosophy: Beyond Toys]]
* [[Bespoke_Robot_Society:Cheap_Stuff_Works|Philosophy: Cheap Stuff Works]]
* [[Bespoke_Robot_Society:Toddler_Testing|Philosophy: Toddler Testing]]

----

<div style="text-align: center; font-size: 90%; color: #666; margin-top: 40px;">
This wiki is maintained by the Bespoke Robot Society community.<br>
All robot designs, code, and documentation are open source.<br>
[[Bespoke_Robot_Society:About|Learn more about BRS]] | [https://github.com/Bespoke-Robot-Society GitHub] | [[Contact]]
</div>

[[Category:Main]]

Bespoke Robot Society:Beyond Toys

2025-10-11T17:30:25Z

John: /* Work vs Play */

= Beyond Toys =

This is BRS rant number two, exploring the distinction between toys and robots, and how we can use toys as a starting point without making them dead ends.

== The Question ==

How do we distinguish between a robot and a toy? Especially when the robots are mostly being advertised toward or made accessible to children, there's actually going to have a lot of overlap with a toy.

But we want to move '''beyond toys'''.

== Work vs Play ==

While exploration is a great form of play, not every toy enables you to learn something from it. Not every toy is extensible. A lot of toys just make some kind of amusement available, but they don't make the mechanics of the toy itself available. A lot of toys cover up their internals as a means of safety or protecting intellectual property.

Both of those causes are not applicable to Bespoke Robot Society's robots.

'''Toys are for play. Robots are for work.''' And sometimes the work we want to do is learning and teaching.

See also: [[Bespoke_Robot_Society:Battlebots_Are_Not_Robots|BattleBots Are Not Robots]] for more on what makes something a real robot versus a remote-control toy.

== Toys vs Tools ==

Toys, like many beginner robotics kits, are designed with limited complexity and predefined goals—like following a line, bumping into walls. If all the thing does is that single task that it's built for, it could technically be a robot, but you're still probably looking at a toy.

A true robot, on the other hand, is a '''tool designed to interact with an environment'''.

== Forward-Looking Robots ==

I want to have a forward-looking definition of robot in Bespoke Robot Society.

The old definition of robot would be those giant arms that assemble cars. They move very precisely, they have a lot of strength, they are enormously stiff, and you cannot go near them while they're in motion for your own safety. They're uncompromising. They are executing and repeating some motion a lot. Many of these robots may not have real feedback loops in the sense that they aren't really able to detect if their task is going well or not. They may require a human operator to observe and hit the e-stop when they do something faulty.

But a '''forward-looking definition of robot is about autonomy'''. It's about reacting to your environment without planning it out perfectly ahead of time.

What I mean by that is: if we have goals and we have capabilities and we have sensors, but we don't necessarily know everything about the environment—people could walk by, you don't need to bump into them, the terrain may have changed, stuff could move—we want to use our sensors and figure that out dynamically. '''That's a real robot.'''

== The Problem with Staying a Toy ==

Specifically, to advance away from a toy: a non-toy robot enables you to '''understand the problem it tries to solve''' and '''understand the limitations of the environment it can work in'''.

Then if you get a new constraint, a new difficulty added to that environment, or you want to move the robot to a new environment, if you understand how the robot works and how it relies on those environmental limitations, you can enhance the elements of the robot that don't suit the changes to the environment and you'll be able to create that new functionality yourself.

That's really the goal: enabling real-world use cases. What we mean is, you think of something that your robot might be able to do, and now you need to:
# Understand the limitations it's currently built around
# Have some resources about how to go beyond those current limitations and make the robot more robust, or robust against different hazards

Staying in the toy phase has an allure of '''false mastery'''. It's like playing with a toy that you understand fully. You might understand ''what'', but not ''why''. You may fully know how to operate, but you don't know how to extend. You may get proficiency as a user, but you will not become a creator.

That's one of the main problems with toys: even when Bespoke Robot Society robots make good toys, I don't want them to remain toys or be limited by the definition of toy.

== Tech Trees ==

One of the ways I want to address this is with '''tech trees'''.

Bespoke Robot Society's $20 robot like [[SimpleBot]] might come in a kit with every single part. The PCB is already made, and you have no real requirements put upon you besides using a Phillips head screwdriver. Now you can hit go, and you can see the robot do the task it was immediately built for.

That's great because we want people to feel the confidence, we want them to get the rapid feedback of being able to play. We want them to have a working thing quickly, not a pile of parts or an endless project.

But where do you go from there?

== From Kit to Custom ==

You could mod your robot, you could add new parts, you could repeat the robot but from a lower level of pre-completion.

Maybe you get another kit which does not include any 3D-printed parts. You go to the library and you 3D-print the parts that you need. Now you get to pick the colors, you might have to deal with a print failure, you have to think about the filaments you're going to use.

Or maybe instead of a pre-built PCB, you can solder together a kit. It's the same circuit that you're familiar with, but it's just through-hole soldering. Or maybe you want to learn the surface-mount version of that board, so you go and get the smaller SMD components.

Now we start to establish that equivalence: the prefab one is a factory-made SMD board, but the one you put together yourself is a through-hole board. But all the components are equivalent, the behavior is equivalent.

Or we go all the way for artisanal, and we get a protoboard and we hand-wire it. Again, it could be equivalent, but now you're looking at something that's not just a circuit board—it is a '''steampunk work of art'''. It is a retro-aesthetic design choice, not just a part that completes the requirements or does the behavior. It's an expression of your mastery that you've gone forward to do that.

Same thing with the software. If you have a robot that does some task, you can improve it just by changing the software. The same hardware everyone has—whether it's surface-mount, through-hole, self-made, completely custom—if it meets the standard, if it does the same task, we can share that same software. Now you're not just learning about how to change things, you're also '''collaborating with other folks'''.

This relates directly to [[Bespoke_Robot_Society:Give_Them_Away_For_Free|giving robots away for free]]—when the designs are open and shared, everyone benefits from improvements.

== The Starting Point ==

There's this huge tech tree, and we want everyone to be able to hop on and get the lay of the land by using pre-built robots, kits that are mostly assembled, things like that. But we also want you to be able to use your perspective of having that working robot to see all the different paths you could go down.

'''Toys are a starting point'''—we want you to turn it on and play immediately. But toys cannot be the end, and so many toys are dead ends as technology.

I want you to take a toy and break it and fix it. I want you to learn something from it, and I want you to think of what it can't do right now but could if you just had X, Y, or Z.

That's why I hope that Bespoke Robot Society will deliver robots that are not just toys. They should withstand [[Bespoke Robot Society:Toddler Testing|toddler testing]] and enable real learning and extension.

[[Category:Bespoke Robot Society]]
[[Category:Philosophy]]

Bespoke Robot Society:Beyond Toys

2025-10-11T17:30:14Z

John: /* Work vs Play */

= Beyond Toys =

This is BRS rant number two, exploring the distinction between toys and robots, and how we can use toys as a starting point without making them dead ends.

== The Question ==

How do we distinguish between a robot and a toy? Especially when the robots are mostly being advertised toward or made accessible to children, there's actually going to have a lot of overlap with a toy.

But we want to move '''beyond toys'''.

== Work vs Play ==

While exploration is a great form of play, not every toy enables you to learn something from it. Not every toy is extensible. A lot of toys just make some kind of amusement available, but they don't make the mechanics of the toy itself available. A lot of toys cover up their internals as a means of safety or protecting intellectual property.

Both of those causes are not applicable to Bespoke Robot Society's robots.

'''Toys are for play. Robots are for work.''' And sometimes the work we want to do is learning and teaching.

See also: [[BBespoke_Robot_Society:Battlebots_Are_Not_Robots|BattleBots Are Not Robots]] for more on what makes something a real robot versus a remote-control toy.

== Toys vs Tools ==

Toys, like many beginner robotics kits, are designed with limited complexity and predefined goals—like following a line, bumping into walls. If all the thing does is that single task that it's built for, it could technically be a robot, but you're still probably looking at a toy.

A true robot, on the other hand, is a '''tool designed to interact with an environment'''.

== Forward-Looking Robots ==

I want to have a forward-looking definition of robot in Bespoke Robot Society.

The old definition of robot would be those giant arms that assemble cars. They move very precisely, they have a lot of strength, they are enormously stiff, and you cannot go near them while they're in motion for your own safety. They're uncompromising. They are executing and repeating some motion a lot. Many of these robots may not have real feedback loops in the sense that they aren't really able to detect if their task is going well or not. They may require a human operator to observe and hit the e-stop when they do something faulty.

But a '''forward-looking definition of robot is about autonomy'''. It's about reacting to your environment without planning it out perfectly ahead of time.

What I mean by that is: if we have goals and we have capabilities and we have sensors, but we don't necessarily know everything about the environment—people could walk by, you don't need to bump into them, the terrain may have changed, stuff could move—we want to use our sensors and figure that out dynamically. '''That's a real robot.'''

== The Problem with Staying a Toy ==

Specifically, to advance away from a toy: a non-toy robot enables you to '''understand the problem it tries to solve''' and '''understand the limitations of the environment it can work in'''.

Then if you get a new constraint, a new difficulty added to that environment, or you want to move the robot to a new environment, if you understand how the robot works and how it relies on those environmental limitations, you can enhance the elements of the robot that don't suit the changes to the environment and you'll be able to create that new functionality yourself.

That's really the goal: enabling real-world use cases. What we mean is, you think of something that your robot might be able to do, and now you need to:
# Understand the limitations it's currently built around
# Have some resources about how to go beyond those current limitations and make the robot more robust, or robust against different hazards

Staying in the toy phase has an allure of '''false mastery'''. It's like playing with a toy that you understand fully. You might understand ''what'', but not ''why''. You may fully know how to operate, but you don't know how to extend. You may get proficiency as a user, but you will not become a creator.

That's one of the main problems with toys: even when Bespoke Robot Society robots make good toys, I don't want them to remain toys or be limited by the definition of toy.

== Tech Trees ==

One of the ways I want to address this is with '''tech trees'''.

Bespoke Robot Society's $20 robot like [[SimpleBot]] might come in a kit with every single part. The PCB is already made, and you have no real requirements put upon you besides using a Phillips head screwdriver. Now you can hit go, and you can see the robot do the task it was immediately built for.

That's great because we want people to feel the confidence, we want them to get the rapid feedback of being able to play. We want them to have a working thing quickly, not a pile of parts or an endless project.

But where do you go from there?

== From Kit to Custom ==

You could mod your robot, you could add new parts, you could repeat the robot but from a lower level of pre-completion.

Maybe you get another kit which does not include any 3D-printed parts. You go to the library and you 3D-print the parts that you need. Now you get to pick the colors, you might have to deal with a print failure, you have to think about the filaments you're going to use.

Or maybe instead of a pre-built PCB, you can solder together a kit. It's the same circuit that you're familiar with, but it's just through-hole soldering. Or maybe you want to learn the surface-mount version of that board, so you go and get the smaller SMD components.

Now we start to establish that equivalence: the prefab one is a factory-made SMD board, but the one you put together yourself is a through-hole board. But all the components are equivalent, the behavior is equivalent.

Or we go all the way for artisanal, and we get a protoboard and we hand-wire it. Again, it could be equivalent, but now you're looking at something that's not just a circuit board—it is a '''steampunk work of art'''. It is a retro-aesthetic design choice, not just a part that completes the requirements or does the behavior. It's an expression of your mastery that you've gone forward to do that.

Same thing with the software. If you have a robot that does some task, you can improve it just by changing the software. The same hardware everyone has—whether it's surface-mount, through-hole, self-made, completely custom—if it meets the standard, if it does the same task, we can share that same software. Now you're not just learning about how to change things, you're also '''collaborating with other folks'''.

This relates directly to [[Bespoke_Robot_Society:Give_Them_Away_For_Free|giving robots away for free]]—when the designs are open and shared, everyone benefits from improvements.

== The Starting Point ==

There's this huge tech tree, and we want everyone to be able to hop on and get the lay of the land by using pre-built robots, kits that are mostly assembled, things like that. But we also want you to be able to use your perspective of having that working robot to see all the different paths you could go down.

'''Toys are a starting point'''—we want you to turn it on and play immediately. But toys cannot be the end, and so many toys are dead ends as technology.

I want you to take a toy and break it and fix it. I want you to learn something from it, and I want you to think of what it can't do right now but could if you just had X, Y, or Z.

That's why I hope that Bespoke Robot Society will deliver robots that are not just toys. They should withstand [[Bespoke Robot Society:Toddler Testing|toddler testing]] and enable real learning and extension.

[[Category:Bespoke Robot Society]]
[[Category:Philosophy]]

Bespoke Robot Society:Beyond Toys

2025-10-11T17:29:55Z

John: /* From Kit to Custom */

= Beyond Toys =

This is BRS rant number two, exploring the distinction between toys and robots, and how we can use toys as a starting point without making them dead ends.

== The Question ==

How do we distinguish between a robot and a toy? Especially when the robots are mostly being advertised toward or made accessible to children, there's actually going to have a lot of overlap with a toy.

But we want to move '''beyond toys'''.

== Work vs Play ==

While exploration is a great form of play, not every toy enables you to learn something from it. Not every toy is extensible. A lot of toys just make some kind of amusement available, but they don't make the mechanics of the toy itself available. A lot of toys cover up their internals as a means of safety or protecting intellectual property.

Both of those causes are not applicable to Bespoke Robot Society's robots.

'''Toys are for play. Robots are for work.''' And sometimes the work we want to do is learning and teaching.

See also: [[Bespoke Robot Society:BattleBots Are Not Robots|BattleBots Are Not Robots]] for more on what makes something a real robot versus a remote-control toy.

== Toys vs Tools ==

Toys, like many beginner robotics kits, are designed with limited complexity and predefined goals—like following a line, bumping into walls. If all the thing does is that single task that it's built for, it could technically be a robot, but you're still probably looking at a toy.

A true robot, on the other hand, is a '''tool designed to interact with an environment'''.

== Forward-Looking Robots ==

I want to have a forward-looking definition of robot in Bespoke Robot Society.

The old definition of robot would be those giant arms that assemble cars. They move very precisely, they have a lot of strength, they are enormously stiff, and you cannot go near them while they're in motion for your own safety. They're uncompromising. They are executing and repeating some motion a lot. Many of these robots may not have real feedback loops in the sense that they aren't really able to detect if their task is going well or not. They may require a human operator to observe and hit the e-stop when they do something faulty.

But a '''forward-looking definition of robot is about autonomy'''. It's about reacting to your environment without planning it out perfectly ahead of time.

What I mean by that is: if we have goals and we have capabilities and we have sensors, but we don't necessarily know everything about the environment—people could walk by, you don't need to bump into them, the terrain may have changed, stuff could move—we want to use our sensors and figure that out dynamically. '''That's a real robot.'''

== The Problem with Staying a Toy ==

Specifically, to advance away from a toy: a non-toy robot enables you to '''understand the problem it tries to solve''' and '''understand the limitations of the environment it can work in'''.

Then if you get a new constraint, a new difficulty added to that environment, or you want to move the robot to a new environment, if you understand how the robot works and how it relies on those environmental limitations, you can enhance the elements of the robot that don't suit the changes to the environment and you'll be able to create that new functionality yourself.

That's really the goal: enabling real-world use cases. What we mean is, you think of something that your robot might be able to do, and now you need to:
# Understand the limitations it's currently built around
# Have some resources about how to go beyond those current limitations and make the robot more robust, or robust against different hazards

Staying in the toy phase has an allure of '''false mastery'''. It's like playing with a toy that you understand fully. You might understand ''what'', but not ''why''. You may fully know how to operate, but you don't know how to extend. You may get proficiency as a user, but you will not become a creator.

That's one of the main problems with toys: even when Bespoke Robot Society robots make good toys, I don't want them to remain toys or be limited by the definition of toy.

== Tech Trees ==

One of the ways I want to address this is with '''tech trees'''.

Bespoke Robot Society's $20 robot like [[SimpleBot]] might come in a kit with every single part. The PCB is already made, and you have no real requirements put upon you besides using a Phillips head screwdriver. Now you can hit go, and you can see the robot do the task it was immediately built for.

That's great because we want people to feel the confidence, we want them to get the rapid feedback of being able to play. We want them to have a working thing quickly, not a pile of parts or an endless project.

But where do you go from there?

== From Kit to Custom ==

You could mod your robot, you could add new parts, you could repeat the robot but from a lower level of pre-completion.

Maybe you get another kit which does not include any 3D-printed parts. You go to the library and you 3D-print the parts that you need. Now you get to pick the colors, you might have to deal with a print failure, you have to think about the filaments you're going to use.

Or maybe instead of a pre-built PCB, you can solder together a kit. It's the same circuit that you're familiar with, but it's just through-hole soldering. Or maybe you want to learn the surface-mount version of that board, so you go and get the smaller SMD components.

Now we start to establish that equivalence: the prefab one is a factory-made SMD board, but the one you put together yourself is a through-hole board. But all the components are equivalent, the behavior is equivalent.

Or we go all the way for artisanal, and we get a protoboard and we hand-wire it. Again, it could be equivalent, but now you're looking at something that's not just a circuit board—it is a '''steampunk work of art'''. It is a retro-aesthetic design choice, not just a part that completes the requirements or does the behavior. It's an expression of your mastery that you've gone forward to do that.

Same thing with the software. If you have a robot that does some task, you can improve it just by changing the software. The same hardware everyone has—whether it's surface-mount, through-hole, self-made, completely custom—if it meets the standard, if it does the same task, we can share that same software. Now you're not just learning about how to change things, you're also '''collaborating with other folks'''.

This relates directly to [[Bespoke_Robot_Society:Give_Them_Away_For_Free|giving robots away for free]]—when the designs are open and shared, everyone benefits from improvements.

== The Starting Point ==

There's this huge tech tree, and we want everyone to be able to hop on and get the lay of the land by using pre-built robots, kits that are mostly assembled, things like that. But we also want you to be able to use your perspective of having that working robot to see all the different paths you could go down.

'''Toys are a starting point'''—we want you to turn it on and play immediately. But toys cannot be the end, and so many toys are dead ends as technology.

I want you to take a toy and break it and fix it. I want you to learn something from it, and I want you to think of what it can't do right now but could if you just had X, Y, or Z.

That's why I hope that Bespoke Robot Society will deliver robots that are not just toys. They should withstand [[Bespoke Robot Society:Toddler Testing|toddler testing]] and enable real learning and extension.

[[Category:Bespoke Robot Society]]
[[Category:Philosophy]]

Bespoke Robot Society:Give Them Away For Free

2025-10-11T17:28:40Z

John: /* Why Free Is Better */

= Give Them Away for Free =

This is BRS rant number five, about the power of open source and why giving robots away creates more value than selling them.

== The Model ==

I don't know that the robots can ''literally'' be given away for free. My plan for [[SimpleBot]] is actually to sell it for a price that includes enough profit in the sale price to purchase one additional robot and donate it to a school or kids' group.

Like, the $30 price tag might include a whole second robot's components for charity. One person pays for a robot, another group gets a free robot.

== What Is Free? ==

This is part of the power of '''open source'''. There's zero licensing cost to each robot. The blueprints, the code, the designs—everything is just on the internet.

'''I am giving away the robot for free if you define the robot to be all the information you need to make one.'''

Now, that doesn't include the physical parts like microcontrollers. If you've got a 3D printer, I can't give you your own filament. But the idea is that the robot itself is just something that if you were able to get hold of the parts to make it, then you can have it. That's as simple as it gets.

This philosophy connects with [[Bespoke Robot Society:Beyond Toys|the tech tree concept]]—at any level of the tree, from pre-assembled kit to custom build, the knowledge is free.

== Zero Licensing Cost ==

I really don't think that robots should be gatekept. I really don't want to see any licensing costs—not just for the use of the robot, but for the tools to make it.

I don't want to rely on a student or hobbyist license. I don't want a one-year trial. I want to make this robot out of tools that are '''free for everyone, everywhere, for all time, under all situations'''.

That means if you have no resources except the library computer, you have the same capabilities that I have to extend and learn from the robot.

== Free Tools Only ==

Every part of the robot's design should be made with free tools:
* '''CAD''': FreeCAD (not Fusion 360)
* '''PCB design''': KiCad (not Eagle)
* '''Software''': Works on any platform
* '''Operating system''': Linux-based workflow

I'm going to design and make all these robots from Linux, so that somebody who does not have a Windows computer—if you're stuck on Windows 7 or Windows 10 and Microsoft just gives you hell for trying to operate your old computer on the internet these days—just go to Linux. It's still going to be able to do every single task of this robotic design workflow.

== The Feedback Loop ==

I'm hoping that I can prove this point, but my theory is that '''if you give, you actually get more back in return'''.

Here's the feedback loop:
# I'm going to give away these robots
# I'm going to put the designs out for free
# I'm going to mail them to people that ask for them
# I'm going to send them to testers and say "Hey, how many kids do you have?" and give them that many robot boxes

Everyone is going to send back:
* Feedback
* Complaints
* Ideas
* Photos of what they did with it

If I find the right people to receive them, they're also going to send back:
* '''Patches'''
* '''Pull requests'''
* '''Different software''' that can go on the wiki as more examples

Everything that these people give back, they are repaying me for the free robot I've given them, and they are giving it to everybody else that has received a free robot.

'''My free robots I give away are getting more valuable and more feature-rich the more free robots I give away.'''

Real-world testing, like [[Bespoke Robot Society:Toddler Testing|toddler testing]], comes from this model—people actually using the robots and reporting back what works and what breaks.

== Why Free Is Better ==

As a BRS member, you can just hand out:
* CAD files
* 3D printer files
* Circuit diagrams
* Schematics
* The link to the wiki
* Kits and guides

Anything that allows you to learn how to robot, build your robot, operate the robot—the knowledge, at least, is completely free.

Why is free better than expensive? Seems almost like a silly question, but we need to acknowledge that a high-price robot kit is really common. The cost itself is a limitation which reduces who can participate in the innovation cycle.

'''When you give away robots for free, you get more helpers.''' A free robot, by definition, just has more people that could help with the project than a hundred-dollar kit or something behind a paywall or a paid class requirement. All that stuff restricts the group of collaborators you can have.

I need collaborators to succeed, so I'm going to make everything I can absolutely free. You can make it free too. You can make whatever you want free.

What I'm hoping you'll see is: you as a robot builder are benefiting from the free robot that I'm giving you. If you add anything to it, I want you to make that free as well. I can't force you—I think you could always keep it secret—but I'm hoping you will also make it public and make it cost zero dollars for everyone else.

That's the idea. See also [[Bespoke_Robot_Society:Battlebots_Are_Not_Robots|why BRS focuses on useful, educational robots]] rather than expensive competition machines.

[[Category:Bespoke Robot Society]]
[[Category:Open Source]]
[[Category:Philosophy]]

Bespoke Robot Society:Toddler Testing

2025-10-11T17:28:04Z

John: /* Why Toddler-Friendly Robots Matter */

= Toddler Testing =

This is BRS rant number four, about why testing your robots in the real world—with actual toddlers—makes them better.

== The Real World Includes Toddlers ==

It's very important to test your robots in the real world. And guess what? '''The real world includes toddlers.'''

A lot of robotic projects fail because they encounter an edge case that was never tested for during development. Why not encourage testing with the metaphor of a toddler who will break anything they can, however they can?

== Edge Cases in Human Form ==

Toddlers do not share your preconceptions of the happy path of how to use your robot. They will:
* Poke and prod it
* Attempt to dismantle it
* Smash it
* Toss it
* Drop it

They are edge cases in human form—unpredictable, creative, and relentless in their exploration.

This relates to [[Bespoke Robot Society:Beyond Toys|moving beyond toys]]—real robots need to handle unexpected interactions, not just the controlled scenarios we design for.

== Why Toddler-Friendly Robots Matter ==

There's another aspect of this, which is that I actually ''do'' want robots that toddlers can play with. I want toddlers to be exposed to these things and start to understand:
* "Oh, hey, look—this is a thing that's exhibiting behavior"
* "It has parts that I can remove"
* "I can add the parts back on"
* Maybe even start to imagine how to change the behavior

How could I interact with this robot? I'm going to block its path. I'm going to draw a fork in the lines. Just whatever it takes to get kids thinking about '''systems''' and '''interactivity''' and '''cause and effect''' is a good thing.

Cheap robots that validate their exploration without risking a lot of money are a great tool for that. This supports the philosophy of [[Bespoke_Robot_Society:Give_Them_Away_For_Free|making robots accessible to everyone]].

== What Toddler Testing Improves ==

=== Durability ===

This happened to me while I was revising [[SimpleBot]]. The toddler got hold of the bot and dropped it off a table. One of the motor mounts snapped. I didn't freak out—I just went back to CAD and made that part twice as beefy.

It was not a big drop, maybe a couple of feet, but it's the sort of thing that could feasibly happen in a school or something. Having that toddler test—you know what, you're going to need to make this part a bit thicker—that is a valid test.

=== Simplicity ===

If your parts are kind of fragile, or have sensitive gears, or fine parts that can be bent out of shape, '''a toddler will find those and bend them'''. They will cause that fragile part to stop working.

If your robot can continue to function after being handled by a toddler, that's a good design. The principles that make robots [[Bespoke Robot Society:BattleBots Are Not Robots|actually useful]] also make them robust.

== A Story from Airman Leadership School ==

This was probably going on closer to two decades ago now. I had built a little Arduino robot. Back in those days, the Arduino was powered by a 9-volt battery and the motors by four double-As.

I'm just showing my classmates what I'm working on recently. I put the robot down and flip the switch, and it starts driving ahead. You know, it's the military—everyone thinks they're cute. Some guy stands up, goes in front of it, and puts his boot in the way.

The distance sensor on the front of it got up within a couple inches of his boot, started turning clockwise, and then kept going forward around his foot.

In that moment everyone was just like "ooh." I don't think that back in those days, when Arduino was kind of a new thing going around, anyone expected it to have that reactivity. They just did not remotely expect it to do that. The guy just expected it to run into his boot and not have any reaction to him being there.

If we can do that same level of '''autonomy'''—that your toddler picks up and moves the robot, and when it gets set back down it continues its task—that's going to make it more robust to other, more realistic disruptions too.

== Simulation vs Reality ==

'''Simulation is good. But toddlers are real.''' That's the idea here.

Real-world conditions change. You need to have not just random noise from your simulation, but actual random events from things your robot has to deal with.

Be robust. Let a toddler try your stuff. If your robot survives a toddler, it will survive anything.

[[Category:Bespoke Robot Society]]
[[Category:Testing]]
[[Category:Philosophy]]

Bespoke Robot Society:Toddler Testing

2025-10-11T17:27:35Z

John:

= Toddler Testing =

This is BRS rant number four, about why testing your robots in the real world—with actual toddlers—makes them better.

== The Real World Includes Toddlers ==

It's very important to test your robots in the real world. And guess what? '''The real world includes toddlers.'''

A lot of robotic projects fail because they encounter an edge case that was never tested for during development. Why not encourage testing with the metaphor of a toddler who will break anything they can, however they can?

== Edge Cases in Human Form ==

Toddlers do not share your preconceptions of the happy path of how to use your robot. They will:
* Poke and prod it
* Attempt to dismantle it
* Smash it
* Toss it
* Drop it

They are edge cases in human form—unpredictable, creative, and relentless in their exploration.

This relates to [[Bespoke Robot Society:Beyond Toys|moving beyond toys]]—real robots need to handle unexpected interactions, not just the controlled scenarios we design for.

== Why Toddler-Friendly Robots Matter ==

There's another aspect of this, which is that I actually ''do'' want robots that toddlers can play with. I want toddlers to be exposed to these things and start to understand:
* "Oh, hey, look—this is a thing that's exhibiting behavior"
* "It has parts that I can remove"
* "I can add the parts back on"
* Maybe even start to imagine how to change the behavior

How could I interact with this robot? I'm going to block its path. I'm going to draw a fork in the lines. Just whatever it takes to get kids thinking about '''systems''' and '''interactivity''' and '''cause and effect''' is a good thing.

Cheap robots that validate their exploration without risking a lot of money are a great tool for that. This supports the philosophy of [[Bespoke Robot Society:Give Them Away for Free|making robots accessible to everyone]].

== What Toddler Testing Improves ==

=== Durability ===

This happened to me while I was revising [[SimpleBot]]. The toddler got hold of the bot and dropped it off a table. One of the motor mounts snapped. I didn't freak out—I just went back to CAD and made that part twice as beefy.

It was not a big drop, maybe a couple of feet, but it's the sort of thing that could feasibly happen in a school or something. Having that toddler test—you know what, you're going to need to make this part a bit thicker—that is a valid test.

=== Simplicity ===

If your parts are kind of fragile, or have sensitive gears, or fine parts that can be bent out of shape, '''a toddler will find those and bend them'''. They will cause that fragile part to stop working.

If your robot can continue to function after being handled by a toddler, that's a good design. The principles that make robots [[Bespoke Robot Society:BattleBots Are Not Robots|actually useful]] also make them robust.

== A Story from Airman Leadership School ==

This was probably going on closer to two decades ago now. I had built a little Arduino robot. Back in those days, the Arduino was powered by a 9-volt battery and the motors by four double-As.

I'm just showing my classmates what I'm working on recently. I put the robot down and flip the switch, and it starts driving ahead. You know, it's the military—everyone thinks they're cute. Some guy stands up, goes in front of it, and puts his boot in the way.

The distance sensor on the front of it got up within a couple inches of his boot, started turning clockwise, and then kept going forward around his foot.

In that moment everyone was just like "ooh." I don't think that back in those days, when Arduino was kind of a new thing going around, anyone expected it to have that reactivity. They just did not remotely expect it to do that. The guy just expected it to run into his boot and not have any reaction to him being there.

If we can do that same level of '''autonomy'''—that your toddler picks up and moves the robot, and when it gets set back down it continues its task—that's going to make it more robust to other, more realistic disruptions too.

== Simulation vs Reality ==

'''Simulation is good. But toddlers are real.''' That's the idea here.

Real-world conditions change. You need to have not just random noise from your simulation, but actual random events from things your robot has to deal with.

Be robust. Let a toddler try your stuff. If your robot survives a toddler, it will survive anything.

[[Category:Bespoke Robot Society]]
[[Category:Testing]]
[[Category:Philosophy]]

Bespoke Robot Society:Battlebots Are Not Robots

2025-10-11T17:27:23Z

John:

= BattleBots Are Not Robots =

This is the first BRS rant, addressing a fundamental misconception about what constitutes a robot.

== The Problem ==

Everyone hears the word "robot" and they immediately jump to "oh, let's make a BattleBot." This popular show has been in the zeitgeist for possibly decades now—I think it's still going on. I face this problem constantly: you say "I'm building a robot," and everyone's like "oh, I've heard of BattleBots, I know all about those."

This is such a poisonous understanding of what a robot is.

== What Is a Robot? ==

So first of all, what's the definition of a robot?

A robot is something that has a '''control loop''' behind it. It's software reading data from sensors, making decisions, and taking actions. It's about:
* '''Navigating'''
* '''Perceiving'''
* '''Manipulating the world'''

== Why BattleBots Aren't Robots ==

A BattleBot is not a robot. A BattleBot is just remote control. The BattleBot itself is only a radio receiver and a bunch of actuators. '''It's a puppet.''' There's no robotics to it because it's not using any sensors, it's not deciding what to do—that's just a person driving it. Not even a robot. The "bot" part of it is just a lie. It's just battle.

See also: [[Bespoke Robot Society:Beyond Toys|Beyond Toys]] for more on the distinction between robots and remote-control toys.

== What Robotics Is Really About ==

Philosophically, what is a BattleBot in comparison to the field of robotics? It doesn't automate anything. It doesn't solve a problem. It doesn't make your life easier or better. It doesn't enable some process that wasn't possible on human labor alone.

It's only '''destruction entertainment'''. They're completely aware of this, by the way they market it and design the show. This is no different from a destruction derby or those mud pits where they crash cars into each other. There's nothing robotic about the entertainment value of that show.

Actual robotics is about:
* '''Problem solving'''
* '''Innovation'''
* '''Reducing cost'''
* '''Accuracy, repetition, and perfection'''

It's not about just smashing things by remote control. I think BattleBots has completely associated the wrong ideas with "robot" in people's minds.

== The BRS Alternative ==

BRS's mission, specifically, is supposed to get away from the BattleBot thing. BattleBots are remote control [[Bespoke Robot Society:Beyond Toys|toys]]. I want all of Bespoke Robot Society's robots to '''serve an actual purpose'''.

Now, the purpose might just be that you don't know that much about robots and you want to fix that in a hands-on way. That's a problem that a BRS robot design could solve. I'm completely happy with that being the problem. But smashing up another robot? Not really an interesting problem I want to solve with BRS robots.

== Autonomy on a Budget ==

The very first Bespoke Robot Society robot—[[SimpleBot]]—'''already has more sensors than the most sophisticated BattleBots''', and it's only got line sensors.

A BRS robot is about demonstrating that loop even under $20:
# '''Have sensors'''
# '''Make a decision based on those sensors'''
# '''Actuate in the world'''—use some kind of manipulator

SimpleBot already has all those elements:
* It detects lines on the ground
* It has programmed logic to respond to those lines
* It changes its behavior in the world

This is actual robotics, not just remote-control toys. See [[Bespoke Robot Society:Toddler Testing|Toddler Testing]] for how we validate that these robots work in the real world.

== Battle Without Destruction ==

Now, will we play war games? Sure. One of my prototypes here, the Tiny Tank 2, has a pan-tilt camera, a front-facing camera, and a LiDAR sensor. The intended use case for that robot is backyard-scale autonomous navigation and remote operation—either two-person (one driver, one gunner) or one of those roles, or both of those roles being served by AI—to interact with each other on the battlefield of my grassy yard.

We'll use IR blasters pointed at each other, detecting being hit, detecting that there's a signal coming at you. That's a way to have some of the tactical excitement of a BattleBot without being focused on destruction. And it's also using it as an entry point to artificial intelligence and autonomy of the robot—whether that robot is literally learning by playing against us, or we custom-write software as an additional challenge for us, the designers, to try to write software ourselves that solves the problem rather than just remote-controlling it and solving the problem one time.

You want to write software that solves it every time. Those are the sorts of things I think actually embody the spirit of robotics—the direction I want to take Bespoke Robot Society in.

[[Category:Bespoke Robot Society]]
[[Category:Philosophy]]

Bespoke Robot Society:Beyond Toys

2025-10-11T17:26:36Z

John:

= Beyond Toys =

This is BRS rant number two, exploring the distinction between toys and robots, and how we can use toys as a starting point without making them dead ends.

== The Question ==

How do we distinguish between a robot and a toy? Especially when the robots are mostly being advertised toward or made accessible to children, there's actually going to have a lot of overlap with a toy.

But we want to move '''beyond toys'''.

== Work vs Play ==

While exploration is a great form of play, not every toy enables you to learn something from it. Not every toy is extensible. A lot of toys just make some kind of amusement available, but they don't make the mechanics of the toy itself available. A lot of toys cover up their internals as a means of safety or protecting intellectual property.

Both of those causes are not applicable to Bespoke Robot Society's robots.

'''Toys are for play. Robots are for work.''' And sometimes the work we want to do is learning and teaching.

See also: [[Bespoke Robot Society:BattleBots Are Not Robots|BattleBots Are Not Robots]] for more on what makes something a real robot versus a remote-control toy.

== Toys vs Tools ==

Toys, like many beginner robotics kits, are designed with limited complexity and predefined goals—like following a line, bumping into walls. If all the thing does is that single task that it's built for, it could technically be a robot, but you're still probably looking at a toy.

A true robot, on the other hand, is a '''tool designed to interact with an environment'''.

== Forward-Looking Robots ==

I want to have a forward-looking definition of robot in Bespoke Robot Society.

The old definition of robot would be those giant arms that assemble cars. They move very precisely, they have a lot of strength, they are enormously stiff, and you cannot go near them while they're in motion for your own safety. They're uncompromising. They are executing and repeating some motion a lot. Many of these robots may not have real feedback loops in the sense that they aren't really able to detect if their task is going well or not. They may require a human operator to observe and hit the e-stop when they do something faulty.

But a '''forward-looking definition of robot is about autonomy'''. It's about reacting to your environment without planning it out perfectly ahead of time.

What I mean by that is: if we have goals and we have capabilities and we have sensors, but we don't necessarily know everything about the environment—people could walk by, you don't need to bump into them, the terrain may have changed, stuff could move—we want to use our sensors and figure that out dynamically. '''That's a real robot.'''

== The Problem with Staying a Toy ==

Specifically, to advance away from a toy: a non-toy robot enables you to '''understand the problem it tries to solve''' and '''understand the limitations of the environment it can work in'''.

Then if you get a new constraint, a new difficulty added to that environment, or you want to move the robot to a new environment, if you understand how the robot works and how it relies on those environmental limitations, you can enhance the elements of the robot that don't suit the changes to the environment and you'll be able to create that new functionality yourself.

That's really the goal: enabling real-world use cases. What we mean is, you think of something that your robot might be able to do, and now you need to:
# Understand the limitations it's currently built around
# Have some resources about how to go beyond those current limitations and make the robot more robust, or robust against different hazards

Staying in the toy phase has an allure of '''false mastery'''. It's like playing with a toy that you understand fully. You might understand ''what'', but not ''why''. You may fully know how to operate, but you don't know how to extend. You may get proficiency as a user, but you will not become a creator.

That's one of the main problems with toys: even when Bespoke Robot Society robots make good toys, I don't want them to remain toys or be limited by the definition of toy.

== Tech Trees ==

One of the ways I want to address this is with '''tech trees'''.

Bespoke Robot Society's $20 robot like [[SimpleBot]] might come in a kit with every single part. The PCB is already made, and you have no real requirements put upon you besides using a Phillips head screwdriver. Now you can hit go, and you can see the robot do the task it was immediately built for.

That's great because we want people to feel the confidence, we want them to get the rapid feedback of being able to play. We want them to have a working thing quickly, not a pile of parts or an endless project.

But where do you go from there?

== From Kit to Custom ==

You could mod your robot, you could add new parts, you could repeat the robot but from a lower level of pre-completion.

Maybe you get another kit which does not include any 3D-printed parts. You go to the library and you 3D-print the parts that you need. Now you get to pick the colors, you might have to deal with a print failure, you have to think about the filaments you're going to use.

Or maybe instead of a pre-built PCB, you can solder together a kit. It's the same circuit that you're familiar with, but it's just through-hole soldering. Or maybe you want to learn the surface-mount version of that board, so you go and get the smaller SMD components.

Now we start to establish that equivalence: the prefab one is a factory-made SMD board, but the one you put together yourself is a through-hole board. But all the components are equivalent, the behavior is equivalent.

Or we go all the way for artisanal, and we get a protoboard and we hand-wire it. Again, it could be equivalent, but now you're looking at something that's not just a circuit board—it is a '''steampunk work of art'''. It is a retro-aesthetic design choice, not just a part that completes the requirements or does the behavior. It's an expression of your mastery that you've gone forward to do that.

Same thing with the software. If you have a robot that does some task, you can improve it just by changing the software. The same hardware everyone has—whether it's surface-mount, through-hole, self-made, completely custom—if it meets the standard, if it does the same task, we can share that same software. Now you're not just learning about how to change things, you're also '''collaborating with other folks'''.

This relates directly to [[Bespoke Robot Society:Give Them Away for Free|giving robots away for free]]—when the designs are open and shared, everyone benefits from improvements.

== The Starting Point ==

There's this huge tech tree, and we want everyone to be able to hop on and get the lay of the land by using pre-built robots, kits that are mostly assembled, things like that. But we also want you to be able to use your perspective of having that working robot to see all the different paths you could go down.

'''Toys are a starting point'''—we want you to turn it on and play immediately. But toys cannot be the end, and so many toys are dead ends as technology.

I want you to take a toy and break it and fix it. I want you to learn something from it, and I want you to think of what it can't do right now but could if you just had X, Y, or Z.

That's why I hope that Bespoke Robot Society will deliver robots that are not just toys. They should withstand [[Bespoke Robot Society:Toddler Testing|toddler testing]] and enable real learning and extension.

[[Category:Bespoke Robot Society]]
[[Category:Philosophy]]

Bespoke Robot Society:Give Them Away For Free

2025-10-11T17:26:22Z

John:

= Give Them Away for Free =

This is BRS rant number five, about the power of open source and why giving robots away creates more value than selling them.

== The Model ==

I don't know that the robots can ''literally'' be given away for free. My plan for [[SimpleBot]] is actually to sell it for a price that includes enough profit in the sale price to purchase one additional robot and donate it to a school or kids' group.

Like, the $30 price tag might include a whole second robot's components for charity. One person pays for a robot, another group gets a free robot.

== What Is Free? ==

This is part of the power of '''open source'''. There's zero licensing cost to each robot. The blueprints, the code, the designs—everything is just on the internet.

'''I am giving away the robot for free if you define the robot to be all the information you need to make one.'''

Now, that doesn't include the physical parts like microcontrollers. If you've got a 3D printer, I can't give you your own filament. But the idea is that the robot itself is just something that if you were able to get hold of the parts to make it, then you can have it. That's as simple as it gets.

This philosophy connects with [[Bespoke Robot Society:Beyond Toys|the tech tree concept]]—at any level of the tree, from pre-assembled kit to custom build, the knowledge is free.

== Zero Licensing Cost ==

I really don't think that robots should be gatekept. I really don't want to see any licensing costs—not just for the use of the robot, but for the tools to make it.

I don't want to rely on a student or hobbyist license. I don't want a one-year trial. I want to make this robot out of tools that are '''free for everyone, everywhere, for all time, under all situations'''.

That means if you have no resources except the library computer, you have the same capabilities that I have to extend and learn from the robot.

== Free Tools Only ==

Every part of the robot's design should be made with free tools:
* '''CAD''': FreeCAD (not Fusion 360)
* '''PCB design''': KiCad (not Eagle)
* '''Software''': Works on any platform
* '''Operating system''': Linux-based workflow

I'm going to design and make all these robots from Linux, so that somebody who does not have a Windows computer—if you're stuck on Windows 7 or Windows 10 and Microsoft just gives you hell for trying to operate your old computer on the internet these days—just go to Linux. It's still going to be able to do every single task of this robotic design workflow.

== The Feedback Loop ==

I'm hoping that I can prove this point, but my theory is that '''if you give, you actually get more back in return'''.

Here's the feedback loop:
# I'm going to give away these robots
# I'm going to put the designs out for free
# I'm going to mail them to people that ask for them
# I'm going to send them to testers and say "Hey, how many kids do you have?" and give them that many robot boxes

Everyone is going to send back:
* Feedback
* Complaints
* Ideas
* Photos of what they did with it

If I find the right people to receive them, they're also going to send back:
* '''Patches'''
* '''Pull requests'''
* '''Different software''' that can go on the wiki as more examples

Everything that these people give back, they are repaying me for the free robot I've given them, and they are giving it to everybody else that has received a free robot.

'''My free robots I give away are getting more valuable and more feature-rich the more free robots I give away.'''

Real-world testing, like [[Bespoke Robot Society:Toddler Testing|toddler testing]], comes from this model—people actually using the robots and reporting back what works and what breaks.

== Why Free Is Better ==

As a BRS member, you can just hand out:
* CAD files
* 3D printer files
* Circuit diagrams
* Schematics
* The link to the wiki
* Kits and guides

Anything that allows you to learn how to robot, build your robot, operate the robot—the knowledge, at least, is completely free.

Why is free better than expensive? Seems almost like a silly question, but we need to acknowledge that a high-price robot kit is really common. The cost itself is a limitation which reduces who can participate in the innovation cycle.

'''When you give away robots for free, you get more helpers.''' A free robot, by definition, just has more people that could help with the project than a hundred-dollar kit or something behind a paywall or a paid class requirement. All that stuff restricts the group of collaborators you can have.

I need collaborators to succeed, so I'm going to make everything I can absolutely free. You can make it free too. You can make whatever you want free.

What I'm hoping you'll see is: you as a robot builder are benefiting from the free robot that I'm giving you. If you add anything to it, I want you to make that free as well. I can't force you—I think you could always keep it secret—but I'm hoping you will also make it public and make it cost zero dollars for everyone else.

That's the idea. See also [[Bespoke Robot Society:BattleBots Are Not Robots|why BRS focuses on useful, educational robots]] rather than expensive competition machines.

[[Category:Bespoke Robot Society]]
[[Category:Open Source]]
[[Category:Philosophy]]

Bespoke Robot Society:Give Them Away For Free

2025-10-11T17:25:55Z

John: LLM cleaned up audio transcript

= Give Them Away for Free =

This is BRS rant number five, about the power of open source and why giving robots away creates more value than selling them.

== Table of Contents ==
# [[#The_Model|The Model]]
# [[#What_Is_Free?|What Is Free?]]
# [[#Zero_Licensing_Cost|Zero Licensing Cost]]
# [[#Free_Tools_Only|Free Tools Only]]
# [[#The_Feedback_Loop|The Feedback Loop]]
# [[#Why_Free_Is_Better|Why Free Is Better]]

== The Model ==

I don't know that the robots can ''literally'' be given away for free. My plan for [[SimpleBot]] is actually to sell it for a price that includes enough profit in the sale price to purchase one additional robot and donate it to a school or kids' group.

Like, the $30 price tag might include a whole second robot's components for charity. One person pays for a robot, another group gets a free robot.

== What Is Free? ==

This is part of the power of '''open source'''. There's zero licensing cost to each robot. The blueprints, the code, the designs—everything is just on the internet.

'''I am giving away the robot for free if you define the robot to be all the information you need to make one.'''

Now, that doesn't include the physical parts like microcontrollers. If you've got a 3D printer, I can't give you your own filament. But the idea is that the robot itself is just something that if you were able to get hold of the parts to make it, then you can have it. That's as simple as it gets.

This philosophy connects with [[Bespoke Robot Society:Beyond Toys|the tech tree concept]]—at any level of the tree, from pre-assembled kit to custom build, the knowledge is free.

== Zero Licensing Cost ==

I really don't think that robots should be gatekept. I really don't want to see any licensing costs—not just for the use of the robot, but for the tools to make it.

I don't want to rely on a student or hobbyist license. I don't want a one-year trial. I want to make this robot out of tools that are '''free for everyone, everywhere, for all time, under all situations'''.

That means if you have no resources except the library computer, you have the same capabilities that I have to extend and learn from the robot.

== Free Tools Only ==

Every part of the robot's design should be made with free tools:
* '''CAD''': FreeCAD (not Fusion 360)
* '''PCB design''': KiCad (not Eagle)
* '''Software''': Works on any platform
* '''Operating system''': Linux-based workflow

I'm going to design and make all these robots from Linux, so that somebody who does not have a Windows computer—if you're stuck on Windows 7 or Windows 10 and Microsoft just gives you hell for trying to operate your old computer on the internet these days—just go to Linux. It's still going to be able to do every single task of this robotic design workflow.

== The Feedback Loop ==

I'm hoping that I can prove this point, but my theory is that '''if you give, you actually get more back in return'''.

Here's the feedback loop:
# I'm going to give away these robots
# I'm going to put the designs out for free
# I'm going to mail them to people that ask for them
# I'm going to send them to testers and say "Hey, how many kids do you have?" and give them that many robot boxes

Everyone is going to send back:
* Feedback
* Complaints
* Ideas
* Photos of what they did with it

If I find the right people to receive them, they're also going to send back:
* '''Patches'''
* '''Pull requests'''
* '''Different software''' that can go on the wiki as more examples

Everything that these people give back, they are repaying me for the free robot I've given them, and they are giving it to everybody else that has received a free robot.

'''My free robots I give away are getting more valuable and more feature-rich the more free robots I give away.'''

Real-world testing, like [[Bespoke Robot Society:Toddler Testing|toddler testing]], comes from this model—people actually using the robots and reporting back what works and what breaks.

== Why Free Is Better ==

As a BRS member, you can just hand out:
* CAD files
* 3D printer files
* Circuit diagrams
* Schematics
* The link to the wiki
* Kits and guides

Anything that allows you to learn how to robot, build your robot, operate the robot—the knowledge, at least, is completely free.

Why is free better than expensive? Seems almost like a silly question, but we need to acknowledge that a high-price robot kit is really common. The cost itself is a limitation which reduces who can participate in the innovation cycle.

'''When you give away robots for free, you get more helpers.''' A free robot, by definition, just has more people that could help with the project than a hundred-dollar kit or something behind a paywall or a paid class requirement. All that stuff restricts the group of collaborators you can have.

I need collaborators to succeed, so I'm going to make everything I can absolutely free. You can make it free too. You can make whatever you want free.

What I'm hoping you'll see is: you as a robot builder are benefiting from the free robot that I'm giving you. If you add anything to it, I want you to make that free as well. I can't force you—I think you could always keep it secret—but I'm hoping you will also make it public and make it cost zero dollars for everyone else.

That's the idea. See also [[Bespoke Robot Society:BattleBots Are Not Robots|why BRS focuses on useful, educational robots]] rather than expensive competition machines.

[[Category:Bespoke Robot Society]]
[[Category:Open Source]]
[[Category:Philosophy]]

Bespoke Robot Society:Toddler Testing

2025-10-11T17:25:41Z

John: LLM cleaned up audio transcript

= Toddler Testing =

This is BRS rant number four, about why testing your robots in the real world—with actual toddlers—makes them better.

== Table of Contents ==
# [[#The_Real_World_Includes_Toddlers|The Real World Includes Toddlers]]
# [[#Edge_Cases_in_Human_Form|Edge Cases in Human Form]]
# [[#Why_Toddler-Friendly_Robots_Matter|Why Toddler-Friendly Robots Matter]]
# [[#What_Toddler_Testing_Improves|What Toddler Testing Improves]]
# [[#A_Story_from_Airman_Leadership_School|A Story from Airman Leadership School]]
# [[#Simulation_vs_Reality|Simulation vs Reality]]

== The Real World Includes Toddlers ==

It's very important to test your robots in the real world. And guess what? '''The real world includes toddlers.'''

A lot of robotic projects fail because they encounter an edge case that was never tested for during development. Why not encourage testing with the metaphor of a toddler who will break anything they can, however they can?

== Edge Cases in Human Form ==

Toddlers do not share your preconceptions of the happy path of how to use your robot. They will:
* Poke and prod it
* Attempt to dismantle it
* Smash it
* Toss it
* Drop it

They are edge cases in human form—unpredictable, creative, and relentless in their exploration.

This relates to [[Bespoke Robot Society:Beyond Toys|moving beyond toys]]—real robots need to handle unexpected interactions, not just the controlled scenarios we design for.

== Why Toddler-Friendly Robots Matter ==

There's another aspect of this, which is that I actually ''do'' want robots that toddlers can play with. I want toddlers to be exposed to these things and start to understand:
* "Oh, hey, look—this is a thing that's exhibiting behavior"
* "It has parts that I can remove"
* "I can add the parts back on"
* Maybe even start to imagine how to change the behavior

How could I interact with this robot? I'm going to block its path. I'm going to draw a fork in the lines. Just whatever it takes to get kids thinking about '''systems''' and '''interactivity''' and '''cause and effect''' is a good thing.

Cheap robots that validate their exploration without risking a lot of money are a great tool for that. This supports the philosophy of [[Bespoke Robot Society:Give Them Away for Free|making robots accessible to everyone]].

== What Toddler Testing Improves ==

=== Durability ===

This happened to me while I was revising [[SimpleBot]]. The toddler got hold of the bot and dropped it off a table. One of the motor mounts snapped. I didn't freak out—I just went back to CAD and made that part twice as beefy.

It was not a big drop, maybe a couple of feet, but it's the sort of thing that could feasibly happen in a school or something. Having that toddler test—you know what, you're going to need to make this part a bit thicker—that is a valid test.

=== Simplicity ===

If your parts are kind of fragile, or have sensitive gears, or fine parts that can be bent out of shape, '''a toddler will find those and bend them'''. They will cause that fragile part to stop working.

If your robot can continue to function after being handled by a toddler, that's a good design. The principles that make robots [[Bespoke Robot Society:BattleBots Are Not Robots|actually useful]] also make them robust.

== A Story from Airman Leadership School ==

This was probably going on closer to two decades ago now. I had built a little Arduino robot. Back in those days, the Arduino was powered by a 9-volt battery and the motors by four double-As.

I'm just showing my classmates what I'm working on recently. I put the robot down and flip the switch, and it starts driving ahead. You know, it's the military—everyone thinks they're cute. Some guy stands up, goes in front of it, and puts his boot in the way.

The distance sensor on the front of it got up within a couple inches of his boot, started turning clockwise, and then kept going forward around his foot.

In that moment everyone was just like "ooh." I don't think that back in those days, when Arduino was kind of a new thing going around, anyone expected it to have that reactivity. They just did not remotely expect it to do that. The guy just expected it to run into his boot and not have any reaction to him being there.

If we can do that same level of '''autonomy'''—that your toddler picks up and moves the robot, and when it gets set back down it continues its task—that's going to make it more robust to other, more realistic disruptions too.

== Simulation vs Reality ==

'''Simulation is good. But toddlers are real.''' That's the idea here.

Real-world conditions change. You need to have not just random noise from your simulation, but actual random events from things your robot has to deal with.

Be robust. Let a toddler try your stuff. If your robot survives a toddler, it will survive anything.

[[Category:Bespoke Robot Society]]
[[Category:Testing]]
[[Category:Philosophy]]

Bespoke Robot Society:Beyond Toys

2025-10-11T17:25:30Z

John: LLM cleaned up audio transcript

= Beyond Toys =

This is BRS rant number two, exploring the distinction between toys and robots, and how we can use toys as a starting point without making them dead ends.

== Table of Contents ==
# [[#The_Question|The Question]]
# [[#Work_vs_Play|Work vs Play]]
# [[#Toys_vs_Tools|Toys vs Tools]]
# [[#Forward-Looking_Robots|Forward-Looking Robots]]
# [[#The_Problem_with_Staying_a_Toy|The Problem with Staying a Toy]]
# [[#Tech_Trees|Tech Trees]]
# [[#From_Kit_to_Custom|From Kit to Custom]]
# [[#The_Starting_Point|The Starting Point]]

== The Question ==

How do we distinguish between a robot and a toy? Especially when the robots are mostly being advertised toward or made accessible to children, there's actually going to have a lot of overlap with a toy.

But we want to move '''beyond toys'''.

== Work vs Play ==

While exploration is a great form of play, not every toy enables you to learn something from it. Not every toy is extensible. A lot of toys just make some kind of amusement available, but they don't make the mechanics of the toy itself available. A lot of toys cover up their internals as a means of safety or protecting intellectual property.

Both of those causes are not applicable to Bespoke Robot Society's robots.

'''Toys are for play. Robots are for work.''' And sometimes the work we want to do is learning and teaching.

See also: [[Bespoke Robot Society:BattleBots Are Not Robots|BattleBots Are Not Robots]] for more on what makes something a real robot versus a remote-control toy.

== Toys vs Tools ==

Toys, like many beginner robotics kits, are designed with limited complexity and predefined goals—like following a line, bumping into walls. If all the thing does is that single task that it's built for, it could technically be a robot, but you're still probably looking at a toy.

A true robot, on the other hand, is a '''tool designed to interact with an environment'''.

== Forward-Looking Robots ==

I want to have a forward-looking definition of robot in Bespoke Robot Society.

The old definition of robot would be those giant arms that assemble cars. They move very precisely, they have a lot of strength, they are enormously stiff, and you cannot go near them while they're in motion for your own safety. They're uncompromising. They are executing and repeating some motion a lot. Many of these robots may not have real feedback loops in the sense that they aren't really able to detect if their task is going well or not. They may require a human operator to observe and hit the e-stop when they do something faulty.

But a '''forward-looking definition of robot is about autonomy'''. It's about reacting to your environment without planning it out perfectly ahead of time.

What I mean by that is: if we have goals and we have capabilities and we have sensors, but we don't necessarily know everything about the environment—people could walk by, you don't need to bump into them, the terrain may have changed, stuff could move—we want to use our sensors and figure that out dynamically. '''That's a real robot.'''

== The Problem with Staying a Toy ==

Specifically, to advance away from a toy: a non-toy robot enables you to '''understand the problem it tries to solve''' and '''understand the limitations of the environment it can work in'''.

Then if you get a new constraint, a new difficulty added to that environment, or you want to move the robot to a new environment, if you understand how the robot works and how it relies on those environmental limitations, you can enhance the elements of the robot that don't suit the changes to the environment and you'll be able to create that new functionality yourself.

That's really the goal: enabling real-world use cases. What we mean is, you think of something that your robot might be able to do, and now you need to:
# Understand the limitations it's currently built around
# Have some resources about how to go beyond those current limitations and make the robot more robust, or robust against different hazards

Staying in the toy phase has an allure of '''false mastery'''. It's like playing with a toy that you understand fully. You might understand ''what'', but not ''why''. You may fully know how to operate, but you don't know how to extend. You may get proficiency as a user, but you will not become a creator.

That's one of the main problems with toys: even when Bespoke Robot Society robots make good toys, I don't want them to remain toys or be limited by the definition of toy.

== Tech Trees ==

One of the ways I want to address this is with '''tech trees'''.

Bespoke Robot Society's $20 robot like [[SimpleBot]] might come in a kit with every single part. The PCB is already made, and you have no real requirements put upon you besides using a Phillips head screwdriver. Now you can hit go, and you can see the robot do the task it was immediately built for.

That's great because we want people to feel the confidence, we want them to get the rapid feedback of being able to play. We want them to have a working thing quickly, not a pile of parts or an endless project.

But where do you go from there?

== From Kit to Custom ==

You could mod your robot, you could add new parts, you could repeat the robot but from a lower level of pre-completion.

Maybe you get another kit which does not include any 3D-printed parts. You go to the library and you 3D-print the parts that you need. Now you get to pick the colors, you might have to deal with a print failure, you have to think about the filaments you're going to use.

Or maybe instead of a pre-built PCB, you can solder together a kit. It's the same circuit that you're familiar with, but it's just through-hole soldering. Or maybe you want to learn the surface-mount version of that board, so you go and get the smaller SMD components.

Now we start to establish that equivalence: the prefab one is a factory-made SMD board, but the one you put together yourself is a through-hole board. But all the components are equivalent, the behavior is equivalent.

Or we go all the way for artisanal, and we get a protoboard and we hand-wire it. Again, it could be equivalent, but now you're looking at something that's not just a circuit board—it is a '''steampunk work of art'''. It is a retro-aesthetic design choice, not just a part that completes the requirements or does the behavior. It's an expression of your mastery that you've gone forward to do that.

Same thing with the software. If you have a robot that does some task, you can improve it just by changing the software. The same hardware everyone has—whether it's surface-mount, through-hole, self-made, completely custom—if it meets the standard, if it does the same task, we can share that same software. Now you're not just learning about how to change things, you're also '''collaborating with other folks'''.

This relates directly to [[Bespoke Robot Society:Give Them Away for Free|giving robots away for free]]—when the designs are open and shared, everyone benefits from improvements.

== The Starting Point ==

There's this huge tech tree, and we want everyone to be able to hop on and get the lay of the land by using pre-built robots, kits that are mostly assembled, things like that. But we also want you to be able to use your perspective of having that working robot to see all the different paths you could go down.

'''Toys are a starting point'''—we want you to turn it on and play immediately. But toys cannot be the end, and so many toys are dead ends as technology.

I want you to take a toy and break it and fix it. I want you to learn something from it, and I want you to think of what it can't do right now but could if you just had X, Y, or Z.

That's why I hope that Bespoke Robot Society will deliver robots that are not just toys. They should withstand [[Bespoke Robot Society:Toddler Testing|toddler testing]] and enable real learning and extension.

[[Category:Bespoke Robot Society]]
[[Category:Philosophy]]

Bespoke Robot Society:Battlebots Are Not Robots

2025-10-11T17:25:14Z

John: LLM cleaned up audio transcript

= BattleBots Are Not Robots =

This is the first BRS rant, addressing a fundamental misconception about what constitutes a robot.

== Table of Contents ==
# [[#The_Problem|The Problem]]
# [[#What_Is_a_Robot?|What Is a Robot?]]
# [[#Why_BattleBots_Aren't_Robots|Why BattleBots Aren't Robots]]
# [[#What_Robotics_Is_Really_About|What Robotics Is Really About]]
# [[#The_BRS_Alternative|The BRS Alternative]]
# [[#Autonomy_on_a_Budget|Autonomy on a Budget]]
# [[#Battle_Without_Destruction|Battle Without Destruction]]

== The Problem ==

Everyone hears the word "robot" and they immediately jump to "oh, let's make a BattleBot." This popular show has been in the zeitgeist for possibly decades now—I think it's still going on. I face this problem constantly: you say "I'm building a robot," and everyone's like "oh, I've heard of BattleBots, I know all about those."

This is such a poisonous understanding of what a robot is.

== What Is a Robot? ==

So first of all, what's the definition of a robot?

A robot is something that has a '''control loop''' behind it. It's software reading data from sensors, making decisions, and taking actions. It's about:
* '''Navigating'''
* '''Perceiving'''
* '''Manipulating the world'''

== Why BattleBots Aren't Robots ==

A BattleBot is not a robot. A BattleBot is just remote control. The BattleBot itself is only a radio receiver and a bunch of actuators. '''It's a puppet.''' There's no robotics to it because it's not using any sensors, it's not deciding what to do—that's just a person driving it. Not even a robot. The "bot" part of it is just a lie. It's just battle.

See also: [[Bespoke Robot Society:Beyond Toys|Beyond Toys]] for more on the distinction between robots and remote-control toys.

== What Robotics Is Really About ==

Philosophically, what is a BattleBot in comparison to the field of robotics? It doesn't automate anything. It doesn't solve a problem. It doesn't make your life easier or better. It doesn't enable some process that wasn't possible on human labor alone.

It's only '''destruction entertainment'''. They're completely aware of this, by the way they market it and design the show. This is no different from a destruction derby or those mud pits where they crash cars into each other. There's nothing robotic about the entertainment value of that show.

Actual robotics is about:
* '''Problem solving'''
* '''Innovation'''
* '''Reducing cost'''
* '''Accuracy, repetition, and perfection'''

It's not about just smashing things by remote control. I think BattleBots has completely associated the wrong ideas with "robot" in people's minds.

== The BRS Alternative ==

BRS's mission, specifically, is supposed to get away from the BattleBot thing. BattleBots are remote control [[Bespoke Robot Society:Beyond Toys|toys]]. I want all of Bespoke Robot Society's robots to '''serve an actual purpose'''.

Now, the purpose might just be that you don't know that much about robots and you want to fix that in a hands-on way. That's a problem that a BRS robot design could solve. I'm completely happy with that being the problem. But smashing up another robot? Not really an interesting problem I want to solve with BRS robots.

== Autonomy on a Budget ==

The very first Bespoke Robot Society robot—[[SimpleBot]]—'''already has more sensors than the most sophisticated BattleBots''', and it's only got line sensors.

A BRS robot is about demonstrating that loop even under $20:
# '''Have sensors'''
# '''Make a decision based on those sensors'''
# '''Actuate in the world'''—use some kind of manipulator

SimpleBot already has all those elements:
* It detects lines on the ground
* It has programmed logic to respond to those lines
* It changes its behavior in the world

This is actual robotics, not just remote-control toys. See [[Bespoke Robot Society:Toddler Testing|Toddler Testing]] for how we validate that these robots work in the real world.

== Battle Without Destruction ==

Now, will we play war games? Sure. One of my prototypes here, the Tiny Tank 2, has a pan-tilt camera, a front-facing camera, and a LiDAR sensor. The intended use case for that robot is backyard-scale autonomous navigation and remote operation—either two-person (one driver, one gunner) or one of those roles, or both of those roles being served by AI—to interact with each other on the battlefield of my grassy yard.

We'll use IR blasters pointed at each other, detecting being hit, detecting that there's a signal coming at you. That's a way to have some of the tactical excitement of a BattleBot without being focused on destruction. And it's also using it as an entry point to artificial intelligence and autonomy of the robot—whether that robot is literally learning by playing against us, or we custom-write software as an additional challenge for us, the designers, to try to write software ourselves that solves the problem rather than just remote-controlling it and solving the problem one time.

You want to write software that solves it every time. Those are the sorts of things I think actually embody the spirit of robotics—the direction I want to take Bespoke Robot Society in.

[[Category:Bespoke Robot Society]]
[[Category:Philosophy]]

Template:Pico

2025-10-11T16:54:01Z

John: Claude edited based on my notes, prompt, and SimpleBot code repository

<includeonly>{{MCU
| name = Raspberry Pi Pico
| manufacturer = Raspberry Pi Ltd
| cpu = Dual-core ARM Cortex-M0+
| cpu_speed = 133 MHz
| cores = 2
| ram = 264 KB
| flash = 2 MB
| gpio = 26 (3 ADC)
| voltage = 1.8–5.5V
| cost = $4 USD
| datasheet = [https://datasheets.raspberrypi.com/rp2040/rp2040-datasheet.pdf Datasheet]
}}</includeonly><noinclude>
== Usage ==

This template provides a compact info box for the Raspberry Pi Pico that can be included in any page.

=== Syntax ===
<pre>
{{Pico}}
</pre>

This will display the full MCU info box with all Raspberry Pi Pico specifications.

For detailed information, see the [[Raspberry Pi Pico]] article.
</noinclude>

Template:SBC

2025-10-11T16:53:47Z

John: Claude edited based on my notes, prompt, and SimpleBot code repository

{| class="infobox" style="width: 300px; float: right; clear: right; margin: 0 0 1em 1em; border: 1px solid #aaa; background-color: #f9f9f9; font-size: 90%; line-height: 1.4em;"
! colspan="2" style="text-align: center; font-size: 125%; font-weight: bold; background-color: #ccffcc;" | {{{name|{{PAGENAME}}}}}
|-
{{#if:{{{image|}}}|
! colspan="2" style="text-align: center;" {{!}} [[File:{{{image}}}{{!}}250px]]
}}
|-
! style="text-align: right; padding-right: 0.5em;" | '''Manufacturer'''
| {{{manufacturer|—}}}
|-
{{#if:{{{cpu|}}}|
! style="text-align: right; padding-right: 0.5em;" {{!}} '''CPU'''
{{!}} {{{cpu}}}
}}
|-
{{#if:{{{cpu_speed|}}}|
! style="text-align: right; padding-right: 0.5em;" {{!}} '''Clock Speed'''
{{!}} {{{cpu_speed}}}
}}
|-
{{#if:{{{cores|}}}|
! style="text-align: right; padding-right: 0.5em;" {{!}} '''Cores'''
{{!}} {{{cores}}}
}}
|-
{{#if:{{{ram|}}}|
! style="text-align: right; padding-right: 0.5em;" {{!}} '''RAM'''
{{!}} {{{ram}}}
}}
|-
{{#if:{{{storage|}}}|
! style="text-align: right; padding-right: 0.5em;" {{!}} '''Storage'''
{{!}} {{{storage}}}
}}
|-
{{#if:{{{os|}}}|
! style="text-align: right; padding-right: 0.5em;" {{!}} '''Operating System'''
{{!}} {{{os}}}
}}
|-
{{#if:{{{gpio|}}}|
! style="text-align: right; padding-right: 0.5em;" {{!}} '''GPIO Pins'''
{{!}} {{{gpio}}}
}}
|-
{{#if:{{{connectivity|}}}|
! style="text-align: right; padding-right: 0.5em;" {{!}} '''Connectivity'''
{{!}} {{{connectivity}}}
}}
|-
{{#if:{{{cost|}}}|
! style="text-align: right; padding-right: 0.5em;" {{!}} '''Typical Cost'''
{{!}} {{{cost}}}
}}
|-
|}
[[Category:SBC]]

Template:Robot

2025-10-11T16:53:16Z

John: Claude edited based on my notes, prompt, and SimpleBot code repository

{| class="infobox" style="width: 300px; float: right; clear: right; margin: 0 0 1em 1em; border: 1px solid #aaa; background-color: #f9f9f9; font-size: 90%; line-height: 1.4em;"
! colspan="2" style="text-align: center; font-size: 125%; font-weight: bold; background-color: #ddd;" | {{{name|{{PAGENAME}}}}}
|-
{{#if:{{{image|}}}|
! colspan="2" style="text-align: center;" {{!}} [[File:{{{image}}}{{!}}300px]]
}}
|-
{{#if:{{{caption|}}}|
! colspan="2" style="text-align: center; font-size: 90%; font-style: italic;" {{!}} {{{caption}}}
}}
|-
! style="text-align: right; padding-right: 0.5em;" | '''Use Case'''
| {{{use_case|General purpose robot}}}
|-
{{#if:{{{microcontroller|}}}|
! style="text-align: right; padding-right: 0.5em;" {{!}} '''Microcontroller'''
{{!}} {{{microcontroller}}}
}}
|-
{{#if:{{{sensors|}}}|
! style="text-align: right; padding-right: 0.5em;" {{!}} '''Sensors'''
{{!}} {{{sensors}}}
}}
|-
{{#if:{{{power|}}}|
! style="text-align: right; padding-right: 0.5em;" {{!}} '''Power'''
{{!}} {{{power}}}
}}
|-
{{#if:{{{pcb|}}}|
! style="text-align: right; padding-right: 0.5em;" {{!}} '''PCB'''
{{!}} {{{pcb}}}
}}
|-
{{#if:{{{cost|}}}|
! style="text-align: right; padding-right: 0.5em;" {{!}} '''Est. Cost'''
{{!}} {{{cost}}}
}}
|-
{{#if:{{{repository|}}}|
! style="text-align: right; padding-right: 0.5em;" {{!}} '''Repository'''
{{!}} {{{repository}}}
}}
|-
|}
[[Category:Robot]]

Behavior:SLAM

2025-10-11T16:50:46Z

John: Claude edited based on my notes, prompt, and SimpleBot code repository

{{Behavior
| name = SLAM
| requires = [[Capability:LIDAR Sensing]] or [[Capability:Camera Vision]], [[Capability:Optical Odometry]], [[Capability:Differential Drive]]
| enables = [[Activity:Room Mapping]], [[Activity:Maze Optimization]], autonomous navigation
| difficulty = Advanced
| status = '''Stub''' - Algorithm not yet implemented
}}

'''SLAM''' is a behavior (algorithm) that simultaneously builds a map of an environment while tracking the robot's position within it.

== Overview ==

'''This is a stub page.''' This behavior is not yet implemented in any BRS robot. This page exists to:
* Document the algorithmic concept
* Invite community members to implement it
* Provide a starting point for algorithm design

== Required Capabilities ==

This behavior requires:

* [[Capability:LIDAR Sensing]]
* [[Capability:Camera Vision]]
* [[Capability:Optical Odometry]]
* [[Capability:Differential Drive]]

== Enables Activities ==

Implementing this behavior enables:

* [[Activity:Room Mapping]]
* [[Activity:Maze Optimization]]

== Algorithm Outline ==

SLAM is computationally intensive and typically uses established algorithms:

**2D LIDAR SLAM**:
* Gmapping
* Hector SLAM
* Cartographer

**Visual SLAM**:
* ORB-SLAM
* LSD-SLAM

General approach:
# Capture sensor data (LIDAR scan or camera image)
# Extract features/landmarks
# Match to previously seen features
# Estimate robot motion (odometry + sensor matching)
# Update map with new observations
# Correct for loop closure (detecting return to known location)

== Pseudocode ==

<pre>
# Simplified SLAM Concept (not implementable as-is)
map = initialize_empty_map()
robot_pose = (0, 0, 0) # x, y, theta

while True:
sensor_data = capture_lidar_scan()
odometry_delta = read_odometry()

# Predict new pose from odometry
predicted_pose = robot_pose + odometry_delta

# Match sensor data to map
matched_features = feature_matching(sensor_data, map)

# Correct pose estimate based on matches
corrected_pose = optimize_pose(predicted_pose, matched_features)

# Update map with new observations
update_map(map, corrected_pose, sensor_data)

robot_pose = corrected_pose
</pre>

== Implementation Challenges ==

* **Computational cost**: Requires significant processing power (use ROS on Raspberry Pi)
* **Loop closure**: Detecting when robot returns to known location
* **Data association**: Matching current observations to previous ones
* **Scale**: Large maps require sophisticated data structures
* **Recommended**: Use existing SLAM libraries (ROS navigation stack) rather than implementing from scratch

== Contributing ==

Want to implement this behavior? Here's how:

# Study the algorithm outline above
# Implement in your language of choice (MicroPython, C++, Arduino)
# Test on a robot with the required capabilities
# Create an Implementation page (e.g., <code>[[YourRobot:SLAM Implementation]]</code>)
# Update this page with algorithm refinements
# Share working code on GitHub

== See Also ==

* [[Behaviors]] - All behaviors
* [[Capabilities]] - Hardware required
* [[Activities]] - What this enables
* [[Robotics Ontology]] - How behaviors fit into BRS knowledge structure

[[Category:Behavior]]
[[Category:Advanced Behavior]]
[[Category:Stub]]

Behavior:Wall Following

2025-10-11T16:48:27Z

John: Claude edited based on my notes, prompt, and SimpleBot code repository

{{Behavior
| name = Wall Following
| requires = [[Capability:Time-of-Flight Sensing]] or [[Capability:Ultrasonic Sensing]], [[Capability:Differential Drive]]
| enables = [[Activity:Maze Solving]]
| difficulty = Beginner
| status = '''Stub''' - Algorithm not yet implemented
}}

'''Wall Following''' is a behavior (algorithm) that maintains a constant distance from a wall while moving parallel to it.

== Overview ==

'''This is a stub page.''' This behavior is not yet implemented in any BRS robot. This page exists to:
* Document the algorithmic concept
* Invite community members to implement it
* Provide a starting point for algorithm design

== Required Capabilities ==

This behavior requires:

* [[Capability:Time-of-Flight Sensing]]
* [[Capability:Ultrasonic Sensing]]
* [[Capability:Differential Drive]]

== Enables Activities ==

Implementing this behavior enables:

* [[Activity:Maze Solving]]

== Algorithm Outline ==

Wall following uses distance sensing and proportional control:

# Measure distance to wall
# If distance < target: turn away from wall
# If distance > target: turn toward wall
# Drive forward

For maze solving, consistently follow left or right wall until exit is reached.

== Pseudocode ==

<pre>
# Wall Following
TARGET_DISTANCE = 20 # cm

while True:
distance_to_wall = read_distance_sensor()
error = distance_to_wall - TARGET_DISTANCE

turn_adjustment = error * gain # Proportional control

left_speed = BASE_SPEED + turn_adjustment
right_speed = BASE_SPEED - turn_adjustment

set_motors(left_speed, right_speed)
</pre>

== Implementation Challenges ==

* **Corners**: Detecting and handling inside/outside corners
* **Gaps**: What to do when wall disappears (doorways, openings)
* **Obstacles**: Handling objects protruding from wall
* **Sensor placement**: Angled sensors vs perpendicular sensors

== Contributing ==

Want to implement this behavior? Here's how:

# Study the algorithm outline above
# Implement in your language of choice (MicroPython, C++, Arduino)
# Test on a robot with the required capabilities
# Create an Implementation page (e.g., <code>[[YourRobot:Wall Following Implementation]]</code>)
# Update this page with algorithm refinements
# Share working code on GitHub

== See Also ==

* [[Behaviors]] - All behaviors
* [[Capabilities]] - Hardware required
* [[Activities]] - What this enables
* [[Robotics Ontology]] - How behaviors fit into BRS knowledge structure

[[Category:Behavior]]
[[Category:Beginner Behavior]]
[[Category:Stub]]

Behavior:PID Control

2025-10-11T16:48:13Z

John: Claude edited based on my notes, prompt, and SimpleBot code repository

{{Behavior
| name = PID Control
| requires = Any sensing capability that provides error measurement
| enables = [[Activity:Line Following]] (smooth), precise position control, speed control
| difficulty = Intermediate
| status = '''Stub''' - Algorithm not yet implemented
}}

'''PID Control''' is a behavior (algorithm) that uses proportional, integral, and derivative terms to minimize error in control systems.

== Overview ==

'''This is a stub page.''' This behavior is not yet implemented in any BRS robot. This page exists to:
* Document the algorithmic concept
* Invite community members to implement it
* Provide a starting point for algorithm design

== Required Capabilities ==

This behavior requires:

* [[Capability:Line Sensing]]
* [[Capability:Optical Odometry]]

== Enables Activities ==

Implementing this behavior enables:

* [[Activity:Line Following]]

== Algorithm Outline ==

PID control is a feedback loop that continuously calculates an error value and applies a correction:

* **P (Proportional)**: Correction proportional to current error
* **I (Integral)**: Correction based on accumulated past errors
* **D (Derivative)**: Correction based on rate of error change

The output is: <code>output = Kp × error + Ki × ∫error·dt + Kd × d(error)/dt</code>

== Pseudocode ==

<pre>
# PID Controller
error = setpoint - measured_value
integral = integral + error * dt
derivative = (error - previous_error) / dt

output = Kp * error + Ki * integral + Kd * derivative

previous_error = error
apply_output(output)
</pre>

== Implementation Challenges ==

* **Tuning**: Finding optimal Kp, Ki, Kd values requires experimentation
* **Integral windup**: Integral term can accumulate excessively
* **Derivative noise**: Derivative is sensitive to sensor noise
* **Sampling rate**: PID requires consistent timing for accurate integral/derivative

== Contributing ==

Want to implement this behavior? Here's how:

# Study the algorithm outline above
# Implement in your language of choice (MicroPython, C++, Arduino)
# Test on a robot with the required capabilities
# Create an Implementation page (e.g., <code>[[YourRobot:PID Control Implementation]]</code>)
# Update this page with algorithm refinements
# Share working code on GitHub

== See Also ==

* [[Behaviors]] - All behaviors
* [[Capabilities]] - Hardware required
* [[Activities]] - What this enables
* [[Robotics Ontology]] - How behaviors fit into BRS knowledge structure

[[Category:Behavior]]
[[Category:Intermediate Behavior]]
[[Category:Stub]]

Behavior:Dead Reckoning

2025-10-11T16:47:59Z

John: Claude edited based on my notes, prompt, and SimpleBot code repository

{{Behavior
|name=Dead Reckoning
|requires=[[Capability:Optical Odometry]] or [[Capability:IMU Sensing]], [[Capability:Differential Drive]]
|enables=[[Activity:Dead Reckoning Navigation]]
|difficulty=Beginner to Intermediate
|implementations=[[SimpleBot:Dead Reckoning Implementation]]
|status=Fully Documented
}}

'''Dead reckoning''' is a navigation technique where a robot estimates its current position by tracking all motion from a known starting position. The term comes from maritime navigation ("deduced reckoning") and involves continuously calculating position based on direction and distance traveled, without external reference points.

== Overview ==

Dead reckoning works by:
# Starting from a known position (typically x=0, y=0, heading=0)
# Measuring all motion (linear and angular)
# Continuously updating the estimated position based on motion measurements
# Maintaining a pose estimate (x position, y position, heading angle θ)

Unlike GPS or beacon-based navigation, dead reckoning is completely self-contained and works in any environment. However, small measurement errors accumulate over time, causing position estimates to drift from the true position.

== Odometry-Based Dead Reckoning ==

'''Odometry-based dead reckoning''' uses wheel encoder measurements to track motion. This is the most common approach for ground robots and is the method used by SimpleBot.

=== Principle of Operation ===

For a differential drive robot:
# Count encoder pulses from left and right wheels independently
# Calculate distance traveled by each wheel using known wheel circumference and encoder resolution
# Determine robot motion based on wheel motion differences:
#* '''Equal wheel distances''' → Robot moves straight
#* '''Different wheel distances''' → Robot follows a curved path (arc)
# Update robot pose (x, y, θ) based on calculated motion

=== Mathematical Foundation ===

The basic calculations for odometry-based dead reckoning:

'''Step 1: Calculate wheel distances'''
distance_left = left_pulses × distance_per_pulse
distance_right = right_pulses × distance_per_pulse

Where:
distance_per_pulse = (wheel_circumference) / (pulses_per_revolution)
wheel_circumference = π × wheel_diameter

'''Step 2: Calculate motion parameters'''
distance_traveled = (distance_left + distance_right) / 2
angle_turned = (distance_right - distance_left) / wheel_separation

'''Step 3: Update pose'''

For straight motion (distance_left ≈ distance_right):
x_new = x_old + distance_traveled × cos(θ_old)
y_new = y_old + distance_traveled × sin(θ_old)
θ_new = θ_old

For curved motion (general case):
θ_new = θ_old + angle_turned
x_new = x_old + distance_traveled × cos(θ_old + angle_turned/2)
y_new = y_old + distance_traveled × sin(θ_old + angle_turned/2)

=== Pseudocode Example ===

<syntaxhighlight lang="python">
# Initialize robot pose
pose_x = 0.0
pose_y = 0.0
pose_theta = 0.0

# Robot physical parameters
WHEEL_DIAMETER = 0.065 # meters
WHEEL_SEPARATION = 0.15 # meters
PULSES_PER_REV = 20

# Calculate distance per pulse
WHEEL_CIRCUMFERENCE = math.pi * WHEEL_DIAMETER
DISTANCE_PER_PULSE = WHEEL_CIRCUMFERENCE / PULSES_PER_REV

def update_odometry(left_pulses, right_pulses):
global pose_x, pose_y, pose_theta

# Calculate distances traveled by each wheel
dist_left = left_pulses * DISTANCE_PER_PULSE
dist_right = right_pulses * DISTANCE_PER_PULSE

# Calculate center distance and rotation
dist_center = (dist_left + dist_right) / 2.0
delta_theta = (dist_right - dist_left) / WHEEL_SEPARATION

# Update pose using midpoint method
if abs(delta_theta) < 0.001: # Straight motion
pose_x += dist_center * math.cos(pose_theta)
pose_y += dist_center * math.sin(pose_theta)
else: # Curved motion
# Use heading at midpoint of arc
mid_theta = pose_theta + delta_theta / 2.0
pose_x += dist_center * math.cos(mid_theta)
pose_y += dist_center * math.sin(mid_theta)
pose_theta += delta_theta

# Normalize angle to [-π, π]
pose_theta = math.atan2(math.sin(pose_theta), math.cos(pose_theta))

return (pose_x, pose_y, pose_theta)

# Main loop
while robot_running:
# Read encoder increments since last update
left_pulses = read_left_encoder_delta()
right_pulses = read_right_encoder_delta()

# Update position estimate
position = update_odometry(left_pulses, right_pulses)

# Use position for navigation decisions
navigate_using_position(position)
</syntaxhighlight>

=== Odometry Error Sources ===

Common error sources in odometry-based dead reckoning:
* '''Wheel slippage''': Wheels slip on smooth surfaces or during rapid acceleration
* '''Uneven wheel diameters''': Manufacturing variations or uneven wear
* '''Mechanical play''': Backlash in gears and drivetrain
* '''Encoder resolution''': Limited pulse count causes quantization errors
* '''Surface irregularities''': Bumps, cracks, and slopes affect wheel rotation
* '''Wheel alignment''': Misaligned wheels cause systematic drift

== IMU-Based Dead Reckoning ==

'''IMU-based dead reckoning''' uses inertial measurement unit sensors (accelerometers and gyroscopes) to track motion. This approach is more complex than odometry and requires sophisticated sensor fusion.

=== Principle of Operation ===

# '''Measure acceleration''' using 3-axis accelerometer
# '''Remove gravity component''' from acceleration readings
# '''Integrate acceleration''' to obtain velocity
# '''Integrate velocity''' to obtain position
# '''Measure angular velocity''' using 3-axis gyroscope
# '''Integrate gyroscope readings''' to obtain heading angle
# '''Apply sensor fusion''' to combine all measurements and reduce drift

=== Mathematical Foundation ===

'''For position (simplified 2D case):'''
# Measure acceleration in body frame
accel_body = read_accelerometer()

# Rotate to world frame using current heading
accel_world_x = accel_body_x × cos(θ) - accel_body_y × sin(θ)
accel_world_y = accel_body_x × sin(θ) + accel_body_y × cos(θ)

# Remove gravity (9.81 m/s² in z-axis)
accel_world_z = accel_body_z - 9.81

# Integrate to get velocity
velocity_x = velocity_x_prev + accel_world_x × dt
velocity_y = velocity_y_prev + accel_world_y × dt

# Integrate to get position
position_x = position_x_prev + velocity_x × dt
position_y = position_y_prev + velocity_y × dt

'''For heading:'''
# Measure angular velocity
gyro_z = read_gyroscope_z()

# Integrate to get heading
θ = θ_prev + gyro_z × dt

=== Pseudocode Example ===

<syntaxhighlight lang="python">
# Initialize state
position = [0.0, 0.0, 0.0] # x, y, z
velocity = [0.0, 0.0, 0.0]
theta = 0.0 # heading angle
prev_time = time.now()

# IMU calibration offsets (determined during calibration)
ACCEL_BIAS = [0.05, -0.03, 0.02] # m/s²
GYRO_BIAS = [0.01, 0.02, -0.01] # rad/s
GRAVITY = 9.81 # m/s²

def rotation_matrix_2d(angle):
"""Create 2D rotation matrix"""
return [[math.cos(angle), -math.sin(angle)],
[math.sin(angle), math.cos(angle)]]

def update_imu_dead_reckoning():
global position, velocity, theta, prev_time

# Calculate time step
current_time = time.now()
dt = current_time - prev_time
prev_time = current_time

# Read IMU sensors
accel_body = read_accelerometer() # [ax, ay, az] in body frame
gyro_body = read_gyroscope() # [gx, gy, gz] in body frame

# Apply calibration corrections
accel_body = [accel_body[i] - ACCEL_BIAS[i] for i in range(3)]
gyro_body = [gyro_body[i] - GYRO_BIAS[i] for i in range(3)]

# Update heading from gyroscope
theta += gyro_body[2] * dt # z-axis gyro

# Rotate acceleration to world frame
rot_mat = rotation_matrix_2d(theta)
accel_world_x = rot_mat[0][0] * accel_body[0] + rot_mat[0][1] * accel_body[1]
accel_world_y = rot_mat[1][0] * accel_body[0] + rot_mat[1][1] * accel_body[1]
accel_world_z = accel_body[2]

# Remove gravity from z-axis
accel_world_z -= GRAVITY

# Integrate acceleration to velocity
velocity[0] += accel_world_x * dt
velocity[1] += accel_world_y * dt
velocity[2] += accel_world_z * dt

# Integrate velocity to position
position[0] += velocity[0] * dt
position[1] += velocity[1] * dt
position[2] += velocity[2] * dt

return (position, velocity, theta)

# Main loop
while robot_running:
pose = update_imu_dead_reckoning()

# Use position for navigation
navigate_using_position(pose)

# Sleep to maintain consistent update rate
time.sleep(0.01) # 100 Hz update rate
</syntaxhighlight>

=== IMU Error Sources ===

IMU-based dead reckoning faces significant challenges:
* '''Gyroscope drift''': Bias errors accumulate rapidly when integrated
* '''Accelerometer bias''': Small constant errors become large position errors after double integration
* '''Sensor noise''': Random noise accumulates through integration
* '''Gravity vector estimation''': Errors in removing gravity cause acceleration measurement errors
* '''Temperature effects''': Sensor characteristics change with temperature
* '''Vibration''': High-frequency vibration can bias accelerometer readings

IMU-only dead reckoning typically exhibits much higher drift rates than odometry-based systems. Most practical systems combine IMU data with other sensors (sensor fusion).

== Error Accumulation ==

All dead reckoning systems suffer from '''unbounded error growth''' because small measurement errors are integrated over time:

* '''Odometry drift''': Typically 5-10% of distance traveled under good conditions
** Example: After driving 10 meters, position error might be 0.5-1.0 meters
** Error grows approximately linearly with distance
** Systematic errors (like unequal wheel diameters) cause circular drift patterns

* '''IMU drift''': Much worse due to double integration of accelerometer noise
** Position error grows quadratically with time
** Without corrections, IMU-only systems become unusable within seconds
** Gyro drift causes heading errors that compound position errors

* '''Combined effects''': Heading errors particularly problematic
** A 1-degree heading error causes 1.7% lateral drift
** After driving 10 meters with 1° heading error, lateral position error is 0.17 meters

== Coordinate Systems ==

Dead reckoning requires careful management of coordinate frames:

=== Robot Frame (Body Frame) ===
* Origin at robot center
* X-axis points forward
* Y-axis points left
* Rotates with the robot

=== World Frame (Global Frame) ===
* Fixed reference frame
* Origin at starting position
* X and Y axes aligned with environment
* Does not move

=== Pose Representation ===

Robot pose in world frame: '''(x, y, θ)'''
* '''x''': Position along world X-axis
* '''y''': Position along world Y-axis
* '''θ''': Heading angle (orientation) relative to world X-axis

=== Coordinate Transformation ===

To transform a point from robot frame to world frame:

x_world = x_robot × cos(θ) - y_robot × sin(θ) + pose_x
y_world = x_robot × sin(θ) + y_robot × cos(θ) + pose_y

Using rotation matrix form:
[x_world] [cos(θ) -sin(θ)] [x_robot] [pose_x]
[y_world] = [sin(θ) cos(θ)] [y_robot] + [pose_y]

== Improving Accuracy ==

Several techniques can reduce dead reckoning errors:

=== Sensor Fusion ===
Combine multiple sensor types to leverage their complementary characteristics:
* '''Odometry + IMU''': Odometry for position, IMU for rapid orientation updates
* '''Complementary filtering''': Use IMU for short-term (fast response), odometry for long-term (low drift)
* '''Kalman filtering''': Optimal fusion of multiple noisy sensors

=== External Reference Points ===
Reset or correct position estimates when passing known landmarks:
* '''Beacon detection''': Reset position when detecting a marker at known location
* '''Wall following''': Use distance sensors to maintain known offset from wall
* '''Line detection''': Reset position when crossing known lines or boundaries
* '''Visual landmarks''': Use camera to identify known features

=== Calibration ===
Reduce systematic errors through careful calibration:
* '''Wheel diameter''': Measure actual effective diameter under load
* '''Wheel separation''': Measure actual track width between wheel contact points
* '''Encoder resolution''': Verify actual pulses per revolution
* '''IMU bias''': Measure sensor offsets while stationary

=== Closed-Loop Verification ===
Test dead reckoning accuracy by:
* Driving a closed path (square, circle) and measuring final position error
* Comparing estimated position to known checkpoints
* Recording error statistics over multiple runs
* Adjusting calibration parameters to minimize systematic errors

=== Advanced Techniques ===
* '''Kalman filters''': Optimal state estimation with uncertainty quantification
* '''Particle filters''': Handle non-Gaussian errors and multiple hypotheses
* '''Extended Kalman Filter (EKF)''': Handle non-linear motion models
* '''Unscented Kalman Filter (UKF)''': Better handling of severe non-linearities

== SimpleBot Implementation ==

SimpleBot implements odometry-based dead reckoning using optical wheel encoders:

* '''Sensor type''': Optical encoders on each wheel
* '''Pulse counting''': Interrupt-driven pulse accumulation
* '''Update rate''': Real-time position calculation on each encoder pulse
* '''Drivetrain''': Differential drive with two independent motors
* '''Capabilities''':
** Track current (x, y, θ) pose continuously
** Execute motion patterns (squares, circles, arbitrary paths)
** Return to starting position via reverse path
** Report position estimates for navigation decisions

See [[SimpleBot:Dead Reckoning Implementation]] for complete implementation details including:
* Hardware setup (encoder mounting and wiring)
* Interrupt service routines for pulse counting
* Position calculation algorithms
* Calibration procedures
* Example programs and test patterns

== Practical Challenges ==

=== Challenge 1: Drive and Return ===
'''Objective''': Test basic dead reckoning accuracy

# Program robot to drive a pattern (square, circle, or arbitrary path)
# Record the motion commands
# Execute the reverse motion sequence to return to start
# Measure final position error

'''Success criteria''':
* Position error < 5% of total distance traveled
* Heading error < 5 degrees

=== Challenge 2: Right Triangle Test ===
'''Objective''': Test position accuracy across different motion types

# Drive forward distance D
# Turn 90 degrees right
# Drive forward distance D (now at far corner of square)
# Calculate and turn toward starting position
# Drive directly back to start (hypotenuse of right triangle)
# Measure final position error

'''Success criteria''':
* Return to within 10 cm of starting position
* Demonstrates both distance and angle accuracy

This challenge tests:
* Forward distance measurement accuracy
* Turn angle accuracy
* Integration of distance and angle to calculate return path
* Cumulative error over multi-segment path

=== Challenge 3: Long Distance Drift ===
'''Objective''': Characterize error growth over distance

# Drive straight for increasing distances: 1m, 2m, 5m, 10m
# At each distance, measure lateral drift and distance error
# Calculate drift as percentage of distance traveled
# Plot error versus distance to characterize error growth

== See Also ==

* [[Capability:Optical Odometry]] - Wheel encoder hardware and pulse counting
* [[Capability:IMU Sensing]] - Inertial measurement unit sensors
* [[Capability:Differential Drive]] - Two-wheeled drivetrain fundamentals
* [[Activity:Dead Reckoning Navigation]] - Using dead reckoning for autonomous navigation
* [[SimpleBot:Dead Reckoning Implementation]] - Complete implementation on SimpleBot
* [[Behavior:Wall Following]] - Navigation behavior that can correct dead reckoning drift

[[Category:Behavior]]
[[Category:Beginner Behavior]]
[[Category:Intermediate Behavior]]

Behavior:Line Following

2025-10-11T16:47:35Z

John: Claude edited based on my notes, prompt, and SimpleBot code repository

{{Behavior
|name=Line Following
|requires=[[Capability:Line Sensing]], [[Capability:Differential Drive]]
|enables=[[Activity:Line Following]]
|difficulty=Beginner
|implementations=[[SimpleBot:Line Following Implementation]]
|status=Fully Documented
}}

'''Line Following''' is a fundamental robotic behavior that enables a robot to autonomously track and follow a visible line on the ground. This behavior interprets data from line sensors (typically infrared reflectance sensors) to continuously adjust the robot's steering and maintain alignment with the line path.

== Overview ==

Line-following behavior is one of the most common introductory robotics tasks, yet it scales from simple bang-bang control to sophisticated PID-based systems. The core principle remains constant: detect position relative to the line, and adjust motor speeds to correct any deviation.

The behavior operates in a continuous sense-think-act loop:
# '''Sense''': Read reflectance values from line sensors
# '''Think''': Determine position relative to the line (on line, left of line, right of line, or lost)
# '''Act''': Adjust motor speeds to steer back toward the line

Line-following is typically used with high-contrast lines (black tape on white surface or vice versa), though the algorithms can be adapted for other visual markers.

== Algorithm Variants by Sensor Count ==

The complexity and performance of line-following behavior depends heavily on the number of sensors used. Each configuration has distinct trade-offs.

=== One-Sensor Algorithm ===

The simplest line-following approach uses a single sensor positioned at the robot's front center.

'''Algorithm:'''
<pre>
loop forever:
if sensor detects line:
drive forward
else:
rotate in place (searching)
wait until line is found again
</pre>

'''Pseudocode:'''
<pre>
while true:
if read_sensor() == LINE_DETECTED:
set_motors(FORWARD_SPEED, FORWARD_SPEED)
else:
// Lost the line - search by rotating
set_motors(TURN_SPEED, -TURN_SPEED) // Spin in place
</pre>

'''Pros:'''
* Simplest hardware and code
* Minimal cost
* Good for teaching basic concepts

'''Cons:'''
* Jerky, inefficient motion (constant stop-and-turn)
* Cannot anticipate curves
* Very slow on anything but straight lines
* No way to determine which direction to correct

=== Two-Sensor Algorithm ===

Using two sensors positioned on either side of the line enables the robot to detect which direction it's drifting and make appropriate corrections. '''This is the approach used by SimpleBot.'''

'''Algorithm:'''
<pre>
loop forever:
read left_sensor and right_sensor

if both sensors on white (off line):
drive straight - robot is centered on line

else if left_sensor on line (black):
turn right - robot is drifting left

else if right_sensor on line (black):
turn left - robot is drifting right

else if both sensors on line (black):
intersection or completely lost
execute special handling
</pre>

'''Pseudocode:'''
<pre>
const BASE_SPEED = 150
const TURN_SPEED = 100

while true:
left = read_left_sensor()
right = read_right_sensor()

if left == WHITE and right == WHITE:
// Centered on line - drive straight
set_motors(BASE_SPEED, BASE_SPEED)

else if left == BLACK and right == WHITE:
// Drifting left - turn right
set_motors(BASE_SPEED, TURN_SPEED)

else if left == WHITE and right == BLACK:
// Drifting right - turn left
set_motors(TURN_SPEED, BASE_SPEED)

else if left == BLACK and right == BLACK:
// Both on line - intersection or lost
// Option 1: Stop and signal
set_motors(0, 0)
// Option 2: Drive straight through
set_motors(BASE_SPEED, BASE_SPEED)
// Option 3: Execute turn decision
make_intersection_decision()
</pre>

'''Pros:'''
* Simple to understand and implement
* Directional correction (knows which way to turn)
* Smooth following on gentle curves
* Can detect intersections
* Good cost-to-performance ratio

'''Cons:'''
* Fixed correction amount (not proportional)
* Struggles with sharp curves
* Sensor spacing critical to performance
* Line width must match sensor spacing

=== Three-Sensor Algorithm ===

Three sensors (left, center, right) provide better tracking by distinguishing between centered, slightly off, and significantly off positions.

'''Algorithm:'''
<pre>
loop forever:
read left_sensor, center_sensor, right_sensor

if center_sensor on line:
drive fast and straight - perfectly centered

else if left_sensor on line:
gentle turn right

else if right_sensor on line:
gentle turn left

else if no sensors on line:
execute lost-line recovery
</pre>

'''Pseudocode:'''
<pre>
const FAST_SPEED = 200
const NORMAL_SPEED = 150
const SLOW_SPEED = 100

while true:
left = read_left_sensor()
center = read_center_sensor()
right = read_right_sensor()

if center == BLACK:
// Perfectly centered - drive fast
set_motors(FAST_SPEED, FAST_SPEED)

else if left == BLACK:
// Slightly left - gentle right turn
set_motors(NORMAL_SPEED, SLOW_SPEED)

else if right == BLACK:
// Slightly right - gentle left turn
set_motors(SLOW_SPEED, NORMAL_SPEED)

else:
// Lost line - slow search
set_motors(SLOW_SPEED, -SLOW_SPEED)
</pre>

'''Pros:'''
* Better detection of centered position
* Can optimize speed (drive faster when centered)
* More graceful corrections
* Better lost-line detection

'''Cons:'''
* More hardware complexity
* Still uses discrete corrections
* Cannot handle very sharp curves without slowing significantly

=== Multi-Sensor Array (5-8 Sensors) ===

High-performance line following uses an array of sensors to calculate a continuous "line position" value, enabling proportional control.

'''Algorithm:'''
<pre>
loop forever:
read all sensors (s0, s1, s2, s3, s4, s5, s6, s7)

calculate line_position using weighted average:
line_position = sum(sensor_value[i] * position_weight[i]) / sum(sensor_value[i])

calculate error = line_position - desired_position (0 = center)

apply PID control:
correction = Kp * error + Ki * integral_error + Kd * derivative_error

adjust motors:
left_motor = BASE_SPEED + correction
right_motor = BASE_SPEED - correction
</pre>

'''Pseudocode:'''
<pre>
const BASE_SPEED = 180
const Kp = 0.8 // Proportional gain
const Ki = 0.01 // Integral gain
const Kd = 2.0 // Derivative gain

integral_error = 0
last_error = 0

while true:
// Read sensor array (0 = white, 1000 = black)
sensors = [read_sensor(0), read_sensor(1), ..., read_sensor(7)]

// Calculate weighted line position (-3.5 to +3.5 for 8 sensors)
weighted_sum = 0
total_activation = 0

for i in 0 to 7:
weight = i - 3.5 // Position weights: -3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5
weighted_sum += sensors[i] * weight
total_activation += sensors[i]

if total_activation > 0:
line_position = weighted_sum / total_activation
else:
// Lost line - use last known position
line_position = last_line_position

// PID control
error = line_position // Target is 0 (center)
integral_error += error
derivative_error = error - last_error

correction = Kp * error + Ki * integral_error + Kd * derivative_error

// Apply correction
left_speed = BASE_SPEED + correction
right_speed = BASE_SPEED - correction

set_motors(left_speed, right_speed)

last_error = error
last_line_position = line_position
</pre>

'''Pros:'''
* Smooth, precise tracking
* Proportional corrections (gentle curves vs. sharp turns)
* High speed capability
* Excellent on complex paths
* Can implement look-ahead strategies

'''Cons:'''
* Significant hardware cost
* Complex algorithm and tuning
* Requires PID understanding
* Overkill for simple tasks

== Tuning Parameters ==

Successful line-following requires careful tuning of several parameters:

=== Base Speed ===
The forward speed when driving straight or making corrections.

* '''Too slow''': Robot is stable but inefficient; wastes time
* '''Too fast''': Robot overshoots corrections and oscillates
* '''Optimal''': As fast as possible while maintaining stable tracking

Start with low speeds (50-100 motor units) and gradually increase until oscillation appears, then reduce by 20%.

=== Turn Aggression ===
How sharply the robot corrects when off-line.

* '''Too gentle''': Robot drifts off line before correction takes effect
* '''Too aggressive''': Robot oscillates or zigzags
* '''Optimal''': Smooth sinusoidal path that stays on line

For differential corrections, the turn speed should be 50-70% of base speed.

=== Sensor Spacing ===
Physical distance between sensors affects behavior.

* '''Narrow spacing''': More sensitive to small deviations; better on gentle curves; struggles on sharp turns
* '''Wide spacing''': Less sensitive; handles sharp turns; may miss gentle curves
* '''Optimal''': Spacing slightly wider than line width

For a 20mm wide line, sensors should be 25-30mm apart.

=== Sensor Threshold ===
The reflectance value that distinguishes line from background.

* Calibrate in actual operating environment
* Use midpoint between average white and average black readings
* Implement hysteresis to prevent flickering at boundary

<pre>
// Calibration procedure
white_value = read_sensor_on_white_surface()
black_value = read_sensor_on_black_line()
threshold = (white_value + black_value) / 2
</pre>

== Common Challenges and Solutions ==

=== Lost Line ===
'''Problem:''' Robot loses the line completely (all sensors read white or all read black).

'''Solutions:'''
* '''Memory-based recovery''': Remember last known direction and turn that way
<pre>
if line_lost():
if last_correction == TURNING_LEFT:
set_motors(-SEARCH_SPEED, SEARCH_SPEED) // Continue left
else:
set_motors(SEARCH_SPEED, -SEARCH_SPEED) // Continue right
</pre>

* '''Spiral search''': Gradually expand search radius
* '''Timeout and stop''': If line not found within N seconds, halt and signal error

=== Sharp Turns ===
'''Problem:''' Robot cannot turn sharply enough to stay on line.

'''Solutions:'''
* '''Detect sharp turn''': Multiple consecutive corrections in same direction
* '''Reduce speed''': Slow down when sharp turn detected
<pre>
consecutive_turns_right += 1
if consecutive_turns_right > 5:
base_speed = SLOW_SPEED // Sharp curve detected
</pre>

* '''Aggressive correction''': Increase turn speed or even stop one wheel

=== Intersections ===
'''Problem:''' Multiple possible paths (T-junction, cross, etc.).

'''Solutions:'''
* '''Detection''': Both sensors (or multiple sensors) detect line simultaneously
* '''Pre-programmed decisions''': Follow sequence of turns (left, right, straight, right...)
<pre>
intersection_sequence = [LEFT, STRAIGHT, RIGHT, LEFT]
current_intersection = 0

if detect_intersection():
execute_turn(intersection_sequence[current_intersection])
current_intersection += 1
</pre>

* '''Marker-based navigation''': Use additional sensors to detect colored markers
* '''Default behavior''': Always go straight through intersections

=== Line Width Variations ===
'''Problem:''' Line width changes along path.

'''Solutions:'''
* '''Calibration''': Test on actual track
* '''Adaptive thresholds''': Continuously recalibrate based on recent readings
* '''Edge detection''': Track line edge rather than center (more consistent)

== Advanced Techniques ==

=== PID Control ===
Proportional-Integral-Derivative control provides smooth, optimized tracking:

* '''Proportional (P)''': Correction proportional to current error (distance from line)
* '''Integral (I)''': Corrects for persistent bias (e.g., one motor slightly faster)
* '''Derivative (D)''': Dampens oscillation by responding to rate of change

Start with P-only control (set I and D to zero), then add D to reduce oscillation, and finally add small I if steady-state error exists.

=== Look-Ahead ===
With sensor arrays, use forward sensors to anticipate curves:

<pre>
if sensors[0] or sensors[1] active:
// Sharp left turn coming
reduce_speed()
increase_left_correction()
</pre>

=== Intersection Navigation ===
Sophisticated intersection handling:

* Count intersections to determine position on known map
* Use timing to ensure robot fully enters intersection before turning
* Implement "intersection memory" to avoid counting same intersection twice

=== Path Memory ===
Record successful paths and replay:

<pre>
// Record mode
path = []
while running:
sensor_state = read_sensors()
motor_command = calculate_correction(sensor_state)
path.append(motor_command)
execute(motor_command)

// Replay mode
for command in path:
execute(command)
delay(LOOP_TIME)
</pre>

== SimpleBot Implementation ==

SimpleBot uses the '''two-sensor algorithm''' with basic bang-bang control. The sensors are positioned 25mm apart, straddling a 20mm wide black line on a white surface.

The implementation uses:
* Reflectance sensors with analog output
* Threshold-based line detection
* Four-state control logic (straight, left, right, lost)
* Simple lost-line recovery (continue last turn direction)

For complete implementation details including circuit diagrams, calibration procedures, and code, see [[SimpleBot:Line Following Implementation]].

== See Also ==

* [[Capability:Line Sensing]] - Hardware and sensor technology
* [[Capability:Differential Drive]] - Motor control fundamentals
* [[Activity:Line Following]] - Using line following for navigation tasks
* [[SimpleBot:Line Following Implementation]] - Complete working example
* [[Behavior:PID Control]] - Advanced smooth control technique

[[Category:Behavior]]
[[Category:Beginner Behavior]]

Behaviors

2025-10-11T16:47:13Z

John: Claude edited based on my notes, prompt, and SimpleBot code repository

= Behaviors: How Robots Think and Act =

'''Behaviors''' are algorithms and software patterns that connect sensing to action. They represent the "how" of robotics - the intelligence that transforms sensor data into purposeful movement.

For an introduction to how Behaviors fit into the BRS knowledge structure, see [[Robotics Ontology]].

== What Makes a Behavior? ==

A Behavior has these characteristics:

* '''Algorithm-based''': It's a defined process or decision-making pattern
* '''Language-agnostic''': Can be implemented in any programming language
* '''Sensor-agnostic''': Works with different hardware providing the same capability
* '''Reusable''': The same behavior can be used in multiple activities
* '''Testable''': You can verify if the behavior works correctly

Behaviors are different from '''Activities''' (which are user-facing tasks) and '''Capabilities''' (which are hardware). A Behavior defines "how" a robot thinks, not "what" it accomplishes or "what hardware" it uses.

== Current Behaviors ==

These behaviors have full documentation with tested implementations on [[SimpleBot]]:

{| class="wikitable" style="width: 100%;"
! Behavior !! Type !! Required Capabilities !! Used In !! Status
|-
| '''[[Behavior:Line Following]]''' || Navigation || [[Capability:Line Sensing|Line Sensing]], [[Capability:Differential Drive|Differential Drive]] || [[Activity:Line Following]] || '''Fully Documented'''
|-
| '''[[Behavior:Dead Reckoning]]''' || Navigation || [[Capability:Optical Odometry|Odometry]], [[Capability:Differential Drive|Differential Drive]] || [[Activity:Dead Reckoning Navigation]] || '''Fully Documented'''
|}

== Future Behaviors (Stubs) ==

These behaviors are '''not yet implemented''' in any BRS robot. They represent opportunities for community contribution! Implement these algorithms and document them.

{| class="wikitable sortable" style="width: 100%;"
! Behavior !! Type !! Required Capabilities !! Enables Activities !! Status
|-
| [[Behavior:PID Control]] || Control || Sensors + Actuators || Precise motion, line following improvements || '''Stub''' - Waiting for implementation
|-
| [[Behavior:Wall Following]] || Navigation || Distance Sensing, Movement || Maze solving, room navigation || '''Stub''' - Waiting for implementation
|-
| [[Behavior:Pathfinding]] || Planning || Mapping, Movement || Optimal navigation, maze optimization || '''Stub''' - Advanced algorithm
|-
| [[Behavior:SLAM]] || Mapping || LIDAR/Distance, Odometry || Room mapping, autonomous navigation || '''Stub''' - Advanced algorithm
|}

== Behaviors by Type ==

=== Navigation Behaviors ===
* [[Behavior:Line Following]] (documented) - Follow visual guides
* [[Behavior:Dead Reckoning]] (documented) - Navigate using motion measurement
* [[Behavior:Wall Following]] (stub) - Follow walls and obstacles

=== Control Behaviors ===
* [[Behavior:PID Control]] (stub) - Proportional-Integral-Derivative feedback control

=== Planning Behaviors ===
* [[Behavior:Pathfinding]] (stub) - Calculate optimal routes

=== Mapping Behaviors ===
* [[Behavior:SLAM]] (stub) - Simultaneous Localization and Mapping

== How Behaviors Connect Capabilities to Activities ==

Behaviors are the bridge between what your robot '''can''' do (capabilities) and what it '''should''' do (activities). Here's how they connect:

{| class="wikitable" style="width: 100%;"
! Activity !! Behavior !! Required Capabilities !! Status
|-
| [[Activity:Line Following]] || [[Behavior:Line Following]] || Line Sensing + Differential Drive || '''Implemented'''
|-
| [[Activity:Dead Reckoning Navigation]] || [[Behavior:Dead Reckoning]] || Optical Odometry + Differential Drive || '''Implemented'''
|-
| [[Activity:Maze Solving]] || [[Behavior:Wall Following]] + Navigation || Distance/Bump Sensing + Movement || Stub
|-
| [[Activity:Room Mapping]] || [[Behavior:SLAM]] || LIDAR + Odometry + Movement || Stub
|}

== Algorithm Variations ==

Many behaviors have multiple algorithm variants. For example, [[Behavior:Line Following]] includes:

* '''One-sensor algorithm''' - Rotate until line found, drive forward, repeat (simple but choppy)
* '''Two-sensor algorithm''' - Turn toward whichever sensor detects the line (smooth beginner approach)
* '''Multi-sensor array with PID''' - Proportional control for smooth, fast tracking (advanced)

Good behavior documentation should:
* Describe multiple approaches (from simple to advanced)
* Explain trade-offs (speed vs complexity, smoothness vs code simplicity)
* Provide pseudocode for each variant
* Show when to use each variant

== How to Use Behavior Pages ==

Each Behavior page provides:

# '''Overview''' - What the behavior does and why it matters
# '''Algorithm description''' - Step-by-step logic in plain language
# '''Pseudocode''' - Language-agnostic code structure
# '''Variants''' - Different approaches (simple, intermediate, advanced)
# '''Tuning parameters''' - Variables you can adjust (speed, thresholds, gains)
# '''Required capabilities''' - What hardware is needed
# '''Activities enabled''' - What this behavior allows robots to do
# '''Implementation links''' - Robot-specific code examples

== Implementing Behaviors on Your Robot ==

Want to implement a behavior on your robot?

# '''Read the behavior page''' - Understand the algorithm
# '''Verify capabilities''' - Ensure your robot has required sensors/actuators
# '''Choose a variant''' - Pick an algorithm complexity that fits your needs
# '''Study the pseudocode''' - Understand the logic flow
# '''Write code for your platform''' - Translate to Python, C++, Arduino, etc.
# '''Test incrementally''' - Start simple, verify each step works
# '''Tune parameters''' - Adjust speeds, thresholds, timing
# '''Document it!''' - Create an implementation page for your robot
# '''Share your results''' - Help others learn from your experience

== Pseudocode Standards ==

BRS behavior documentation uses consistent pseudocode conventions:

* '''Indentation''' shows control flow (loops, conditionals)
* '''CAPS_WITH_UNDERSCORES''' for configuration constants
* '''camelCase''' for variables
* '''Comments''' explain the "why", not just the "what"
* '''Functions''' are named with action verbs (driveForward, readSensor)

This makes pseudocode easy to translate to any real programming language.

== Contributing New Behaviors ==

Want to add a new behavior?

Consider:
# '''Is it distinct?''' - Different from existing behaviors?
# '''Is it reusable?''' - Can it enable multiple activities?
# '''Is it well-understood?''' - Can you explain the algorithm clearly?
# '''Can you provide variants?''' - Simple and advanced approaches?

Then:
# Create a Behavior page using [[Template:Behavior]]
# Describe the algorithm in plain language
# Provide clear pseudocode
# Explain tuning parameters and trade-offs
# Show which capabilities it requires
# List activities it enables
# Implement it on your robot
# Create implementation documentation with real code

== See Also ==

* [[Robotics Ontology]] - How Behaviors fit into the BRS knowledge structure
* [[Activities]] - What behaviors enable robots to accomplish
* [[Capabilities]] - Hardware that behaviors require
* [[SimpleBot]] - BRS's first robot, demonstrating two behaviors

[[Category:Behaviors]]
[[Category:Ontology]]

File:Simplebot.jpeg

2025-10-11T16:46:12Z

John: An early prototype of Simplebot.

== Summary ==
An early prototype of Simplebot.