Skip to content

Lesson Order

Order of Lessons and Concept

This section provides you with sample prompts you can give to any generative AI system. The first is a general prompt that just returns a list of concepts. The next prompt is much more detailed and includes exactly the tools you have in your lab.

Sample General Prompt

You are an expert at teaching MicroPython to high school
students using fun sensors and displays to create fun
STEM robots.

List the 100 most important concepts that you would teach
in your courses.  For each concept, just return the
name of the concept without any definition. 
Return the 100 items in the order they should be
taught in a class with the simplest first,
to the most complex at the end of the list.

ChatGPT response

  1. Introduction to MicroPython
  2. Setting Up the Thonny Development Environment
  3. Basic Syntax and Variables
  4. Data Types
  5. Arithmetic Operators
  6. Comparison Operators
  7. Logical Operators
  8. Control Structures: If Statements
  9. Control Structures: Else and Elif
  10. For Loops
  11. While Loops
  12. Functions
  13. Parameters and Return Values
  14. Importing Modules
  15. Using Built-in Libraries
  16. Working with LEDs
  17. Reading Button Inputs
  18. Serial Communication Basics
  19. Using the REPL
  20. Exception Handling
  21. Lists
  22. Tuples
  23. Dictionaries
  24. String Manipulation
  25. Working with Time and Delays
  26. Understanding Analog vs Digital Signals
  27. GPIO Pin Basics
  28. Pulse Width Modulation (PWM)
  29. Reading Analog Sensors
  30. Writing to LCD Displays
  31. Using I2C Communication
  32. Using SPI Communication
  33. Handling Interrupts
  34. Debouncing Buttons
  35. Managing Power Consumption
  36. Introduction to Robotics
  37. Motor Control Basics
  38. Using Servo Motors
  39. Using DC Motors
  40. Understanding H-Bridge Circuits
  41. Using Motor Drivers
  42. Reading from Ultrasonic Sensors
  43. Using Temperature Sensors
  44. Using Light Sensors
  45. Using Accelerometers
  46. Using Gyroscopes
  47. Implementing Serial Protocols
  48. Debugging Techniques
  49. Introduction to Version Control with Git
  50. Project Planning and Design
  51. Building a Basic Robot Frame
  52. Integrating Sensors and Actuators
  53. Using Bluetooth Modules
  54. Using Wi-Fi Modules
  55. Implementing Bluetooth Communication
  56. Implementing Wi-Fi Communication
  57. Data Logging Techniques
  58. Storing Data on SD Cards
  59. Using Real-Time Clocks
  60. Implementing Timers
  61. PWM for LED Dimming
  62. Creating a User Interface
  63. Using Touch Sensors
  64. Implementing Obstacle Avoidance
  65. Line Following Algorithms
  66. Introduction to PID Control
  67. Using Encoders
  68. Implementing Feedback Loops
  69. Basics of Machine Learning
  70. Creating Autonomous Behaviors
  71. Implementing Remote Control
  72. Introduction to Speech Recognition
  73. Using Camera Modules
  74. Basics of Image Processing
  75. Integrating Multiple Sensors
  76. Power Management for Robots
  77. Wireless Charging Basics
  78. Safety Practices in Robotics
  79. Designing for Modularity
  80. Implementing Error Recovery
  81. Advanced Data Structures
  82. Using Queues and Stacks
  83. Multithreading in MicroPython
  84. Asynchronous Programming
  85. Implementing State Machines
  86. Networking Protocols
  87. Cloud Integration Basics
  88. Using MQTT Protocol
  89. Implementing REST APIs
  90. Secure Communication Practices
  91. Basics of Encryption
  92. Advanced Sensor Fusion
  93. Path Planning Algorithms
  94. Introduction to SLAM (Simultaneous Localization and Mapping)
  95. Using GPS Modules
  96. Integrating with Mobile Devices
  97. Using NFC Modules
  98. Implementing Gesture Control
  99. Voice Command Integration
  100. Advanced AI for Object Recognition

STEM Robotics Course

You are an expert at teaching MicroPython to high
school students using fun sensors and displays to
create fun STEM robots.  In your lab,
you have the following equipment:

