Kurse › Raspberry Pi

Raspberry Pi: Zero to Professional

Name: Raspberry Pi: Zero to Professional
Price: 9.90 CHF

From your first boot to a product you can ship: 40 levels, 400 hands-on lessons with real hardware.

Stufen 1–13

Einsteiger

Stufe 1

First Boot: Meet Your Raspberry Pi

🔒

Assemble a Raspberry Pi, install Raspberry Pi OS Bookworm and use the desktop and terminal with confidence. Details zur Stufe →

1.1What a Single-Board Computer Is and What It Is Not1.2Choosing Between Pi 5, Pi 4, Zero 2 W and Pico1.3A Tour of the Board: Ports, Header and Connectors1.4Powering the Pi Correctly: 5 V, 5 A and USB-C PD1.5Picking and Preparing a microSD Card1.6Flashing Raspberry Pi OS Bookworm with Raspberry Pi Imager1.7Assembling the Case, Cooler and Cables Before Power-On1.8First Boot and a Walk Through the Desktop1.9Opening the Terminal and Running Your First Commands1.10Updating the System and Shutting Down Safely

Stufe 2

Command Line Essentials

🔒

Work fluently in the Bash shell: navigate, edit, search, install software and automate a task with a script. Details zur Stufe →

2.1Reading the Prompt and Moving Around with pwd, ls and cd2.2Creating, Copying, Moving and Deleting Files Safely2.3Viewing Text with cat, less, head and tail2.4Editing Configuration Files with nano2.5Getting Help from man Pages and Built-In Usage Text2.6Wildcards, Tab Completion and Command History2.7Redirecting Output and Chaining Commands with Pipes2.8Finding Files and Text with find and grep2.9Installing and Removing Software with apt2.10Writing Your First Shell Script

Stufe 3

Files, Users and Permissions

🔒

Understand who owns what on a Linux system and control access, storage and processes safely. Details zur Stufe →

3.1How the Linux Directory Tree Is Organised3.2Users, Groups and Why You Are Not root3.3Using sudo Responsibly3.4Reading and Changing Permissions with chmod3.5Ownership with chown and Group-Based Access3.6Watching and Stopping Processes with ps, top and kill3.7Checking Disk Space and Memory with df, du and free3.8Mounting USB Drives and Understanding Device Names3.9Archiving and Compressing with tar and gzip3.10Environment Variables, PATH and Your .bashrc

Stufe 4

Networking and Remote Access

🔒

Connect a Pi to a network, find it, and control it securely from another computer without a monitor. Details zur Stufe →

4.1IP Addresses, Routers and DNS in Plain Terms4.2Connecting to Wi-Fi and Ethernet with NetworkManager4.3Finding Your Pi on the Network by Hostname and mDNS4.4Testing Connections with ping, ip and ss4.5Logging In Remotely with SSH4.6Passwordless Login with SSH Key Pairs4.7Copying Files Across the Network with scp and rsync4.8Setting Up a Headless Pi with No Monitor4.9Remote Desktop Options: VNC and Raspberry Pi Connect4.10Reserving a Fixed Address for a Pi

Stufe 5

Python Foundations on the Pi

🔒

Write, run and debug small Python 3 programs inside a virtual environment. Details zur Stufe →

5.1Running Python in Thonny and from the Terminal5.2Variables, Numbers and Strings5.3Making Decisions with if, elif and else5.4Repeating Work with for and while Loops5.5Lists, Tuples and Dictionaries5.6Writing and Calling Your Own Functions5.7Reading and Writing Text Files in Python5.8Handling Errors with try and except5.9Importing Modules and Using the Standard Library5.10Virtual Environments and pip on Bookworm

Stufe 6

Electricity and Your First GPIO Outputs

🔒

Understand enough electricity to wire safely, then control LEDs from Python with gpiozero. Details zur Stufe →

