Raspberry Pi for Complete Beginners

A Raspberry Pi is a single-board computer (SBC) — a complete, small computer with a CPU, memory, and ports, all on one credit-card-sized board. Unlike your laptop, it has no built-in screen, keyboard, or storage drive — you supply those, or run it "headless" (no monitor at all, controlled remotely).

What makes it different from a normal desktop is the GPIO header — a row of 40 pins along one edge that let the board directly control and read real-world electronics: LEDs, sensors, motors, switches. That's the part a laptop can't do.

• SoC (System on Chip) — the black chip in the middle; it's the CPU and GPU combined.
• microSD card slot (underside) — this is where the entire operating system lives. There's no internal hard drive.
• USB-C power port — this is power input only, not a data connection to a computer.
• USB-A ports — for keyboard, mouse, flash drives.
• Ethernet port — wired networking; Wi-Fi is also built in.
• Micro-HDMI ports (×2 on Pi 4/5) — video output to a monitor. Note: micro-HDMI, not full-size — you'll likely need an adapter cable.
• Camera (CSI) and Display (DSI) connectors — small ribbon-cable slots for the official Camera Module (Module 11) and touchscreens.
• 40-pin GPIO header — the row of pins along the top edge. This is what the rest of this course is built around.

The 40-pin header has three categories of pins, and mixing them up is the most common wiring mistake:

1. A microSD card (16GB minimum, 32GB+ recommended) — this becomes your entire operating system and storage.
2. A proper power supply — official Pi power adapters are rated for the current spikes the board needs; an underpowered phone charger causes random reboots and corrupted SD cards. This is a common, confusing failure mode for beginners.
3. Either: a monitor + micro-HDMI cable + USB keyboard/mouse (for a normal first setup), or just a laptop on the same network (for a "headless" no-monitor setup, covered in Module 3).
4. Optional but recommended: a case, for both physical protection and cooling.

The official Raspberry Pi Imager tool (free, from raspberrypi.com/software) writes an operating system onto your microSD card. This step happens on your regular computer, not on the Pi itself — the Pi doesn't exist as a working device until this card is ready.

1. Download and install Raspberry Pi Imager on your PC/Mac.
2. Insert your microSD card via a USB card reader.
3. Open Imager → Choose Device → select your Pi model.
4. Choose OS → Raspberry Pi OS (64-bit) is the standard choice. Choose the Lite version if you plan to go headless (no desktop environment, smaller and faster); choose the full version if you want a monitor and desktop.
5. Choose Storage → select your microSD card. Double-check this is the SD card and not your PC's main drive — Imager will erase whatever you select.

Before clicking write, click the gear/advanced options icon. This is where you configure everything you'd otherwise need a monitor and keyboard to set up manually:

1. Enable SSH — check this box. Without it, you cannot connect to the Pi remotely at all.
2. Set username and password — pick your own; don't leave this on any default.
3. Configure Wi-Fi — enter your network name and password so the Pi connects automatically on first boot.
4. Set hostname — e.g. mypi.local — lets you find the Pi on your network by name instead of hunting for its IP address.

1. Insert the finished microSD card into the Pi (slot is on the underside).
2. Connect power last, after everything else is plugged in.
3. Wait 60–90 seconds for first boot — it's doing first-time setup in the background, so don't panic if nothing appears on a monitor immediately.
4. Headless: from your PC's terminal, run ssh username@mypi.local (using the username and hostname you set in Imager).
5. With monitor: you'll be dropped into either a desktop or a login prompt directly.

ssh jude@mypi.local
# First connection asks to confirm the host's fingerprint — type "yes"
# Then enter the password you set in Imager

Once connected, raspi-config is a text-based menu for settings you'll come back to constantly throughout this course — enabling I2C/SPI/Camera (Modules 7, 11), expanding filesystem, changing hostname, and more.

sudo raspi-config

Navigate with arrow keys, Enter to select, Tab to move between buttons. You'll return to this tool repeatedly in later modules to enable specific interfaces.

You'll write Python scripts directly on the Pi. nano is the easiest terminal text editor to start with (vim is more powerful but has a steeper learning curve — feel free to explore it later).

nano blink.py
# Type your code directly
# Ctrl+O then Enter → saves the file
# Ctrl+X → exits nano

sudo ("superuser do") runs a command with administrator privileges. Some tasks — installing software, editing system config, accessing certain hardware pins — require it; running everything with sudo out of habit is unnecessary and can mask real permission problems.

