Block Coding to MicroPython: Sensors and Raspberry Pi Pico

Going from block coding to MicroPython is easiest once you can read a sensor with blocks. Reading a sensor with blocks means getting a value without typing code: the "analog read A0" block grabs the light level from an LDR, and the "serial print" block sends that number to the Serial Monitor on your computer. In this article you'll first read sensors with blocks on Arduino using the LDR and HC-SR04 projects, comparing each block with its analogRead(), Serial.begin(), Serial.println() and pulseIn() line. Then you'll take the step from blocks to MicroPython on the Raspberry Pi Pico and see what changes when the same blocks become Python code.

So far every program in the series made something happen in the outside world: we lit LEDs, checked a button and built a counter with a loop. Reading a sensor works the other way round: the board measures the world and you get to see the number. That's why the serial port joins in here, since the easiest way to understand what a sensor measures is to watch its value on your screen. In the second half, the Raspberry Pi Pico block coding projects map to MicroPython instead of C++. Every project used here is free in BlueGrays, and the code quoted below is exactly the project code.

What reading a sensor means: digital and analog inputs

A button only reports two states: pressed or not. You read it with the digital pin read block (digitalRead) and the result is 0 or 1. Parts such as an LDR, a potentiometer or a soil moisture sensor give you every value in between: the voltage on the pin changes smoothly between 0 and 5 V. The circuit that turns this voltage into a number is the ADC (analog-to-digital converter). The Arduino Uno's ADC is 10-bit, so it splits the voltage into 1024 steps and returns a number from 0 to 1023; each step is about 4.9 mV. The ESP32 and the Pico have 12-bit ADCs that run at 3.3 V. This difference between boards is one of the most common sources of confusion when moving from blocks to code; you'll find the details in the ADC and analog-to-digital conversion article.

Reading an LDR with blocks on Arduino

Our first example is the Measuring Light Intensity with an LDR project. An LDR is a resistor whose resistance drops as the light gets brighter; on its own it doesn't produce a voltage. To measure it, we put it in series with a fixed 10 kΩ resistor to build a voltage divider and connect the midpoint to A0. With the wiring below, the LDR sits on the 5V side, so more light means a higher voltage on A0 and a bigger reading; swap the LDR and the resistor and the direction flips. You can work out the divider output for different LDR values with the voltage divider calculator, and see how many ohms an LDR has in the dark and in bright light in the LDR light sensor article. We'll use the Pico column of the table in the MicroPython example near the end.

Read the blocks from top to bottom. The "declare integer (int) value = 0" block inside global variables (at the top) is the int value; line at the top of the code. The setup (runs once) section holds a single block, "start serial at 9600 baud", which is Serial.begin(9600);. Inside loop forever, "set value to analog read A0" comes first; that's the value = analogRead(A0); line. Then there are two "serial print" blocks. The first prints the text "Value:" with the no line break option and becomes Serial.print(); the second prints value with the new line option and becomes Serial.println(). That way each measurement shows up as a single line such as "Value: 512". The last block, "wait 500 ms", is delay(500);, so you get two readings per second. To turn the reading into a voltage, use value × 5.0 / 1023: 512 is roughly 2.5 V. In a dark room the value drops to a few hundred, and with a flashlight on the LDR it climbs above 900; the exact numbers depend on your LDR and the room.

1int value;   // Işık değeri / Light reading (0-1023)
2
3void setup() {
4  Serial.begin(9600);   // Seri port 9600 baud / Serial at 9600 baud
5}
6
7void loop() {
8  value = analogRead(A0);   // LDR gerilimini oku / Read the LDR voltage
9  Serial.print("Value: ");
10  Serial.println(value);
11  delay(500);               // 0,5 sn bekle / Wait 0.5 s
12}

Opening the Serial Monitor and watching the values

1. Paste the code into the Arduino IDE, select your board and port, then click Upload.
2. When the upload finishes, click the magnifier icon at the top right or open Tools > Serial Monitor (shortcut Ctrl+Shift+M).
3. Set the Serial Monitor's baud rate box to the value in the code: 9600 baud for this project.
4. A "Value: …" line scrolls by every half second. Cover the LDR with your hand and watch the number drop.
5. To see the change as a graph, open Tools > Serial Plotter; the same data is drawn as a timeline.
6. Line ending settings and sending data from the Serial Monitor to the board are covered in detail in the Arduino Serial Monitor article.

Distance with the HC-SR04: the µs wait and pulse length blocks