6.1Voltage, Current and Resistance for Makers6.2How a Breadboard Is Wired Inside6.3Measuring Voltage, Continuity and Resistance with a Multimeter6.4The 40-Pin Header: Power, Ground and GPIO Numbering6.5GPIO Safety Limits: 3.3 V Logic and Current Budgets6.6Calculating a Resistor and Lighting an LED from 3.3 V6.7Blinking an LED with gpiozero6.8How gpiozero Reaches the Pins: Pin Factories and lgpio6.9Fading with PWM and Mixing Colours on an RGB LED6.10Sequencing Several LEDs into a Traffic Light

Stufe 7

Buttons, Buzzers and Events

🔒

Read switches and simple digital sensors reliably and write event-driven GPIO programs. Details zur Stufe →

7.1Reading a Push Button with Pull-Up and Pull-Down Resistors7.2Polling Versus Events: when_pressed Callbacks7.3Taming Switch Bounce7.4Long Presses, Double Presses and Hold Timers7.5Making Sound with Active and Passive Buzzers7.6Detecting Movement with a PIR Sensor7.7Door and Window Sensing with a Reed Switch7.8Connecting Devices in Code with source and values7.9Keeping Scripts Alive and Exiting Cleanly7.10Building a Reaction-Time Game

Stufe 8

Beginner Sensors and Data Logging

🔒

Connect common sensor modules safely, turn their signals into numbers and record them over time. Details zur Stufe →

8.1Digital Versus Analog Signals and Why the Pi Has No Analog Input8.2Level Shifting 5 V Signals with a Voltage Divider8.3Measuring Distance with an Ultrasonic Sensor8.4Reading Temperature from a DS18B20 on the 1-Wire Bus8.5Estimating Light Level with an LDR and a Capacitor8.6Tilt, Vibration and Flame Modules from a Sensor Kit8.7Timestamps and Sampling Intervals8.8Logging Sensor Readings to CSV8.9Smoothing Noisy Readings with Averages and Medians8.10Plotting Logged Data with matplotlib

Stufe 9

Camera Basics

🔒

Connect a camera module and capture stills, video and time-lapses from the command line and from Python. Details zur Stufe →

9.1Camera Modules, Ribbon Cables and the Two Connector Sizes9.2Checking the Camera with rpicam-hello9.3Taking Still Photos with rpicam-still9.4Recording Video with rpicam-vid9.5First picamera2 Script: Preview and Capture9.6Resolution, Sensor Modes and File Size9.7Focus, Exposure and White Balance for Beginners9.8Shooting a Time-Lapse and Assembling It with ffmpeg9.9Triggering Photos with a Button and a PIR Sensor9.10Organising, Naming and Transferring Captures

Stufe 10

Your First Complete Projects

🔒

Plan, build, enclose and document a small device so that someone else could reproduce it. Details zur Stufe →

10.1Turning an Idea into a Requirements List10.2Drawing a Wiring Diagram and Pin Map10.3Splitting a Script into Functions and Modules10.4Settings in a JSON Configuration File10.5Command-Line Options with argparse10.6Replacing print with the logging Module10.7Soldering Header Pins and Wires Safely10.8Moving from Breadboard to Perfboard10.9Fitting a Project into an Enclosure10.10Writing a Test Checklist and a Build Guide

Stufe 11

The I2C Bus

🔒

Wire, scan and program I2C devices, from ready-made libraries down to raw register access. Details zur Stufe →

11.1How I2C Shares Two Wires Among Many Devices11.2Enabling I2C and Scanning the Bus with i2cdetect11.3Reading a BME280 with a Ready-Made Library11.4Reading Registers Directly with smbus2 and a Datasheet11.5Bytes, Bits and Two's Complement for Sensor Data11.6Several Devices on One Bus and Address Conflicts11.7Pull-Ups, Cable Length and Bus Speed11.8Motion Data from an MPU6050 Accelerometer and Gyro11.9Keeping Time with a DS3231 and the Pi 5 Onboard RTC11.10Diagnosing I2C Faults: NACKs, Stuck Buses and Wrong Voltages

Stufe 12

SPI, UART and Analog Signals

🔒

Use SPI and serial devices, add true analog inputs and inspect bus traffic with a logic analyzer. Details zur Stufe →