sudo apt update
sudo apt upgrade -y

apt is Raspberry Pi OS's package manager — how you install nearly all software from the command line. update refreshes the list of what's available; upgrade actually installs newer versions of what you have.

python3 blink.py

Every GPIO script from Module 5 onward is run exactly this way — python3 followed by the filename. Press Ctrl+C to stop a running script.

From Module 2: pins can be referred to by their physical position (BOARD numbering, 1–40) or by their internal chip number (BCM numbering, e.g. GPIO17). Every GPIO library needs to be told which system you're using — mixing them up in your head is the single most common beginner bug.

Both come pre-installed on Raspberry Pi OS. This course leads with gpiozero because it maps directly onto real components — an LED object, a Button object — matching how you're already thinking about the breadboard.

Using the exact LED + resistor circuit you built in Module 1, wired so the resistor leg connects to GPIO17 instead of the positive power rail:

from gpiozero import LED
from time import sleep

led = LED(17)  # GPIO17, BCM numbering

while True:
    led.on()
    sleep(1)
    led.off()
    sleep(1)

Run it with python3 blink.py, stop it with Ctrl+C. That's the entire pattern you'll reuse for every digital output device in this course — create an object with a pin number, call methods on it.

from gpiozero import Button

button = Button(2)  # GPIO2

while True:
    button.wait_for_press()
    print("Button pressed!")

gpiozero automatically handles the internal pull-up/pull-down resistor configuration for you here — a detail RPi.GPIO makes you set manually. This is part of why gpiozero reads so much cleaner for beginners.

from gpiozero import LED, Button

led    = LED(17)
button = Button(2)

button.when_pressed  = led.on
button.when_released = led.off

from signal import pause
pause()

when_pressed and when_released let you assign a function to run automatically on an event, instead of manually polling in a loop. pause() just keeps the script alive waiting for those events.

Wire three LEDs (red, yellow, green) each with their own 220Ω resistor, each to a separate GPIO pin, all sharing one ground connection back to the negative rail.

from gpiozero import LED
from time import sleep

red    = LED(17)
yellow = LED(27)
green  = LED(22)

try:
    while True:
        red.on();    sleep(4);  red.off()
        green.on();  sleep(4);  green.off()
        yellow.on(); sleep(1);  yellow.off()
except KeyboardInterrupt:
    print("Stopped.")

Mechanical buttons don't switch cleanly — the metal contacts physically bounce for a few milliseconds, which can register as several rapid presses instead of one. This is called bounce, and it's why a naive button script sometimes counts 3 presses for 1 press.

from gpiozero import Button

count = 0
# bounce_time filters out rapid duplicate triggers within 0.1 seconds
button = Button(2, bounce_time=0.1)

def on_press():
    global count
    count += 1
    print(f"Press #{count}")

button.when_pressed = on_press

from signal import pause
pause()

A passive piezo buzzer wires exactly like an LED (one leg to a GPIO pin through a resistor, one to ground) and is controlled identically in code.

from gpiozero import Buzzer, Button
from signal import pause

buzzer = Buzzer(27)
button = Button(2)

button.when_pressed  = buzzer.on
button.when_released = buzzer.off

pause()

Digital pins read exactly two states: roughly 0V (LOW/off) or roughly 3.3V (HIGH/on) — nothing in between. Many real-world sensors — a potentiometer's position, a light sensor's brightness, a flex sensor's bend — output a continuously varying voltage, not a clean on/off signal. Microcontrollers like Arduino have built-in circuitry (an ADC) to read those in-between voltages directly. The Raspberry Pi's GPIO does not — you need to add that circuitry yourself with an external chip.

The MCP3008 is a small chip that reads up to 8 separate analog inputs and reports each one back to the Pi as a digital number (0–1023) over a protocol called SPI (covered in more depth in Module 8). It's the standard, well-documented choice for adding analog sensing to a Pi project.

Wire a potentiometer's outer two legs to 3.3V and GND, and its middle (wiper) leg to MCP3008 channel 0.

from gpiozero import MCP3008
from time import sleep

pot = MCP3008(channel=0)

while True:
    print(f"Value: {pot.value:.2f}")  # 0.0 to 1.0
    sleep(0.5)

gpiozero's MCP3008 class handles the SPI communication for you and gives back a clean 0.0–1.0 float, regardless of the chip's internal 0–1023 resolution — the same "let the library handle the messy part" pattern from Module 5.

from gpiozero import MCP3008, PWMLED
from time import sleep

