Raspberry Pi Pico Lesson Plan: 6 Weeks of MicroPython in Class

If you are looking for a Raspberry Pi Pico lesson plan, here is the short answer: 6 weeks, one 40-minute lesson a week, pairs of students and a single new MicroPython concept each week. In week 1 students light the onboard LED with one line in Thonny's REPL; then come variables and timing, functions, buttons and conditions, sound and a distance sensor with PWM, and in the last week a five-button piano built with a list and a for loop. Every week's project is free in BlueGrays with its circuit diagram, parts list and code, so students don't need Premium. The plan uses the Raspberry Pi Pico or Pico W with Thonny and is written for middle and high school students who have never written code before.

First we look at why the Pico and MicroPython work so well in a classroom, then at preparing before the first lesson: the MicroPython UF2 file, the BOOTSEL button, choosing the interpreter in Thonny and what to watch out for on school computers. After that you get the week-by-week plan with the Arduino C++ equivalent of every concept, a materials list for a class of 24, a minute-by-minute sample lesson, three short code examples, an assessment table and fixes for the problems that come up most in class. We covered the 8-week version of this approach with Arduino and blocks in the block coding lesson plan; this plan doesn't repeat it and is meant for classes that want to start straight with text-based code or move on to Python after blocks.

Why the Raspberry Pi Pico and MicroPython?

The Pico is a small microcontroller board built by Raspberry Pi around its own RP2040 chip. It isn't a computer; like an Arduino, it runs a single program over and over. It has three strengths in a classroom. The first is MicroPython, a slimmed-down version of Python for microcontrollers. It is easy to read and has no semicolons or curly braces, so students who have met Python in computing class use the same language to control an LED or a buzzer. The second is that there is no compiling: the moment you press Run in Thonny, the code runs on the board, and you don't wait for a compile and upload after every small change. In a 40-minute lesson that means far more attempts in the same time. The third is the REPL: type a single line into Thonny's Shell, press Enter, and the board carries it out right away. When a student types led.on() and the LED lights up, they understand within five minutes that programming means giving the board commands. The low price and the fact that the board plugs straight into a breadboard also make pairs realistic. When is the Arduino the easier choice? With younger students who have only just learned to read, or if most of your kit is 5 V modules, starting with the Arduino and blocks brings fewer surprises. For the board's specifications and pinout, see what the Raspberry Pi Pico is.

Before the first lesson: MicroPython and Thonny

1. Know your board: the Pico, Pico W, Pico 2 and Pico 2 W each need a different MicroPython file. Check the printing on the board and download the latest .uf2 file for exactly that board from the official MicroPython download page. With the wrong file the board won't start or Wi-Fi won't work.
2. Plug in while holding BOOTSEL: hold down the white BOOTSEL button next to the USB port while you plug the cable into the computer, then let go. A drive called RPI-RP2 appears on the computer (on the Pico 2 it is called RP2350).
3. Copy the UF2 file: drag the .uf2 file onto that drive. The board restarts within a few seconds and the drive disappears; that isn't an error, it means MicroPython is installed. MicroPython stays on the board, so you don't reinstall it every lesson.
4. Choose the interpreter in Thonny: in Tools > Options > Interpreter, select "MicroPython (Raspberry Pi Pico)" and leave the port on automatic detection. You can make the same choice by clicking the bottom-right corner of the Thonny window.
5. Test the connection: you should see the >>> prompt in the Shell at the bottom. Type print("hello") and press Enter; if you get a reply, the board is ready for class.

Don't leave the setup on school computers for the lesson itself; talk to your IT team a week in advance. Thonny runs on Windows, macOS and Linux and comes with its own Python, so there is no separate Python to install. There is also a portable version for Windows that needs no installation at all, which makes life much easier in locked-down labs where only IT can install software. Windows 10 and 11 recognise the Pico as a serial port (COM) without any extra driver. Some schools block USB drives; then the RPI-RP2 drive may not show up on student computers, but if you installed MicroPython on the boards beforehand on your own computer, it doesn't matter, because the lesson only uses the serial connection. Finally, show students the two options in Thonny's save dialog: "This computer" saves the file to the computer, "Raspberry Pi Pico" saves it to the board. Pairs who don't know which one they picked won't find their code in week 6.