12.1SPI Signals: Clock, MOSI, MISO and Chip Select12.2Talking to SPI Devices with spidev12.3Adding Analog Inputs with an MCP300812.4Potentiometers, Joysticks and Soil Moisture Probes12.5Higher Resolution with an ADS1115 over I2C12.6Converting ADC Counts into Real Units12.7UART Framing: Baud Rate, Start and Stop Bits12.8Freeing the Header UART and the Serial Console12.9Reading GPS NMEA Sentences with pyserial12.10Decoding I2C, SPI and UART with a Logic Analyzer

Stufe 13

Displays and User Interfaces

🔒

Show information on character, OLED, TFT, e-paper and touch displays and build simple interactive interfaces. Details zur Stufe →

13.1Text on a 16x2 Character LCD with an I2C Backpack13.2Drawing on an SSD1306 OLED with luma.oled and Pillow13.3Fonts, Icons and Layout on Tiny Screens13.4Colour Graphics on an SPI TFT13.5Low-Power Signage with an E-Paper Display13.6Navigating Menus with a Rotary Encoder13.7Addressable RGB LED Strips Driven over SPI13.8Desktop-Style Interfaces with guizero13.9Connecting a DSI Touch Display13.10Full-Screen Kiosk Mode on Wayland

Stufen 14–26

Intermediate

Stufe 14

Motors, Drivers and HATs

🔒

Switch and move real loads safely: transistors, relays, DC motors, servos, steppers and add-on boards. Details zur Stufe →

14.1Switching Loads with Transistors and MOSFETs14.2Flyback Diodes and Inductive Kickback14.3Relay Modules and Safe Isolation14.4Driving DC Motors with an H-Bridge Driver14.5Positioning Hobby Servos Without Jitter14.6Many Servos from a PCA9685 PWM Driver14.7Stepper Motors: Geared Unipolar and NEMA 17 Bipolar14.8Separate Motor Supplies, Common Ground and Decoupling14.9How HATs Identify Themselves: EEPROM, HAT+ and Stacking14.10Fan Control and Thermal Management on Pi 4 and Pi 5

Stufe 15

Services and Scheduling

🔒

Make programs start at boot, restart after failure, run on a schedule and log sensibly using systemd and cron. Details zur Stufe →

15.1What systemd Does During Boot15.2Writing a Service Unit for a Python Program15.3Reading Logs with journalctl15.4Restart Policies and Start Limits15.5Dedicated Service Users and Environment Files15.6Handling SIGTERM for a Clean Stop15.7Scheduling Jobs with cron15.8systemd Timers as a cron Alternative15.9Rotating and Capping Logs15.10Measuring and Shortening Boot Time

Stufe 16

Git and Project Workflow

🔒

Version, test and deploy Pi projects like a professional using Git, pytest and remote editing. Details zur Stufe →

16.1Tracking Changes with git init, add and commit16.2Reading History and Undoing Mistakes16.3Branching and Merging for Experiments16.4Ignoring Secrets and Generated Files16.5Pushing to a Remote Repository over SSH16.6Deploying to a Pi with git pull16.7Pinning Dependencies with Requirements Files16.8Unit Testing Hardware Code with Mock Pins and pytest16.9Editing on the Pi from a Laptop over Remote SSH16.10Tagging Releases and Keeping a Changelog

Stufe 17

Web Apps with Flask and SQLite

🔒

Build a database-backed web dashboard and API that shows sensor data and controls hardware. Details zur Stufe →

17.1HTTP Requests, Responses and Status Codes17.2A Minimal Flask App with Routes17.3HTML Templates with Jinja17.4Switching GPIO Outputs from a Web Page17.5Forms, Validation and Login Sessions17.6Designing a JSON API for Sensor Data17.7Designing a SQLite Schema for Time-Series Readings17.8Querying and Aggregating with SQL17.9Live Charts in the Browser17.10Serving Flask in Production with gunicorn and nginx

Stufe 18

Docker on the Pi

🔒

Package, run and update applications in containers, including ones that need hardware access. Details zur Stufe →

