Can There Be "Authentic Learning" With AI?

“How do we preserve authentic learning when students can instantly generate answers with AI?”

• AI Workshop - Teaching In The Age Of AI - STEAM Clown -  🖼️ Presentation 

• AI Documentation Rules - 🕸️ Web Links - GitHub - Use these rules when specifying how AI should document and report results

• AI Rules For Study Guide Prompt - 🕸️ Web Links - GitHub - Use this link to describe the AI role and expected output for a study guide

• 
  

The biggest mistake teachers make is using prompts that are too short and too vague.

When You Ask Students to write code to 1) read a Photoresistor 2) Turn on and LED when the analogRead() value is more than 1000

And they ask AI - "Generate complete Arduino C++ code for reading an analog value from a Photoresistor and turn on an LED when that value is greater than 1000"

Arduino C++ Code:

/**

 * Photoresistor (LDR) + LED Demo

 * 

 * Reads analog light level from a photoresistor voltage divider on A0.

 * Turns on an LED connected to Pin 13 when the reading exceeds 1000.

 *

 * Wiring:

 *   Photoresistor (LDR):

 *     - One leg  → 5V

 *     - Other leg → A0 AND one end of a 10kΩ pull-down resistor

 *     - Other end of 10kΩ resistor → GND

 *

 *   LED:

 *     - Anode (+) → 220Ω resistor → Pin 13

 *     - Cathode (-) → GND

 *

 * Analog range: 0 (dark) to 1023 (bright)

 * Threshold: 1000 — adjust LIGHT_THRESHOLD to tune sensitivity

 */

// ──────────────────────────────────────────────

// Pin definitions

// ──────────────────────────────────────────────

const int LDR_PIN = A0;   // Analog input: photoresistor voltage divider

const int LED_PIN = 13;   // Digital output: LED (built-in LED on most boards)

// ──────────────────────────────────────────────

// Configuration

// ──────────────────────────────────────────────

const int LIGHT_THRESHOLD = 1000;  // 0–1023; LED turns ON above this value

const int SAMPLE_DELAY_MS = 100;   // Milliseconds between readings

// ──────────────────────────────────────────────

// setup() — runs once on power-up or reset

// ──────────────────────────────────────────────

void setup() {

  pinMode(LED_PIN, OUTPUT);        // Configure LED pin as output

  digitalWrite(LED_PIN, LOW);      // Ensure LED starts OFF

  Serial.begin(9600);              // Open serial monitor for debugging

  Serial.println("Photoresistor monitor started.");

  Serial.print("Threshold: ");

  Serial.println(LIGHT_THRESHOLD);

}

// ──────────────────────────────────────────────

// loop() — runs repeatedly after setup()

// ──────────────────────────────────────────────

void loop() {

  // Read the analog voltage from the LDR voltage divider (0–1023)

  int lightLevel = analogRead(LDR_PIN);

  // Determine LED state based on threshold

  if (lightLevel > LIGHT_THRESHOLD) {

    digitalWrite(LED_PIN, HIGH);   // Bright enough — turn LED ON

  } else {

    digitalWrite(LED_PIN, LOW);    // Too dark — turn LED OFF

  }

  // Print reading to Serial Monitor for debugging / calibration

  Serial.print("Light level: ");

  Serial.print(lightLevel);

  Serial.print("  |  LED: ");

  Serial.println(lightLevel > LIGHT_THRESHOLD ? "ON" : "OFF");

  delay(SAMPLE_DELAY_MS);          // Short pause before next sample

}

Key points to note:

The voltage divider is what makes this work. The 10kΩ pull-down resistor and the photoresistor share the same node that feeds A0. As light increases, the LDR's resistance drops, more voltage appears at A0, and the reading climbs toward 1023.

Calibration tip — the right threshold depends on your specific LDR and ambient lighting. Upload the sketch, open Serial Monitor at 9600 baud, and watch the live readings. In your target "bright" condition, note the reading and set LIGHT_THRESHOLD just below it.