The 6-week Raspberry Pi Pico lesson plan

Each lesson is planned for 40 minutes with pairs. Every project in the table is free in BlueGrays, and the projects of the first three weeks also have a block view next to the code. The order is deliberate: output (LED) first, then variables and timing, functions, then input and conditions, sound and a sensor with PWM, and finally lists and loops. Each week adds a single new idea on top of the previous one. The last column shows the same concept in Arduino C++, which builds a bridge for students who will move on to the Arduino later; for the C++ side in detail, see Arduino programming basics.

As you run the plan, make it a rule that students change a single value at the end of every week. In week 1, the onboard LED project calls the LED by the name "LED", so it works the same on the Pico and the Pico W; the external LED goes to GP14, which is physical pin 19, and pin 18 right next to it is GND. In week 2, dropping WAIT_MS in the Police Strobe Light Effect from 300 to 80 shows that one variable changes the rhythm of both LEDs at once. In week 3, the Traffic Light calls all_off() three times in the loop; ask students to delete the function and write the same thing by hand, and once they see nine lines pile up they'll tell you themselves why functions exist. Week 4 is an intermediate project: the button is wired with PULL_UP, so it reads 0 when pressed, and each press cycles the mode through normal, red only, flashing yellow and off. The code is long, so read it first with the steps in the Understand the code tab. In week 5, the HC-SR04 runs on 5 V, so don't forget to connect ECHO through the divider; playing with the GREEN_CM 100, YELLOW_CM 50, RED_CM 25 and STOP_CM 10 values gives students the idea of a threshold. You'll find how the sensor works in the HC-SR04 distance sensor post and how to make sound with PWM in what a buzzer is; use a passive buzzer, because the project changes the frequency. In week 6, the piano plays five notes from DO to SOL between 523 and 784 Hz, and holding the DO key for one second starts recording a melody. The full code is long for this level; instead of asking students to type it all, ask them to change the frequencies in the NOTE_HZ list and build their own scale.

Exit questions for every week

• Week 1: What happens if you swap the led.on() and time.sleep(0.5) lines? Why do the lines under while True: start further in?
• Week 2: How does the strobe change when you raise WAIT_MS from 300 to 1000? Which two lines does toggle() replace on its own?
• Week 3: How many more lines would you write without the all_off() function? What is the difference between defining a function and calling it?
• Week 4: Why does button.value() return 0 when you press a button that uses PULL_UP? If mode is 3 and you press the button, what is mode now?
• Week 5: Why don't we connect the HC-SR04's ECHO pin directly to the Pico? What does the duty_u16(0) line make the buzzer do?
• Week 6: Which lists in the code do you need to change to add a sixth key to the piano?

Materials list for a class of 24

Split 24 students into pairs and you get 12 groups; with one spare, prepare 13 sets. Because the Pico is cheap, pairs instead of groups of three are possible in most schools and every student gets more time at the keyboard; if you go with groups of three, cut the numbers down to 9 sets. Every group needs a computer, because Thonny talks to the Pico over USB. A phone or tablet is used to keep the week's project, its circuit diagram and the Understand the code tab open in BlueGrays. Nothing needs soldering; everything plugs into the breadboard.

Sample lesson: week 1, the first program

The plan below is for week 1. The first lesson is the riskiest one, because this is where setup problems show up. We assume you installed MicroPython on the boards beforehand and that Thonny is installed on the computers. You can use the same skeleton in the other weeks: warm-up, reading together, prediction, circuit, running the code, changing one value and an exit question. If you have an 80-minute double lesson, stretch the "change one value" stage and let the pairs present their exit answers.

Three short MicroPython examples for class