18.1Containers Versus Virtual Machines Versus Virtual Environments18.2Installing Docker Engine on Raspberry Pi OS18.3Running, Stopping and Inspecting Containers18.4Volumes and Bind Mounts for Persistent Data18.5Ports, Bridge Networks and Container DNS18.6Writing a Dockerfile for a Python App18.7Multi-Container Stacks with Docker Compose18.8Passing GPIO, I2C and Cameras into Containers18.9ARM64 Images and Multi-Architecture Builds18.10Updating, Pruning and Limiting Containers

Stufe 19

MQTT and Home Automation

🔒

Connect devices through an MQTT broker and automate them with a home-automation platform. Details zur Stufe →

19.1Publish and Subscribe: How MQTT Decouples Devices19.2Running a Mosquitto Broker19.3Designing a Topic Tree and JSON Payloads19.4Publishing Sensor Data with paho-mqtt19.5QoS, Retained Messages and Last Will19.6Broker Authentication and TLS19.7Running Home Assistant in a Container19.8MQTT Discovery: Making Your Devices Appear Automatically19.9Automations, Scenes and Notifications19.10Adding Zigbee Devices with a USB Coordinator

Stufe 20

Storage, NVMe Boot and Backups

🔒

Move a Pi onto fast, durable storage and protect it with backups you have actually restored. Details zur Stufe →

20.1Why SD Cards Wear Out and How to Slow It20.2Partitions, Filesystems and fstab20.3Booting from a USB SSD20.4The Pi 5 PCIe Connector and M.2 HATs20.5Bootloader EEPROM Settings and Boot Order20.6Migrating a Running System from SD to NVMe20.7Benchmarking Storage and PCIe Gen 2 Versus Gen 320.8File-Level Backups with rsync Snapshots20.9Encrypted Off-Device Backups with restic20.10Full-Image Backups and a Timed Restore Drill

Stufe 21

picamera2 and libcamera in Depth

🔒

Control the camera pipeline precisely and build recording and streaming systems with picamera2. Details zur Stufe →

21.1The libcamera Pipeline from Sensor to Frame21.2Camera Configurations: Main, Lores and Raw Streams21.3Manual Exposure, Gain and Colour Controls21.4Capturing Frames as NumPy Arrays21.5H.264 Encoding: Hardware on Pi 4, Software on Pi 521.6Pre-Roll Recording with a Circular Buffer21.7MJPEG Streaming to a Browser21.8Low-Latency RTSP and WebRTC with a Media Server21.9Night Vision with NoIR Cameras and IR Illumination21.10Two Cameras at Once on Pi 5

Stufe 22

Computer Vision with OpenCV

🔒

Process live camera frames to detect, measure and track objects in real time. Details zur Stufe →

22.1Installing OpenCV and Understanding Image Arrays22.2Colour Spaces and HSV Thresholding22.3Blurring, Edges and Morphology22.4Finding and Measuring Contours22.5Motion Detection by Background Subtraction22.6Tracking a Coloured Object in Real Time22.7Calibrating a Camera and Removing Lens Distortion22.8Pose from ArUco Markers22.9Reading QR Codes and Barcodes22.10Profiling a Vision Loop for Frame Rate

Stufe 23

On-Device Machine Learning

🔒

Run, evaluate and customise neural-network inference on the Pi, with and without accelerators. Details zur Stufe →

23.1Training Versus Inference and What Fits on a Pi23.2Image Classification with a TensorFlow Lite Runtime23.3Object Detection and Reading Bounding Boxes23.4Quantisation: Trading Accuracy for Speed23.5Collecting and Labelling Your Own Dataset23.6Transfer Learning on a PC and Exporting to the Pi23.7Running ONNX and NCNN Models23.8Accelerating Inference with an AI HAT23.9In-Sensor Inference with an AI Camera23.10Evaluating a Model: Accuracy, Latency and Heat

Stufe 24

Robotics: Rovers and Arms

🔒

Build and program a mobile robot and a servo arm with closed-loop control, sensing and behaviours. Details zur Stufe →