The second sensor project is HC-SR04 Distance Measurement (Serial Display). It adds two new blocks. The trio that starts with "write HIGH to pin trigPin" tells the sensor to send a burst of sound: the "wait 10 µs" block in the middle is delayMicroseconds(10);, a wait a thousand times shorter than "wait … ms". Next comes "set duration to HIGH pulse length on pin echoPin (µs)", which is the unsigned long duration = pulseIn(echoPin, HIGH); line and measures how many microseconds the Echo pin stays HIGH. Sound travels through air at about 0.034 cm/µs, and that time covers the round trip. So "set totalPath to duration × 0.034" calculates the whole path and "set distance to totalPath ÷ 2" the one-way distance. A 1000 µs pulse, for example, means a 34 cm path, so the object is 17 cm away; since distance is an int, the decimals are dropped. Finally, the block "if distance > minDistance and distance < maxDistance" becomes if (distance > minDistance && distance < maxDistance) and only prints readings between 3 and 100 cm. If the sensor gets no echo, pulseIn() returns 0, and this check keeps those bogus zeros off the screen as well. In the code the pins are trigPin = 7 and echoPin = 6. For the sensor's range and accuracy, see the HC-SR04 distance sensor article.

Same idea on the ESP32: a 12-bit ADC

The ESP32 version of the same LDR logic is the Reading Light Intensity with the ESP32 LDR Module project. The blocks still map to C++ and read just like on Arduino, with three differences. First, setup() locks the ADC to 12 bits with analogReadResolution(12), so analogRead() returns 0–4095 instead of 0–1023, and a threshold written for Arduino such as "dark below 500" doesn't mean the same thing on the ESP32. Second, the serial port runs at 115200 baud instead of 9600, so set the Serial Monitor to 115200 as well. Third, on the LDR module's AO output the voltage and the raw value drop as the light gets brighter. That's why the code uses the calibration values RAW_DARK = 4000 and RAW_LIGHT = 100, keeps the reading in that range with constrain() and turns it into 0% for dark and 100% for bright with map(). On a classic ESP32 DevKit the LDR goes to GPIO 34, an input-only pin on ADC1. Since ADC2 pins can't be read while Wi-Fi is on, wiring analog sensors to ADC1 pins is a good habit. For the board's general features, see What is the ESP32.

From blocks to MicroPython on the Raspberry Pi Pico

In Pico projects the blocks map to MicroPython instead of C++. The blocks look familiar, but the language underneath is different: no curly braces or semicolons, code blocks are marked by indentation, and there are no setup() or loop() functions. Let's make the switch with the simplest project, Raspberry Pi Pico: Controlling an External LED (GP14 + Breadboard). The circuit is tiny: GP14 (physical pin 19) goes through a 220–330 Ω resistor to the LED's long leg, and the LED's short leg goes to GND (for example physical pin 18). The program turns the LED on for half a second, off for half a second, and prints a line to Thonny's Shell at each step. If the Pico is new to you, start with What is the Raspberry Pi Pico.

1from machine import Pin
2import time
3
4# ============ PIN / PIN ============
5LED_PIN = 14                    # Boştaki herhangi bir GPIO / Any free GPIO
6led = Pin(LED_PIN, Pin.OUT)
7
8print("== BlueGrays: Pico Harici LED Blink ==")
9print("LED pin: GP" + str(LED_PIN))
10print("500ms yakip 500ms sonduruyor / 500ms on 500ms off")
11
12# ============ ANA DÖNGÜ / MAIN LOOP ============
13while True:
14    led.on()                    # LED'i yak / Turn the LED on
15    print("[LED] ACIK / ON")
16    time.sleep(0.5)
17
18    led.off()                   # LED'i söndür / Turn the LED off
19    print("[LED] KAPALI / OFF")
20    time.sleep(0.5)

Four things stand out in that table. First, the from machine import Pin and import time lines have no block; in Python you import the modules you need at the top, and the blocks assume that for you. Second, Arduino's "start serial at 9600 baud" block has no counterpart here: on the Pico, print() output goes straight over USB to Thonny's Shell, with no baud rate to set. Third, the unit of waiting has changed: on Arduino "wait 500 ms" is delay(500), while on the Pico "wait 0.5 seconds" is time.sleep(0.5). Fourth, and most important, indentation: every block that sits inside the "loop forever" block is written four spaces in under the while True: line. Delete a line's indentation and that line falls out of the loop; in Python, spaces do the job that curly braces do in C++. You'll find the other core rules of MicroPython in the MicroPython basics article.

The same operations in three languages: blocks, C++ and MicroPython

Your own example: reading an LDR on the Pico with MicroPython

Now let's move the Arduino LDR project to the Pico. The wiring follows the Pico column of the table above: one LDR leg to the 3V3(OUT) pin, the other leg to both GP26 and one end of the 10 kΩ resistor, and the other end of the resistor to GND. The Pico has three pins that can read analog values: GP26 (ADC0), GP27 (ADC1) and GP28 (ADC2). In MicroPython you create an ADC(26) object and call read_u16(); although the Pico's ADC is 12-bit in hardware, this function scales the result to 0–65535. To get the voltage, multiply the value by 3.3 and divide by 65535. The program follows the same flow as the Arduino version: measure, print, wait half a second. On top of that we added a threshold: when the room gets dark, the onboard LED turns on. Thinking in blocks, the lines before while True are the "setup (runs once)" section, while True: is "loop forever", the if/else is the if block from part 3 of the series, led.on() is "turn on (on) pin led", time.sleep(0.5) is "wait 0.5 seconds", and the + str() inside print() is the "create text with" block. The ADC(26).read_u16() line does the job of Arduino's "analog read A0" block. Tune THRESHOLD to the numbers you see in the Shell in your own room.