The onboard LED causes the most confusion between the Pico and the Pico W. On the classic Pico the LED is wired to GP25, which is why older examples use Pin(25). On the Pico W the LED is wired to the Wi-Fi chip and has no numbered GP pin, so Pin(25) won't light it there. The way that works on both is to call the LED by name: Pin("LED"). Current MicroPython releases define this name for the Pico, the Pico W and the Pico 2, which is why the onboard LED project in BlueGrays uses it. If your class has a mix of boards, you can hand out the same code to everyone. If an old firmware doesn't know the name "LED", the fix is to update the UF2 file.

1from machine import Pin
2import time
3
4# "LED" adı Pico, Pico W ve Pico 2'de karttaki LED'i bulur / The name "LED" finds the onboard LED on Pico, Pico W and Pico 2
5led = Pin("LED", Pin.OUT)
6# Eski firmware'li klasik Pico'da: Pin(25, Pin.OUT) / Classic Pico with old firmware: Pin(25, Pin.OUT)
7# Pico W'de Pin(25) LED'i yakmaz / On the Pico W, Pin(25) does not light the LED
8
9while True:
10    led.toggle()       # Durumu tersine çevir / Flip the state
11    time.sleep(0.5)    # 0,5 saniye bekle / Wait 0.5 seconds
12

The external LED code uses the same skeleton; only the pin number changes. Here we moved the wait time into a variable called WAIT, which becomes the first line students change in week 2. The count variable and the print() line write a number to Thonny's Shell every time the LED lights, so students can see on screen that the loop really is running. The 14 in the code is a GP number, not a physical pin number; that's the point students mix up most often.

1from machine import Pin
2import time
3
4LED_PIN = 14          # LED'in bağlı olduğu GP pini (fiziksel pin 19) / GP pin the LED is wired to (physical pin 19)
5WAIT = 0.5            # Bekleme süresi, saniye / Wait time in seconds
6
7led = Pin(LED_PIN, Pin.OUT)   # Pini çıkış yap / Make the pin an output
8count = 0                     # Kaç kez yandığını say / Count how many times it lit
9
10while True:
11    led.on()                  # LED'i yak / Turn the LED on
12    count = count + 1
13    print("LED", count)       # Thonny Shell'e yaz / Print to the Thonny Shell
14    time.sleep(WAIT)
15    led.off()                 # LED'i söndür / Turn the LED off
16    time.sleep(WAIT)
17

There are two ways to wire a button, and both are worth showing. With PULL_UP, one leg of the button goes to GP15 and the opposite leg to GND; a resistor inside the Pico pulls the pin up to 3.3 V, pressing the button connects the pin to GND and it reads 0. All the Pico button projects in BlueGrays use this approach because it needs no extra wire. With PULL_DOWN, the opposite leg goes to the 3V3(OUT) pin (pin 36) and the button reads 1 when pressed; the logic feels more natural, but it's easy to plug the wire into VBUS (pin 40, 5 V) by mistake. We explained which of the button's four legs are connected in the button wiring post. You can start week 4 with the short code below and then move on to the mode selector.

1from machine import Pin
2import time
3
4led = Pin(14, Pin.OUT)                  # GP14 -> 220 ohm -> LED -> GND / GP14 -> 220 ohm -> LED -> GND
5button = Pin(15, Pin.IN, Pin.PULL_UP)   # Buton GP15 ile GND arasında / Button between GP15 and GND
6# PULL_DOWN: Pin(15, Pin.IN, Pin.PULL_DOWN), buton GP15 ile 3V3(OUT) arasında / button between GP15 and 3V3(OUT)
7# PULL_DOWN ile koşul == 1 olur / With PULL_DOWN the condition becomes == 1
8
9while True:
10    if button.value() == 0:             # PULL_UP: basınca 0 okunur / PULL_UP: reads 0 when pressed
11        led.on()
12    else:
13        led.off()
14    time.sleep_ms(10)                   # Döngüyü biraz yavaşlat / Slow the loop down a little
15

How to use BlueGrays in a Pico lesson