1. Computers running the Thonny IDE
2. Raspberry Pi Picos mounted on breadboards
3. Basic electronic components (LEDs, resistors, transistors, motors, etc.)
4. A Smart Car robot chassis with 2 DC motors and a battery pack of 4 AA batteries
5. The Cytron motor controller board with the RP2040 chip that supports DC motors, servos, I2C, and SPI interfaces
6. 128x64 OLED displays that use the SPI interface
7. WS2816 LED strips (neopixels)

List the 100 most important concepts that you would
teach in your STEM Robots course.  For each concept,
just return the name of the concept and a short definition.
Return the 100 items in the order they should be taught
in a class, with the simplest first to the most
complex at the end of the list.

  1. Introduction to Robotics Overview of robotics, course objectives, and the role of robots in STEM.

  2. Introduction to MicroPython Understanding MicroPython and its applications in embedded systems.

  3. Setting Up the Development Environment Installing Thonny IDE and configuring it for Raspberry Pi Pico.

  4. Connecting Raspberry Pi Pico to Computer Physical setup of the Pico with the computer for programming.

  5. Basic Syntax and Variables Learning the fundamental syntax of MicroPython and how to declare variables.

  6. Data Types in MicroPython Exploring different data types such as integers, floats, strings, and booleans.

  7. Basic Electronics Principles Introduction to voltage, current, and basic electronic components.

  8. Using a Breadboard Understanding breadboard layout and how to create simple circuits.

  9. Working with LEDs Connecting and controlling LEDs using the Raspberry Pi Pico.

  10. Understanding Resistors Learning the purpose of resistors and how to calculate resistance values.

  11. GPIO Pin Basics Overview of General Purpose Input/Output pins on the Pico.

  12. Digital Input and Output Reading digital inputs and controlling digital outputs.

  13. Using Push Buttons Connecting and reading input from push buttons.

  14. Control Structures: If Statements Implementing conditional logic in MicroPython.

  15. Control Structures: Else and Elif Expanding conditional logic with else and elif statements.

  16. For Loops Creating loops to execute code multiple times.

  17. While Loops Implementing loops that run based on a condition.

  18. Functions in MicroPython Defining and calling functions to organize code.

  19. Parameters and Return Values Using parameters and return values in functions.

  20. Lists in MicroPython Creating and manipulating lists to store multiple values.

  21. String Manipulation Working with strings, including concatenation and formatting.

  22. Basic Arithmetic Operations Performing arithmetic calculations in code.

  23. Using Built-in Libraries Importing and utilizing MicroPython's built-in libraries.

  24. Serial Communication Basics Understanding serial communication between devices.

  25. Using the REPL Utilizing the Read-Eval-Print Loop for interactive coding.

  26. Exception Handling Managing errors and exceptions in your programs.

  27. Introduction to PWM (Pulse Width Modulation) Understanding PWM and its applications in controlling devices.

  28. Controlling LED Brightness with PWM Using PWM to adjust LED brightness levels.

  29. Working with Transistors Learning how transistors can control larger currents.

  30. Introduction to the Cytron Motor Controller Overview of the Cytron board and its capabilities.

  31. Connecting DC Motors Wiring DC motors to the motor controller and Pico.

  32. Basic Motor Control Writing code to start and stop DC motors.

  33. Controlling Motor Speed with PWM Using PWM to adjust the speed of DC motors.

  34. Understanding Motor Direction Changing the direction of motor rotation.

  35. Building a Simple Robot Frame Assembling the Smart Car chassis with motors and battery pack.

  36. Powering the Raspberry Pi Pico Connecting the battery pack to power the Pico and motors.

  37. Using Servo Motors Connecting and controlling servo motors for precise movements.

  38. Introduction to I2C Communication Understanding the I2C protocol for connecting peripherals.

  39. Connecting the OLED Display via SPI Wiring the 128x64 OLED display using the SPI interface.

  40. Displaying Text on OLED Writing code to show text messages on the OLED screen.

  41. Using the WS2816 LED Strips (Neopixels) Connecting and controlling Neopixel LED strips.

  42. Creating LED Animations Programming dynamic lighting effects on LED strips.

  43. Reading Analog Inputs Using analog sensors to read varying voltage levels.

  44. Using Light Sensors Connecting light sensors and interpreting their data.

  45. Using Temperature Sensors Reading temperature data from connected sensors.

  46. Debouncing Buttons Implementing software techniques to stabilize button inputs.

  47. Implementing Timers and Delays Managing timing in your programs for precise control.

  48. Introduction to Dictionaries Using dictionaries to store key-value pairs of data.

  49. Using Tuples Understanding and utilizing tuples for immutable data.

  50. Advanced String Operations Performing complex manipulations on string data.

  51. Storing and Accessing Data with Lists Managing and accessing data stored in lists.

  52. Introduction to the Smart Car Chassis Detailed overview of the Smart Car components and functionality.

  53. Connecting Multiple LEDs Wiring and controlling multiple LEDs in a circuit.

  54. Using the Motor Controller's I2C Interface Communicating with the motor controller via I2C.

  55. Basic Sensor Integration Connecting simple sensors to the Raspberry Pi Pico.

  56. Reading Sensor Data Collecting and interpreting data from various sensors.

  57. Displaying Sensor Data on OLED Showing real-time sensor information on the OLED display.

  58. Using Transistors for Motor Control Enhancing motor control with transistor circuits.

  59. Introduction to PWM for Servo Control Using PWM signals to precisely control servos.

  60. Creating Interactive LED Displays Programming LEDs to respond to sensor inputs.

  61. Implementing Basic Obstacle Avoidance Using sensors to detect and avoid obstacles.

  62. Building a Line-Following Robot Programming the robot to follow a line using sensors.

  63. Introduction to Encoders Understanding encoders for tracking motor rotation.

  64. Implementing Motor Feedback Using encoder data to control motor movements accurately.

  65. Using Accelerometers Integrating accelerometers to measure movement and orientation.

  66. Using Gyroscopes Adding gyroscopes for detecting rotational motion.

  67. Basic Data Logging Recording sensor data for later analysis.

  68. Storing Data on SD Cards Writing and reading data to/from SD cards.

  69. Using Real-Time Clocks (RTC) Keeping track of time in your projects with RTC modules.

  70. Implementing State Machines Managing complex behaviors using state machines.

  71. Introduction to Interrupts Handling asynchronous events in your programs.

  72. Using Queues and Stacks Managing data flow with queues and stacks.

  73. Multithreading in MicroPython Running multiple threads for concurrent tasks.

  74. Asynchronous Programming Implementing non-blocking code for efficient processing.

  75. Introduction to PID Control Understanding Proportional-Integral-Derivative control for precise movement.

  76. Implementing Feedback Loops Using sensor feedback to adjust motor control dynamically.

  77. Basic Networking Concepts Understanding how devices communicate over networks.

  78. Using Bluetooth Modules Connecting and communicating with Bluetooth devices.

  79. Using Wi-Fi Modules Integrating Wi-Fi for wireless communication and control.

  80. Implementing Bluetooth Communication Setting up Bluetooth to send and receive data.

  81. Implementing Wi-Fi Communication Configuring Wi-Fi for internet connectivity and data exchange.

  82. Introduction to Version Control with Git Managing code versions and collaborating using Git.

  83. Project Planning and Design Planning and designing robotics projects effectively.

  84. Integrating Multiple Sensors Combining data from various sensors for complex behaviors.

  85. Advanced Data Structures Utilizing advanced structures like linked lists and trees.

  86. Introduction to Machine Learning Basics of machine learning and its applications in robotics.

  87. Creating Autonomous Behaviors Programming robots to operate independently without user input.

  88. Implementing Remote Control Controlling the robot remotely via wireless connections.

  89. Using Touch Sensors Integrating touch sensors for interactive control.

  90. Implementing Gesture Control Using sensors to interpret and respond to user gestures.

  91. Voice Command Integration Adding voice recognition to control the robot through speech.

  92. Using Camera Modules Connecting and utilizing camera modules for vision-based tasks.

  93. Basics of Image Processing Processing and interpreting images captured by the camera.

  94. Advanced Sensor Fusion Combining multiple sensor inputs for accurate data interpretation.

  95. Path Planning Algorithms Designing algorithms for efficient navigation and movement paths.

  96. Introduction to SLAM (Simultaneous Localization and Mapping) Enabling robots to build maps and locate themselves within them.

  97. Using GPS Modules Integrating GPS for location tracking and navigation.

  98. Integrating with Mobile Devices Connecting the robot to smartphones or tablets for control and feedback.

  99. Using NFC Modules Adding Near Field Communication for short-range interactions.

  100. Advanced AI for Object Recognition Implementing artificial intelligence techniques to recognize and respond to objects.