24.1Robot Power: Batteries, Protection Boards and Buck Converters24.2Wheel Encoders and Measuring Speed24.3PID Speed Control from First Principles24.4Differential-Drive Kinematics and Odometry24.5Heading from an IMU with a Complementary Filter24.6Obstacle Sensing with Ultrasonic and Time-of-Flight Sensors24.7Behaviour State Machines for Robots24.8Line Following with Reflectance Sensors and with a Camera24.9Servo Arm Geometry: Forward and Inverse Kinematics24.10ROS 2 Nodes and Topics in a Container

Stufe 25

Raspberry Pi Pico with MicroPython

🔒

Program a microcontroller for timing-critical and low-power jobs and connect it to a Pi. Details zur Stufe →

25.1Microcontroller Versus Linux Computer: When to Use a Pico25.2Flashing MicroPython Firmware with UF225.3Pico GPIO: Pins, Interrupts and Debouncing25.4Built-In ADC and the Temperature Sensor25.5PWM, Timers and Non-Blocking Loops25.6I2C and SPI Peripherals on the Pico25.7Wi-Fi on the Pico W25.8Publishing MQTT from a Microcontroller25.9Sleep Modes and Battery Life Budgeting25.10Linking a Pico to a Pi over UART and USB Serial

Stufe 26

Pico C SDK and Programmable I/O

🔒

Write fast, deterministic firmware in C and build custom hardware interfaces with PIO. Details zur Stufe →

26.1Setting Up the Pico C SDK Toolchain and CMake26.2C for Python Programmers: Types, Pointers and Headers26.3Interrupts, Alarms and Repeating Timers in C26.4PIO State Machines Explained Instruction by Instruction26.5Writing a PIO Program for WS2812 LEDs26.6Counting Quadrature Encoders in PIO26.7Moving Data with DMA26.8Using Both Cores Safely26.9Debugging over SWD with a Debug Probe and GDB26.10Designing a Register-Style I2C Peripheral

Stufen 27–40

Advanced

Stufe 27

Performance Tuning and Real-Time Behaviour

🔒

Measure before tuning, get more out of the hardware safely and know when Linux timing is good enough. Details zur Stufe →

27.1Profiling CPU, Memory and I/O Before Tuning27.2Throttling, Temperature and Under-Voltage Flags27.3CPU Governors, Overclocking and Its Risks27.4Memory Pressure, Swap and zram27.5Making Python Faster: NumPy, multiprocessing and Compiled Helpers27.6Why Standard Linux Is Not Real-Time: Latency and Jitter27.7Measuring Jitter with cyclictest and a Logic Analyzer27.8Real-Time Scheduling Classes and CPU Isolation27.9Running a PREEMPT_RT Kernel27.10Hardware PWM, Timestamped Edges and Offloading to a Pico

Stufe 28

Network Services: Router, VPN, DNS and NAS

🔒

Turn a Pi into dependable network infrastructure: routing, firewalling, filtering, remote access and storage. Details zur Stufe →

28.1Routing, NAT and Forwarding on Linux28.2Firewalls with nftables28.3Turning a Pi into a Wi-Fi Access Point28.4DHCP and Local DNS with dnsmasq28.5Network-Wide DNS Filtering28.6A WireGuard VPN Server and Clients28.7Reaching a Pi Behind Carrier-Grade NAT28.8A Samba File Server for Mixed Networks28.9Redundant Storage: mdadm RAID on a SATA HAT28.10VLANs and Segmenting IoT Devices

Stufe 29

Security Hardening

🔒

Reduce the attack surface of a connected Pi and detect and respond when something goes wrong. Details zur Stufe →

29.1Threat Modelling a Connected Device29.2Hardening SSH Beyond Key Login29.3Automatic Security Patching29.4Least Privilege: Service Sandboxing in systemd29.5Secrets Management Without Hard-Coded Passwords29.6TLS Certificates for Local and Public Services29.7Encrypting Data at Rest with LUKS29.8Auditing Open Ports and Running Services29.9Physical Access, USB and Boot Integrity29.10Detecting and Responding to an Incident

