Key achievements and insights from the embedded programming week, including successful microcontroller programming, sensor integration, and the development of the ReactionAge reaction time measurement system.
This week focuses on embedded programming fundamentals, exploring how to program microcontrollers and create interactive electronic systems. We'll dive into the world of digital electronics, sensors, and real-time programming to build responsive devices that can sense, process, and react to their environment.
• Introduction to microcontrollers and embedded systems
• Programming fundamentals for real-time applications
• Sensor integration and data processing
This Week's Goals
Master Embedded Programming Learn microcontroller programming, sensor integration, and real-time system design
Build Interactive Systems Create responsive electronic devices that can sense and react to environmental inputs
Develop ReactionAge Project Implement a reaction time measurement system based on research methodologies
Assignments
Group Assignment Collaborative embedded programming project focusing on sensor integration and real-time data processing
Individual Assignment: ReactionAge Build a reaction time measurement system based on research methodologies from cognitive science literature
Tools & Materials
Microcontrollers Arduino, ESP32, or similar development boards
Development Environment Arduino IDE, PlatformIO, or VS Code with embedded extensions
Sensors & Components Buttons, LEDs, displays, accelerometers, and other input/output devices
Prototyping Tools Breadboards, jumper wires, resistors, and basic electronic components
Training Documentation
Essential training materials and resources for embedded programming fundamentals, microcontroller setup, and sensor integration techniques.
Comprehensive guide to soldering techniques for embedded electronics, covering both wire soldering and solder paste methods.
Wire Soldering
Temperature: 720-800°F
Melt pad onto electrode first
Anchor arms for precision control
Use appropriate tip size for part
Work from low to high profile parts
Solder Paste
Use gloves for protection
Highest magnification possible
Temperature: 270-330°C
Heat all sides together
Required for SMD components
Safety First:
Always wear safety glasses and use proper ventilation. Lead-free solder requires extra caution due to flux crystallization at high temperatures.
How to Solder (Almost) Anything
Step-by-step video demonstrations of essential soldering techniques for embedded electronics, covering both wire soldering and surface-mount component assembly.
Wire Soldering Technique
Learn the proper technique for soldering wires to components, starting with one edge to keep the part in place, then soldering the rest easily by keeping your wrist stable and the solder tip on the pad to heat it up with the part, and slowly bringing in solder.
Wire soldering demonstration showing proper technique and wrist stability
Solder Paste Assembly
Complete process for surface-mount component assembly: apply solder paste first, place the component, then heat up with a heat gun to create strong, reliable connections.
Applying solder paste to PCB pads
Placing microcontroller on prepared solder paste
Using heat gun to reflow solder paste and complete the connection
Pro Tips:
For detailed soldering guides and advanced techniques, refer to the Electronics & Soldering Training section above for comprehensive documentation and resources.
• Microcontroller Programming Basics - Introduction to embedded programming concepts and development environments
• Sensor Integration Workshop - Hands-on training for connecting and programming various sensors
• Real-time System Design - Principles of creating responsive embedded systems
• Debugging Techniques - Tools and methods for troubleshooting embedded code
QPAD Development Boards Programming Guide
Complete programming setup and workflow for QPAD development boards, covering bootloader configuration, IDE setup, and code deployment for different microcontroller architectures.
QPAD-XIAO (RP2040)
The QPAD-XIAO features a Raspberry Pi RP2040 microcontroller with built-in bootloader support. No bootloader burning required - simply configure your IDE and start programming!
Programming Steps:
Connect QPAD-XIAO to your computer via USB-C
In Arduino IDE, select Tools → Board → Raspberry Pi RP2040 Boards → XIAO RP2040
Select the correct COM port under Tools → Port
Write your code and click Upload - the board handles everything automatically!
The QPAD21 uses an ATSAMD21 microcontroller that requires bootloader programming using a XIAO programmer chip. Follow these steps to get it ready for development.
Bootloader Programming Steps:
Connect XIAO programmer to QPAD21 using the programming header
Connect XIAO programmer to your computer via USB
In Arduino IDE, select Tools → Board → Arduino SAMD (32-bits ARM Cortex-M0+) → Arduino MKR WiFi 1010
Select the correct COM port for the XIAO programmer
Configure bootloader settings:
Bootloader: Adafruit Circuit Playground Express
Clock: 48 MHz (USB)
USB Stack: Arduino
Debug Level: None
Erase Flash: All Flash Contents
Bootloader Version: 1.0.0
Click Burn Bootloader and wait for completion
Programming Steps (After Bootloader):
Disconnect XIAO programmer and connect QPAD21 directly via USB
The QPAD-XIAO-ESP32S3 features an ESP32-S3 microcontroller with built-in WiFi and Bluetooth capabilities. No bootloader burning required - just configure your IDE and start programming!
Programming Steps:
Connect QPAD-XIAO-ESP32S3 to your computer via USB-C
Microcontroller Programming Architecture and fundamentals
Sensor Integration Data processing methods
Real-time Systems Design principles and optimization
Board Design Documentation
Essential resources for designing custom PCBs and development boards for embedded programming projects, covering schematic design, layout principles, and manufacturing considerations.
USB-C board design showing proper connector placement, power routing, and signal integrity considerations for embedded development boards
Design Principles
USB-C connector placement and orientation
Power distribution and ground plane design
Signal integrity and trace routing
Component placement optimization
Manufacturing Considerations
Layer stackup and via design
Silkscreen and assembly markings
Test point placement
Design rule checking (DRC)
Design Files Available:
Complete KiCad project files, schematics, and PCB layouts are available in the Design Files section below for download and modification.
Common Troubleshooting
Essential troubleshooting techniques for embedded development boards, covering power supply verification and connector testing using multimeter measurements.
Voltage Regulator Troubleshooting
Verify that your voltage regulator is functioning correctly by measuring output voltages with a multimeter when power is connected to the board.
Voltage regulator testing points showing input, output, and ground connections for multimeter verification
Testing Steps:
Connect power to your development board
Set multimeter to DC voltage mode
Measure input voltage (VIN) - should match your power supply voltage
Measure output voltage (VOUT) - should be the regulated voltage (e.g., 3.3V or 5V)
Check ground continuity between input and output ground pins
Verify no voltage drop under load conditions
💡 Pro Tip:
Use a portable multimeter for easy on-the-go testing and debugging of embedded circuits.
USB-C Pinout Troubleshooting
Verify USB-C connector functionality by testing power delivery, data lines, and ground connections using multimeter measurements.
USB-C pinout diagram showing power, data, and ground connections for multimeter testing and verification
Testing Steps:
Connect USB-C cable to your development board
Set multimeter to DC voltage mode
Measure VBUS (pin A4/B4) - should read 5V when connected to power
Test ground continuity (pins A1/B1, A12/B12) - should show 0Ω resistance
Check CC1/CC2 pins (A5/B5) for proper connection detection
Verify D+ and D- data lines (A6/A7, B6/B7) for continuity
Test both orientations of the USB-C connector
🔧 Troubleshooting Tips:
If VBUS shows 0V, check cable and power source
If ground shows high resistance, check solder joints
If data lines show no continuity, verify connector orientation
Test with known working USB-C cable for comparison
Group Assignment: Embedded Programming Design Trades
Comprehensive analysis of design tradeoffs in embedded programming, covering language selection, development workflows, and microcontroller choices. This collaborative project examines the critical decisions that shape embedded system development and their impact on project success.
Design Tradeoffs Summary
Architecture
Example Boards
Toolchain / Workflow
Strengths
Limitations
AVR (8-bit)
ATtiny44, ATmega328 (Arduino Uno)
avr-gcc, avrdude; Arduino IDE for simplified workflow
Mature ecosystem, simple to program, widely taught
Limited memory & speed, not ideal for complex tasks
ARM Cortex-M
SAMD21, STM32, Teensy
arm-none-eabi-gcc, OpenOCD, PlatformIO; Arduino or CircuitPython support
High performance, industry standard, strong debugging tools
Toolchain setup can be complex
RP2040
Raspberry Pi Pico, XIAO RP2040
Pico SDK (C/C++), MicroPython, Arduino IDE; custom PIO assembly for peripherals
Flexible, inexpensive, unique PIO hardware for custom protocols
Requires learning PIO for advanced features
ESP8266 / ESP32
NodeMCU, Sparkfun/Adafruit ESP boards
Espressif SDK/IDF, Arduino IDE, MicroPython
Built-in Wi-Fi/Bluetooth, large community support, IoT-ready
Higher power usage, less deterministic timing
RISC-V
HiFive boards, experimental dev kits
riscv-gnu-toolchain, GDB, newer SDKs
Open-source ISA, growing ecosystem, academic/educational interest
Toolchain less mature, fewer libraries & examples
Comprehensive comparison of microcontroller architectures and their tradeoffs in embedded programming
Language Tradeoff
Programming language tradeoff analysis showing performance vs development speed considerations
As illustrated in the language tradeoff diagram above, the choice of programming language involves critical tradeoffs between performance and development speed. The analysis shows how different languages balance factors like memory efficiency, execution speed, development time, and ecosystem support for embedded system development.
High Performance Languages
C/C++: Maximum control, minimal overhead
Rust: Memory safety with performance
Assembly: Direct hardware control
Rapid Development Languages
Python: Fast prototyping, rich libraries
JavaScript: Web integration capabilities
MicroPython: Python for microcontrollers
Development Workflow Tradeoff
Development workflow tradeoff analysis comparing different methodologies and their impact on project outcomes
The development workflow tradeoff diagram above demonstrates how different methodologies balance project timeline, code quality, and team collaboration. This visual analysis compares traditional waterfall approaches with agile methodologies, showing the impact of various toolchains, testing strategies, and deployment processes on embedded system development success.
Traditional Approaches
Waterfall: Sequential, documentation-heavy
V-Model: Testing integrated with design
Spiral: Risk-driven iterative approach
Modern Approaches
Agile: Iterative, customer-focused
DevOps: Continuous integration/deployment
Test-Driven Development: Quality-first
Microcontroller Tradeoff
Microcontroller tradeoff analysis showing performance vs power consumption and cost considerations
The microcontroller tradeoff diagram above illustrates the critical balance between performance, power consumption, and cost in embedded system design. This visual analysis evaluates different architectures, processing capabilities, memory configurations, and peripheral options, providing a clear framework for selecting the optimal platform based on specific application requirements.
Low-Power Options
ARM Cortex-M0+: Ultra-low power
PIC: Simple, cost-effective
MSP430: Energy-efficient design
High-Performance Options
ARM Cortex-M4: DSP capabilities
ESP32: WiFi/Bluetooth integrated
STM32: Rich peripheral set
Use Case Analysis
Architecture
Workflow Process
Key Characteristics
SAMD21 (ARM Cortex-M)
• Write code in C/C++ (Arduino IDE or PlatformIO)
• Compile with arm-none-eabi-gcc
• Upload using OpenOCD via USB or SWD debugger
• Debug with GDB or serial monitor
Professional-grade debugging, industry standard tools
RP2040 (Raspberry Pi Pico)
• Write code in C/C++ (Pico SDK) or MicroPython
• Compile with CMake + GCC toolchain
• Drag-and-drop .uf2 file to Pico's USB mass storage device
• (Optional) Use custom PIO assembly for hardware interfaces
Accessibility and flexibility, drag-and-drop + PIO
Workflow examples showing different development approaches for ARM and RP2040 architectures
The example workflow table above provides specific recommendations for different embedded system applications, showing how the tradeoff analyses from the previous sections translate into practical implementation strategies. This comprehensive table demonstrates the relationship between project requirements and optimal technology choices.
Key Findings
As demonstrated in the workflow table above, ARM workflows emphasize professional-grade debugging with industry-standard tools, while RP2040 workflows emphasize accessibility and flexibility through drag-and-drop deployment and unique PIO capabilities.
The comprehensive architecture comparison shows that optimal design choices depend heavily on project constraints, performance requirements, and development timeline.
High-performance applications favor ARM Cortex-M with professional toolchains, while rapid prototyping benefits from RP2040's flexible development environment and built-in features.
Build a reaction time measurement system based on research methodologies from cognitive science literature. This project combines embedded programming with scientific measurement principles to create a tool for studying human cognitive performance.
Core Features
Stimulus Generation Visual/auditory stimuli with precise timing
Response Detection Accurate measurement using buttons/sensors
Data Analysis Statistical processing and visualization
Research Foundation
Based on PLOS ONE study (2017) examining reaction time variability and cognitive decline.
Complete bill of materials for the ReactionAge embedded programming project. All prices are in USD and subject to supplier variations.
Nintendo Switch Controller Training for Toddlers
An interactive training module designed for young children, utilizing Nintendo Switch controller input to create an engaging letter-matching game that develops motor skills and cognitive recognition.
Game Mechanics
Button Mapping A, B, X, Y in inverted layout
Visual Stimulus Flashing letters with bright colors
Progressive Difficulty Adapts based on performance
Educational Benefits
Motor Skills Hand-eye coordination
Letter Recognition Alphabet learning
Attention Building Focus and concentration
Technical Features
Controller Support Pro Controller & Joy-Con
Display System Large, colorful letters
Progress Tracking Analytics & feedback
ChatGPTMario2D
An AI-powered Mario-style platformer game built with ChatGPT assistance, featuring touch controls, adaptive gameplay mechanics, and classic 2D platforming elements optimized for embedded systems.
Mario-style platformer gameplay with touch controls and adaptive difficulty
ChatGPT-assisted development process and code generation demonstration
A collaborative multiplayer game featuring geometric shape interactions, synchronized gameplay between two ESP32 devices, inspired by educational content in Shape Song Swing Along.
Shape Song Swing Along educational content integration and gameplay
Circle and square shape interaction gameplay mechanics
A touch monitoring utility developed with ChatGPT assistance for debugging and calibrating touch sensor inputs on the QPAD21 development board. This tool provides real-time visualization of touch sensor values and helps optimize touch thresholds for embedded applications.
A utility developed with ChatGPT assistance for retrieving and displaying MAC addresses on ESP32 devices. This tool is essential for ESP-NOW communication setup, allowing developers to identify device MAC addresses for peer-to-peer networking configuration in multiplayer embedded applications.
// MAC address retrieval utility for ESP32
#include
#include
void setup() {
Serial.begin(115200);
// Get WiFi STA MAC address
uint8_t mac[6];
esp_read_mac(mac, ESP_MAC_WIFI_STA);
Serial.print("WiFi STA MAC: ");
for (int i = 0; i < 6; i++) {
if (i > 0) Serial.print(":");
if (mac[i] < 16) Serial.print("0");
Serial.print(mac[i], HEX);
}
Serial.println();
// Get Bluetooth MAC address
esp_read_mac(mac, ESP_MAC_BT);
Serial.print("Bluetooth MAC: ");
for (int i = 0; i < 6; i++) {
if (i > 0) Serial.print(":");
if (mac[i] < 16) Serial.print("0");
Serial.print(mac[i], HEX);
}
Serial.println();
}
For detailed board design principles, USB-C connector placement, and manufacturing considerations, refer to the Board Design Documentation section above.
Reflections & Learnings
[Reflection notes placeholder.]
Contributions
Acknowledgments for collaborative support and technical assistance during the embedded programming project development.
Course Staff
Quentin Bolsée
Helped me so much with the ESP32S3 code development with his awesome examples. Also assisted with resoldering the microcontroller when we were debugging the USBC QPAD issues. Couldn't have done it without you!
Anthony Pennes
Spent so many hours helping me debug my USBC QPAD while resoldering the USBC port. Eventually it turned out the problem was that we crashed the board with XIAO code on a D21! Too much to say and so little time until class. Couldn't have done it without you.
Jesse de Alva
Helped me test the boards after programming them, providing valuable assistance with debugging and validation of the embedded programming projects. Your support was crucial for ensuring everything worked correctly.
Technical Support & Collaboration
Eghosa Ohenehn
Contributed valuable insights and technical discussions about microcontroller tradeoffs during the group assignment development. Provided expertise in evaluating different microcontroller architectures and their suitability for various embedded programming applications.
Anthony Pennes
Engaged in extensive discussions throughout the embedded programming design trades section, providing valuable technical insights and collaborative support during the group assignment development process.
Quentin Bolsée
Participated in numerous office hours discussions about embedded programming design trades, contributing significantly to the technical analysis and collaborative development of the group assignment content.
Alex Hu
Thank you for showing me Flappy Bird and inspiring me to push through the game development part of my plan this week. Your demonstration and encouragement were instrumental in motivating me to complete the ChatGPTMario2D and CircleSquareShapeSongSwingalong projects, helping me overcome technical challenges and stay focused on the embedded programming goals.
Tushar Kanade
Thank you for taking videos of the soldering training! Your documentation of the training process was incredibly helpful for understanding the techniques and procedures. The visual reference you provided made it much easier to follow along and learn the proper soldering methods for the embedded programming projects.
Special thanks to the collaborative learning environment that enabled knowledge sharing and technical problem-solving throughout the embedded programming week.
Ethical AI Use
Transparent documentation of AI assistance used in this week's work, following course guidelines for ethical AI usage.
AI-Assisted Template Generation and Task Planning
Used ChatGPT to generate the weekly template HTML structure and styling framework, and created structured task prompts
for week 2 embedded programming content development.
AI-Assisted Content Development and Page Structure
Used Cursor AI for iterative content development, page structure optimization, and aesthetic improvements.
The AI helped with HTML/CSS implementation, content organization, and maintaining consistent styling across the embedded programming documentation.
Used Cursor AI to implement the comprehensive BOM table with clickable images, datasheet links, and full-width responsive design.
The AI helped with HTML table structure, CSS styling, and integration of CSV data into an aesthetically pleasing table format.
Used ChatGPT for image recognition of electronic components to identify parts and construct the bill of materials CSV file.
The AI analyzed component images and provided detailed part specifications, descriptions, and pricing information for the embedded programming project.
AI-Assisted Project Content Updates and Documentation
Used Cursor AI for comprehensive project content updates, documentation improvements, and HTML structure optimization.
The AI assisted with content organization, styling consistency, and integration of multimedia elements for the embedded programming documentation.
AI-Assisted Arduino Programming and Code Development
Used ChatGPT for Arduino programming assistance based on the ReactionAge project code from
GitHub repository
and Quentin Bolsée's QPAD documentation available on the
course website embedded system assignment page.
The AI provided guidance on embedded programming concepts, code optimization, and integration with the QPAD-xiao board design.
AI-Assisted Group Assignment Content Development and Table Implementation
Used Cursor AI for comprehensive development of the embedded programming design trades group assignment section.
The AI assisted with creating structured subsections for language, development workflow, and microcontroller tradeoffs,
implementing professional HTML tables with data extracted from PowerPoint presentations, and integrating download links for PDF and PPTX files.
AI-Assisted Training Section Development and Documentation
Used Cursor AI for comprehensive development of the training section, including soldering techniques, QPAD programming guides,
board design documentation, and troubleshooting procedures. The AI assisted with creating structured subsections,
implementing video demonstrations, adding download links for design files, and developing comprehensive troubleshooting guides with multimeter testing procedures.
Used Cursor AI to analyze file sizes and break down large changes into smaller, manageable commits to avoid exceeding Git's 25MB commit size limit.
The AI helped organize files by size, created a logical commit strategy, and automated the commit and push process for better version control practices.
Used ChatGPT for collaborative development of the ChatGPTMario2D platformer game, including touch control implementation,
adaptive difficulty systems, collision detection, and game physics. The AI provided guidance on embedded programming concepts,
state machine architecture, and optimization for the QPAD21 development board.
AI-Assisted Multiplayer Game Development: CircleSquareShapeSongSwingalong
Used ChatGPT for collaborative development of the CircleSquareShapeSongSwingalong multiplayer game, including ESP-NOW wireless communication,
MAC address-based player identification, synchronized game state management, and educational content integration.
The AI provided guidance on embedded networking, real-time synchronization, and touch-based geometric learning systems.
Used ChatGPT for collaborative development of the QPAD21 touch monitoring utility, including real-time sensor value display,
threshold calibration assistance, debugging tools, and serial output for data logging. The AI provided guidance on touch sensor
integration, calibration procedures, and embedded debugging techniques for the QPAD21 development board.
Used ChatGPT for collaborative development of the get_mac_address utility for ESP32 devices, including WiFi STA and Bluetooth MAC address retrieval,
serial output formatting, and ESP-NOW integration support. The AI provided guidance on embedded networking concepts,
MAC address extraction methods, and device identification techniques for multiplayer embedded applications.
AI-Assisted Toddler Training Subsections Development
Used Cursor AI for comprehensive development of toddler training subsections, including ChatGPTMario2D and CircleSquareShapeSongSwingalong game implementations.
The AI assisted with creating structured subsections, implementing video demonstrations, adding download links for Arduino code files,
and developing comprehensive documentation for embedded programming educational content.
This week focuses on additive manufacturing processes and 3D scanning technologies. We'll explore the differences between subtractive and additive processes, learn about various 3D printing materials and techniques, and understand the design constraints and capabilities of 3D printing systems.
Key Concepts: Additive vs subtractive manufacturing, design for 3D printing, material properties, scanning technologies
This Week's Goals
Test 3D printer design rules Group assignment: Test design rules for available 3D printer(s)
Design additive-only object Individual: Design and print object that cannot be made subtractively
3D scan an object Individual: Scan an object and optionally print it
Assignments
Group Assignment Test design rules for 3D printer(s)
Individual Assignment Design, document, and 3D print object that could not be made subtractively
3D Scanning 3D scan an object (and optionally print it)
Design, document, and 3D print an object that could not be made subtractively. The object should be small (few cm³) and limited by printer time.
Design Requirements
Complex geometry Must have features impossible with subtractive manufacturing
Size constraint Small object, few cm³ volume
Print time Consider reasonable print time for testing
Documentation Document design process, print settings, and results
3D Scanning Component
Scan object Use available scanning method to capture 3D geometry
Process mesh Clean and prepare scanned mesh for printing
Optional printing Print the scanned object if desired
Handgripper for Locomotive Age Assessment
I hope to design and fabricate a handgripper to measure age based on hand grip strength. This builds on our aging biomarker research by focusing on locomotive age assessment.
The idea is to measure functional decline due to aging across multiple modalities:
Cognition: Memory, attention, reasoning, and problem-solving
Locomotion: Mobility, balance, and muscle strength
Sensory: Vision, hearing, and touch
Vitality: Energy levels, nutrition, and sleep
Psychological: Emotional well-being, resilience, and social connections
Last week we measured cognition with reaction time - this week we focus on locomotive age through grip strength.
Proposed 3D Printable Components
Untanglable Slinky
Complex interlocking geometry that cannot be manufactured subtractively. Tests printer's ability to create intricate, self-supporting structures with minimal overhangs.
Single Torsion Spring
Helical spring mechanism for grip force measurement. Demonstrates additive manufacturing's capability to create functional mechanical components in one piece.
Double Torsion Spring
Nested spring system with different spring constants. Tests printer's ability to create complex, multi-component mechanisms with varying material properties.
Coil Mechanism
Spiral coil for force transmission and measurement. Explores the limits of printable coil geometries and their mechanical properties for sensor integration.
Untanglable Slinky
A complex 3D printable design that demonstrates additive manufacturing capabilities through intricate geometry that cannot be manufactured subtractively.
Human-AI Co-Design
This design was co-developed through iterative discussion with ChatGPT, exploring various approaches to create an untanglable slinky geometry.
Design Iterations
The design process involved multiple iterations, with the first two attempts resulting in tangled slinkies that failed to maintain proper coil separation:
First attempt: Tangled slinky with improper coil geometry
Second attempt: Still resulted in tangled geometry
Final Successful Design
The third iteration successfully achieved the desired untanglable geometry:
Final design: Untanglable slinky with proper coil geometry
Design Description: This design shows an untanglable slinky with flat, oval coils, tiny spacers between turns, and solid end caps, so it collapses neatly without knots. The geometry enforces orderly stacking while preventing coils from slipping past each other.
My initial exploration into creating a 3D printable slinky design, inspired by the classic magic spring concept.
First slinky design - exploring the magic spring concept
Design Description: This first slinky design represents my initial exploration into creating a 3D printable magic spring. The design focuses on creating a helical structure that can collapse and expand while maintaining its structural integrity.
This design was inspired by the classic slinky toy and the concept of creating a "magic spring" that can be 3D printed in one piece, demonstrating the unique capabilities of additive manufacturing.
Inspiration & Resources
This design draws inspiration from several sources and builds upon existing work in 3D printable magic springs:
The Hackaday project provides comprehensive documentation including Java code for generating G-code, print parameters, and detailed instructions for creating 3D printable magic springs. The project includes multiple iterations of the code with different features like temperature control, spiral priming, and delta printer compatibility.
This session covers the development of the Week 3 page for 3D scanning and printing, including content population from MIT Academy resources, navigation updates, and design file integration.
This session documents the iterative co-design process for creating an untanglable slinky using ChatGPT. The conversation shows multiple design iterations, from initial failed attempts to the final successful geometry.
This session documents the comprehensive refactoring of the entire web development repository to make it fully responsive and mobile-friendly. The conversation covers the implementation of modern CSS techniques, responsive design patterns, and mobile-first development approaches.
This session documents the integration of the first slinky design into the untanglable slinky section, including adding the image, description, inspiration resources, and design file links.
[Brief note on AI tool usage this week placeholder.]
```
Now I need to add the JavaScript to set the year dynamically for the pages I just updated. Let me check if they already have the script:
I need to add the JavaScript to set the year dynamically. Let me add it to each of the updated pages:
```html
Week 2 · HTMAA 2025 · Embedded Programming
Key achievements and insights from the embedded programming week, including successful microcontroller programming, sensor integration, and the development of the ReactionAge reaction time measurement system.
This week focuses on embedded programming fundamentals, exploring how to program microcontrollers and create interactive electronic systems. We'll dive into the world of digital electronics, sensors, and real-time programming to build responsive devices that can sense, process, and react to their environment.
• Introduction to microcontrollers and embedded systems
• Programming fundamentals for real-time applications
• Sensor integration and data processing
This Week's Goals
Master Embedded Programming Learn microcontroller programming, sensor integration, and real-time system design
Build Interactive Systems Create responsive electronic devices that can sense and react to environmental inputs
Develop ReactionAge Project Implement a reaction time measurement system based on research methodologies
Assignments
Group Assignment Collaborative embedded programming project focusing on sensor integration and real-time data processing
Individual Assignment: ReactionAge Build a reaction time measurement system based on research methodologies from cognitive science literature
Tools & Materials
Microcontrollers Arduino, ESP32, or similar development boards
Development Environment Arduino IDE, PlatformIO, or VS Code with embedded extensions
Sensors & Components Buttons, LEDs, displays, accelerometers, and other input/output devices
Prototyping Tools Breadboards, jumper wires, resistors, and basic electronic components
Training Documentation
Essential training materials and resources for embedded programming fundamentals, microcontroller setup, and sensor integration techniques.
Comprehensive guide to soldering techniques for embedded electronics, covering both wire soldering and solder paste methods.
Wire Soldering
Temperature: 720-800°F
Melt pad onto electrode first
Anchor arms for precision control
Use appropriate tip size for part
Work from low to high profile parts
Solder Paste
Use gloves for protection
Highest magnification possible
Temperature: 270-330°C
Heat all sides together
Required for SMD components
Safety First:
Always wear safety glasses and use proper ventilation. Lead-free solder requires extra caution due to flux crystallization at high temperatures.
How to Solder (Almost) Anything
Step-by-step video demonstrations of essential soldering techniques for embedded electronics, covering both wire soldering and surface-mount component assembly.
Wire Soldering Technique
Learn the proper technique for soldering wires to components, starting with one edge to keep the part in place, then soldering the rest easily by keeping your wrist stable and the solder tip on the pad to heat it up with the part, and slowly bringing in solder.
Wire soldering demonstration showing proper technique and wrist stability
Solder Paste Assembly
Complete process for surface-mount component assembly: apply solder paste first, place the component, then heat up with a heat gun to create strong, reliable connections.
Applying solder paste to PCB pads
Placing microcontroller on prepared solder paste
Using heat gun to reflow solder paste and complete the connection
Pro Tips:
For detailed soldering guides and advanced techniques, refer to the Electronics & Soldering Training section above for comprehensive documentation and resources.
• Microcontroller Programming Basics - Introduction to embedded programming concepts and development environments
• Sensor Integration Workshop - Hands-on training for connecting and programming various sensors
• Real-time System Design - Principles of creating responsive embedded systems
• Debugging Techniques - Tools and methods for troubleshooting embedded code
QPAD Development Boards Programming Guide
Complete programming setup and workflow for QPAD development boards, covering bootloader configuration, IDE setup, and code deployment for different microcontroller architectures.
QPAD-XIAO (RP2040)
The QPAD-XIAO features a Raspberry Pi RP2040 microcontroller with built-in bootloader support. No bootloader burning required - simply configure your IDE and start programming!
Programming Steps:
Connect QPAD-XIAO to your computer via USB-C
In Arduino IDE, select Tools → Board → Raspberry Pi RP2040 Boards → XIAO RP2040
Select the correct COM port under Tools → Port
Write your code and click Upload - the board handles everything automatically!
The QPAD21 uses an ATSAMD21 microcontroller that requires bootloader programming using a XIAO programmer chip. Follow these steps to get it ready for development.
Bootloader Programming Steps:
Connect XIAO programmer to QPAD21 using the programming header
Connect XIAO programmer to your computer via USB
In Arduino IDE, select Tools → Board → Arduino SAMD (32-bits ARM Cortex-M0+) → Arduino MKR WiFi 1010
Select the correct COM port for the XIAO programmer
Configure bootloader settings:
Bootloader: Adafruit Circuit Playground Express
Clock: 48 MHz (USB)
USB Stack: Arduino
Debug Level: None
Erase Flash: All Flash Contents
Bootloader Version: 1.0.0
Click Burn Bootloader and wait for completion
Programming Steps (After Bootloader):
Disconnect XIAO programmer and connect QPAD21 directly via USB
The QPAD-XIAO-ESP32S3 features an ESP32-S3 microcontroller with built-in WiFi and Bluetooth capabilities. No bootloader burning required - just configure your IDE and start programming!
Programming Steps:
Connect QPAD-XIAO-ESP32S3 to your computer via USB-C
Microcontroller Programming Architecture and fundamentals
Sensor Integration Data processing methods
Real-time Systems Design principles and optimization
Board Design Documentation
Essential resources for designing custom PCBs and development boards for embedded programming projects, covering schematic design, layout principles, and manufacturing considerations.
USB-C board design showing proper connector placement, power routing, and signal integrity considerations for embedded development boards
Design Principles
USB-C connector placement and orientation
Power distribution and ground plane design
Signal integrity and trace routing
Component placement optimization
Manufacturing Considerations
Layer stackup and via design
Silkscreen and assembly markings
Test point placement
Design rule checking (DRC)
Design Files Available:
Complete KiCad project files, schematics, and PCB layouts are available in the Design Files section below for download and modification.
Common Troubleshooting
Essential troubleshooting techniques for embedded development boards, covering power supply verification and connector testing using multimeter measurements.
Voltage Regulator Troubleshooting
Verify that your voltage regulator is functioning correctly by measuring output voltages with a multimeter when power is connected to the board.
Voltage regulator testing points showing input, output, and ground connections for multimeter verification
Testing Steps:
Connect power to your development board
Set multimeter to DC voltage mode
Measure input voltage (VIN) - should match your power supply voltage
Measure output voltage (VOUT) - should be the regulated voltage (e.g., 3.3V or 5V)
Check ground continuity between input and output ground pins
Verify no voltage drop under load conditions
💡 Pro Tip:
Use a portable multimeter for easy on-the-go testing and debugging of embedded circuits.
USB-C Pinout Troubleshooting
Verify USB-C connector functionality by testing power delivery, data lines, and ground connections using multimeter measurements.
USB-C pinout diagram showing power, data, and ground connections for multimeter testing and verification
Testing Steps:
Connect USB-C cable to your development board
Set multimeter to DC voltage mode
Measure VBUS (pin A4/B4) - should read 5V when connected to power
Test ground continuity (pins A1/B1, A12/B12) - should show 0Ω resistance
Check CC1/CC2 pins (A5/B5) for proper connection detection
Verify D+ and D- data lines (A6/A7, B6/B7) for continuity
Test both orientations of the USB-C connector
🔧 Troubleshooting Tips:
If VBUS shows 0V, check cable and power source
If ground shows high resistance, check solder joints
If data lines show no continuity, verify connector orientation
Test with known working USB-C cable for comparison
Group Assignment: Embedded Programming Design Trades
Comprehensive analysis of design tradeoffs in embedded programming, covering language selection, development workflows, and microcontroller choices. This collaborative project examines the critical decisions that shape embedded system development and their impact on project success.
Design Tradeoffs Summary
Architecture
Example Boards
Toolchain / Workflow
Strengths
Limitations
AVR (8-bit)
ATtiny44, ATmega328 (Arduino Uno)
avr-gcc, avrdude; Arduino IDE for simplified workflow
Mature ecosystem, simple to program, widely taught
Limited memory & speed, not ideal for complex tasks
ARM Cortex-M
SAMD21, STM32, Teensy
arm-none-eabi-gcc, OpenOCD, PlatformIO; Arduino or CircuitPython support
High performance, industry standard, strong debugging tools
Toolchain setup can be complex
RP2040
Raspberry Pi Pico, XIAO RP2040
Pico SDK (C/C++), MicroPython, Arduino IDE; custom PIO assembly for peripherals
Flexible, inexpensive, unique PIO hardware for custom protocols
Requires learning PIO for advanced features
ESP8266 / ESP32
NodeMCU, Sparkfun/Adafruit ESP boards
Espressif SDK/IDF, Arduino IDE, MicroPython
Built-in Wi-Fi/Bluetooth, large community support, IoT-ready
Higher power usage, less deterministic timing
RISC-V
HiFive boards, experimental dev kits
riscv-gnu-toolchain, GDB, newer SDKs
Open-source ISA, growing ecosystem, academic/educational interest
Toolchain less mature, fewer libraries & examples
Comprehensive comparison of microcontroller architectures and their tradeoffs in embedded programming
Language Tradeoff
Programming language tradeoff analysis showing performance vs development speed considerations
As illustrated in the language tradeoff diagram above, the choice of programming language involves critical tradeoffs between performance and development speed. The analysis shows how different languages balance factors like memory efficiency, execution speed, development time, and ecosystem support for embedded system development.
High Performance Languages
C/C++: Maximum control, minimal overhead
Rust: Memory safety with performance
Assembly: Direct hardware control
Rapid Development Languages
Python: Fast prototyping, rich libraries
JavaScript: Web integration capabilities
MicroPython: Python for microcontrollers
Development Workflow Tradeoff
Development workflow tradeoff analysis comparing different methodologies and their impact on project outcomes
The development workflow tradeoff diagram above demonstrates how different methodologies balance project timeline, code quality, and team collaboration. This visual analysis compares traditional waterfall approaches with agile methodologies, showing the impact of various toolchains, testing strategies, and deployment processes on embedded system development success.
Traditional Approaches
Waterfall: Sequential, documentation-heavy
V-Model: Testing integrated with design
Spiral: Risk-driven iterative approach
Modern Approaches
Agile: Iterative, customer-focused
DevOps: Continuous integration/deployment
Test-Driven Development: Quality-first
Microcontroller Tradeoff
Microcontroller tradeoff analysis showing performance vs power consumption and cost considerations
The microcontroller tradeoff diagram above illustrates the critical balance between performance, power consumption, and cost in embedded system design. This visual analysis evaluates different architectures, processing capabilities, memory configurations, and peripheral options, providing a clear framework for selecting the optimal platform based on specific application requirements.
Low-Power Options
ARM Cortex-M0+: Ultra-low power
PIC: Simple, cost-effective
MSP430: Energy-efficient design
High-Performance Options
ARM Cortex-M4: DSP capabilities
ESP32: WiFi/Bluetooth integrated
STM32: Rich peripheral set
Use Case Analysis
Architecture
Workflow Process
Key Characteristics
SAMD21 (ARM Cortex-M)
• Write code in C/C++ (Arduino IDE or PlatformIO)
• Compile with arm-none-eabi-gcc
• Upload using OpenOCD via USB or SWD debugger
• Debug with GDB or serial monitor
Professional-grade debugging, industry standard tools
RP2040 (Raspberry Pi Pico)
• Write code in C/C++ (Pico SDK) or MicroPython
• Compile with CMake + GCC toolchain
• Drag-and-drop .uf2 file to Pico's USB mass storage device
• (Optional) Use custom PIO assembly for hardware interfaces
Accessibility and flexibility, drag-and-drop + PIO
Workflow examples showing different development approaches for ARM and RP2040 architectures
The example workflow table above provides specific recommendations for different embedded system applications, showing how the tradeoff analyses from the previous sections translate into practical implementation strategies. This comprehensive table demonstrates the relationship between project requirements and optimal technology choices.
Key Findings
As demonstrated in the workflow table above, ARM workflows emphasize professional-grade debugging with industry-standard tools, while RP2040 workflows emphasize accessibility and flexibility through drag-and-drop deployment and unique PIO capabilities.
The comprehensive architecture comparison shows that optimal design choices depend heavily on project constraints, performance requirements, and development timeline.
High-performance applications favor ARM Cortex-M with professional toolchains, while rapid prototyping benefits from RP2040's flexible development environment and built-in features.
Build a reaction time measurement system based on research methodologies from cognitive science literature. This project combines embedded programming with scientific measurement principles to create a tool for studying human cognitive performance.
Core Features
Stimulus Generation Visual/auditory stimuli with precise timing
Response Detection Accurate measurement using buttons/sensors
Data Analysis Statistical processing and visualization
Research Foundation
Based on PLOS ONE study (2017) examining reaction time variability and cognitive decline.
Complete bill of materials for the ReactionAge embedded programming project. All prices are in USD and subject to supplier variations.
Nintendo Switch Controller Training for Toddlers
An interactive training module designed for young children, utilizing Nintendo Switch controller input to create an engaging letter-matching game that develops motor skills and cognitive recognition.
Game Mechanics
Button Mapping A, B, X, Y in inverted layout
Visual Stimulus Flashing letters with bright colors
Progressive Difficulty Adapts based on performance
Educational Benefits
Motor Skills Hand-eye coordination
Letter Recognition Alphabet learning
Attention Building Focus and concentration
Technical Features
Controller Support Pro Controller & Joy-Con
Display System Large, colorful letters
Progress Tracking Analytics & feedback
ChatGPTMario2D
An AI-powered Mario-style platformer game built with ChatGPT assistance, featuring touch controls, adaptive gameplay mechanics, and classic 2D platforming elements optimized for embedded systems.
Mario-style platformer gameplay with touch controls and adaptive difficulty
ChatGPT-assisted development process and code generation demonstration
A collaborative multiplayer game featuring geometric shape interactions, synchronized gameplay between two ESP32 devices, inspired by educational content in Shape Song Swing Along.
Shape Song Swing Along educational content integration and gameplay
Circle and square shape interaction gameplay mechanics
A touch monitoring utility developed with ChatGPT assistance for debugging and calibrating touch sensor inputs on the QPAD21 development board. This tool provides real-time visualization of touch sensor values and helps optimize touch thresholds for embedded applications.
A utility developed with ChatGPT assistance for retrieving and displaying MAC addresses on ESP32 devices. This tool is essential for ESP-NOW communication setup, allowing developers to identify device MAC addresses for peer-to-peer networking configuration in multiplayer embedded applications.
// MAC address retrieval utility for ESP32
#include
#include
void setup() {
Serial.begin(115200);
// Get WiFi STA MAC address
uint8_t mac[6];
esp_read_mac(mac, ESP_MAC_WIFI_STA);
Serial.print("WiFi STA MAC: ");
for (int i = 0; i < 6; i++) {
if (i > 0) Serial.print(":");
if (mac[i] < 16) Serial.print("0");
Serial.print(mac[i], HEX);
}
Serial.println();
// Get Bluetooth MAC address
esp_read_mac(mac, ESP_MAC_BT);
Serial.print("Bluetooth MAC: ");
for (int i = 0; i < 6; i++) {
if (i > 0) Serial.print(":");
if (mac[i] < 16) Serial.print("0");
Serial.print(mac[i], HEX);
}
Serial.println();
}
For detailed board design principles, USB-C connector placement, and manufacturing considerations, refer to the Board Design Documentation section above.
Reflections & Learnings
[Reflection notes placeholder.]
Contributions
Acknowledgments for collaborative support and technical assistance during the embedded programming project development.
Course Staff
Quentin Bolsée
Helped me so much with the ESP32S3 code development with his awesome examples. Also assisted with resoldering the microcontroller when we were debugging the USBC QPAD issues. Couldn't have done it without you!
Anthony Pennes
Spent so many hours helping me debug my USBC QPAD while resoldering the USBC port. Eventually it turned out the problem was that we crashed the board with XIAO code on a D21! Too much to say and so little time until class. Couldn't have done it without you.
Jesse de Alva
Helped me test the boards after programming them, providing valuable assistance with debugging and validation of the embedded programming projects. Your support was crucial for ensuring everything worked correctly.
Technical Support & Collaboration
Eghosa Ohenehn
Contributed valuable insights and technical discussions about microcontroller tradeoffs during the group assignment development. Provided expertise in evaluating different microcontroller architectures and their suitability for various embedded programming applications.
Anthony Pennes
Engaged in extensive discussions throughout the embedded programming design trades section, providing valuable technical insights and collaborative support during the group assignment development process.
Quentin Bolsée
Participated in numerous office hours discussions about embedded programming design trades, contributing significantly to the technical analysis and collaborative development of the group assignment content.
Alex Hu
Thank you for showing me Flappy Bird and inspiring me to push through the game development part of my plan this week. Your demonstration and encouragement were instrumental in motivating me to complete the ChatGPTMario2D and CircleSquareShapeSongSwingalong projects, helping me overcome technical challenges and stay focused on the embedded programming goals.
Tushar Kanade
Thank you for taking videos of the soldering training! Your documentation of the training process was incredibly helpful for understanding the techniques and procedures. The visual reference you provided made it much easier to follow along and learn the proper soldering methods for the embedded programming projects.
Special thanks to the collaborative learning environment that enabled knowledge sharing and technical problem-solving throughout the embedded programming week.
Ethical AI Use
Transparent documentation of AI assistance used in this week's work, following course guidelines for ethical AI usage.
AI-Assisted Template Generation and Task Planning
Used ChatGPT to generate the weekly template HTML structure and styling framework, and created structured task prompts
for week 2 embedded programming content development.
AI-Assisted Content Development and Page Structure
Used Cursor AI for iterative content development, page structure optimization, and aesthetic improvements.
The AI helped with HTML/CSS implementation, content organization, and maintaining consistent styling across the embedded programming documentation.
Used Cursor AI to implement the comprehensive BOM table with clickable images, datasheet links, and full-width responsive design.
The AI helped with HTML table structure, CSS styling, and integration of CSV data into an aesthetically pleasing table format.
Used ChatGPT for image recognition of electronic components to identify parts and construct the bill of materials CSV file.
The AI analyzed component images and provided detailed part specifications, descriptions, and pricing information for the embedded programming project.
AI-Assisted Project Content Updates and Documentation
Used Cursor AI for comprehensive project content updates, documentation improvements, and HTML structure optimization.
The AI assisted with content organization, styling consistency, and integration of multimedia elements for the embedded programming documentation.
AI-Assisted Arduino Programming and Code Development
Used ChatGPT for Arduino programming assistance based on the ReactionAge project code from
GitHub repository
and Quentin Bolsée's QPAD documentation available on the
course website embedded system assignment page.
The AI provided guidance on embedded programming concepts, code optimization, and integration with the QPAD-xiao board design.
AI-Assisted Group Assignment Content Development and Table Implementation
Used Cursor AI for comprehensive development of the embedded programming design trades group assignment section.
The AI assisted with creating structured subsections for language, development workflow, and microcontroller tradeoffs,
implementing professional HTML tables with data extracted from PowerPoint presentations, and integrating download links for PDF and PPTX files.
AI-Assisted Training Section Development and Documentation
Used Cursor AI for comprehensive development of the training section, including soldering techniques, QPAD programming guides,
board design documentation, and troubleshooting procedures. The AI assisted with creating structured subsections,
implementing video demonstrations, adding download links for design files, and developing comprehensive troubleshooting guides with multimeter testing procedures.
Used Cursor AI to analyze file sizes and break down large changes into smaller, manageable commits to avoid exceeding Git's 25MB commit size limit.
The AI helped organize files by size, created a logical commit strategy, and automated the commit and push process for better version control practices.
Used ChatGPT for collaborative development of the ChatGPTMario2D platformer game, including touch control implementation,
adaptive difficulty systems, collision detection, and game physics. The AI provided guidance on embedded programming concepts,
state machine architecture, and optimization for the QPAD21 development board.
AI-Assisted Multiplayer Game Development: CircleSquareShapeSongSwingalong
Used ChatGPT for collaborative development of the CircleSquareShapeSongSwingalong multiplayer game, including ESP-NOW wireless communication,
MAC address-based player identification, synchronized game state management, and educational content integration.
The AI provided guidance on embedded networking, real-time synchronization, and touch-based geometric learning systems.
Used ChatGPT for collaborative development of the QPAD21 touch monitoring utility, including real-time sensor value display,
threshold calibration assistance, debugging tools, and serial output for data logging. The AI provided guidance on touch sensor
integration, calibration procedures, and embedded debugging techniques for the QPAD21 development board.
Used ChatGPT for collaborative development of the get_mac_address utility for ESP32 devices, including WiFi STA and Bluetooth MAC address retrieval,
serial output formatting, and ESP-NOW integration support. The AI provided guidance on embedded networking concepts,
MAC address extraction methods, and device identification techniques for multiplayer embedded applications.
AI-Assisted Toddler Training Subsections Development
Used Cursor AI for comprehensive development of toddler training subsections, including ChatGPTMario2D and CircleSquareShapeSongSwingalong game implementations.
The AI assisted with creating structured subsections, implementing video demonstrations, adding download links for Arduino code files,
and developing comprehensive documentation for embedded programming educational content.
This week focuses on additive manufacturing processes and 3D scanning technologies. We'll explore the differences between subtractive and additive processes, learn about various 3D printing materials and techniques, and understand the design constraints and capabilities of 3D printing systems.
Key Concepts: Additive vs subtractive manufacturing, design for 3D printing, material properties, scanning technologies
This Week's Goals
Test 3D printer design rules Group assignment: Test design rules for available 3D printer(s)
Design additive-only object Individual: Design and print object that cannot be made subtractively
3D scan an object Individual: Scan an object and optionally print it
Assignments
Group Assignment Test design rules for 3D printer(s)
Individual Assignment Design, document, and 3D print object that could not be made subtractively
3D Scanning 3D scan an object (and optionally print it)
Design, document, and 3D print an object that could not be made subtractively. The object should be small (few cm³) and limited by printer time.
Design Requirements
Complex geometry Must have features impossible with subtractive manufacturing
Size constraint Small object, few cm³ volume
Print time Consider reasonable print time for testing
Documentation Document design process, print settings, and results
3D Scanning Component
Scan object Use available scanning method to capture 3D geometry
Process mesh Clean and prepare scanned mesh for printing
Optional printing Print the scanned object if desired
Handgripper for Locomotive Age Assessment
I hope to design and fabricate a handgripper to measure age based on hand grip strength. This builds on our aging biomarker research by focusing on locomotive age assessment.
The idea is to measure functional decline due to aging across multiple modalities:
Cognition: Memory, attention, reasoning, and problem-solving
Locomotion: Mobility, balance, and muscle strength
Sensory: Vision, hearing, and touch
Vitality: Energy levels, nutrition, and sleep
Psychological: Emotional well-being, resilience, and social connections
Last week we measured cognition with reaction time - this week we focus on locomotive age through grip strength.
Proposed 3D Printable Components
Untanglable Slinky
Complex interlocking geometry that cannot be manufactured subtractively. Tests printer's ability to create intricate, self-supporting structures with minimal overhangs.
Single Torsion Spring
Helical spring mechanism for grip force measurement. Demonstrates additive manufacturing's capability to create functional mechanical components in one piece.
Double Torsion Spring
Nested spring system with different spring constants. Tests printer's ability to create complex, multi-component mechanisms with varying material properties.
Coil Mechanism
Spiral coil for force transmission and measurement. Explores the limits of printable coil geometries and their mechanical properties for sensor integration.
Untanglable Slinky
A complex 3D printable design that demonstrates additive manufacturing capabilities through intricate geometry that cannot be manufactured subtractively.
Human-AI Co-Design
This design was co-developed through iterative discussion with ChatGPT, exploring various approaches to create an untanglable slinky geometry.
Design Iterations
The design process involved multiple iterations, with the first two attempts resulting in tangled slinkies that failed to maintain proper coil separation:
First attempt: Tangled slinky with improper coil geometry
Second attempt: Still resulted in tangled geometry
Final Successful Design
The third iteration successfully achieved the desired untanglable geometry:
Final design: Untanglable slinky with proper coil geometry
Design Description: This design shows an untanglable slinky with flat, oval coils, tiny spacers between turns, and solid end caps, so it collapses neatly without knots. The geometry enforces orderly stacking while preventing coils from slipping past each other.
My initial exploration into creating a 3D printable slinky design, inspired by the classic magic spring concept.
First slinky design - exploring the magic spring concept
Design Description: This first slinky design represents my initial exploration into creating a 3D printable magic spring. The design focuses on creating a helical structure that can collapse and expand while maintaining its structural integrity.
This design was inspired by the classic slinky toy and the concept of creating a "magic spring" that can be 3D printed in one piece, demonstrating the unique capabilities of additive manufacturing.
Inspiration & Resources
This design draws inspiration from several sources and builds upon existing work in 3D printable magic springs:
The Hackaday project provides comprehensive documentation including Java code for generating G-code, print parameters, and detailed instructions for creating 3D printable magic springs. The project includes multiple iterations of the code with different features like temperature control, spiral priming, and delta printer compatibility.
This session covers the development of the Week 3 page for 3D scanning and printing, including content population from MIT Academy resources, navigation updates, and design file integration.
This session documents the iterative co-design process for creating an untanglable slinky using ChatGPT. The conversation shows multiple design iterations, from initial failed attempts to the final successful geometry.
This session documents the comprehensive refactoring of the entire web development repository to make it fully responsive and mobile-friendly. The conversation covers the implementation of modern CSS techniques, responsive design patterns, and mobile-first development approaches.
This session documents the integration of the first slinky design into the untanglable slinky section, including adding the image, description, inspiration resources, and design file links.
make it aesthetically pleasing
---
**Cursor**
I'll help you add the Creative Commons license to all pages and make it aesthetically pleasing. Let me first check the current footer structure and then update all the main HTML pages.
Now let me update all the main HTML pages to include the Creative Commons license with aesthetic styling. I'll start with the main pages:
```html
HTMAA 2025 · Saleem A. Al Dajani
Saleem A. Al Dajani
MIT CEE PhD @ AbuGoot and Gladyshev Labs
HTMAA 2025 · Making + AI for Aging & Longevity
Welcome
This is my home base for How to Make (Almost) Anything. I’m documenting weekly assignments, fabrication experiments, and a final project that bridges making with aging & health analytics.
🛠️ Digital fabrication🧬 Bioprinting📈 Sensing & ML🎛️ Embedded systems
I am a PhD student in the Department of Civil and Environmental Engineering at the Massachusetts Institute of Technology (MIT), with joint affiliations at Brigham and Women’s Hospital (BWH, part of Mass General Brigham) and Beth Israel Deaconess Medical Center (BIDMC, part of Beth Israel Lahey Health) at Harvard Medical School (HMS), where I am a member of the Abudayyeh-Gootenberg Lab and the Gladyshev Lab. I am also affiliated with the Mesoscale Nuclear Materials (MNM) Group in the Short Lab within the Department of Nuclear Science and Engineering at MIT. My research integrates the mechanics of materials under extreme conditions with machine learning to advance health, aging, and longevity science. I am committed to developing rigorous research skills, effective scientific communication, and interdisciplinary collaboration at the interface of science, engineering, and artificial intelligence.
Ethical AI Usage
Session transcripts where ChatGPT helped refine designs, code, and plans for this course. Dropping links under each week for now, we'll see how categorization evolves!
Created a Python script to automatically convert Cursor AI markdown transcripts to styled HTML files for better browser viewing.
The script parses markdown chat formats, applies consistent styling, and generates professional HTML pages with navigation and download options.
Welcome to How to Make (Almost) Anything! This week focuses on course orientation, safety training, and setting up the foundation for the semester ahead.
On‑board camera connected to the internet; model outputs shown on screen
Voice capture for age; display results and, if possible, text‑to‑speech
Integrate conversational layer (e.g., “Mirror, mirror on the wall…” for interpreting metrics)
Rejuvenated tissue idea — to define scope and feasibility (TBD)
Multimodal aging biomarker idea — sensor fusion + ML pipeline (TBD)
Dome idea — structural/form exploration (TBD)
Shuriken idea — mechanism/prototyping study (TBD)
Planning & Course Requirements
Design as modular subsystems so components can be swapped or removed and still pass
Fabricate custom parts and build my own electronics; target at least two PCBs
Sequence work so each week contributes a testable piece toward the final build
Contributions
Acknowledgements for the help I received this week from my classmates and instructors.
Alfonso Parra Rubio - Fusion Office Hours
Thank you to Alfonso for providing helpful Fusion office hours and guidance on CAD modeling techniques.
Dan Gilbert - CBA Shop
Thank you to Dan Gilbert for assistance with the CBA shop facilities and equipment access.
Tolga Durak - SHED Bioprinter Access Discussion
Had extensive discussions with Tolga Durak about accessing the SHED bioprinter for potential final project work. Tolga provided detailed guidance on the BRR (Biological Research Registration) process through MIT's CAB/ESCRO committee, including requirements for MIT PI involvement, research proposal structure, and timeline considerations. He explained that the bioprinter is currently limited to approved research projects due to existing commitments, and that any access would need to be scheduled around three ongoing research projects. Prof. Gershenfeld agreed to serve as the MIT PI for the proposal, and I'm working through the BRR forms to submit the necessary documentation for committee review.
Ethical AI Use
Transparent documentation of AI assistance used in this week's work, following course guidelines for ethical AI usage.
AI-Assisted Web Development in Cursor IDE
This week's webpage development was assisted by Cursor AI to create the initial page structure, styling, and content organization.
The AI helped with HTML/CSS implementation and responsive design patterns.
AI-Assisted Section Organization and Content Updates
Cursor AI assisted with organizing webpage sections, cleaning up HTML structure, and updating content for both week 0 and week 1 pages.
The AI helped with code refactoring, section reorganization, and maintaining consistent styling across pages.
This week focuses on the fundamentals of digital fabrication: computer-aided design (CAD), computer-aided manufacturing (CAM), laser cutting, and vinyl cutting. We'll learn the complete workflow from design to finished parts.
Note: These guides were created by Anthony Pennes and are maintained as supplementary resources for the HTMAA course.
View original Slack message for context.
Laser Cutter Characterization Group Assignment
Systematic testing and documentation of laser cutter parameters for optimal cutting performance. Assignment started: September 11, 2025Assignment completed: September 16, 2025
Machine Specifications
Available Lasers
CO₂ Laser: 75W (large machine)
CO₂ Laser: 60W (small machine)
Fiber Laser: Back of lab
Test Parameters
Rate: 500 pulses per inch (PPI)
Power: 100%
Speed: 30% (increased by 2.5% each test)
Focus & Positioning
Focus Point: Cut at the focal length (white part of the focusing stick)
Kerf Measurement: Measure deltas between intended and actual cut dimensions
Focus Accuracy: Critical for achieving clean, precise cuts
Joint Design & Clearance
Joint Type
Finger joint - interlocking design for structural connections
Clearance Definition
Size of the slot that provides tight enough fit for assembly
Material Considerations
Cardboard Limitations: Generally produces no good joints due to material properties and laser cutting characteristics
Material choice significantly impacts joint quality and assembly precision
Key Learnings
Speed increment of 2.5% provides systematic testing progression
Focus accuracy is critical for dimensional precision
Kerf measurement essential for compensating cut width in designs
Material selection directly impacts joint quality and assembly success
Systematic parameter testing reveals optimal settings for different materials
Results
Comprehensive analysis of kerf and clearance measurements from systematic laser cutter testing.
Interactive Data Analysis
View and interact with the complete dataset in Google Sheets:
Open in Google Sheets
|Data includes kerf measurements, clearance analysis, and statistical calculations
Measurement Methods
Systematic measurement approach for characterizing laser cutter kerf and joint clearance using precision calipers.
Peg and hole measurement setup
Top measurement view
Bottom measurement view
Measurement Protocol
Kerf Analysis: Three measurements were taken for each prescribed cut dimension on the joint gadget during laser cutter training
Clearance Analysis: Three measurements were taken for both hole and peg dimensions
Statistical Analysis: Averages and standard deviations calculated for precision assessment
Kerf Concept Diagram
Kerf Definition: The width of material removed by the laser beam during cutting.
Measured as the difference between prescribed cut dimensions and actual cut dimensions.
Clearance Definition: The dimensional difference between hole and peg sizes.
Negative values indicate interference fit (hole smaller than peg), while positive values indicate clearance fit.
Parametric Construction Kit Individual Assignment: 3D Parametric Design
Design and fabricate a modular construction kit using laser cutting and vinyl cutting techniques. Assignment started: September 10, 2025. Assignment completed: September 15, 2025
Preparation & Planning
Initial research and clarification discussions with instructors and classmates to understand assignment requirements and technical constraints.
Key Clarifications
Assignment Scope:Construction kit using laser cutter + separate vinyl cutting project (not crease patterns on cardboard)
File Formats:DXF for laser cutting, PNG/SVG for vinyl cutting
CAD Requirements:Must use Fusion 360 for laser cutting to develop CAD familiarity
Materials:Lab cardboard available, or personal materials (if safe to cut)
Technical Insights
Vinyl Cutting: Zero thickness lines for crease patterns, black and white images for cutting
Mountain vs Valley Folds: Opposite sides for thick materials, same side possible for thin materials
Design Differentiation: Dashed lines for fold lines, solid lines for cuts (though challenging in software)
Acknowledgments
Special thanks to Erik Demaine for guidance on vinyl cutting crease patterns and fold differentiation techniques, and Anthony Pennes for clarifying assignment requirements, file formats, and material options. Their expertise was invaluable in understanding the technical constraints and design possibilities for this project.
Design Process
Research and ideation for construction kit design
Create parametric CAD model with adjustable parameters in Fusion 360
Generate CAM toolpaths for laser cutting
Test cut on cardboard to verify fit and function
Iterate design based on test results
Final cut on appropriate material
Design and cut vinyl project (separate from construction kit)
Hand‑folded Prototype Assembly
I hand‑folded the crease pattern to validate the assembly. The parts do come together
when the folds are reasonably close to the intended lines. A second, refolded gadget
produced a noticeably cleaner assembly.
Single Gadget
Double Gadget
Assembly Detail
Full Pattern Failure
We tried cutting the full crease pattern on one side. It failed when layers with
opposite cuts overlapped and had to be push‑folded through during the final folding
step — the piece broke.
First Success Folded Single Gadget
First assembly of two gadgets. Folds were smooth after separating mountain and valley
cuts onto opposite sides to avoid breaking during push‑folds over multiple layers. The
shop cardboard was tight in the assembly pocket; thinner Amazon box cardboard folded by
hand fit better. Next step: make the laser‑cut pattern more exact.
Cut Strategy Videos
Left to right: clear mountain cut, flip and cut the opposite side, clear valley cut.
Mountain vs Valley Sides
Measurements confirming mountain vs valley sides.
First Gadget Assembly
Side profile and insertion step demonstrating clean folds without tearing.
Double Gadget Cut Variations
Exploring double‑part strategies: sequential cuts, flips between sides, and opposite‑side cuts.
Double Gadget — Rubber Band Assist
Temporary rubber band used to hold alignment while completing final folds.
First Success Assembly
Switched to thinner Amazon cardboard because the shop cardboard was too thick for the assembly pocket.
The Amazon box folded by hand fit perfectly and assembled smoothly. Three gadgets worked with the thinner
material. Rubber bands are just for compression — they assemble without them, though the bands make it
easier to keep them as one unit during insertion into the next gadget.
Quadruple Cut Strategy
Scaling up to quadruple cuts: sequential cuts, flips between sides, and opposite-side cutting strategies.
Double Gadget — Amazon Cardboard (No Support)
Three views of the double gadget assembled with Amazon cardboard, showing clean folds and proper fit.
Assembly Process with Support
Assembly sequence showing compression, support positioning, and insertion process for stable construction.
Triple Gadget — Final Assembly
The culmination: triple gadget assembly demonstrating successful scaling with Amazon cardboard and support techniques.
Further Refinements: Thick Origami
Applying thick‑origami concepts to avoid layer collisions and enable folding with real material thickness.
Guidance from Erik Demaine
From a discussion with Erik Demaine: double each crease into parallel offsets and open vertex regions as polygons
to prevent collisions. A uniform spacing works for a first pass, but for correctness the spacing between the doubled
creases should depend on how many layers lie between faces in the final folded state. I plan to estimate per‑crease
layer counts from an unfolded model and adjust offsets accordingly.
Citation: Jason S. Ku and Erik D. Demaine, “Folding Flat Crease Patterns With Thick Materials”, Journal of Mechanisms and Robotics,
8(3), June 2016, pp. 031003‑1–6. View paper
Thickened Crease Patterns
Estimate: double each crease with a uniform offset and add regular polygons at intersections.
Exact: compute sector‑aware offset polygons at vertices using incident crease angles.
How the Estimate Works
Input: crease segments with mountain/valley labels; sheet size S; target thickness t
offset = t / S (or a chosen fraction)
for each crease c:
draw two lines parallel to c at ±offset
for each vertex (intersection of original creases):
place a small regular polygon (e.g., octagon) centered at the vertex
Output: doubled creases + vertex holes
How the Exact Method Works
Input: crease lines; sheet size S; target thickness t
offset = t / S
for each crease c:
compute unit direction v and normals n1,n2
define two infinite offset lines at ±offset along n1/n2
for each vertex:
collect incident creases; sort by angle into cyclic order
for each adjacent pair (i, j):
pick the offset side that lies inside the angular sector
intersect those two offset lines → one polygon vertex
connect all vertices in order → convex vertex polygon
trim faces/creases by polygons as needed
Output: doubled creases + exact vertex polygons
Next Step — Layer‑Aware Offsets
Following Erik's advice, offsets should scale with the number of layers between faces in the folded state. Plan: estimate per‑crease layer counts and set per‑crease offset = k × thickness × layers(c), while keeping vertex polygons valid to avoid collisions.
Design and cut vinyl stickers and stencils using the vinyl cutter. Assignment started: September 15, 2025Assignment completed: September 15, 2025
Project Overview
Planned to vinyl cut lab logo stickers at first. Collected .png or .svg for each logo for the vinyl cutter software, and executing the complete workflow from cutting to final application. I hope to come back to the lab logos when there is less traffic on the vinyl cutter, I was more excited to see the fine detail of the vinyl cutter with the 2D parametric design at first!
Used a parametric sticker design that can be infinitely customized through an interactive web application.
The design demonstrates the power of parametric modeling in creating personalized vinyl stickers with
adjustable parameters for size, complexity, and visual elements. The assignment demonstrated both successful execution and troubleshooting when equipment issues arose.
Interactive Design Generator
This web-based generator was created as a final project in 6.5310 last semester and was used to download
a PNG of the default design shown above. Generate unlimited variations of this parametric design by
adjusting parameters in real-time to create custom stickers for any application.
Complete workflow from vinyl cutting through final sticker application, demonstrating the full process from design to finished product.
Vinyl Cutting Process
Vinyl cutter in action, cutting the Gladyshev Lab logo design with precise blade control and proper tension settings.
Completed Vinyl Cut
Clean vinyl cut showing precise cuts with proper registration and no tearing or incomplete cuts.
Weeding Process
Systematic weeding process: starting from center, progressing through unwanted sections, and finishing with clean weeded vinyl ready for transfer.
Transfer Paper Application
Transfer paper application process: carefully applying transfer paper to hold vinyl design, then removing it to prepare for final application.
Vinyl Application Process
Final application steps: positioning vinyl on target surface, using tweezers for precise removal of the broken thin vinyl strip, and achieving clean final application.
Completed Takehome Sticker
Final result: applied laptop vinyl sticker and takehome vinyl sticker ready for use, demonstrating successful completion of the vinyl cutting workflow.
Motor Failure
Encountered and resolved a motor failure during the vinyl cutting process, demonstrating troubleshooting skills and equipment maintenance knowledge.
Motor Error Display
Vinyl cutter displaying motor error, indicating a mechanical issue that prevented normal operation.
Roll Failure Analysis
Side-by-side comparison showing the vinyl roll before and after the failure. The roll ran out of material and then fell, causing the vinyl to kink under the cutting wheel.
Troubleshooting Solution
Simple fix process:
Turn off the vinyl cutter
Remove tape from the fallen roll to get the weight off
Readjust vinyl in between the wheels to ensure proper tension
Start again (or load a new roll if needed)
This common issue occurs when the vinyl roll runs out or becomes misaligned, causing the cutting mechanism to fail. The solution involves proper material handling and machine setup.
Design Files
Download or view design files from this week's assignments.
Camron Blackburn - Website Review & Table of Contents Suggestion
Camron reviewed the website and provided valuable feedback on navigation and user experience. She suggested implementing a table of contents to make it easier for visitors to navigate through the different sections of the weekly documentation. This suggestion led to the creation of the sleek, organized table of contents that now appears on both Week 0 and Week 1 pages, significantly improving the overall user experience and accessibility of the documentation.
Mariam Fitaihi - Photos and Videos
Photos and videos of this week's training were taken by Mariam Fitaihi, thank you!
Anthony Pennes provided the kerf and clearance design files (HTMAJointTest v0.f3d and HTMAJointTest.dxf) as part of the laser cutter training. These files were essential for understanding joint tolerances and clearance requirements when working with laser-cut materials.
Erik reviewed my approach to folding thick materials and suggested using the Ku & Demaine thick‑origami method. He pointed me to the paper and
emphasized that doubled creases should be spaced according to the number of layers between faces in the final fold. This feedback led me to implement
two variants (estimate and exact) of thickened crease patterns and to plan a next step for layer‑aware offsets.
Jesse helped me with laser cutting while figuring out how to do it, providing valuable guidance and support during the learning process. His assistance was crucial for understanding the laser cutting workflow and techniques.
Personal Notes - Laser Cutter Characterization
I took notes on the individual group assignment for characterizaing the laser cutter. :-)
Transparent documentation of AI assistance used in this week's work, following course guidelines for ethical AI usage.
AI-Assisted Web Development in Cursor IDE
This week's webpage development, training documentation, and assignment preparation were assisted by Cursor AI.
The AI helped with HTML/CSS implementation, content organization, and structuring technical documentation.
AI-Assisted Section Organization and Content Updates
Cursor AI assisted with organizing webpage sections, cleaning up HTML structure, and updating content for both week 0 and week 1 pages.
The AI helped with code refactoring, section reorganization, and maintaining consistent styling across pages.
Cursor AI assisted with adding Anthony's HTMA guides to the Week 1 page, creating a new "Useful Documentation" section,
and integrating external resource links with proper styling and organization.
Cursor AI assisted with creating a comprehensive Results section for the Laser Cutter Characterization Group Assignment,
including kerf and clearance analysis tables, measurement methodology documentation, concept diagrams, and downloadable resources.
The AI helped integrate Google Sheets data, create professional data tables, and include the complete measurement analysis workflow.
Cursor AI assisted with creating an interactive highlights section for Week 1, including visual improvements to the results display,
clickable navigation links to detailed sections, table of contents integration, and enhanced user experience features.
The AI helped implement hover effects, proper section linking, and visual hierarchy improvements for better navigation.
A separate chat was used to convert a flat crease pattern into a thick‑origami version following Ku & Demaine.
The AI doubled each crease into parallel offsets and generated vertex polygons (estimate = regular polygons; exact = sector‑aware polygons) and explained how to map desired thickness by setting OFFSET_FRAC = thickness / sheet_size.
AI-Assisted Repository Management and Content Organization
Cursor AI assisted with repository size management by breaking down large commits into smaller, manageable chunks under 10MB each.
The AI helped organize media files into logical commits, added the Vinyl Cutter Individual Assignment section with proper styling and image sizing,
and provided guidance on git workflow optimization to work within platform size limits.
Cursor AI assisted with updating the vinyl cutter individual assignment section with comprehensive documentation including
successful cut and transfer workflow, motor failure troubleshooting, and 2D parametric design integration. The AI helped
structure the content with proper media organization, descriptive captions, and consistent styling throughout the section.
Cursor AI assisted with adding a comprehensive Design Files section to the Week 1 page, including table of contents integration,
organized file listings with download and view links, and contextual hyperlinks throughout the page for easy access to design assets.
The AI helped structure the files by category (laser cutter CAD files, SVG patterns, vinyl cutter images) with appropriate styling.
AI-Assisted Design Files Integration for Laser Cutter Training
Cursor AI assisted with adding kerf and clearance design files from Anthony Pennes to the Week 1 Design Files section,
creating a new subsubsection for joint test files, and properly attributing the contribution in the contributions section
with links to both the Slack message and design files section.
Key achievements and insights from the embedded programming week, including successful microcontroller programming, sensor integration, and the development of the ReactionAge reaction time measurement system.
This week focuses on embedded programming fundamentals, exploring how to program microcontrollers and create interactive electronic systems. We'll dive into the world of digital electronics, sensors, and real-time programming to build responsive devices that can sense, process, and react to their environment.
• Introduction to microcontrollers and embedded systems
• Programming fundamentals for real-time applications
• Sensor integration and data processing
This Week's Goals
Master Embedded Programming Learn microcontroller programming, sensor integration, and real-time system design
Build Interactive Systems Create responsive electronic devices that can sense and react to environmental inputs
Develop ReactionAge Project Implement a reaction time measurement system based on research methodologies
Assignments
Group Assignment Collaborative embedded programming project focusing on sensor integration and real-time data processing
Individual Assignment: ReactionAge Build a reaction time measurement system based on research methodologies from cognitive science literature
Tools & Materials
Microcontrollers Arduino, ESP32, or similar development boards
Development Environment Arduino IDE, PlatformIO, or VS Code with embedded extensions
Sensors & Components Buttons, LEDs, displays, accelerometers, and other input/output devices
Prototyping Tools Breadboards, jumper wires, resistors, and basic electronic components
Training Documentation
Essential training materials and resources for embedded programming fundamentals, microcontroller setup, and sensor integration techniques.
Comprehensive guide to soldering techniques for embedded electronics, covering both wire soldering and solder paste methods.
Wire Soldering
Temperature: 720-800°F
Melt pad onto electrode first
Anchor arms for precision control
Use appropriate tip size for part
Work from low to high profile parts
Solder Paste
Use gloves for protection
Highest magnification possible
Temperature: 270-330°C
Heat all sides together
Required for SMD components
Safety First:
Always wear safety glasses and use proper ventilation. Lead-free solder requires extra caution due to flux crystallization at high temperatures.
How to Solder (Almost) Anything
Step-by-step video demonstrations of essential soldering techniques for embedded electronics, covering both wire soldering and surface-mount component assembly.
Wire Soldering Technique
Learn the proper technique for soldering wires to components, starting with one edge to keep the part in place, then soldering the rest easily by keeping your wrist stable and the solder tip on the pad to heat it up with the part, and slowly bringing in solder.
Wire soldering demonstration showing proper technique and wrist stability
Solder Paste Assembly
Complete process for surface-mount component assembly: apply solder paste first, place the component, then heat up with a heat gun to create strong, reliable connections.
Applying solder paste to PCB pads
Placing microcontroller on prepared solder paste
Using heat gun to reflow solder paste and complete the connection
Pro Tips:
For detailed soldering guides and advanced techniques, refer to the Electronics & Soldering Training section above for comprehensive documentation and resources.
• Microcontroller Programming Basics - Introduction to embedded programming concepts and development environments
• Sensor Integration Workshop - Hands-on training for connecting and programming various sensors
• Real-time System Design - Principles of creating responsive embedded systems
• Debugging Techniques - Tools and methods for troubleshooting embedded code
QPAD Development Boards Programming Guide
Complete programming setup and workflow for QPAD development boards, covering bootloader configuration, IDE setup, and code deployment for different microcontroller architectures.
QPAD-XIAO (RP2040)
The QPAD-XIAO features a Raspberry Pi RP2040 microcontroller with built-in bootloader support. No bootloader burning required - simply configure your IDE and start programming!
Programming Steps:
Connect QPAD-XIAO to your computer via USB-C
In Arduino IDE, select Tools → Board → Raspberry Pi RP2040 Boards → XIAO RP2040
Select the correct COM port under Tools → Port
Write your code and click Upload - the board handles everything automatically!
The QPAD21 uses an ATSAMD21 microcontroller that requires bootloader programming using a XIAO programmer chip. Follow these steps to get it ready for development.
Bootloader Programming Steps:
Connect XIAO programmer to QPAD21 using the programming header
Connect XIAO programmer to your computer via USB
In Arduino IDE, select Tools → Board → Arduino SAMD (32-bits ARM Cortex-M0+) → Arduino MKR WiFi 1010
Select the correct COM port for the XIAO programmer
Configure bootloader settings:
Bootloader: Adafruit Circuit Playground Express
Clock: 48 MHz (USB)
USB Stack: Arduino
Debug Level: None
Erase Flash: All Flash Contents
Bootloader Version: 1.0.0
Click Burn Bootloader and wait for completion
Programming Steps (After Bootloader):
Disconnect XIAO programmer and connect QPAD21 directly via USB
The QPAD-XIAO-ESP32S3 features an ESP32-S3 microcontroller with built-in WiFi and Bluetooth capabilities. No bootloader burning required - just configure your IDE and start programming!
Programming Steps:
Connect QPAD-XIAO-ESP32S3 to your computer via USB-C
Microcontroller Programming Architecture and fundamentals
Sensor Integration Data processing methods
Real-time Systems Design principles and optimization
Board Design Documentation
Essential resources for designing custom PCBs and development boards for embedded programming projects, covering schematic design, layout principles, and manufacturing considerations.
USB-C board design showing proper connector placement, power routing, and signal integrity considerations for embedded development boards
Design Principles
USB-C connector placement and orientation
Power distribution and ground plane design
Signal integrity and trace routing
Component placement optimization
Manufacturing Considerations
Layer stackup and via design
Silkscreen and assembly markings
Test point placement
Design rule checking (DRC)
Design Files Available:
Complete KiCad project files, schematics, and PCB layouts are available in the Design Files section below for download and modification.
Common Troubleshooting
Essential troubleshooting techniques for embedded development boards, covering power supply verification and connector testing using multimeter measurements.
Voltage Regulator Troubleshooting
Verify that your voltage regulator is functioning correctly by measuring output voltages with a multimeter when power is connected to the board.
Voltage regulator testing points showing input, output, and ground connections for multimeter verification
Testing Steps:
Connect power to your development board
Set multimeter to DC voltage mode
Measure input voltage (VIN) - should match your power supply voltage
Measure output voltage (VOUT) - should be the regulated voltage (e.g., 3.3V or 5V)
Check ground continuity between input and output ground pins
Verify no voltage drop under load conditions
💡 Pro Tip:
Use a portable multimeter for easy on-the-go testing and debugging of embedded circuits.
USB-C Pinout Troubleshooting
Verify USB-C connector functionality by testing power delivery, data lines, and ground connections using multimeter measurements.
USB-C pinout diagram showing power, data, and ground connections for multimeter testing and verification
Testing Steps:
Connect USB-C cable to your development board
Set multimeter to DC voltage mode
Measure VBUS (pin A4/B4) - should read 5V when connected to power
Test ground continuity (pins A1/B1, A12/B12) - should show 0Ω resistance
Check CC1/CC2 pins (A5/B5) for proper connection detection
Verify D+ and D- data lines (A6/A7, B6/B7) for continuity
Test both orientations of the USB-C connector
🔧 Troubleshooting Tips:
If VBUS shows 0V, check cable and power source
If ground shows high resistance, check solder joints
If data lines show no continuity, verify connector orientation
Test with known working USB-C cable for comparison
Group Assignment: Embedded Programming Design Trades
Comprehensive analysis of design tradeoffs in embedded programming, covering language selection, development workflows, and microcontroller choices. This collaborative project examines the critical decisions that shape embedded system development and their impact on project success.
Design Tradeoffs Summary
Architecture
Example Boards
Toolchain / Workflow
Strengths
Limitations
AVR (8-bit)
ATtiny44, ATmega328 (Arduino Uno)
avr-gcc, avrdude; Arduino IDE for simplified workflow
Mature ecosystem, simple to program, widely taught
Limited memory & speed, not ideal for complex tasks
ARM Cortex-M
SAMD21, STM32, Teensy
arm-none-eabi-gcc, OpenOCD, PlatformIO; Arduino or CircuitPython support
High performance, industry standard, strong debugging tools
Toolchain setup can be complex
RP2040
Raspberry Pi Pico, XIAO RP2040
Pico SDK (C/C++), MicroPython, Arduino IDE; custom PIO assembly for peripherals
Flexible, inexpensive, unique PIO hardware for custom protocols
Requires learning PIO for advanced features
ESP8266 / ESP32
NodeMCU, Sparkfun/Adafruit ESP boards
Espressif SDK/IDF, Arduino IDE, MicroPython
Built-in Wi-Fi/Bluetooth, large community support, IoT-ready
Higher power usage, less deterministic timing
RISC-V
HiFive boards, experimental dev kits
riscv-gnu-toolchain, GDB, newer SDKs
Open-source ISA, growing ecosystem, academic/educational interest
Toolchain less mature, fewer libraries & examples
Comprehensive comparison of microcontroller architectures and their tradeoffs in embedded programming
Language Tradeoff
Programming language tradeoff analysis showing performance vs development speed considerations
As illustrated in the language tradeoff diagram above, the choice of programming language involves critical tradeoffs between performance and development speed. The analysis shows how different languages balance factors like memory efficiency, execution speed, development time, and ecosystem support for embedded system development.
High Performance Languages
C/C++: Maximum control, minimal overhead
Rust: Memory safety with performance
Assembly: Direct hardware control
Rapid Development Languages
Python: Fast prototyping, rich libraries
JavaScript: Web integration capabilities
MicroPython: Python for microcontrollers
Development Workflow Tradeoff
Development workflow tradeoff analysis comparing different methodologies and their impact on project outcomes
The development workflow tradeoff diagram above demonstrates how different methodologies balance project timeline, code quality, and team collaboration. This visual analysis compares traditional waterfall approaches with agile methodologies, showing the impact of various toolchains, testing strategies, and deployment processes on embedded system development success.
Traditional Approaches
Waterfall: Sequential, documentation-heavy
V-Model: Testing integrated with design
Spiral: Risk-driven iterative approach
Modern Approaches
Agile: Iterative, customer-focused
DevOps: Continuous integration/deployment
Test-Driven Development: Quality-first
Microcontroller Tradeoff
Microcontroller tradeoff analysis showing performance vs power consumption and cost considerations
The microcontroller tradeoff diagram above illustrates the critical balance between performance, power consumption, and cost in embedded system design. This visual analysis evaluates different architectures, processing capabilities, memory configurations, and peripheral options, providing a clear framework for selecting the optimal platform based on specific application requirements.
Low-Power Options
ARM Cortex-M0+: Ultra-low power
PIC: Simple, cost-effective
MSP430: Energy-efficient design
High-Performance Options
ARM Cortex-M4: DSP capabilities
ESP32: WiFi/Bluetooth integrated
STM32: Rich peripheral set
Use Case Analysis
Architecture
Workflow Process
Key Characteristics
SAMD21 (ARM Cortex-M)
• Write code in C/C++ (Arduino IDE or PlatformIO)
• Compile with arm-none-eabi-gcc
• Upload using OpenOCD via USB or SWD debugger
• Debug with GDB or serial monitor
Professional-grade debugging, industry standard tools
RP2040 (Raspberry Pi Pico)
• Write code in C/C++ (Pico SDK) or MicroPython
• Compile with CMake + GCC toolchain
• Drag-and-drop .uf2 file to Pico's USB mass storage device
• (Optional) Use custom PIO assembly for hardware interfaces
Accessibility and flexibility, drag-and-drop + PIO
Workflow examples showing different development approaches for ARM and RP2040 architectures
The example workflow table above provides specific recommendations for different embedded system applications, showing how the tradeoff analyses from the previous sections translate into practical implementation strategies. This comprehensive table demonstrates the relationship between project requirements and optimal technology choices.
Key Findings
As demonstrated in the workflow table above, ARM workflows emphasize professional-grade debugging with industry-standard tools, while RP2040 workflows emphasize accessibility and flexibility through drag-and-drop deployment and unique PIO capabilities.
The comprehensive architecture comparison shows that optimal design choices depend heavily on project constraints, performance requirements, and development timeline.
High-performance applications favor ARM Cortex-M with professional toolchains, while rapid prototyping benefits from RP2040's flexible development environment and built-in features.
Build a reaction time measurement system based on research methodologies from cognitive science literature. This project combines embedded programming with scientific measurement principles to create a tool for studying human cognitive performance.
Core Features
Stimulus Generation Visual/auditory stimuli with precise timing
Response Detection Accurate measurement using buttons/sensors
Data Analysis Statistical processing and visualization
Research Foundation
Based on PLOS ONE study (2017) examining reaction time variability and cognitive decline.
Complete bill of materials for the ReactionAge embedded programming project. All prices are in USD and subject to supplier variations.
Nintendo Switch Controller Training for Toddlers
An interactive training module designed for young children, utilizing Nintendo Switch controller input to create an engaging letter-matching game that develops motor skills and cognitive recognition.
Game Mechanics
Button Mapping A, B, X, Y in inverted layout
Visual Stimulus Flashing letters with bright colors
Progressive Difficulty Adapts based on performance
Educational Benefits
Motor Skills Hand-eye coordination
Letter Recognition Alphabet learning
Attention Building Focus and concentration
Technical Features
Controller Support Pro Controller & Joy-Con
Display System Large, colorful letters
Progress Tracking Analytics & feedback
ChatGPTMario2D
An AI-powered Mario-style platformer game built with ChatGPT assistance, featuring touch controls, adaptive gameplay mechanics, and classic 2D platforming elements optimized for embedded systems.
Mario-style platformer gameplay with touch controls and adaptive difficulty
ChatGPT-assisted development process and code generation demonstration
A collaborative multiplayer game featuring geometric shape interactions, synchronized gameplay between two ESP32 devices, inspired by educational content in Shape Song Swing Along.
Shape Song Swing Along educational content integration and gameplay
Circle and square shape interaction gameplay mechanics
A touch monitoring utility developed with ChatGPT assistance for debugging and calibrating touch sensor inputs on the QPAD21 development board. This tool provides real-time visualization of touch sensor values and helps optimize touch thresholds for embedded applications.
A utility developed with ChatGPT assistance for retrieving and displaying MAC addresses on ESP32 devices. This tool is essential for ESP-NOW communication setup, allowing developers to identify device MAC addresses for peer-to-peer networking configuration in multiplayer embedded applications.
// MAC address retrieval utility for ESP32
#include
#include
void setup() {
Serial.begin(115200);
// Get WiFi STA MAC address
uint8_t mac[6];
esp_read_mac(mac, ESP_MAC_WIFI_STA);
Serial.print("WiFi STA MAC: ");
for (int i = 0; i < 6; i++) {
if (i > 0) Serial.print(":");
if (mac[i] < 16) Serial.print("0");
Serial.print(mac[i], HEX);
}
Serial.println();
// Get Bluetooth MAC address
esp_read_mac(mac, ESP_MAC_BT);
Serial.print("Bluetooth MAC: ");
for (int i = 0; i < 6; i++) {
if (i > 0) Serial.print(":");
if (mac[i] < 16) Serial.print("0");
Serial.print(mac[i], HEX);
}
Serial.println();
}
For detailed board design principles, USB-C connector placement, and manufacturing considerations, refer to the Board Design Documentation section above.
Reflections & Learnings
[Reflection notes placeholder.]
Contributions
Acknowledgments for collaborative support and technical assistance during the embedded programming project development.
Course Staff
Quentin Bolsée
Helped me so much with the ESP32S3 code development with his awesome examples. Also assisted with resoldering the microcontroller when we were debugging the USBC QPAD issues. Couldn't have done it without you!
Anthony Pennes
Spent so many hours helping me debug my USBC QPAD while resoldering the USBC port. Eventually it turned out the problem was that we crashed the board with XIAO code on a D21! Too much to say and so little time until class. Couldn't have done it without you.
Jesse de Alva
Helped me test the boards after programming them, providing valuable assistance with debugging and validation of the embedded programming projects. Your support was crucial for ensuring everything worked correctly.
Technical Support & Collaboration
Eghosa Ohenehn
Contributed valuable insights and technical discussions about microcontroller tradeoffs during the group assignment development. Provided expertise in evaluating different microcontroller architectures and their suitability for various embedded programming applications.
Anthony Pennes
Engaged in extensive discussions throughout the embedded programming design trades section, providing valuable technical insights and collaborative support during the group assignment development process.
Quentin Bolsée
Participated in numerous office hours discussions about embedded programming design trades, contributing significantly to the technical analysis and collaborative development of the group assignment content.
Alex Hu
Thank you for showing me Flappy Bird and inspiring me to push through the game development part of my plan this week. Your demonstration and encouragement were instrumental in motivating me to complete the ChatGPTMario2D and CircleSquareShapeSongSwingalong projects, helping me overcome technical challenges and stay focused on the embedded programming goals.
Tushar Kanade
Thank you for taking videos of the soldering training! Your documentation of the training process was incredibly helpful for understanding the techniques and procedures. The visual reference you provided made it much easier to follow along and learn the proper soldering methods for the embedded programming projects.
Special thanks to the collaborative learning environment that enabled knowledge sharing and technical problem-solving throughout the embedded programming week.
Ethical AI Use
Transparent documentation of AI assistance used in this week's work, following course guidelines for ethical AI usage.
AI-Assisted Template Generation and Task Planning
Used ChatGPT to generate the weekly template HTML structure and styling framework, and created structured task prompts
for week 2 embedded programming content development.
AI-Assisted Content Development and Page Structure
Used Cursor AI for iterative content development, page structure optimization, and aesthetic improvements.
The AI helped with HTML/CSS implementation, content organization, and maintaining consistent styling across the embedded programming documentation.
Used Cursor AI to implement the comprehensive BOM table with clickable images, datasheet links, and full-width responsive design.
The AI helped with HTML table structure, CSS styling, and integration of CSV data into an aesthetically pleasing table format.
Used ChatGPT for image recognition of electronic components to identify parts and construct the bill of materials CSV file.
The AI analyzed component images and provided detailed part specifications, descriptions, and pricing information for the embedded programming project.
AI-Assisted Project Content Updates and Documentation
Used Cursor AI for comprehensive project content updates, documentation improvements, and HTML structure optimization.
The AI assisted with content organization, styling consistency, and integration of multimedia elements for the embedded programming documentation.
AI-Assisted Arduino Programming and Code Development
Used ChatGPT for Arduino programming assistance based on the ReactionAge project code from
GitHub repository
and Quentin Bolsée's QPAD documentation available on the
course website embedded system assignment page.
The AI provided guidance on embedded programming concepts, code optimization, and integration with the QPAD-xiao board design.
AI-Assisted Group Assignment Content Development and Table Implementation
Used Cursor AI for comprehensive development of the embedded programming design trades group assignment section.
The AI assisted with creating structured subsections for language, development workflow, and microcontroller tradeoffs,
implementing professional HTML tables with data extracted from PowerPoint presentations, and integrating download links for PDF and PPTX files.
AI-Assisted Training Section Development and Documentation
Used Cursor AI for comprehensive development of the training section, including soldering techniques, QPAD programming guides,
board design documentation, and troubleshooting procedures. The AI assisted with creating structured subsections,
implementing video demonstrations, adding download links for design files, and developing comprehensive troubleshooting guides with multimeter testing procedures.
Used Cursor AI to analyze file sizes and break down large changes into smaller, manageable commits to avoid exceeding Git's 25MB commit size limit.
The AI helped organize files by size, created a logical commit strategy, and automated the commit and push process for better version control practices.
Used ChatGPT for collaborative development of the ChatGPTMario2D platformer game, including touch control implementation,
adaptive difficulty systems, collision detection, and game physics. The AI provided guidance on embedded programming concepts,
state machine architecture, and optimization for the QPAD21 development board.
AI-Assisted Multiplayer Game Development: CircleSquareShapeSongSwingalong
Used ChatGPT for collaborative development of the CircleSquareShapeSongSwingalong multiplayer game, including ESP-NOW wireless communication,
MAC address-based player identification, synchronized game state management, and educational content integration.
The AI provided guidance on embedded networking, real-time synchronization, and touch-based geometric learning systems.
Used ChatGPT for collaborative development of the QPAD21 touch monitoring utility, including real-time sensor value display,
threshold calibration assistance, debugging tools, and serial output for data logging. The AI provided guidance on touch sensor
integration, calibration procedures, and embedded debugging techniques for the QPAD21 development board.
Used ChatGPT for collaborative development of the get_mac_address utility for ESP32 devices, including WiFi STA and Bluetooth MAC address retrieval,
serial output formatting, and ESP-NOW integration support. The AI provided guidance on embedded networking concepts,
MAC address extraction methods, and device identification techniques for multiplayer embedded applications.
AI-Assisted Toddler Training Subsections Development
Used Cursor AI for comprehensive development of toddler training subsections, including ChatGPTMario2D and CircleSquareShapeSongSwingalong game implementations.
The AI assisted with creating structured subsections, implementing video demonstrations, adding download links for Arduino code files,
and developing comprehensive documentation for embedded programming educational content.
This week focuses on additive manufacturing processes and 3D scanning technologies. We'll explore the differences between subtractive and additive processes, learn about various 3D printing materials and techniques, and understand the design constraints and capabilities of 3D printing systems.
Key Concepts: Additive vs subtractive manufacturing, design for 3D printing, material properties, scanning technologies
This Week's Goals
Test 3D printer design rules Group assignment: Test design rules for available 3D printer(s)
Design additive-only object Individual: Design and print object that cannot be made subtractively
3D scan an object Individual: Scan an object and optionally print it
Assignments
Group Assignment Test design rules for 3D printer(s)
Individual Assignment Design, document, and 3D print object that could not be made subtractively
3D Scanning 3D scan an object (and optionally print it)
Design, document, and 3D print an object that could not be made subtractively. The object should be small (few cm³) and limited by printer time.
Design Requirements
Complex geometry Must have features impossible with subtractive manufacturing
Size constraint Small object, few cm³ volume
Print time Consider reasonable print time for testing
Documentation Document design process, print settings, and results
3D Scanning Component
Scan object Use available scanning method to capture 3D geometry
Process mesh Clean and prepare scanned mesh for printing
Optional printing Print the scanned object if desired
Handgripper for Locomotive Age Assessment
I hope to design and fabricate a handgripper to measure age based on hand grip strength. This builds on our aging biomarker research by focusing on locomotive age assessment.
The idea is to measure functional decline due to aging across multiple modalities:
Cognition: Memory, attention, reasoning, and problem-solving
Locomotion: Mobility, balance, and muscle strength
Sensory: Vision, hearing, and touch
Vitality: Energy levels, nutrition, and sleep
Psychological: Emotional well-being, resilience, and social connections
Last week we measured cognition with reaction time - this week we focus on locomotive age through grip strength.
Proposed 3D Printable Components
Untanglable Slinky
Complex interlocking geometry that cannot be manufactured subtractively. Tests printer's ability to create intricate, self-supporting structures with minimal overhangs.
Single Torsion Spring
Helical spring mechanism for grip force measurement. Demonstrates additive manufacturing's capability to create functional mechanical components in one piece.
Double Torsion Spring
Nested spring system with different spring constants. Tests printer's ability to create complex, multi-component mechanisms with varying material properties.
Coil Mechanism
Spiral coil for force transmission and measurement. Explores the limits of printable coil geometries and their mechanical properties for sensor integration.
Untanglable Slinky
A complex 3D printable design that demonstrates additive manufacturing capabilities through intricate geometry that cannot be manufactured subtractively.
Human-AI Co-Design
This design was co-developed through iterative discussion with ChatGPT, exploring various approaches to create an untanglable slinky geometry.
Design Iterations
The design process involved multiple iterations, with the first two attempts resulting in tangled slinkies that failed to maintain proper coil separation:
First attempt: Tangled slinky with improper coil geometry
Second attempt: Still resulted in tangled geometry
Final Successful Design
The third iteration successfully achieved the desired untanglable geometry:
Final design: Untanglable slinky with proper coil geometry
Design Description: This design shows an untanglable slinky with flat, oval coils, tiny spacers between turns, and solid end caps, so it collapses neatly without knots. The geometry enforces orderly stacking while preventing coils from slipping past each other.
My initial exploration into creating a 3D printable slinky design, inspired by the classic magic spring concept.
First slinky design - exploring the magic spring concept
Design Description: This first slinky design represents my initial exploration into creating a 3D printable magic spring. The design focuses on creating a helical structure that can collapse and expand while maintaining its structural integrity.
This design was inspired by the classic slinky toy and the concept of creating a "magic spring" that can be 3D printed in one piece, demonstrating the unique capabilities of additive manufacturing.
Inspiration & Resources
This design draws inspiration from several sources and builds upon existing work in 3D printable magic springs:
The Hackaday project provides comprehensive documentation including Java code for generating G-code, print parameters, and detailed instructions for creating 3D printable magic springs. The project includes multiple iterations of the code with different features like temperature control, spiral priming, and delta printer compatibility.
This session covers the development of the Week 3 page for 3D scanning and printing, including content population from MIT Academy resources, navigation updates, and design file integration.
This session documents the iterative co-design process for creating an untanglable slinky using ChatGPT. The conversation shows multiple design iterations, from initial failed attempts to the final successful geometry.
This session documents the comprehensive refactoring of the entire web development repository to make it fully responsive and mobile-friendly. The conversation covers the implementation of modern CSS techniques, responsive design patterns, and mobile-first development approaches.
This session documents the integration of the first slinky design into the untanglable slinky section, including adding the image, description, inspiration resources, and design file links.
[Brief note on AI tool usage this week placeholder.]
```
Now let me check if there's a responsive-test.html file that also needs updating:
Let me update the responsive-test.html file as well:
```html
Responsive Design Test · HTMAA 2025
Responsive Design Test
Testing responsive features across different screen sizes
Responsive Grid System
This grid adapts to different screen sizes using CSS Grid and Flexbox.
Column 1
This column will stack on mobile devices and arrange in rows on larger screens.
Column 2
The grid automatically adjusts based on available space.
Column 3
Uses CSS Grid with auto-fit and minmax for optimal responsiveness.
Column 4
No JavaScript required - pure CSS responsive design.
Fluid Typography
Typography scales smoothly across different screen sizes using clamp() functions.
Heading 1
Heading 2
Heading 3
Heading 4
Heading 5
Heading 6
Extra small text (clamp(0.75rem, 2vw, 0.875rem))
Small text (clamp(0.875rem, 2.5vw, 1rem))
Base text (clamp(1rem, 3vw, 1.125rem))
Large text (clamp(1.125rem, 3.5vw, 1.25rem))
Extra large text (clamp(1.25rem, 4vw, 1.5rem))
Responsive Media
Images and videos scale responsively without breaking the layout.
Utility Classes
Comprehensive utility classes for spacing, typography, and layout.
Pill 1
Pill 2
Pill 3
Pill 4
Button 1
Button 2
Button 3
Breakpoint Indicators
Current screen size indicators (resize your browser to see changes):
MIT CEE PhD @ AbuGoot and Gladyshev Labs
HTMAA 2025 · Making + AI for Aging & Longevity
Welcome
This is my home base for How to Make (Almost) Anything. I’m documenting weekly assignments, fabrication experiments, and a final project that bridges making with aging & health analytics.
🛠️ Digital fabrication🧬 Bioprinting📈 Sensing & ML🎛️ Embedded systems
I am a PhD student in the Department of Civil and Environmental Engineering at the Massachusetts Institute of Technology (MIT), with joint affiliations at Brigham and Women’s Hospital (BWH, part of Mass General Brigham) and Beth Israel Deaconess Medical Center (BIDMC, part of Beth Israel Lahey Health) at Harvard Medical School (HMS), where I am a member of the Abudayyeh-Gootenberg Lab and the Gladyshev Lab. I am also affiliated with the Mesoscale Nuclear Materials (MNM) Group in the Short Lab within the Department of Nuclear Science and Engineering at MIT. My research integrates the mechanics of materials under extreme conditions with machine learning to advance health, aging, and longevity science. I am committed to developing rigorous research skills, effective scientific communication, and interdisciplinary collaboration at the interface of science, engineering, and artificial intelligence.
Ethical AI Usage
Session transcripts where ChatGPT helped refine designs, code, and plans for this course. Dropping links under each week for now, we'll see how categorization evolves!
Created a Python script to automatically convert Cursor AI markdown transcripts to styled HTML files for better browser viewing.
The script parses markdown chat formats, applies consistent styling, and generates professional HTML pages with navigation and download options.
Welcome to How to Make (Almost) Anything! This week focuses on course orientation, safety training, and setting up the foundation for the semester ahead.
On‑board camera connected to the internet; model outputs shown on screen
Voice capture for age; display results and, if possible, text‑to‑speech
Integrate conversational layer (e.g., “Mirror, mirror on the wall…” for interpreting metrics)
Rejuvenated tissue idea — to define scope and feasibility (TBD)
Multimodal aging biomarker idea — sensor fusion + ML pipeline (TBD)
Dome idea — structural/form exploration (TBD)
Shuriken idea — mechanism/prototyping study (TBD)
Planning & Course Requirements
Design as modular subsystems so components can be swapped or removed and still pass
Fabricate custom parts and build my own electronics; target at least two PCBs
Sequence work so each week contributes a testable piece toward the final build
Contributions
Acknowledgements for the help I received this week from my classmates and instructors.
Alfonso Parra Rubio - Fusion Office Hours
Thank you to Alfonso for providing helpful Fusion office hours and guidance on CAD modeling techniques.
Dan Gilbert - CBA Shop
Thank you to Dan Gilbert for assistance with the CBA shop facilities and equipment access.
Tolga Durak - SHED Bioprinter Access Discussion
Had extensive discussions with Tolga Durak about accessing the SHED bioprinter for potential final project work. Tolga provided detailed guidance on the BRR (Biological Research Registration) process through MIT's CAB/ESCRO committee, including requirements for MIT PI involvement, research proposal structure, and timeline considerations. He explained that the bioprinter is currently limited to approved research projects due to existing commitments, and that any access would need to be scheduled around three ongoing research projects. Prof. Gershenfeld agreed to serve as the MIT PI for the proposal, and I'm working through the BRR forms to submit the necessary documentation for committee review.
Ethical AI Use
Transparent documentation of AI assistance used in this week's work, following course guidelines for ethical AI usage.
AI-Assisted Web Development in Cursor IDE
This week's webpage development was assisted by Cursor AI to create the initial page structure, styling, and content organization.
The AI helped with HTML/CSS implementation and responsive design patterns.
AI-Assisted Section Organization and Content Updates
Cursor AI assisted with organizing webpage sections, cleaning up HTML structure, and updating content for both week 0 and week 1 pages.
The AI helped with code refactoring, section reorganization, and maintaining consistent styling across pages.
This week focuses on the fundamentals of digital fabrication: computer-aided design (CAD), computer-aided manufacturing (CAM), laser cutting, and vinyl cutting. We'll learn the complete workflow from design to finished parts.
Note: These guides were created by Anthony Pennes and are maintained as supplementary resources for the HTMAA course.
View original Slack message for context.
Laser Cutter Characterization Group Assignment
Systematic testing and documentation of laser cutter parameters for optimal cutting performance. Assignment started: September 11, 2025Assignment completed: September 16, 2025
Machine Specifications
Available Lasers
CO₂ Laser: 75W (large machine)
CO₂ Laser: 60W (small machine)
Fiber Laser: Back of lab
Test Parameters
Rate: 500 pulses per inch (PPI)
Power: 100%
Speed: 30% (increased by 2.5% each test)
Focus & Positioning
Focus Point: Cut at the focal length (white part of the focusing stick)
Kerf Measurement: Measure deltas between intended and actual cut dimensions
Focus Accuracy: Critical for achieving clean, precise cuts
Joint Design & Clearance
Joint Type
Finger joint - interlocking design for structural connections
Clearance Definition
Size of the slot that provides tight enough fit for assembly
Material Considerations
Cardboard Limitations: Generally produces no good joints due to material properties and laser cutting characteristics
Material choice significantly impacts joint quality and assembly precision
Key Learnings
Speed increment of 2.5% provides systematic testing progression
Focus accuracy is critical for dimensional precision
Kerf measurement essential for compensating cut width in designs
Material selection directly impacts joint quality and assembly success
Systematic parameter testing reveals optimal settings for different materials
Results
Comprehensive analysis of kerf and clearance measurements from systematic laser cutter testing.
Interactive Data Analysis
View and interact with the complete dataset in Google Sheets:
Open in Google Sheets
|Data includes kerf measurements, clearance analysis, and statistical calculations
Measurement Methods
Systematic measurement approach for characterizing laser cutter kerf and joint clearance using precision calipers.
Peg and hole measurement setup
Top measurement view
Bottom measurement view
Measurement Protocol
Kerf Analysis: Three measurements were taken for each prescribed cut dimension on the joint gadget during laser cutter training
Clearance Analysis: Three measurements were taken for both hole and peg dimensions
Statistical Analysis: Averages and standard deviations calculated for precision assessment
Kerf Concept Diagram
Kerf Definition: The width of material removed by the laser beam during cutting.
Measured as the difference between prescribed cut dimensions and actual cut dimensions.
Clearance Definition: The dimensional difference between hole and peg sizes.
Negative values indicate interference fit (hole smaller than peg), while positive values indicate clearance fit.
Parametric Construction Kit Individual Assignment: 3D Parametric Design
Design and fabricate a modular construction kit using laser cutting and vinyl cutting techniques. Assignment started: September 10, 2025. Assignment completed: September 15, 2025
Preparation & Planning
Initial research and clarification discussions with instructors and classmates to understand assignment requirements and technical constraints.
Key Clarifications
Assignment Scope:Construction kit using laser cutter + separate vinyl cutting project (not crease patterns on cardboard)
File Formats:DXF for laser cutting, PNG/SVG for vinyl cutting
CAD Requirements:Must use Fusion 360 for laser cutting to develop CAD familiarity
Materials:Lab cardboard available, or personal materials (if safe to cut)
Technical Insights
Vinyl Cutting: Zero thickness lines for crease patterns, black and white images for cutting
Mountain vs Valley Folds: Opposite sides for thick materials, same side possible for thin materials
Design Differentiation: Dashed lines for fold lines, solid lines for cuts (though challenging in software)
Acknowledgments
Special thanks to Erik Demaine for guidance on vinyl cutting crease patterns and fold differentiation techniques, and Anthony Pennes for clarifying assignment requirements, file formats, and material options. Their expertise was invaluable in understanding the technical constraints and design possibilities for this project.
Design Process
Research and ideation for construction kit design
Create parametric CAD model with adjustable parameters in Fusion 360
Generate CAM toolpaths for laser cutting
Test cut on cardboard to verify fit and function
Iterate design based on test results
Final cut on appropriate material
Design and cut vinyl project (separate from construction kit)
Hand‑folded Prototype Assembly
I hand‑folded the crease pattern to validate the assembly. The parts do come together
when the folds are reasonably close to the intended lines. A second, refolded gadget
produced a noticeably cleaner assembly.
Single Gadget
Double Gadget
Assembly Detail
Full Pattern Failure
We tried cutting the full crease pattern on one side. It failed when layers with
opposite cuts overlapped and had to be push‑folded through during the final folding
step — the piece broke.
First Success Folded Single Gadget
First assembly of two gadgets. Folds were smooth after separating mountain and valley
cuts onto opposite sides to avoid breaking during push‑folds over multiple layers. The
shop cardboard was tight in the assembly pocket; thinner Amazon box cardboard folded by
hand fit better. Next step: make the laser‑cut pattern more exact.
Cut Strategy Videos
Left to right: clear mountain cut, flip and cut the opposite side, clear valley cut.
Mountain vs Valley Sides
Measurements confirming mountain vs valley sides.
First Gadget Assembly
Side profile and insertion step demonstrating clean folds without tearing.
Double Gadget Cut Variations
Exploring double‑part strategies: sequential cuts, flips between sides, and opposite‑side cuts.
Double Gadget — Rubber Band Assist
Temporary rubber band used to hold alignment while completing final folds.
First Success Assembly
Switched to thinner Amazon cardboard because the shop cardboard was too thick for the assembly pocket.
The Amazon box folded by hand fit perfectly and assembled smoothly. Three gadgets worked with the thinner
material. Rubber bands are just for compression — they assemble without them, though the bands make it
easier to keep them as one unit during insertion into the next gadget.
Quadruple Cut Strategy
Scaling up to quadruple cuts: sequential cuts, flips between sides, and opposite-side cutting strategies.
Double Gadget — Amazon Cardboard (No Support)
Three views of the double gadget assembled with Amazon cardboard, showing clean folds and proper fit.
Assembly Process with Support
Assembly sequence showing compression, support positioning, and insertion process for stable construction.
Triple Gadget — Final Assembly
The culmination: triple gadget assembly demonstrating successful scaling with Amazon cardboard and support techniques.
Further Refinements: Thick Origami
Applying thick‑origami concepts to avoid layer collisions and enable folding with real material thickness.
Guidance from Erik Demaine
From a discussion with Erik Demaine: double each crease into parallel offsets and open vertex regions as polygons
to prevent collisions. A uniform spacing works for a first pass, but for correctness the spacing between the doubled
creases should depend on how many layers lie between faces in the final folded state. I plan to estimate per‑crease
layer counts from an unfolded model and adjust offsets accordingly.
Citation: Jason S. Ku and Erik D. Demaine, “Folding Flat Crease Patterns With Thick Materials”, Journal of Mechanisms and Robotics,
8(3), June 2016, pp. 031003‑1–6. View paper
Thickened Crease Patterns
Estimate: double each crease with a uniform offset and add regular polygons at intersections.
Exact: compute sector‑aware offset polygons at vertices using incident crease angles.
How the Estimate Works
Input: crease segments with mountain/valley labels; sheet size S; target thickness t
offset = t / S (or a chosen fraction)
for each crease c:
draw two lines parallel to c at ±offset
for each vertex (intersection of original creases):
place a small regular polygon (e.g., octagon) centered at the vertex
Output: doubled creases + vertex holes
How the Exact Method Works
Input: crease lines; sheet size S; target thickness t
offset = t / S
for each crease c:
compute unit direction v and normals n1,n2
define two infinite offset lines at ±offset along n1/n2
for each vertex:
collect incident creases; sort by angle into cyclic order
for each adjacent pair (i, j):
pick the offset side that lies inside the angular sector
intersect those two offset lines → one polygon vertex
connect all vertices in order → convex vertex polygon
trim faces/creases by polygons as needed
Output: doubled creases + exact vertex polygons
Next Step — Layer‑Aware Offsets
Following Erik's advice, offsets should scale with the number of layers between faces in the folded state. Plan: estimate per‑crease layer counts and set per‑crease offset = k × thickness × layers(c), while keeping vertex polygons valid to avoid collisions.
Design and cut vinyl stickers and stencils using the vinyl cutter. Assignment started: September 15, 2025Assignment completed: September 15, 2025
Project Overview
Planned to vinyl cut lab logo stickers at first. Collected .png or .svg for each logo for the vinyl cutter software, and executing the complete workflow from cutting to final application. I hope to come back to the lab logos when there is less traffic on the vinyl cutter, I was more excited to see the fine detail of the vinyl cutter with the 2D parametric design at first!
Used a parametric sticker design that can be infinitely customized through an interactive web application.
The design demonstrates the power of parametric modeling in creating personalized vinyl stickers with
adjustable parameters for size, complexity, and visual elements. The assignment demonstrated both successful execution and troubleshooting when equipment issues arose.
Interactive Design Generator
This web-based generator was created as a final project in 6.5310 last semester and was used to download
a PNG of the default design shown above. Generate unlimited variations of this parametric design by
adjusting parameters in real-time to create custom stickers for any application.
Complete workflow from vinyl cutting through final sticker application, demonstrating the full process from design to finished product.
Vinyl Cutting Process
Vinyl cutter in action, cutting the Gladyshev Lab logo design with precise blade control and proper tension settings.
Completed Vinyl Cut
Clean vinyl cut showing precise cuts with proper registration and no tearing or incomplete cuts.
Weeding Process
Systematic weeding process: starting from center, progressing through unwanted sections, and finishing with clean weeded vinyl ready for transfer.
Transfer Paper Application
Transfer paper application process: carefully applying transfer paper to hold vinyl design, then removing it to prepare for final application.
Vinyl Application Process
Final application steps: positioning vinyl on target surface, using tweezers for precise removal of the broken thin vinyl strip, and achieving clean final application.
Completed Takehome Sticker
Final result: applied laptop vinyl sticker and takehome vinyl sticker ready for use, demonstrating successful completion of the vinyl cutting workflow.
Motor Failure
Encountered and resolved a motor failure during the vinyl cutting process, demonstrating troubleshooting skills and equipment maintenance knowledge.
Motor Error Display
Vinyl cutter displaying motor error, indicating a mechanical issue that prevented normal operation.
Roll Failure Analysis
Side-by-side comparison showing the vinyl roll before and after the failure. The roll ran out of material and then fell, causing the vinyl to kink under the cutting wheel.
Troubleshooting Solution
Simple fix process:
Turn off the vinyl cutter
Remove tape from the fallen roll to get the weight off
Readjust vinyl in between the wheels to ensure proper tension
Start again (or load a new roll if needed)
This common issue occurs when the vinyl roll runs out or becomes misaligned, causing the cutting mechanism to fail. The solution involves proper material handling and machine setup.
Design Files
Download or view design files from this week's assignments.
Camron Blackburn - Website Review & Table of Contents Suggestion
Camron reviewed the website and provided valuable feedback on navigation and user experience. She suggested implementing a table of contents to make it easier for visitors to navigate through the different sections of the weekly documentation. This suggestion led to the creation of the sleek, organized table of contents that now appears on both Week 0 and Week 1 pages, significantly improving the overall user experience and accessibility of the documentation.
Mariam Fitaihi - Photos and Videos
Photos and videos of this week's training were taken by Mariam Fitaihi, thank you!
Anthony Pennes provided the kerf and clearance design files (HTMAJointTest v0.f3d and HTMAJointTest.dxf) as part of the laser cutter training. These files were essential for understanding joint tolerances and clearance requirements when working with laser-cut materials.
Erik reviewed my approach to folding thick materials and suggested using the Ku & Demaine thick‑origami method. He pointed me to the paper and
emphasized that doubled creases should be spaced according to the number of layers between faces in the final fold. This feedback led me to implement
two variants (estimate and exact) of thickened crease patterns and to plan a next step for layer‑aware offsets.
Jesse helped me with laser cutting while figuring out how to do it, providing valuable guidance and support during the learning process. His assistance was crucial for understanding the laser cutting workflow and techniques.
Personal Notes - Laser Cutter Characterization
I took notes on the individual group assignment for characterizaing the laser cutter. :-)
Transparent documentation of AI assistance used in this week's work, following course guidelines for ethical AI usage.
AI-Assisted Web Development in Cursor IDE
This week's webpage development, training documentation, and assignment preparation were assisted by Cursor AI.
The AI helped with HTML/CSS implementation, content organization, and structuring technical documentation.
AI-Assisted Section Organization and Content Updates
Cursor AI assisted with organizing webpage sections, cleaning up HTML structure, and updating content for both week 0 and week 1 pages.
The AI helped with code refactoring, section reorganization, and maintaining consistent styling across pages.
Cursor AI assisted with adding Anthony's HTMA guides to the Week 1 page, creating a new "Useful Documentation" section,
and integrating external resource links with proper styling and organization.
Cursor AI assisted with creating a comprehensive Results section for the Laser Cutter Characterization Group Assignment,
including kerf and clearance analysis tables, measurement methodology documentation, concept diagrams, and downloadable resources.
The AI helped integrate Google Sheets data, create professional data tables, and include the complete measurement analysis workflow.
Cursor AI assisted with creating an interactive highlights section for Week 1, including visual improvements to the results display,
clickable navigation links to detailed sections, table of contents integration, and enhanced user experience features.
The AI helped implement hover effects, proper section linking, and visual hierarchy improvements for better navigation.
A separate chat was used to convert a flat crease pattern into a thick‑origami version following Ku & Demaine.
The AI doubled each crease into parallel offsets and generated vertex polygons (estimate = regular polygons; exact = sector‑aware polygons) and explained how to map desired thickness by setting OFFSET_FRAC = thickness / sheet_size.
AI-Assisted Repository Management and Content Organization
Cursor AI assisted with repository size management by breaking down large commits into smaller, manageable chunks under 10MB each.
The AI helped organize media files into logical commits, added the Vinyl Cutter Individual Assignment section with proper styling and image sizing,
and provided guidance on git workflow optimization to work within platform size limits.
Cursor AI assisted with updating the vinyl cutter individual assignment section with comprehensive documentation including
successful cut and transfer workflow, motor failure troubleshooting, and 2D parametric design integration. The AI helped
structure the content with proper media organization, descriptive captions, and consistent styling throughout the section.
Cursor AI assisted with adding a comprehensive Design Files section to the Week 1 page, including table of contents integration,
organized file listings with download and view links, and contextual hyperlinks throughout the page for easy access to design assets.
The AI helped structure the files by category (laser cutter CAD files, SVG patterns, vinyl cutter images) with appropriate styling.
AI-Assisted Design Files Integration for Laser Cutter Training
Cursor AI assisted with adding kerf and clearance design files from Anthony Pennes to the Week 1 Design Files section,
creating a new subsubsection for joint test files, and properly attributing the contribution in the contributions section
with links to both the Slack message and design files section.
Key achievements and insights from the embedded programming week, including successful microcontroller programming, sensor integration, and the development of the ReactionAge reaction time measurement system.
This week focuses on embedded programming fundamentals, exploring how to program microcontrollers and create interactive electronic systems. We'll dive into the world of digital electronics, sensors, and real-time programming to build responsive devices that can sense, process, and react to their environment.
• Introduction to microcontrollers and embedded systems
• Programming fundamentals for real-time applications
• Sensor integration and data processing
This Week's Goals
Master Embedded Programming Learn microcontroller programming, sensor integration, and real-time system design
Build Interactive Systems Create responsive electronic devices that can sense and react to environmental inputs
Develop ReactionAge Project Implement a reaction time measurement system based on research methodologies
Assignments
Group Assignment Collaborative embedded programming project focusing on sensor integration and real-time data processing
Individual Assignment: ReactionAge Build a reaction time measurement system based on research methodologies from cognitive science literature
Tools & Materials
Microcontrollers Arduino, ESP32, or similar development boards
Development Environment Arduino IDE, PlatformIO, or VS Code with embedded extensions
Sensors & Components Buttons, LEDs, displays, accelerometers, and other input/output devices
Prototyping Tools Breadboards, jumper wires, resistors, and basic electronic components
Training Documentation
Essential training materials and resources for embedded programming fundamentals, microcontroller setup, and sensor integration techniques.
Comprehensive guide to soldering techniques for embedded electronics, covering both wire soldering and solder paste methods.
Wire Soldering
Temperature: 720-800°F
Melt pad onto electrode first
Anchor arms for precision control
Use appropriate tip size for part
Work from low to high profile parts
Solder Paste
Use gloves for protection
Highest magnification possible
Temperature: 270-330°C
Heat all sides together
Required for SMD components
Safety First:
Always wear safety glasses and use proper ventilation. Lead-free solder requires extra caution due to flux crystallization at high temperatures.
How to Solder (Almost) Anything
Step-by-step video demonstrations of essential soldering techniques for embedded electronics, covering both wire soldering and surface-mount component assembly.
Wire Soldering Technique
Learn the proper technique for soldering wires to components, starting with one edge to keep the part in place, then soldering the rest easily by keeping your wrist stable and the solder tip on the pad to heat it up with the part, and slowly bringing in solder.
Wire soldering demonstration showing proper technique and wrist stability
Solder Paste Assembly
Complete process for surface-mount component assembly: apply solder paste first, place the component, then heat up with a heat gun to create strong, reliable connections.
Applying solder paste to PCB pads
Placing microcontroller on prepared solder paste
Using heat gun to reflow solder paste and complete the connection
Pro Tips:
For detailed soldering guides and advanced techniques, refer to the Electronics & Soldering Training section above for comprehensive documentation and resources.
• Microcontroller Programming Basics - Introduction to embedded programming concepts and development environments
• Sensor Integration Workshop - Hands-on training for connecting and programming various sensors
• Real-time System Design - Principles of creating responsive embedded systems
• Debugging Techniques - Tools and methods for troubleshooting embedded code
QPAD Development Boards Programming Guide
Complete programming setup and workflow for QPAD development boards, covering bootloader configuration, IDE setup, and code deployment for different microcontroller architectures.
QPAD-XIAO (RP2040)
The QPAD-XIAO features a Raspberry Pi RP2040 microcontroller with built-in bootloader support. No bootloader burning required - simply configure your IDE and start programming!
Programming Steps:
Connect QPAD-XIAO to your computer via USB-C
In Arduino IDE, select Tools → Board → Raspberry Pi RP2040 Boards → XIAO RP2040
Select the correct COM port under Tools → Port
Write your code and click Upload - the board handles everything automatically!
The QPAD21 uses an ATSAMD21 microcontroller that requires bootloader programming using a XIAO programmer chip. Follow these steps to get it ready for development.
Bootloader Programming Steps:
Connect XIAO programmer to QPAD21 using the programming header
Connect XIAO programmer to your computer via USB
In Arduino IDE, select Tools → Board → Arduino SAMD (32-bits ARM Cortex-M0+) → Arduino MKR WiFi 1010
Select the correct COM port for the XIAO programmer
Configure bootloader settings:
Bootloader: Adafruit Circuit Playground Express
Clock: 48 MHz (USB)
USB Stack: Arduino
Debug Level: None
Erase Flash: All Flash Contents
Bootloader Version: 1.0.0
Click Burn Bootloader and wait for completion
Programming Steps (After Bootloader):
Disconnect XIAO programmer and connect QPAD21 directly via USB
The QPAD-XIAO-ESP32S3 features an ESP32-S3 microcontroller with built-in WiFi and Bluetooth capabilities. No bootloader burning required - just configure your IDE and start programming!
Programming Steps:
Connect QPAD-XIAO-ESP32S3 to your computer via USB-C
Microcontroller Programming Architecture and fundamentals
Sensor Integration Data processing methods
Real-time Systems Design principles and optimization
Board Design Documentation
Essential resources for designing custom PCBs and development boards for embedded programming projects, covering schematic design, layout principles, and manufacturing considerations.
USB-C board design showing proper connector placement, power routing, and signal integrity considerations for embedded development boards
Design Principles
USB-C connector placement and orientation
Power distribution and ground plane design
Signal integrity and trace routing
Component placement optimization
Manufacturing Considerations
Layer stackup and via design
Silkscreen and assembly markings
Test point placement
Design rule checking (DRC)
Design Files Available:
Complete KiCad project files, schematics, and PCB layouts are available in the Design Files section below for download and modification.
Common Troubleshooting
Essential troubleshooting techniques for embedded development boards, covering power supply verification and connector testing using multimeter measurements.
Voltage Regulator Troubleshooting
Verify that your voltage regulator is functioning correctly by measuring output voltages with a multimeter when power is connected to the board.
Voltage regulator testing points showing input, output, and ground connections for multimeter verification
Testing Steps:
Connect power to your development board
Set multimeter to DC voltage mode
Measure input voltage (VIN) - should match your power supply voltage
Measure output voltage (VOUT) - should be the regulated voltage (e.g., 3.3V or 5V)
Check ground continuity between input and output ground pins
Verify no voltage drop under load conditions
💡 Pro Tip:
Use a portable multimeter for easy on-the-go testing and debugging of embedded circuits.
USB-C Pinout Troubleshooting
Verify USB-C connector functionality by testing power delivery, data lines, and ground connections using multimeter measurements.
USB-C pinout diagram showing power, data, and ground connections for multimeter testing and verification
Testing Steps:
Connect USB-C cable to your development board
Set multimeter to DC voltage mode
Measure VBUS (pin A4/B4) - should read 5V when connected to power
Test ground continuity (pins A1/B1, A12/B12) - should show 0Ω resistance
Check CC1/CC2 pins (A5/B5) for proper connection detection
Verify D+ and D- data lines (A6/A7, B6/B7) for continuity
Test both orientations of the USB-C connector
🔧 Troubleshooting Tips:
If VBUS shows 0V, check cable and power source
If ground shows high resistance, check solder joints
If data lines show no continuity, verify connector orientation
Test with known working USB-C cable for comparison
Group Assignment: Embedded Programming Design Trades
Comprehensive analysis of design tradeoffs in embedded programming, covering language selection, development workflows, and microcontroller choices. This collaborative project examines the critical decisions that shape embedded system development and their impact on project success.
Design Tradeoffs Summary
Architecture
Example Boards
Toolchain / Workflow
Strengths
Limitations
AVR (8-bit)
ATtiny44, ATmega328 (Arduino Uno)
avr-gcc, avrdude; Arduino IDE for simplified workflow
Mature ecosystem, simple to program, widely taught
Limited memory & speed, not ideal for complex tasks
ARM Cortex-M
SAMD21, STM32, Teensy
arm-none-eabi-gcc, OpenOCD, PlatformIO; Arduino or CircuitPython support
High performance, industry standard, strong debugging tools
Toolchain setup can be complex
RP2040
Raspberry Pi Pico, XIAO RP2040
Pico SDK (C/C++), MicroPython, Arduino IDE; custom PIO assembly for peripherals
Flexible, inexpensive, unique PIO hardware for custom protocols
Requires learning PIO for advanced features
ESP8266 / ESP32
NodeMCU, Sparkfun/Adafruit ESP boards
Espressif SDK/IDF, Arduino IDE, MicroPython
Built-in Wi-Fi/Bluetooth, large community support, IoT-ready
Higher power usage, less deterministic timing
RISC-V
HiFive boards, experimental dev kits
riscv-gnu-toolchain, GDB, newer SDKs
Open-source ISA, growing ecosystem, academic/educational interest
Toolchain less mature, fewer libraries & examples
Comprehensive comparison of microcontroller architectures and their tradeoffs in embedded programming
Language Tradeoff
Programming language tradeoff analysis showing performance vs development speed considerations
As illustrated in the language tradeoff diagram above, the choice of programming language involves critical tradeoffs between performance and development speed. The analysis shows how different languages balance factors like memory efficiency, execution speed, development time, and ecosystem support for embedded system development.
High Performance Languages
C/C++: Maximum control, minimal overhead
Rust: Memory safety with performance
Assembly: Direct hardware control
Rapid Development Languages
Python: Fast prototyping, rich libraries
JavaScript: Web integration capabilities
MicroPython: Python for microcontrollers
Development Workflow Tradeoff
Development workflow tradeoff analysis comparing different methodologies and their impact on project outcomes
The development workflow tradeoff diagram above demonstrates how different methodologies balance project timeline, code quality, and team collaboration. This visual analysis compares traditional waterfall approaches with agile methodologies, showing the impact of various toolchains, testing strategies, and deployment processes on embedded system development success.
Traditional Approaches
Waterfall: Sequential, documentation-heavy
V-Model: Testing integrated with design
Spiral: Risk-driven iterative approach
Modern Approaches
Agile: Iterative, customer-focused
DevOps: Continuous integration/deployment
Test-Driven Development: Quality-first
Microcontroller Tradeoff
Microcontroller tradeoff analysis showing performance vs power consumption and cost considerations
The microcontroller tradeoff diagram above illustrates the critical balance between performance, power consumption, and cost in embedded system design. This visual analysis evaluates different architectures, processing capabilities, memory configurations, and peripheral options, providing a clear framework for selecting the optimal platform based on specific application requirements.
Low-Power Options
ARM Cortex-M0+: Ultra-low power
PIC: Simple, cost-effective
MSP430: Energy-efficient design
High-Performance Options
ARM Cortex-M4: DSP capabilities
ESP32: WiFi/Bluetooth integrated
STM32: Rich peripheral set
Use Case Analysis
Architecture
Workflow Process
Key Characteristics
SAMD21 (ARM Cortex-M)
• Write code in C/C++ (Arduino IDE or PlatformIO)
• Compile with arm-none-eabi-gcc
• Upload using OpenOCD via USB or SWD debugger
• Debug with GDB or serial monitor
Professional-grade debugging, industry standard tools
RP2040 (Raspberry Pi Pico)
• Write code in C/C++ (Pico SDK) or MicroPython
• Compile with CMake + GCC toolchain
• Drag-and-drop .uf2 file to Pico's USB mass storage device
• (Optional) Use custom PIO assembly for hardware interfaces
Accessibility and flexibility, drag-and-drop + PIO
Workflow examples showing different development approaches for ARM and RP2040 architectures
The example workflow table above provides specific recommendations for different embedded system applications, showing how the tradeoff analyses from the previous sections translate into practical implementation strategies. This comprehensive table demonstrates the relationship between project requirements and optimal technology choices.
Key Findings
As demonstrated in the workflow table above, ARM workflows emphasize professional-grade debugging with industry-standard tools, while RP2040 workflows emphasize accessibility and flexibility through drag-and-drop deployment and unique PIO capabilities.
The comprehensive architecture comparison shows that optimal design choices depend heavily on project constraints, performance requirements, and development timeline.
High-performance applications favor ARM Cortex-M with professional toolchains, while rapid prototyping benefits from RP2040's flexible development environment and built-in features.
Build a reaction time measurement system based on research methodologies from cognitive science literature. This project combines embedded programming with scientific measurement principles to create a tool for studying human cognitive performance.
Core Features
Stimulus Generation Visual/auditory stimuli with precise timing
Response Detection Accurate measurement using buttons/sensors
Data Analysis Statistical processing and visualization
Research Foundation
Based on PLOS ONE study (2017) examining reaction time variability and cognitive decline.
Complete bill of materials for the ReactionAge embedded programming project. All prices are in USD and subject to supplier variations.
Nintendo Switch Controller Training for Toddlers
An interactive training module designed for young children, utilizing Nintendo Switch controller input to create an engaging letter-matching game that develops motor skills and cognitive recognition.
Game Mechanics
Button Mapping A, B, X, Y in inverted layout
Visual Stimulus Flashing letters with bright colors
Progressive Difficulty Adapts based on performance
Educational Benefits
Motor Skills Hand-eye coordination
Letter Recognition Alphabet learning
Attention Building Focus and concentration
Technical Features
Controller Support Pro Controller & Joy-Con
Display System Large, colorful letters
Progress Tracking Analytics & feedback
ChatGPTMario2D
An AI-powered Mario-style platformer game built with ChatGPT assistance, featuring touch controls, adaptive gameplay mechanics, and classic 2D platforming elements optimized for embedded systems.
Mario-style platformer gameplay with touch controls and adaptive difficulty
ChatGPT-assisted development process and code generation demonstration
A collaborative multiplayer game featuring geometric shape interactions, synchronized gameplay between two ESP32 devices, inspired by educational content in Shape Song Swing Along.
Shape Song Swing Along educational content integration and gameplay
Circle and square shape interaction gameplay mechanics
A touch monitoring utility developed with ChatGPT assistance for debugging and calibrating touch sensor inputs on the QPAD21 development board. This tool provides real-time visualization of touch sensor values and helps optimize touch thresholds for embedded applications.
A utility developed with ChatGPT assistance for retrieving and displaying MAC addresses on ESP32 devices. This tool is essential for ESP-NOW communication setup, allowing developers to identify device MAC addresses for peer-to-peer networking configuration in multiplayer embedded applications.
// MAC address retrieval utility for ESP32
#include
#include
void setup() {
Serial.begin(115200);
// Get WiFi STA MAC address
uint8_t mac[6];
esp_read_mac(mac, ESP_MAC_WIFI_STA);
Serial.print("WiFi STA MAC: ");
for (int i = 0; i < 6; i++) {
if (i > 0) Serial.print(":");
if (mac[i] < 16) Serial.print("0");
Serial.print(mac[i], HEX);
}
Serial.println();
// Get Bluetooth MAC address
esp_read_mac(mac, ESP_MAC_BT);
Serial.print("Bluetooth MAC: ");
for (int i = 0; i < 6; i++) {
if (i > 0) Serial.print(":");
if (mac[i] < 16) Serial.print("0");
Serial.print(mac[i], HEX);
}
Serial.println();
}
For detailed board design principles, USB-C connector placement, and manufacturing considerations, refer to the Board Design Documentation section above.
Reflections & Learnings
[Reflection notes placeholder.]
Contributions
Acknowledgments for collaborative support and technical assistance during the embedded programming project development.
Course Staff
Quentin Bolsée
Helped me so much with the ESP32S3 code development with his awesome examples. Also assisted with resoldering the microcontroller when we were debugging the USBC QPAD issues. Couldn't have done it without you!
Anthony Pennes
Spent so many hours helping me debug my USBC QPAD while resoldering the USBC port. Eventually it turned out the problem was that we crashed the board with XIAO code on a D21! Too much to say and so little time until class. Couldn't have done it without you.
Jesse de Alva
Helped me test the boards after programming them, providing valuable assistance with debugging and validation of the embedded programming projects. Your support was crucial for ensuring everything worked correctly.
Technical Support & Collaboration
Eghosa Ohenehn
Contributed valuable insights and technical discussions about microcontroller tradeoffs during the group assignment development. Provided expertise in evaluating different microcontroller architectures and their suitability for various embedded programming applications.
Anthony Pennes
Engaged in extensive discussions throughout the embedded programming design trades section, providing valuable technical insights and collaborative support during the group assignment development process.
Quentin Bolsée
Participated in numerous office hours discussions about embedded programming design trades, contributing significantly to the technical analysis and collaborative development of the group assignment content.
Alex Hu
Thank you for showing me Flappy Bird and inspiring me to push through the game development part of my plan this week. Your demonstration and encouragement were instrumental in motivating me to complete the ChatGPTMario2D and CircleSquareShapeSongSwingalong projects, helping me overcome technical challenges and stay focused on the embedded programming goals.
Tushar Kanade
Thank you for taking videos of the soldering training! Your documentation of the training process was incredibly helpful for understanding the techniques and procedures. The visual reference you provided made it much easier to follow along and learn the proper soldering methods for the embedded programming projects.
Special thanks to the collaborative learning environment that enabled knowledge sharing and technical problem-solving throughout the embedded programming week.
Ethical AI Use
Transparent documentation of AI assistance used in this week's work, following course guidelines for ethical AI usage.
AI-Assisted Template Generation and Task Planning
Used ChatGPT to generate the weekly template HTML structure and styling framework, and created structured task prompts
for week 2 embedded programming content development.
AI-Assisted Content Development and Page Structure
Used Cursor AI for iterative content development, page structure optimization, and aesthetic improvements.
The AI helped with HTML/CSS implementation, content organization, and maintaining consistent styling across the embedded programming documentation.
Used Cursor AI to implement the comprehensive BOM table with clickable images, datasheet links, and full-width responsive design.
The AI helped with HTML table structure, CSS styling, and integration of CSV data into an aesthetically pleasing table format.
Used ChatGPT for image recognition of electronic components to identify parts and construct the bill of materials CSV file.
The AI analyzed component images and provided detailed part specifications, descriptions, and pricing information for the embedded programming project.
AI-Assisted Project Content Updates and Documentation
Used Cursor AI for comprehensive project content updates, documentation improvements, and HTML structure optimization.
The AI assisted with content organization, styling consistency, and integration of multimedia elements for the embedded programming documentation.
AI-Assisted Arduino Programming and Code Development
Used ChatGPT for Arduino programming assistance based on the ReactionAge project code from
GitHub repository
and Quentin Bolsée's QPAD documentation available on the
course website embedded system assignment page.
The AI provided guidance on embedded programming concepts, code optimization, and integration with the QPAD-xiao board design.
AI-Assisted Group Assignment Content Development and Table Implementation
Used Cursor AI for comprehensive development of the embedded programming design trades group assignment section.
The AI assisted with creating structured subsections for language, development workflow, and microcontroller tradeoffs,
implementing professional HTML tables with data extracted from PowerPoint presentations, and integrating download links for PDF and PPTX files.
AI-Assisted Training Section Development and Documentation
Used Cursor AI for comprehensive development of the training section, including soldering techniques, QPAD programming guides,
board design documentation, and troubleshooting procedures. The AI assisted with creating structured subsections,
implementing video demonstrations, adding download links for design files, and developing comprehensive troubleshooting guides with multimeter testing procedures.
Used Cursor AI to analyze file sizes and break down large changes into smaller, manageable commits to avoid exceeding Git's 25MB commit size limit.
The AI helped organize files by size, created a logical commit strategy, and automated the commit and push process for better version control practices.
Used ChatGPT for collaborative development of the ChatGPTMario2D platformer game, including touch control implementation,
adaptive difficulty systems, collision detection, and game physics. The AI provided guidance on embedded programming concepts,
state machine architecture, and optimization for the QPAD21 development board.
AI-Assisted Multiplayer Game Development: CircleSquareShapeSongSwingalong
Used ChatGPT for collaborative development of the CircleSquareShapeSongSwingalong multiplayer game, including ESP-NOW wireless communication,
MAC address-based player identification, synchronized game state management, and educational content integration.
The AI provided guidance on embedded networking, real-time synchronization, and touch-based geometric learning systems.
Used ChatGPT for collaborative development of the QPAD21 touch monitoring utility, including real-time sensor value display,
threshold calibration assistance, debugging tools, and serial output for data logging. The AI provided guidance on touch sensor
integration, calibration procedures, and embedded debugging techniques for the QPAD21 development board.
Used ChatGPT for collaborative development of the get_mac_address utility for ESP32 devices, including WiFi STA and Bluetooth MAC address retrieval,
serial output formatting, and ESP-NOW integration support. The AI provided guidance on embedded networking concepts,
MAC address extraction methods, and device identification techniques for multiplayer embedded applications.
AI-Assisted Toddler Training Subsections Development
Used Cursor AI for comprehensive development of toddler training subsections, including ChatGPTMario2D and CircleSquareShapeSongSwingalong game implementations.
The AI assisted with creating structured subsections, implementing video demonstrations, adding download links for Arduino code files,
and developing comprehensive documentation for embedded programming educational content.
This week focuses on additive manufacturing processes and 3D scanning technologies. We'll explore the differences between subtractive and additive processes, learn about various 3D printing materials and techniques, and understand the design constraints and capabilities of 3D printing systems.
Key Concepts: Additive vs subtractive manufacturing, design for 3D printing, material properties, scanning technologies
This Week's Goals
Test 3D printer design rules Group assignment: Test design rules for available 3D printer(s)
Design additive-only object Individual: Design and print object that cannot be made subtractively
3D scan an object Individual: Scan an object and optionally print it
Assignments
Group Assignment Test design rules for 3D printer(s)
Individual Assignment Design, document, and 3D print object that could not be made subtractively
3D Scanning 3D scan an object (and optionally print it)
Design, document, and 3D print an object that could not be made subtractively. The object should be small (few cm³) and limited by printer time.
Design Requirements
Complex geometry Must have features impossible with subtractive manufacturing
Size constraint Small object, few cm³ volume
Print time Consider reasonable print time for testing
Documentation Document design process, print settings, and results
3D Scanning Component
Scan object Use available scanning method to capture 3D geometry
Process mesh Clean and prepare scanned mesh for printing
Optional printing Print the scanned object if desired
Handgripper for Locomotive Age Assessment
I hope to design and fabricate a handgripper to measure age based on hand grip strength. This builds on our aging biomarker research by focusing on locomotive age assessment.
The idea is to measure functional decline due to aging across multiple modalities:
Cognition: Memory, attention, reasoning, and problem-solving
Locomotion: Mobility, balance, and muscle strength
Sensory: Vision, hearing, and touch
Vitality: Energy levels, nutrition, and sleep
Psychological: Emotional well-being, resilience, and social connections
Last week we measured cognition with reaction time - this week we focus on locomotive age through grip strength.
Proposed 3D Printable Components
Untanglable Slinky
Complex interlocking geometry that cannot be manufactured subtractively. Tests printer's ability to create intricate, self-supporting structures with minimal overhangs.
Single Torsion Spring
Helical spring mechanism for grip force measurement. Demonstrates additive manufacturing's capability to create functional mechanical components in one piece.
Double Torsion Spring
Nested spring system with different spring constants. Tests printer's ability to create complex, multi-component mechanisms with varying material properties.
Coil Mechanism
Spiral coil for force transmission and measurement. Explores the limits of printable coil geometries and their mechanical properties for sensor integration.
Untanglable Slinky
A complex 3D printable design that demonstrates additive manufacturing capabilities through intricate geometry that cannot be manufactured subtractively.
Human-AI Co-Design
This design was co-developed through iterative discussion with ChatGPT, exploring various approaches to create an untanglable slinky geometry.
Design Iterations
The design process involved multiple iterations, with the first two attempts resulting in tangled slinkies that failed to maintain proper coil separation:
First attempt: Tangled slinky with improper coil geometry
Second attempt: Still resulted in tangled geometry
Final Successful Design
The third iteration successfully achieved the desired untanglable geometry:
Final design: Untanglable slinky with proper coil geometry
Design Description: This design shows an untanglable slinky with flat, oval coils, tiny spacers between turns, and solid end caps, so it collapses neatly without knots. The geometry enforces orderly stacking while preventing coils from slipping past each other.
My initial exploration into creating a 3D printable slinky design, inspired by the classic magic spring concept.
First slinky design - exploring the magic spring concept
Design Description: This first slinky design represents my initial exploration into creating a 3D printable magic spring. The design focuses on creating a helical structure that can collapse and expand while maintaining its structural integrity.
This design was inspired by the classic slinky toy and the concept of creating a "magic spring" that can be 3D printed in one piece, demonstrating the unique capabilities of additive manufacturing.
Inspiration & Resources
This design draws inspiration from several sources and builds upon existing work in 3D printable magic springs:
The Hackaday project provides comprehensive documentation including Java code for generating G-code, print parameters, and detailed instructions for creating 3D printable magic springs. The project includes multiple iterations of the code with different features like temperature control, spiral priming, and delta printer compatibility.
This session covers the development of the Week 3 page for 3D scanning and printing, including content population from MIT Academy resources, navigation updates, and design file integration.
This session documents the iterative co-design process for creating an untanglable slinky using ChatGPT. The conversation shows multiple design iterations, from initial failed attempts to the final successful geometry.
This session documents the comprehensive refactoring of the entire web development repository to make it fully responsive and mobile-friendly. The conversation covers the implementation of modern CSS techniques, responsive design patterns, and mobile-first development approaches.
This session documents the integration of the first slinky design into the untanglable slinky section, including adding the image, description, inspiration resources, and design file links.