Adjustable constants at the top:

Constant                           Default                       Purpose

LIGHT_THRESHOLD        1000                         Trigger point (0–1023)

SAMPLE_DELAY_MS       100                           Loop rate in milliseconds

LED_PIN                            13                             Change if using an external LED pin

AI Helping Generate <Topic> Study Guides, Presentations & Quizzes

“A good AI Prompt is like a well-planned garden — the more carefully you prepare the soil, structure, and boundaries, the more meaningful the growth will be.” - Claude

A strong AI prompt for teachers should do more than just ask for “lesson content.” The best prompts establish "Who" the AI is, "What" are your goals, and the Pedagogy of how you want the results represented

• GitHub: AI Rules For Study Guide Prompt

• The educational role of the AI

• Student age/skill level

• Course context

• Learning objectives

• Teaching philosophy

• Required outputs

• Formatting rules

• Assessment depth

• Real-world relevance

• Differentiation and scaffolding

• Hands-on lab integration

• Misconceptions students may have

• Safety considerations

• Extension pathways

The biggest mistake teachers make is using prompts that are too short and too vague.

Teaching In The Age Of AI - GitHub Project Template With AI "Rules"

• Preparing the Prompt Rules for an Engineering or STEAM based "chat" - 🕸️ GitHub Web Links 

pull the documentation rules from https://raw.githubusercontent.com/jimTheSTEAMClown/Robots-Rovers-Project-Template/refs/heads/main/AI-Rules/AI-Rules-Documentation-Projects.md 

please generate a template for a prompt I might use for generating a study guide for students.  Please have to following prompt input options headings with an example prompt rule for each based on my Mechatronics class:

• The Educational Role Of The AI

• Student Age/Skill Level

• Course Context

• Learning Objectives

• Teaching Philosophy

• Required Outputs

• Formatting Rules

• Assessment Depth

• Real-World Relevance

• Differentiation And Scaffolding

• Hands-On Lab Integration

• Misconceptions Students May Have

• Safety Considerations

• Extension Pathways Add the prompt heading for each bullet section with a 1-2 lines specifying the "rule". I'm targeting high school students in Mechatronics Engineering, please add some generic engineering focused context for each of these bullets. I will then use this to edit a specific prompt for a specific engineering topic.

Ask any questions to clarify what I want if you need to.

Teaching In The Age Of AI - AI Study Guide Prompt Template

• Edit this Prompt for your specific topic, career focus

• Preparing the Prompt Rules for an Engineering or STEAM based "chat" - 🕸️ GitHub Web Links 

--- BEGIN PROMPT ---

## The Educational Role of the AI

You are an experienced Mechatronics Engineering instructor and industry mentor.

Write in a clear, direct, encouraging voice aimed at high school students.

Explain the "why" behind every concept before the "how." Use analogies to

everyday systems (cars, bikes, appliances) to ground abstract engineering ideas.

## Student Age and Skill Level

Students are 10th through 12th graders enrolled in a Mechatronics Engineering

pathway at a California CTE high school. They have completed introductory

Arduino programming (digital I/O, analogWrite, Serial monitor) and basic

