Lesson Plan: Autonomous Vehicles: Examining the Technology

Subjects:

Physics, Computer Science

• This lesson fits within a unit on engineering design, artificial intelligence or autonomous systems. Students will explore how sensors, technology and algorithm design enable self-driving cars to navigate real-world challenges.

Grade Level:

9-12

Lesson Duration:

• Two 55 minute class period
  • Day 1: Steps 1-6
  • Day 2: Steps 7-9

Essential Questions:

• What are the roles and limitations of different sensors in autonomous vehicle navigation?
• How do environmental and human factors challenge the design of self-driving car algorithms?
• In what ways do ethical considerations influence the programming of autonomous vehicles?
• How can algorithms be designed to safely navigate complex traffic scenarios like a four-way stop?

Lesson Objectives:

Students will:

• Identify and describe the key hardware components and sensors used in autonomous vehicles, including LiDAR, radar and cameras.
• Explain the main challenges and limitations that affect autonomous vehicle algorithms, such as unpredictable human behavior and adverse weather conditions.
• Analyze the advantages and limitations of current autonomous vehicle technology.
• Design a basic flowchart or write pseudo code for navigating a four-way stop intersection.

Materials:

• Retro Report video “Can We Teach Cars to Drive?” (Transcript}
• Student Activity handout

Procedure:

1. Begin by distributing the Student Activity handout and have students list some driver assistance features in modern cars.
   1. Explain the difference between driver assistance technology which supports the driver, but the driver maintains control versus autonomous vehicle technology, which enables the car to perceive its environment, make decisions, and navigate without human involvement. (Reference:  National Highway Traffic Safety Administration )
2. Have students watch the Retro Report video “Can We Teach Cars to Drive?” and answer the guiding questions while watching the video.
3. Divide the class into three groups: LiDAR, Radar, and Cameras. Each group should prepare notes to share with the class after they research their assigned sensor focusing on: How it works (basic principles), Key strengths and weaknesses, Typical range/coverage, real-world examples, why autonomous vehicles need this sensor. Help direct student groups as necessary. Suggested sources:
   1. An overview of sensors in Autonomous Vehicles | Science Direct
   2. Perception Technologies for Autonomous Transportation: A Comparative Analysis of LiDAR, Radar, Camera, and Sonar | U.S. Department of Transportation, Bureau of Transportation and Statistics
   3. Autonomous Vehicles Factsheet | University of Michigan Center for Sustainable Systems
4. Have each group present their findings to the class. Students should take notes on the other groups’ sensors to build a complete understanding.
5. As a whole class, review why autonomous vehicles use all three sensors instead of relying on just one. Ask:
   1. Based on what we learned, why do you think autonomous vehicles use all three sensors instead of just one? (Expected responses could include: combining all three gives more reliable data, if one fails the others can still detect obstacles, each sensor captures different types of information.)
   2. Which sensor would be most important in a snowstorm? Why? (Expected responses could include: Radar is better for poor visibility. Lidar can struggle with snowflakes because they reflect the laser. Radar is more reliable for distance and speed in low visibility.)
   3. Which sensor would be best for reading a stop sign? Why? (Expected responses could include: The camera because it reads color, shape and text. Lidar can locate the sign in 3D space, but the camera identifies it as a stop sign. A high-resolution camera with good image processing is used for sign recognition in daylight.)
6. Explain the requirements for navigating a four-way stop: 1) Come to a complete stop, 2) Determine right-of-way based upon arrival order, 3) Proceed safely in turn. Then, have students work individually or in pairs to create the pseudocode (using programming language of choice) or a flowchart representing their algorithm. Algorithm means the steps to solve the problem. Students would essentially write the code by hand that would then be used by a computer to solve the problem. A flowchart would just be a visual of how the algorithm would be formatted (like a rough draft).  Sample flowchart can be found in the lesson plan google doc accompanying this lesson.

1. 1. Once students complete their algorithm, have them adapt their algorithm based on a real world scenario (such as: a child on a bike darts out in front of them). How might they need to change the algorithm?
   2. Have students exchange their algorithm with a group and offer feedback on their design.

7. Place students into groups and assign each group one of the five ethical scenarios. Students should complete the following:

1. 1. Proposed Solution: What choice would you make?
   2. Reasoning: What moral principles guide your choice? (e.g., minimize harm, protect the innocent, respect autonomy)
   3. Why does it serve society’s interests? How does this choice balance competing values and benefit society overall?

8. Facilitate small group or whole-class shareout to compare perspectives.

1. 1. Whose interests did your solution prioritize (e.g., the driver, the pedestrian, or the company)?
   2. If your programmed choice became the standard for all self-driving cars, what might be one safety concern that critics could raise?
   3. How would your group address that concern?

Extension Activity:

1. Have students design and simulate a decision-making algorithm for autonomous vehicles in a complex real-world scenario beyond the four-way stop (like navigating a busy pedestrian crosswalk, merging onto a highway or reacting to sudden obstacles like animals or road debris).

About the Author:

Brande Johnson is a middle and high school English, Social Studies and AP Computer Science teacher in Nevada. She has a Master’s in Educational Leadership as well as a Master’s of Education in Instructional Design and Technology.

Standards

Next Generation Science Standards

• HS-ETS1-1 Engineering Design: Analyze a major global challenge to specify qualitative and quantitative criteria and constraints for solutions that account for societal needs and wants.
• HS-ETS1-2 Engineering Design: Design a solution to a complex real-world problem by breaking it down into smaller, more manageable problems that can be solved through engineering.

• HS-ETS1-3 Engineering Design: Evaluate a solution to a complex real-world problem based on prioritized criteria and trade-offs that account for a range of constraints, including cost, safety, reliability and aesthetics, as well as possible social, cultural and environmental impacts.
• HS-ETS1-4 Engineering Design: Use a computer simulation to model the impact of proposed solutions to a complex real-world problem with numerous criteria and constraints on interactions within and between systems relevant to the problem.

Computer Science Teachers Association Standards

• 1B-AP-15: Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended.
• 1B-AP-09: Create programs that use variables to store and modify data.
• 2-AP-13: Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
• 2-AP-17: Systematically test and refine programs using a range of test cases.
• 3A-AP-22: Design and develop computational artifacts working in team roles using collaborative tools and version control.
• 3B-AP-17: Systematically test and refine programs using a range of test cases.
• 4-AP-14: Design and develop computational artifacts working in team roles using collaborative tools and version control.
• 3A-AP-17: Decompose problems into smaller components through systematic analysis, using constructs such as procedures, modules, and/or objects.
• 3B-AP-20: Use version control systems, integrated development environments (IDEs), and collaborative tools and practices (code documentation) in a group software project.
• 3A-IC-24: Evaluate the social and economic implications of tradeoffs in the design of computing innovations.
• 3A-CS-01: Explain how abstractions hide the underlying implementation details of computing systems embedded in everyday objects.