pot = MCP3008(channel=0)
led = PWMLED(17)  # PWMLED supports variable brightness, not just on/off

while True:
    led.value = pot.value  # directly map 0.0-1.0 pot reading to 0.0-1.0 LED brightness
    sleep(0.05)

Turning the potentiometer now smoothly dims the LED — your first real analog-to-digital-to-analog pipeline: a physical continuous input, read through the ADC, driving a continuously variable output (PWM, covered fully in Module 9).

sudo raspi-config
# Interface Options → I2C → Enable → reboot

Once enabled and rebooted, install the detection tool:

sudo apt install -y i2c-tools
i2cdetect -y 1

This prints a grid showing every I2C device's address currently detected on the bus — the fastest way to confirm a sensor is wired correctly before writing a single line of code.

Wire VIN→3.3V, GND→GND, SCL→GPIO3, SDA→GPIO2 — the same two I2C pins every I2C device shares.

pip3 install adafruit-circuitpython-bme280

import board
from adafruit_bme280 import basic as adafruit_bme280

i2c = board.I2C()
bme = adafruit_bme280.Adafruit_BME280_I2C(i2c)

print(f"Temp: {bme.temperature:.1f} C")
print(f"Humidity: {bme.humidity:.1f} %")
print(f"Pressure: {bme.pressure:.1f} hPa")

A small 128×64 OLED screen — same two I2C wires, different address on the bus.

pip3 install adafruit-circuitpython-ssd1306 pillow

import board
import adafruit_ssd1306
from PIL import Image, ImageDraw

i2c = board.I2C()
oled = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c)
oled.fill(0)
oled.show()

image = Image.new("1", (oled.width, oled.height))
draw  = ImageDraw.Draw(image)
draw.text((0, 0), "Hello, Pi!", fill=255)
oled.image(image)
oled.show()