• Code guide, MicroPython track: the Code guide in the Learn section offers an 18-card MicroPython track next to the Arduino C++ track: import, print, pin output, pin input (PULL_UP, PULL_DOWN), time.sleep, while True, indentation, variables, if / elif / else, for and range, lists, def and return, ADC, PWM, ticks_ms, Pin.irq, try / except and I2C. Each card has What does it do?, Syntax, an example with Blocks · Arduino · MicroPython tabs, Common mistake and a mini test. Suggest the cards for the week's concept for students to read between lessons; each student sees their own MicroPython x/18 progress on the My level screen.
• See it in projects: this link at the end of every card lists the projects whose code uses the command, from easy to hard. A student who has read about a command on a card goes from here to finding it in the code of a real project.
• Daily questions: the "Code language in questions" setting offers Both, Arduino and MicroPython. If you teach with the Pico, have students choose MicroPython; general questions without code come with every choice. There is a set of about 3 minutes every day, a 15-question placement test and 6 levels from A1 to C2, which makes a good daily review habit between lessons.
• Show as blocks: five of the free Pico projects (Onboard LED, External LED, Alternating Two LEDs, Traffic Light and Police Strobe) have a block view next to the code. Showing a student who sees Python for the first time the blocks first and then the code of the same program builds the idea "same logic, different spelling"; we covered this step in detail in moving from blocks to MicroPython. The blocks are for reading; they can't be edited in the app, and the MicroPython code is always what goes onto the board.
• Understand the code and Troubleshooting: every free Pico project has both. The Understand the code tab starts with a What does this code do? summary, continues with a Step by step walkthrough and ends with If you get stuck and a Try it yourself task. With the long code in weeks 4 and 6, it is your biggest helper for pairs who can't read quickly yet.
• Let's build it together and Copy Link: the guided mode goes through four steps and, at the code step, reminds students to choose the MicroPython interpreter in Thonny. Copy Link in the source code section gives a link for opening the code on a computer, so students don't have to retype the code from the phone into Thonny.

Assessment and differentiation

• Fast groups, analog reading: the plan has no ADC week; pairs who finish early connect the middle leg of a 10 kΩ potentiometer to GP26, read a value from 0 to 65535 with ADC(26).read_u16() and use it to set the speed of the week 2 strobe. For a bigger challenge, the free Raspberry Pi Pico LED Campfire (8x8 NeoPixel Matrix + Potentiometer + Buzzer) project drives an 8x8 NeoPixel matrix with the same potentiometer.
• Fast groups, combining: adding the week 4 button to the week 5 parking sensor to write a "silent mode" that switches the sound on and off is the first real step towards writing their own code.
• Slower groups: hand out the circuit ready-built, or put a large printed copy of the circuit diagram on the desk. Let them go step by step with the Understand the code tab and aim to change just one value that day; that is a worthwhile result on its own.

Common problems and quick fixes

Pre-lesson checklist

• MicroPython is installed on every board, and boards and cables are numbered 1 to 13.
• Thonny opens on every computer with "MicroPython (Raspberry Pi Pico)" selected as the interpreter.
• Every board and cable pair has been tested and shows >>> in the Shell.
• Resistors are in separate boxes by value: 220 Ω, 1 kΩ, 2 kΩ.
• The week's project is open in BlueGrays on the projector; Show as blocks is ready for the first three weeks.
• Exit question slips are printed and the roles (builder, checker) have been given to the pairs.
• Before week 5, the HC-SR04 divider resistors have been set aside for every group.
• At the end of the lesson, USB cables are unplugged and parts are counted back into the numbered boxes.

You can open every project you'll use over these six weeks in the BlueGrays app for free, with the circuit diagram, parts list, MicroPython code and the Understand the code tab, which makes it easy to run the lesson from the projector while students follow along on their own phones. If after six weeks you want to move on to Premium Pico projects with PWM LED brightness, servos, an OLED screen or a keypad, you can hand out educator codes instead of individual subscriptions; they are a one-time purchase and don't renew automatically.