Stufe 30

Kernel, Device Tree and User-Space Drivers

🔒

Understand how Linux sees Pi hardware and add support for new devices with overlays and your own drivers. Details zur Stufe →

30.1How the Pi Boots: EEPROM, Firmware, Kernel and config.txt30.2Kernel Modules: Loading, Parameters and dmesg30.3Device Tree Fundamentals: Nodes, Properties and Compatible Strings30.4Using and Configuring Stock Overlays30.5Writing Your Own Device Tree Overlay30.6The RP1 I/O Controller and What Changed on Pi 530.7GPIO Through the Character Device with libgpiod30.8User-Space I2C and SPI Drivers from a Datasheet30.9Exposing Hardware Through sysfs, IIO and hwmon30.10Building the Kernel and an Out-of-Tree Module

Stufe 31

Compute Modules and Carrier Boards

🔒

Move from a hobby board to a Compute Module and specify, review and bring up a custom carrier board. Details zur Stufe →

31.1Compute Module 4 and 5: Variants and Trade-Offs31.2Flashing eMMC with rpiboot31.3Learning from the Reference IO Board Schematic31.4Schematic Capture for a Minimal Carrier in KiCad31.5Power Tree Design: Input Protection, Regulators and Sequencing31.6Routing High-Speed Pairs: USB, HDMI, PCIe and Ethernet31.7Device Tree and config.txt for a Custom Carrier31.8Antennas, RTC Backup and Wireless Options on Modules31.9Board Bring-Up: A Step-by-Step Power-On Plan31.10Design for Manufacture, Test Points and Assembly Files

Stufe 32

Robust Systems: Read-Only Root and Power-Loss Survival

🔒

Build a device that keeps working through power cuts, crashes and years of unattended use. Details zur Stufe →

32.1Failure Modes of Unattended Devices32.2A Read-Only Root Filesystem with overlayfs32.3Separating System, Config and Data Partitions32.4Atomic File Writes and fsync32.5SQLite Durability: WAL, Synchronous Modes and Corruption Tests32.6The Hardware Watchdog and systemd Integration32.7Detecting Power Loss and Shutting Down on Stored Energy32.8Flash Endurance: Industrial Cards, eMMC and Write Budgets32.9Self-Healing Boot: Fallback Partitions and Factory Reset32.10Building a Power-Cut Torture Rig

Stufe 33

A/B Updates and Over-the-Air Delivery

🔒

Update devices in the field atomically, verifiably and with automatic rollback. Details zur Stufe →

33.1Update Strategies Compared: Packages, Containers and Images33.2Partition Layouts for A/B Systems33.3The tryboot Mechanism and autoboot.txt33.4Building and Installing Update Bundles with RAUC33.5Signing Updates and Verifying Them on the Device33.6Health Checks and Automatic Rollback33.7Bootloader EEPROM Updates in the Field33.8Hosting an Update Server and Polling Client33.9Delta Updates and Bandwidth Budgets33.10Canary Groups and Staged Rollouts

Stufe 34

Fleet Provisioning and Management

🔒

Enrol, configure, reach and retire many devices without touching each one by hand. Details zur Stufe →

34.1Device Identity: Serial Numbers, Keys and Certificates34.2Zero-Touch Provisioning on First Boot34.3Configuration Management with Ansible34.4Keeping a Fleet Inventory and Device Registry34.5Remote Access at Scale Through a WireGuard Hub34.6Fleet Command and Telemetry Topics over MQTT34.7Per-Device Configuration and Feature Flags34.8Rotating Credentials and Revoking a Stolen Device34.9Collecting Remote Diagnostics Without SSH34.10Decommissioning, Wiping and Replacing Units

Stufe 35

Monitoring and Observability

🔒

See what every device is doing, be alerted to real problems and learn from incidents. Details zur Stufe →