PWM (Pulse Width Modulation) is how a digital-only pin fakes an analog-style output. Instead of a steady voltage, the pin switches on and off very rapidly — the duty cycle (the percentage of time it's on vs. off) determines the effective average power. A 100% duty cycle is full on, 50% is roughly half power, 0% is off.

You already saw this in Module 7's PWMLED — dimming an LED is PWM. Servos and motor speed control both use the exact same underlying concept.

A servo moves to a specific angle (usually 0°–180°) based on the PWM signal it receives, and holds that position — unlike a continuous DC motor, which just spins.

from gpiozero import Servo
from time import sleep

servo = Servo(17)

while True:
    servo.min()  # -1, roughly 0 degrees
    sleep(1)
    servo.mid()  # 0, roughly 90 degrees
    sleep(1)
    servo.max()  # 1, roughly 180 degrees
    sleep(1)

DC motors draw far more current than a GPIO pin can safely provide, and — critically — spinning a motor down generates a voltage spike (back-EMF) that can damage the Pi if wired directly. A motor driver chip (like the L298N or TB6612) sits between the Pi and the motor: the Pi sends it a low-power control signal, and the driver switches the motor's separate, higher-current power supply.

from gpiozero import Motor
from time import sleep

# forward and backward pins go to the motor driver's control inputs, NOT the motor directly
motor = Motor(forward=17, backward=27)

motor.forward()
sleep(2)
motor.backward()
sleep(2)
motor.stop()

gpiozero's Motor class assumes you've wired those two GPIO pins into a motor driver's inputs — it's controlling the driver, which controls the motor.

ssh jude@mypi.local
# or, if the hostname doesn't resolve:
ssh jude@192.168.1.42

If mypi.local doesn't resolve on your network, find the Pi's IP address instead — either check your router's connected-devices list, or run hostname -I directly on the Pi if you have any access to it.

SSH gives you a terminal only. For a full graphical desktop remotely (useful for Module 11's camera preview, for example), enable VNC:

sudo raspi-config
# Interface Options → VNC → Enable

Then install RealVNC Viewer on your PC/Mac/phone and connect using the same hostname or IP you use for SSH. Note this only works if you installed the full Raspberry Pi OS Desktop, not the Lite version from Module 3.

By default, your router can hand the Pi a different IP address each time it reconnects, which breaks any script or bookmark relying on a fixed address. Two ways to fix this:

# copy a file TO the Pi
scp myscript.py jude@mypi.local:/home/jude/

# copy a file FROM the Pi
scp jude@mypi.local:/home/jude/data.csv ./

scp ("secure copy") uses the same SSH connection you already have configured — no extra setup required.

1. Power off the Pi completely before connecting the ribbon cable — this port isn't hot-swappable.
2. Gently pull up the black plastic clip on the CSI camera port (from Module 2's board anatomy).
3. Insert the ribbon cable with the blue side facing the Ethernet port (orientation varies slightly by Pi model — check silkscreen labels if unsure), then push the clip back down to lock it.
4. Power on, then enable the camera interface: sudo raspi-config → Interface Options → Camera → Enable → reboot.

Modern Raspberry Pi OS uses libcamera tools instead of the older raspistill/raspivid commands you may see in older tutorials.

# Take a single photo
libcamera-still -o photo.jpg

# Record 10 seconds of video
libcamera-vid -t 10000 -o video.h264

from picamera2 import Picamera2
from time import sleep

picam2 = Picamera2()
picam2.start()
sleep(2)  # let the sensor's auto-exposure settle first
picam2.capture_file("photo.jpg")
picam2.stop()

Picamera2 is the current official Python library, replacing the older (now deprecated) picamera package — if you find tutorials using import picamera without the "2", they're written for the older Pi OS and won't work the same way here.

OpenCV is the standard computer vision library — face detection, motion detection, edge detection, and far more, all built on the idea of treating an image as a grid of numbers you can process.

pip3 install opencv-python

import cv2
from picamera2 import Picamera2

picam2 = Picamera2()
picam2.configure(picam2.create_preview_configuration())
picam2.start()

prev_frame = None

while True:
    frame = picam2.capture_array()
    gray  = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    gray  = cv2.GaussianBlur(gray, (21, 21), 0)

    if prev_frame is not None:
        diff = cv2.absdiff(prev_frame, gray)
        if diff.mean() > 5:
            print("Motion detected!")

    prev_frame = gray

This compares each frame to the previous one — a meaningful difference between frames means something moved. It's a simple, CPU-cheap technique, not full object recognition, but it's the foundation most beginner vision projects start from.

A desk or room monitor that reads real environmental data, displays it locally, alerts you when something crosses a threshold, and is checkable remotely — the same shape of project as any real IoT sensor node.

1. Sensing: A BME280 (Module 8) reading temperature, humidity, and pressure over I2C.
2. Display: An SSD1306 OLED (Module 8) showing current readings, updating every few seconds — same I2C bus as the sensor, different address.
3. Alerting: An LED + buzzer (Module 6) that trigger when temperature crosses a threshold you set — e.g. too hot, flash the LED and beep.
4. Input: A button (Module 6) that cycles the OLED display between temperature, humidity, and pressure views on press.
5. Dimming: A potentiometer through the MCP3008 (Module 7) controlling the OLED's or LED's brightness, so the display isn't blinding in a dark room.
6. Remote check-in: A small Python script reachable over SSH (Module 10) that prints the latest reading on demand — or, as a stretch goal, logs readings to a file you can scp off the Pi.
7. Optional stretch: Add the Camera Module (Module 11) with simple motion detection to snap a photo whenever someone's in the room, timestamped alongside the sensor log.

The real skill this capstone tests isn't any single sensor — it's combining several independent event sources (a timer for sensor polling, a button press, a threshold check) into one script that doesn't block itself. A pattern worth using:

from gpiozero import LED, Buzzer, Button, MCP3008
import board, adafruit_bme280.basic as adafruit_bme280
import adafruit_ssd1306
from time import sleep

TEMP_THRESHOLD = 28.0  # Celsius — adjust to your room

i2c  = board.I2C()
bme  = adafruit_bme280.Adafruit_BME280_I2C(i2c)
oled = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c)

led     = LED(17)
buzzer  = Buzzer(27)
button  = Button(2)
dimmer  = MCP3008(channel=0)

view = 0  # 0=temp, 1=humidity, 2=pressure
def cycle_view():
    global view
    view = (view + 1) % 3
button.when_pressed = cycle_view

while True:
    temp = bme.temperature

    # alerting
    if temp > TEMP_THRESHOLD:
        led.on(); buzzer.on()
    else:
        led.off(); buzzer.off()

    # display — update based on current view + dimmer-controlled contrast could go here
    oled.fill(0)
    # ... draw whichever reading `view` selects ...
    oled.show()

    sleep(1)

Notice the loop never blocks on any single thing for long — the button's when_pressed callback fires independently of the main loop's timing, which is the same event-driven pattern from Module 5, just with more pieces running at once.