electronics (voltage, current, resistance, Ohm's Law). They are comfortable

reading simple schematics but have limited experience with motor control or

PWM signals.

## Course Context

Course: SVCTE Mechatronics Engineering — Robots and Rovers Unit

Unit 7: Motor Control and Drive Systems

This study guide follows the PWM and analogWrite lab and precedes the

closed-loop PID control unit. Students have wired and tested an L298N

motor driver but have not yet written speed-ramping code.

## Learning Objectives

By the end of this study guide, students will be able to:

1. Explain how PWM signals control motor speed using duty cycle.

2. Identify the role of the H-bridge in controlling motor direction.

3. Read and interpret an L298N motor driver wiring diagram.

4. Write Arduino C++ code to control a differential drive rover's speed and direction.

5. Debug a non-moving rover by systematically checking power, signal, and code.

6. Explain why motor speed ramping prevents mechanical stress and current spikes.

## Teaching Philosophy

Hands-on before theory: introduce what students will build first, then explain why it works.

Use annotated code examples with # LEARN: comments explaining key decisions.

Prefer real wiring diagrams described in text over abstract block diagrams.

Depth over breadth: cover differential drive motor control thoroughly rather

than surveying all motor types.

## Required Outputs

- A student study guide in Markdown with the following sections:

  - Overview (what this guide covers and why it matters)

  - Key Vocabulary (table: term, definition, example)

  - Concept Explanations (PWM, H-bridge, differential drive, speed ramping)

  - Wiring Reference (L298N to Arduino Mega pin mapping table)

  - Annotated Arduino Code Example (forward, reverse, turn, stop)

  - Common Mistakes and How to Fix Them

  - Check for Understanding (5 questions: 2 recall, 2 application, 1 debug scenario)

  - Safety Notes

  - Extension Pathways

  - Sources

## Formatting Rules

Follow all STEAM Clown Documentation Rules:

- Single H1 (document title only)

- Labeled code fences (arduino for .ino code, text for pin tables)

- No raw HTML

- Mermaid diagrams where applicable

- No bare URLs — all links as [text](url)

- No Master/Slave terminology — use Controller/Peripheral or Primary/Secondary

- Source citations at the bottom in a Sources section

- No em dashes, no emojis in headings

## Assessment Depth

Include recall questions (define PWM duty cycle, identify H-bridge pins) and

application questions (predict motor behavior given a specific duty cycle,

identify the bug in a provided code snippet). Include one "debug this rover"

scenario where the motor spins in only one direction.

## Real-World Relevance

Connect differential drive to electric wheelchairs, warehouse robots (Amazon

Kiva), autonomous lawn mowers, and FIRST Robotics drive trains. Explain

why industry uses speed ramping to protect gearboxes and reduce inrush current.

## Differentiation and Scaffolding

Tier 1 (Foundational): Define PWM with a light dimmer analogy. Show a simple

forward/stop code example only.

Tier 2 (Standard): Full differential drive code with direction control.

Tier 3 (Challenge): Add speed ramping with a for-loop and explain the

relationship between ramp rate and motor current draw.

## Hands-On Lab Integration

Suggest a bench activity: students measure PWM frequency and duty cycle on

an oscilloscope at analogWrite values of 64, 128, and 255, then correlate

measured duty cycle to observed motor speed. Connect to the upcoming PID lab.

## Misconceptions Students May Have

- "Higher voltage always means faster motor" — address that PWM controls

  speed at a fixed supply voltage by varying on-time, not voltage level.

- "The L298N controls the motor directly" — clarify that the driver

  amplifies the Arduino's logic signal; the Arduino does not power the motor.

- "analogWrite outputs a real analog voltage" — explain that it outputs a

  digital PWM signal that averages out to appear analog to the motor.

## Safety Considerations

- Maximum 12V supply for L298N in student lab configurations.

- Always connect motor ground and Arduino ground (common ground) or the

  motor will not respond.

- Disconnect power before rewiring. Motors can draw high inrush current

  on startup — never hold wires by hand while powering on.

- Include a software E-Stop: always provide a stop() function students

  can call in an emergency.

## Extension Pathways

- Implement closed-loop speed control using wheel encoders (leads into PID unit).

- Explore the Adafruit Motor Shield v2 as a higher-level abstraction.

- Research FIRST Robotics drive train options (tank drive, swerve drive, mecanum).

- Investigate brushless DC motors (BLDC) and ESC control as used in drones.

--- END PROMPT ---

• GitHub Study Guide Prompt Template  - 🕸️ GitHub Web Links 

Teaching In The Age Of AI - GitHub Project Template With AI "Rules"

• GitHub Project Template - AI Rules - 🕸️ GitHub Web Links 

Differential Drive Motor Control: PWM, H-Bridges, and Your Rover

AI Assist Disclosure: This document was generated with AI assistance (Claude), reviewed and refined by Jim The STEAM Clown, and validated against STEAM Clown documentation rules. Content accuracy has not yet been fully verified — use with appropriate judgment.

Overview

You have wired an L298N motor driver and made a motor spin. Now it is time to understand exactly why it spins, how to control how fast and in what direction it spins, and how to get two motors working together to steer a rover. This guide connects the circuits on your bench to real engineering concepts used in electric wheelchairs, warehouse robots, and FIRST Robotics drive trains.

By the end of this guide you will be able to write Arduino code that drives your rover forward, backward, and through turns, and you will know how to debug it when something goes wrong.

Key Vocabulary

Term

Definition

Example

• PWM (Pulse Width Modulation)

• A digital signal that switches rapidly between HIGH and LOW to simulate a variable output level

• analogWrite(ENA, 128) sends a 50% duty cycle signal

• Duty Cycle

• The percentage of time a PWM signal is HIGH in one period

• 128 out of 255 = roughly 50% duty cycle

• H-Bridge

• A circuit that can send current through a motor in either direction, allowing forward and reverse

• The L298N chip contains two H-bridges

• Motor Driver

• An IC that uses small logic signals from a microcontroller to switch high-current paths to a motor

• L298N takes 5V logic from the Arduino and switches up to 2A to the motors

• Differential Drive

• A drive system where two independently controlled wheels steer the vehicle by spinning at different speeds

• A robot turns left by slowing the left motor and speeding the right motor

• Speed Ramping

• Gradually increasing or decreasing motor speed instead of jumping immediately to full speed or stop

• Using a for-loop to step speed from 0 to 255 over 500ms

• Inrush Current

• A large spike of current drawn by a motor the instant it starts from rest

• Jumping a motor from 0 to 255 instantly can draw 5 to 10 times normal current

• Enable Pin

• The L298N pin that accepts a PWM signal to control motor speed

• ENA controls Motor A speed; ENB controls Motor B speed

• Input Pins

• The L298N pins that set motor direction (IN1/IN2 for Motor A, IN3/IN4 for Motor B)

• IN1 HIGH and IN2 LOW = Motor A spins forward

• Back-EMF

• Voltage generated by a spinning motor that pushes back against the supply voltage

• Back-EMF is why a motor slows down when it hits a load

Concept Explanations

PWM: The Light Dimmer Analogy

Imagine a light switch you flip on and off very fast, 1000 times per second. If it is on half the time and off half the time, the bulb appears half as bright. If it is on 75% of the time, it appears 75% as bright. Your eye averages out the flicker.

A DC motor works the same way. Its spinning mass averages out the rapid on/off pulses. The longer the signal stays HIGH each cycle, the faster the motor spins. That percentage of on-time is the duty cycle.

On the Arduino, analogWrite(pin, value) controls duty cycle:

analogWrite Value

Duty Cycle

Motor Behavior

0

0%

Motor stopped

64

25%

Slow

128

50%

Medium

192

75%

Fast

255

100%

Full speed

Important: analogWrite does not output a real analog voltage. It outputs a digital pulse train that averages to that voltage level. You can verify this with an oscilloscope.

graph LR

    A["Arduino Pin\n(5V digital)"] -->|PWM Signal| B["L298N Enable Pin"]

    B -->|Switched current| C["DC Motor"]

    C -->|Speed proportional\nto duty cycle| D["Rover Wheel"]

The H-Bridge: Controlling Direction

A plain transistor switch can only turn a motor on or off. An H-bridge uses four switches arranged in an H shape to route current through the motor in either direction.

graph TD

    PWR["12V Supply"]

    GND["Ground"]

    S1["Switch 1"] 

    S2["Switch 2"]

    S3["Switch 3"]

    S4["Switch 4"]

    M["Motor"]

    PWR --> S1

    PWR --> S3

    S1 --> M

    M --> S4

    S3 --> M

    M --> S2

    S2 --> GND

    S4 --> GND

Close S1 and S4: current flows left-to-right through the motor. Forward. Close S3 and S2: current flows right-to-left through the motor. Reverse. Close S1 and S3 at the same time: short circuit. Never do this.

The L298N IC handles all of this internally. You control it with logic signals from the Arduino.

IN1

IN2

Motor A Direction

HIGH

LOW

Forward

LOW

HIGH

Reverse

LOW

LOW

Stop (coast)

HIGH

HIGH

Brake (avoid)

Differential Drive: Steering with Speed

Your rover has no steering wheel. It turns the same way a tank does: by spinning the two drive wheels at different speeds.

Left Motor

Right Motor

Rover Movement

Forward

Forward (same speed)

Straight forward

Reverse

Reverse (same speed)

Straight backward

Forward fast

Forward slow

Gradual left turn

Forward

Stopped

Pivot left

Forward

Reverse

Spin in place left

This is called differential drive because the difference in wheel speeds determines the turn radius. Electric wheelchairs, the Roomba, Amazon Kiva warehouse robots, and most FIRST Robotics tank-drive robots all use this principle.

Speed Ramping: Being Kind to Your Gearbox

When you tell your motor to jump from 0 to 255 instantly, the motor draws a huge inrush current spike and the gearbox experiences a sharp mechanical jolt. Over time this cracks gear teeth and wears out motor brushes.

Speed ramping gradually increases or decreases speed using a loop:

// LEARN: This for-loop steps speed up in small increments.

//        Each step adds 5 to the duty cycle and waits 10ms.

//        The motor accelerates smoothly instead of lurching.

for (int speed = 0; speed <= 255; speed += 5) {

    analogWrite(ENA, speed);

    analogWrite(ENB, speed);

    delay(10);

}

Industry uses speed ramping to protect gearboxes, reduce inrush current, and comply with motor controller specifications. The same principle appears in electric vehicle accelerator curves and industrial servo drives.

Wiring Reference: L298N to Arduino Mega

Connect your L298N motor driver to the Arduino Mega using the following pin assignments. Always double-check polarity before powering on.

L298N Pin    Arduino Mega Pin    Purpose

---------    ----------------    -------

ENA          Pin 2               Motor A speed (PWM)

IN1          Pin 3               Motor A direction control

IN2          Pin 4               Motor A direction control

IN3          Pin 5               Motor B direction control

IN4          Pin 6               Motor B direction control

ENB          Pin 7               Motor B speed (PWM)

GND          GND                 Common ground (REQUIRED)

+12V         External 12V supply Motor power supply

+5V (out)    Optional            Can power Arduino if jumper set

Motor A Out  Left motor          Motor A terminals

Motor B Out  Right motor         Motor B terminals

Critical: The Arduino GND and the L298N GND must be connected together (common ground). Without this, the L298N will not respond to the Arduino's logic signals.

Annotated Arduino Code Example

// =============================================================

// Differential Drive Motor Control

// SVCTE Mechatronics — Robots and Rovers Unit 7

// =============================================================

// LEARN: Defining pin numbers as constants makes the code easier

//        to read and update. If you rewire, change it here once.

const int ENA = 2;   // Motor A (left) speed

const int IN1 = 3;   // Motor A direction

const int IN2 = 4;   // Motor A direction

const int IN3 = 5;   // Motor B direction

const int IN4 = 6;   // Motor B direction

const int ENB = 7;   // Motor B (right) speed

// LEARN: Using a constant for speed lets you tune behavior in

//        one place. 180 out of 255 = about 70% duty cycle.

const int CRUISE_SPEED = 180;

// -------------------------------------------------------

// E-STOP: Call stop() immediately if anything goes wrong.

// This is your emergency brake. Always write it first.

// -------------------------------------------------------

void stop() {

    analogWrite(ENA, 0);

    analogWrite(ENB, 0);

    digitalWrite(IN1, LOW);

    digitalWrite(IN2, LOW);

    digitalWrite(IN3, LOW);

    digitalWrite(IN4, LOW);

}

// -------------------------------------------------------

// Drive forward at a given speed (0-255)

// -------------------------------------------------------

void forward(int speed) {

    // LEARN: IN1 HIGH and IN2 LOW tells the H-bridge to

    //        send current through Motor A in the forward direction.

    digitalWrite(IN1, HIGH);

    digitalWrite(IN2, LOW);

    digitalWrite(IN3, HIGH);

    digitalWrite(IN4, LOW);

    analogWrite(ENA, speed);

    analogWrite(ENB, speed);

}

// -------------------------------------------------------

// Drive in reverse at a given speed (0-255)

// -------------------------------------------------------

void reverse(int speed) {

    digitalWrite(IN1, LOW);

    digitalWrite(IN2, HIGH);

    digitalWrite(IN3, LOW);

    digitalWrite(IN4, HIGH);

    analogWrite(ENA, speed);

    analogWrite(ENB, speed);

}

// -------------------------------------------------------

// Turn left: right motor drives, left motor stops

// -------------------------------------------------------

void turnLeft(int speed) {

    // LEARN: Differential drive turns by slowing or stopping

    //        one side. This pivots around the stopped wheel.

    digitalWrite(IN1, LOW);

    digitalWrite(IN2, LOW);   // Left motor stopped

    digitalWrite(IN3, HIGH);

    digitalWrite(IN4, LOW);   // Right motor forward

    analogWrite(ENA, 0);

    analogWrite(ENB, speed);

}

// -------------------------------------------------------

// Turn right: left motor drives, right motor stops

// -------------------------------------------------------

void turnRight(int speed) {

    digitalWrite(IN1, HIGH);

    digitalWrite(IN2, LOW);   // Left motor forward

    digitalWrite(IN3, LOW);

    digitalWrite(IN4, LOW);   // Right motor stopped

    analogWrite(ENA, speed);

    analogWrite(ENB, 0);

}

// -------------------------------------------------------

// Ramp up to speed smoothly to protect the gearbox

// -------------------------------------------------------

void rampForward(int targetSpeed) {

    // LEARN: Stepping in increments of 5 with a 10ms delay

    //        gives a 0.5 second ramp to full speed.

    //        Increase the delay to ramp more slowly.

    for (int s = 0; s <= targetSpeed; s += 5) {

        digitalWrite(IN1, HIGH);

        digitalWrite(IN2, LOW);

        digitalWrite(IN3, HIGH);

        digitalWrite(IN4, LOW);

        analogWrite(ENA, s);

        analogWrite(ENB, s);

        delay(10);

    }

}

void setup() {

    pinMode(ENA, OUTPUT);

    pinMode(IN1, OUTPUT);

    pinMode(IN2, OUTPUT);

    pinMode(IN3, OUTPUT);

    pinMode(IN4, OUTPUT);

    pinMode(ENB, OUTPUT);

    // LEARN: Always start in a known safe state.

    stop();

    Serial.begin(9600);

    Serial.println("Rover ready.");

}

void loop() {

    rampForward(CRUISE_SPEED);   // Smooth start

    delay(2000);                 // Drive forward 2 seconds

    stop();

    delay(500);

    turnLeft(CRUISE_SPEED);      // Pivot left

    delay(600);

    stop();

    delay(500);

    rampForward(CRUISE_SPEED);   // Forward again

    delay(2000);

    stop();

    delay(5000);                 // Pause before repeating

}

Common Mistakes and How to Fix Them

Symptom

Likely Cause

Fix

Motor does not move at all

Missing common ground between Arduino and L298N

Connect L298N GND to Arduino GND

Motor spins in only one direction

IN pins swapped or wired to wrong Arduino pins

Verify IN1/IN2 wiring against the pin table; test each pin with digitalWrite in isolation

Motor runs but ignores analogWrite speed

ENA or ENB pin not defined as OUTPUT, or jumper still installed on EN pins

Call pinMode(ENA, OUTPUT) in setup; remove the enable jumper if present

Both motors spin but rover drives in a circle

One motor wired in reverse polarity

Swap the two motor terminal wires on the backwards motor

Arduino resets when motors start

Motors pulling too much current through Arduino's 5V

Power L298N from an external supply, not the Arduino's 5V pin

Speed feels the same at 100 and 255

Motor stall torque threshold: below a minimum duty cycle the motor does not overcome friction

Find your motor's minimum effective analogWrite value experimentally (typically 80 to 100)

Check for Understanding

Recall

1. What is duty cycle, and what analogWrite value produces a 50% duty cycle on an Arduino?

2. Fill in the table: what direction does Motor A spin for each combination of IN1 and IN2?

IN1     IN2     Motor A Direction

-----   -----   -----------------

HIGH    LOW     ?

LOW     HIGH    ?

LOW     LOW     ?

Application

3. Your rover needs to turn right with a wider arc (gradual curve, not a sharp pivot). You are currently using turnRight() which stops the right motor completely. How would you modify the code to make the right motor run at 30% speed instead of stopping? Write the two lines you would change.

4. A classmate claims that setting analogWrite(ENA, 255) on an L298N powered by 9V will make the motor run at 9V. A different classmate says it will run faster than at 6V because the duty cycle is higher. Who is right, and why?

Debug This Rover

5. You upload the code below. The rover's right motor spins forward correctly, but the left motor spins in reverse when it should go forward. The wiring looks correct on the breadboard. What is the bug in the code, and how do you fix it?

void forward(int speed) {

    digitalWrite(IN1, LOW);   // Left motor

    digitalWrite(IN2, HIGH);  // Left motor

    digitalWrite(IN3, HIGH);  // Right motor

    digitalWrite(IN4, LOW);   // Right motor

    analogWrite(ENA, speed);

    analogWrite(ENB, speed);

}

Safety Notes

Electrical safety.

• Maximum supply voltage for the L298N in student lab configurations is 12V. Do not exceed this.

• Never connect motor power directly to the Arduino's 5V or VIN pins. Motors draw far more current than the Arduino can supply safely.

• Always establish common ground between the Arduino and the L298N before powering on.

Wiring safety.

• Disconnect power before changing any wiring. Motors draw a high inrush current spike at startup, and live rewiring can damage components or cause burns.

• Double-check polarity on the motor supply before powering on. Reversed polarity can destroy the L298N.

Software safety.

• Always write your stop() function first, before any other motor function. Test it before testing forward or reverse.

• Include a Serial command or physical button that calls stop() so you can halt the rover instantly during testing.

• Never run a rover on a desk or workbench without a tether or a clear perimeter. A rover at full speed will reach the edge of a table in under one second.

Differentiation and Scaffolding

Tier 1: Foundational

Think of PWM like a ceiling fan with a speed dial. The dial does not change the voltage to the fan motor. Instead, it pulses power on and off very rapidly. More on-time means faster spinning. analogWrite(pin, 128) means the signal is HIGH exactly half the time.

Try this minimal example to confirm your motor responds:

const int ENA = 2;

const int IN1 = 3;

const int IN2 = 4;

void setup() {

    pinMode(ENA, OUTPUT);

    pinMode(IN1, OUTPUT);

    pinMode(IN2, OUTPUT);

    digitalWrite(IN1, HIGH);

    digitalWrite(IN2, LOW);

    analogWrite(ENA, 180);   // Forward at 70% speed

}

void loop() {

    // Motor runs continuously — no loop code needed for this test

}

Tier 2: Standard

Use the full code example above. Get all four functions (forward, reverse, turnLeft, turnRight) working reliably before adding speed ramping.

Tier 3: Challenge

Add speed ramping to both the ramp-up and ramp-down phases. Then measure the motor's current draw (with a multimeter in series) at:

• Instant start (no ramp)

• Ramp over 500ms

• Ramp over 1500ms

Record your results and explain the relationship between ramp rate and peak inrush current. Why does this matter for battery life on a mobile robot?

Hands-On Lab Activity: Measure Your PWM Signal

Equipment: Oscilloscope, Arduino Mega, L298N, DC motor, jumper wires.

Procedure:

1. Connect the oscilloscope probe to the ENA pin and ground.

2. Upload a simple sketch that calls analogWrite(ENA, 64) in setup.

3. Measure and record the frequency and duty cycle.

4. Repeat for analogWrite values of 128 and 255.

5. Observe the motor speed at each setting.

Record your results:

analogWrite Value    Measured Duty Cycle    Observed Motor Speed

-----------------    -------------------    --------------------

64                   ?                      ?

128                  ?                      ?

255                  ?                      ?

Connect forward: In the upcoming PID control unit, you will use a wheel encoder to measure actual speed and close the loop between what you command and what the motor actually does. This lab gives you the open-loop baseline.

Real-World Relevance

Electric wheelchairs use differential drive because it allows precise, responsive steering with no mechanical linkage. The joystick sends different speed commands to left and right motors.

Amazon Kiva (now Amazon Robotics) warehouse robots navigate using differential drive and QR codes on the floor. Speed ramping is essential because they carry loads up to 1,000 lbs and cannot lurch to a start.

Autonomous lawn mowers (Husqvarna Automower, Roomba) use differential drive combined with GPS or boundary wire to navigate yard obstacles.

FIRST Robotics tank drive trains use the same H-bridge and differential drive principles you are learning now. Teams tune speed ramping constants to prevent brownouts during match play, where six motors starting simultaneously can overwhelm the robot's battery.

Extension Pathways

• Closed-loop speed control with encoders. Add wheel encoders to your rover and implement a simple proportional controller that maintains a target speed regardless of load. This leads directly into the PID unit.

• Adafruit Motor Shield v2. Explore this library-based abstraction that hides the H-bridge details and adds I2C control. Compare the tradeoffs versus direct L298N control.

• FIRST Robotics drive train research. Compare tank drive, swerve drive, and mecanum drive. Explain the tradeoffs in terms of mechanical complexity, software complexity, and maneuverability.

• Brushless DC motors and ESCs. Research how ESCs (Electronic Speed Controllers) replace the H-bridge in drone and RC car applications. Why can an ESC handle much higher currents than an L298N?

Sources

• L298N Motor Driver Datasheet, STMicroelectronics

• Arduino analogWrite() Reference

• STEAM Clown AI Documentation Rules

• Adafruit Motor Shield v2 Documentation

• FIRST Robotics Drive Train Overview

Teaching In The Age Of AI - GitHub Project Template With AI "Rules"

This Lesson is coming soon - click here to be notified when it's available - Professional Development Newsletter

• GitHub Project Template - AI Rules - 🕸️ Web Links :octocat: 📖 Lesson Tutorial

• Mechatronics - <topic> - 📽️ Video / Podcast

• Mechatronics - <topic> - 📰 Slide Presentation (Coming Soon)

  • Mechatronics - <topic> - LAB #1 - 🛠️ LAB Activity

  • Mechatronics - <topic> - LAB #2 - 🛠️ LAB Activity

  • Mechatronics - <topic> - LAB #3 - 🛠️ LAB Activity

Teaching In The Age Of AI - GitHub Project Template With AI "Rules"

This Lesson is coming soon - click here to be notified when it's available - Professional Development Newsletter

• GitHub Project Template - AI Rules - 🕸️ Web Links :octocat: 📖 Lesson Tutorial

• Mechatronics - <topic> - 📽️ Video / Podcast

• Mechatronics - <topic> - 📰 Slide Presentation (Coming Soon)

  • Mechatronics - <topic> - LAB #1 - 🛠️ LAB Activity

  • Mechatronics - <topic> - LAB #2 - 🛠️ LAB Activity

  • Mechatronics - <topic> - LAB #3 - 🛠️ LAB Activity