1from machine import Pin, ADC
2import time
3
4# ============ PIN / PIN ============
5ldr = ADC(26)                   # GP26 = ADC0, bölücünün orta noktası / divider midpoint
6led = Pin(25, Pin.OUT)          # Dahili LED; Pico W'de Pin("LED") / Onboard LED; Pico W: Pin("LED")
7THRESHOLD = 20000               # Karanlık eşiği, odana göre ayarla / Darkness threshold, tune for your room
8
9print("== BlueGrays: Pico LDR ==")
10
11# ============ ANA DÖNGÜ / MAIN LOOP ============
12while True:
13    value = ldr.read_u16()                      # 0-65535
14    voltage = value * 3.3 / 65535               # Volt / Volts
15    print("Value: " + str(value) + "  Voltage: " + str(round(voltage, 2)) + " V")
16
17    if value < THRESHOLD:                       # Az ışık = küçük değer / Little light = small value
18        led.on()
19    else:
20        led.off()
21
22    time.sleep(0.5)                             # 0,5 sn = 500 ms / 0.5 s = 500 ms

Uploading to the Pico with Thonny and main.py

1. Install Thonny on your computer. If the Pico doesn't have MicroPython yet, hold the BOOTSEL button while plugging in the USB cable; Thonny offers to install MicroPython on the first connection.
2. In Thonny's bottom right corner, choose MicroPython (Raspberry Pi Pico) as the interpreter. If you see the >>> prompt in the Shell at the bottom, you're connected.
3. Copy the project code from BlueGrays and paste it into Thonny's editor.
4. Click the green Run button or press F5. The code runs on the Pico and the print() output appears in the Shell. Use the Stop button (Ctrl+F2) to stop it.
5. If you want the code to run without a computer, choose File > Save as, pick Raspberry Pi Pico in the dialog and name the file main.py. The Pico runs this file automatically every time it gets power, so a USB charger or a power bank is all you need.
6. If Thonny doesn't see the board, check the cable and drivers in the order given in the Raspberry Pi Pico not recognized article.

More free Pico block projects

• Raspberry Pi Pico Onboard LED Blink (GP25): no wiring at all; it blinks the LED on the board with LED_PIN = 25. The code is almost identical to the project above, so open the two side by side and you'll see that only the pin number changes. On the Pico W the onboard LED is wired to the Wi-Fi chip, so you use Pin("LED").
• Raspberry Pi Pico Alternating Two LEDs (GP14 + GP13): it starts from opposite states with led1.value(1) and led2.value(0), then calls toggle() on both LEDs in the loop. Because the code says from time import sleep, the wait appears as sleep(0.5) instead of time.sleep(0.5).
• Raspberry Pi Pico Traffic Light Simulator (GP11/GP12/GP13): a function called all_off() switches every LED off; green stays on for 4, yellow for 1.5 and red for 3 seconds, followed by a 1-second red+yellow starting phase.
• Raspberry Pi Pico Police Strobe Light Effect (GP11 + GP12): this time the wait is in milliseconds with sleep_ms(WAIT_MS), where WAIT_MS = 300. Seeing the seconds and milliseconds functions side by side in two projects is the best way to avoid the most common mistake below.

Common mistakes and how to fix them

Keep going with blocks in the BlueGrays app

Every project in this article is free in the BlueGrays app. Turn on the Show as blocks switch in a project's code section and the code is replaced by the same program as blocks; tap the image to open it full screen. The Understand the blocks tab walks you through the program step by step, showing only the blocks for each step and what they do. That's where you can see exactly what the pulse length block measures in the HC-SR04 project, or why the setup part of a Pico project comes before while True. All the Arduino and MicroPython command examples in the Code guide are shown as blocks too. To test what you've learned, Daily questions gives you 5 questions a day from A1 to C2, a weekly leaderboard and badges. Keep in mind that blocks are never uploaded to the board directly: the board always gets the project's real code, which you copy into the Arduino IDE for Arduino and ESP32 or into Thonny for the Pico. You can filter the project list for projects with the block badge and find every block project for Arduino, ESP32 and Pico on the block coding page.

With the serial port and sensor reading under your belt, you can now read every basic part of a project both as blocks and as code. The last part of the series takes these steps into the classroom: a robotics coding lesson plan with block coding for teachers. Until then, you can go through the circuit diagrams and code of the LDR, HC-SR04 and Pico LED projects step by step in the BlueGrays app, switch to the block version of the same program with Show as blocks, and follow what each step does with Understand the blocks.