35.1Metrics, Logs and Traces: What to Collect from a Device35.2Exporting System Metrics with node_exporter35.3Custom Application Metrics in Python35.4Scraping and Storing with Prometheus35.5Dashboards in Grafana35.6Alert Rules That Do Not Cry Wolf35.7Shipping Logs Centrally with Loki35.8Heartbeats and Detecting Silent Devices35.9Monitoring over Metered and Intermittent Links35.10Defining SLOs and Running a Post-Incident Review

Stufe 36

Industrial Interfaces: RS-485, Modbus and CAN

🔒

Connect a Pi to industrial sensors, drives and controllers safely and reliably. Details zur Stufe →

36.1Industrial Signal Levels: 24 V I/O, Isolation and Noise36.2Isolated Digital Inputs and Outputs36.3Reading 4-20 mA Current Loops and 0-10 V Signals36.4RS-485 Wiring, Termination and Biasing36.5Modbus RTU as a Client with pymodbus36.6Modbus TCP and Serving Your Own Registers36.7CAN Bus Physical Layer and an MCP2515 HAT36.8Sending and Filtering Frames with SocketCAN and python-can36.9Surge, ESD and EMC Protection for Field Wiring36.10DIN-Rail Enclosures and 24 V Supply Design

Stufe 37

Clustering with k3s

🔒

Run containerised services across several Pis with scheduling, self-healing and declarative deployment. Details zur Stufe →

37.1Why Cluster Pis: Availability Versus Complexity37.2Preparing Nodes: cgroups, Fixed Addresses and PoE Power37.3Installing a k3s Server and Joining Agents37.4Pods, Deployments and Services37.5Ingress, Load Balancing and TLS in the Cluster37.6Persistent Volumes on Small Clusters37.7ConfigMaps, Secrets and Helm Charts37.8High Availability with Three Server Nodes37.9GitOps: Letting the Cluster Pull Its Own Configuration37.10Node Failure Drills and Rolling Cluster Upgrades

Stufe 38

Custom Images, Device CI/CD and Other Boards

🔒

Produce reproducible system images in a pipeline, test them on real hardware and port your stack to non-Pi boards. Details zur Stufe →

38.1Building a Custom Raspberry Pi OS Image with pi-gen38.2Baking Your Application into the Image with a Custom Stage38.3Yocto Project Concepts: Layers, Recipes and Board Support38.4A CI Pipeline That Lints, Tests and Builds Images38.5Hardware-in-the-Loop Test Rigs38.6Versioning, Signing and Publishing Release Artifacts38.7The SBC Landscape: Rockchip, Allwinner and Their Boot Chains38.8Running Your Stack on an Orange Pi or Radxa ROCK38.9A Hardware Abstraction Layer for Board-Agnostic Code38.10Supply Risk, Second Sources and Board Selection

Stufe 39

Compliance, Production and Capstone Design

🔒

Take a product from idea to a reviewed, certifiable, manufacturable design. Details zur Stufe →

39.1Writing a Product Requirements Specification39.2CE, UKCA and FCC: What Applies to a Pi-Based Product39.3Radio Compliance with Pre-Certified Modules39.4EMC Pre-Compliance Checks on the Bench39.5Electrical Safety, Enclosures and IP Ratings39.6Open-Source Licence Obligations and a Software Bill of Materials39.7Vulnerability Handling and Security Update Commitments39.8Bill of Materials, Costing and Lifecycle Planning39.9Factory Provisioning and End-of-Line Testing39.10Running a Design Review with a Risk Register

Stufe 40

Capstone: Build, Ship and Operate the Product

🔒

Build the gateway designed in Level 39, deploy a pilot fleet and prove you can operate and maintain it. Details zur Stufe →

40.1Capstone Hardware Assembly and Bring-Up40.2Capstone Data Acquisition Layer40.3Local Storage, Buffering and Store-and-Forward40.4Capstone Local Web Interface and API40.5Capstone Production Image: Read-Only, Signed and Reproducible40.6Enrolling the Pilot Fleet40.7Rolling Out a Capstone OTA Release with a Canary40.8Fleet Dashboards and Alerts for the Capstone40.9Acceptance Testing: Soak, Power-Cut and Network-Loss Runs40.10Handover: Runbooks, Support Process and Maintenance Plan