Lesson 01: Set Up Your Pi Board

Required:

1. Raspberry Pi Board (3, 4, or 5)
2. MicroSD Card (minimum 16GB, class 10 recommended)
   • SAMSUNG PRO Endurance 128GB MicroSDXC Memory Card: Amazon
   • SanDisk 128GB High Endurance Video MicroSDXC Card: Amazon
3. MicroSD Card Reader
4. Power Supply: The following table shows the USB-PD power mode required to power various Raspberry Pi models. You can use any high-quality power supply that provides the correct power mode.

   Model	Recommended power supply (voltage/current)	Raspberry Pi power supply
   Raspberry Pi 5	5V/5A 5V/3A limits peripherals to 600mA	45W USB-C Power Supply 27W USB-C Power Supply
   Raspberry Pi 4 Model B	5V/3A	15W USB-C Power Supply
   Raspberry Pi 3 (all models)	5V/2.5A	12.5W Micro USB Power Supply
   Raspberry Pi 2 (all models)	5V/2.5A	12.5W Micro USB Power Supply
   Raspberry Pi 1 (all models)	5V/2.5A	12.5W Micro USB Power Supply
   Raspberry Pi Zero (all models)	5V/2.5A	12.5W Micro USB Power Supply

5. HDMI Cable (micro HDMI for Pi 4/5, standard HDMI for Pi 3)
6. Monitor or TV
7. USB Keyboard and Mouse

Optional:

1. A Case for Raspberry Pi
2. Ethernet Cable (for wire internet connection)
3. USB Wi-Fi Adapter (if using Pi 3 without built-in WiFi)
4. Heatsinks or Fans (recommended for Pi 4/5)

1. Download Raspberry Pi OS:
   Visit the Raspberry Pi Downloads page and download the Raspberry Pi Imager or Raspberry Pi OS image.
2. Install Raspberry Pi Imager:
   Install the Raspberry Pi Imager on your computer.
3. Write the OS Image:
   • Insert the MicroSD card into the card reader and connect it to your computer.
   • Open Raspberry Pi Imager, select the OS image and choose your MicroSD card as the storage device.
   • Click "Write" to start writing the image to the card. This process may take a few minutes.

1. Insert MicroSD Card:
   Remove the MicroSD card from your computer and insert it into the MicroSD card slot on the Raspberry Pi.
2. Connect Monitor and Peripherals:
   • Connect the HDMI cable from the Raspberry Pi to your monitor or TV.
   • Plug in the USB keyboard and mouse.
3. Connect to Network:
   • For a wired connection, plug in the Ethernet cable.
   • For a wireless connection, you'll configure Wi-Fi during the software setup.
4. Power Up the Raspberry Pi:
   Connect the power supply to the Raspberry Pi and plug it into a power outlet. The Raspberry Pi should boot up, and you should see the Raspberry Pi logo and boot messages on the screen.

Update software

After booting, keep the software running on your Raspberry Pi and update it to the latest version. This keeps your device secure from vulnerabilities and ensures you get the latest bug fixes.

sudo apt update
sudo apt full-upgrade

Configure Pi Board

sudo raspi-config nonint <command> <arguments> [optional-argument]

sudo raspi-config nonint do_wifi_ssid_passphrase <ssid> <passphrase> [hidden] [plain]

sudo raspi-config nonint do_wifi_ssid_passphrase myssid mypassphrase

sudo raspi-config nonint do_wifi_ssid_passphrase myssid mypassphrase 1

sudo raspi-config nonint do_wifi_ssid_passphrase myssid "my passphrase" 0 0

sudo raspi-config nonint do_audio <N>

sudo raspi-config nonint do_change_pass

sudo raspi-config nonint do_hostname <hostname>

sudo raspi-config nonint do_boot_behaviour <B1/B2/B3/B4>

sudo raspi-config nonint do_boot_wait <0/1>

sudo raspi-config nonint do_boot_splash <0/1>

sudo raspi-config nonint do_leds <0/1>

sudo raspi-config nonint do_browser <chromium-browser/firefox>

sudo raspi-config nonint do_overscan_kms <device> <enabled>

sudo raspi-config nonint do_blanking <0/1>

[idle]
dpms_timeout=600

sudo raspi-config nonint do_vnc_resolution <width>x<height>

sudo raspi-config nonint do_pi4video <V1/V2/V3>

sudo raspi-config nonint do_composite <0/1>

sudo raspi-config nonint do_ssh <0/1>

sudo raspi-config nonint do_vnc <0/1>

sudo raspi-config nonint do_spi <0/1>

sudo raspi-config nonint do_i2c <0/1>

sudo raspi-config nonint do_serial_hw <0/1/2>

sudo raspi-config nonint do_serial_cons <0/1/2>

sudo raspi-config nonint do_onewire <0/1>

sudo raspi-config nonint do_rgpio <0/1>

sudo raspi-config nonint do_overclock <setting>

sudo raspi-config nonint do_memory_split <megabytes>

sudo raspi-config nonint do_overlayfs <0/1>

sudo raspi-config nonint do_fan <0/1> [gpio] [onTemp]

sudo raspi-config nonint do_change_locale <locale>

sudo raspi-config nonint do_change_timezone <timezone>

sudo raspi-config nonint do_configure_keyboard <keymap>

sudo raspi-config nonint do_wifi_country <country>

sudo raspi-config nonint do_expand_rootfs

sudo raspi-config nonint do_net_names <0/1>

sudo raspi-config nonint do_proxy <SCHEMES> <ADDRESS>

sudo raspi-config nonint do_boot_order <B1/B2/B3>

sudo raspi-config nonint do_boot_rom <E1/E2>

sudo raspi-config nonint do_wayland <W1/W2>

sudo raspi-config nonint do_audioconf <1/2>

sudo raspi-config nonint do_update

By default, the Raspberry Pi 5 consumes around 1W to 1.4W of power when turned off. This can be decreased by manually editing the EEPROM configuration with sudo rpi-eeprom-config -e. Change the settings to the following:

BOOT_UART=1
POWER_OFF_ON_HALT=1
BOOT_ORDER=0xf416

Then reboot the device with sudo reboot. This should drop the power consumption when powered down to around 0.01W.

Raspberry Pi Imager provides a GUI for updating the bootloader and selecting the boot mode.

1. Download Raspberry Pi Imager
2. Select a spare SD card (bootloader images overwrite the entire card)
3. Launch Raspberry Pi Imager
4. Select Choose OS
5. Select Misc utility images
6. Select Bootloader for your version of Raspberry Pi (Pi 400 is part of the 4 family)
7. Select a boot mode: SD (recommended), USB or Network
8. Select SD card, and then Write
9. Click Yes to continue
10. Boot the Raspberry Pi with the new image and wait for at least ten seconds
11. When the green activity LED blinks with a steady pattern and the HDMI display shows a green screen, you have successfully written the bootloader
12. Power off the Raspberry Pi and remove the SD card

To change the boot-mode or bootloader version from within Raspberry Pi OS, run raspi-config.

1. Update Raspberry Pi OS to get the latest version of the rpi-eeprom package.
2. Run the following command to start raspi-config.

   
   sudo raspi-config
   

3. Navigate to Advanced Options and then Bootloader Version. Select Latest and choose Yes to confirm. Select Finish and confirm you want to reboot.
4. After the reboot, open a command prompt again and update your system:

   
   sudo apt update
   

5. If you run sudo rpi-eeprom-update, you should see that a more recent version of the bootloader is available and it’s the latest release.

   
   sudo rpi-eeprom-update      
   
   *** UPDATE AVAILABLE ***
   BOOTLOADER: update available
      CURRENT: Thu 18 Jan 13:59:23 UTC 2024 (1705586363)
       LATEST: Mon 22 Jan 10:41:21 UTC 2024 (1705920081)
      RELEASE: latest (/lib/firmware/raspberrypi/bootloader-2711/latest)
               Use raspi-config to change the release.
   
     VL805_FW: Using bootloader EEPROM
        VL805: up to date
      CURRENT: 000138c0
       LATEST: 000138c0
   

6. Now, you can update your bootloader.

   
   sudo rpi-eeprom-update -a
   sudo reboot
   

7. Reboot, then run sudo rpi-eeprom-update. You should now see that the CURRENT date has been updated to the latest version of the bootloader:

   
   sudo rpi-eeprom-update      
   
   BOOTLOADER: up to date
      CURRENT: Mon 22 Jan 10:41:21 UTC 2024 (1705920081)
       LATEST: Mon 22 Jan 10:41:21 UTC 2024 (1705920081)
      RELEASE: latest (/lib/firmware/raspberrypi/bootloader-2711/latest)
               Use raspi-config to change the release.
   
     VL805_FW: Using bootloader EEPROM
        VL805: up to date
      CURRENT: 000138c0
       LATEST: 000138c0
   

How to Install DKMS on Raspberry Pi 5

1. Introduction

DKMS (Dynamic Kernel Module Support) is a framework developed by Dell that allows dynamic rebuilding of kernel modules whenever the kernel is updated. It helps to avoid manually recompiling modules after every kernel upgrade.

Main Features

• Automatically rebuilds and installs modules when the kernel changes.
• Supports multiple kernel versions simultaneously.
• Commonly used for third-party drivers (e.g., Wi-Fi adapters, GPU drivers, VirtualBox).

2. When Do You Need DKMS?

DKMS is typically needed in the following scenarios on Raspberry Pi 5:

• Installing third-party drivers (e.g., USB Wi-Fi adapters, specific camera drivers, TPU accelerators).
• Frequently updating the kernel (via rpi-update or custom kernels).
• Using PCIe devices (e.g., Coral Edge TPU, SATA adapters, or network cards).

3. Installation Steps

• Step 1: Update System Packages

  sudo apt update && sudo apt upgrade -y

• Step 2: Install DKMS

  sudo apt install dkms -y

• Step 3: Install Kernel Headers and Build Tools

  sudo apt install raspberrypi-kernel-headers build-essential -y

Explanation:

• raspberrypi-kernel-headers: Kernel headers matching your current Pi kernel.
• build-essential: Compilation tools like gcc and make.

4. DKMS Workflow Basics

# Add a module
dkms add -m <module_name> -v <version>

# Build the module
dkms build -m <module_name> -v <version>

# Install the module
dkms install -m <module_name> -v <version>

# Check status
dkms status

5. Verify Installation

dkms --version

2.8.4

dkms status

6. Example: Installing a Wi-Fi Driver with DKMS

git clone https://github.com/tomaspinho/rtl8821ce.git
cd rtl8821ce
sudo dkms add .
sudo dkms build rtl8821ce/1.0.5
sudo dkms install rtl8821ce/1.0.5

dkms status

rtl8821ce, 1.0.5, 6.6.20-v8+, aarch64: installed

7. Reboot and Check Module

sudo reboot
lsmod | grep rtl8821ce

8. Common Issues

Update Pi 5 Kernel Firmware and Install Kernel Headers

Updating your Raspberry Pi 5 to the latest Kernel and installing the appropriate Kernel headers gives you access to pre-release features. This tutorial will guide you through using rpi-update to update the kernel and rpi-source to install the kernel header files.

Upgrade Kernel Firmware

To check the kernel firmware version, run the following command:

uname -a
Linux pi5 6.6.62+rpt-rpi-v8 #1 SMP PREEMPT Debian 1:6.6.62-1+rpt1 (2024-11-25) aarch64 GNU/Linux

If the version ends with v8, the firmware typically does not require an update. However, if it ends with v8+, you may need to downgrade the kernel firmware to install the Coral Edge TPU driver later.

Pre-release versions of the software are not guaranteed to work. Do not use rpi-update on any system unless recommended by a Raspberry Pi engineer to do so. It could leave your system unreliable or broken. Do not use rpi-update as part of any regular update process.

Step 1: Update the System

sudo apt update
sudo apt full-upgrade

Step 2: Install rpi-update

sudo apt install rpi-update

Step 3: Update the Kernel

sudo rpi-update
sudo rm /boot/firmware/.firmware_revision
sudo rm /boot/firmware/.bootloader_revision
sudo reboot

sudo apt-get update
sudo apt install --reinstall raspi-firmware
sudo reboot

Install Kernel Headers

Kernel headers are needed if you plan to build modules or drivers. rpi-source command is a tool that helps fetch the source corresponding to the installed kernel.

Step 1: Install rpi-source to Fetch Kernel Headers

sudo apt install git bc bison flex libssl-dev make libncurses5-dev
sudo wget https://raw.githubusercontent.com/jgartrel/rpi-source/master/rpi-source -O /usr/bin/rpi-source
sudo chmod +x /usr/bin/rpi-source
rpi-source --tag-update

Step 2: Fetch the Kernel Headers

rpi-source --default-config

Method 1: via config.txt

Method 2: via raspi-config

SSD Installation

You must mount an M.2 HAT adapter on the Pi 5 board and connect a ribbon cable to the Pi 5 CM4 port. Complete the following instructions to install the M.2 HAT adapter:

1. First, ensure that your Pi 5 runs the latest software. Run the following command to update:
   

   sudo apt update && sudo apt full-upgrade

2. Next, ensure your Raspberry Pi firmware bootloader is up-to-date [1.2 Update the bootloader]. Run the following command to see what firmware you’re running:

   sudo rpi-eeprom-update

3. Enable PCIe and PCIe Gen 3 support
4. Shut down the system.

   sudo shutdown -P now

5. Disconnect the Raspberry Pi from power before beginning installation.
6. Install M.2 HAT on the Raspberry Pi 5 and mount the PCIe SSD card.

To check that your NVMe drive is connected correctly, boot your Raspberry Pi from another storage device (such as an SD card) and run the following command:

sudo lspci
0000:00:00.0 PCI bridge: Broadcom Inc. and subsidiaries BCM2712 PCIe Bridge (rev 21)
0000:03:00.0 Non-Volatile memory controller: Samsung Electronics Co Ltd NVMe SSD Controller PM9A1/PM9A3/980PRO
0001:00:00.0 PCI bridge: Broadcom Inc. and subsidiaries BCM2712 PCIe Bridge (rev 21)
0001:01:00.0 Ethernet controller: Raspberry Pi Ltd RP1 PCIe 2.0 South Bridge

If your NVMe SSD is not recognized, updating the bootloader firmware is essential! Refer to [1.2 Update the bootloader] to know more details.

Format SSD and Create a Mount Point

• Identify the NVMe SSD:
  Find the SSD device name using lsblk command.
  The output should look like the following:

  
  lsblk
  NAME        MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
  mmcblk0     179:0    0 119.1G  0 disk
  ├─mmcblk0p1 179:1    0   512M  0 part /boot/firmware
  └─mmcblk0p2 179:2    0 118.6G  0 part /
  nvme0n1     259:0    0 238.5G  0 disk
  

  In this case, the SSD name is nvme0n1.
• Partition of the SSD (Optional):
  If you want to partition your SSD before formatting, you can use a tool like fdisk or parted. You can skip this step if you are formatting the entire SSD as a single partition.
  
  To partition the SSD using fdisk, follow these steps:
  Run fdisk on your NVMe SSD (replace /dev/nvme0n1 with your SSD's device name):

  
  sudo fdisk /dev/nvme0n1
  

  Inside fdisk, you can create a new partition table and partitions by following the prompts. Typically, you would:

  1. Press n to create a new partition.
  2. Press p for a primary partition.
  3. Choose the partition number (usually 1 for the first partition).
  4. Accept the default values for the first and last sectors to use the full disk.
  5. Press w to write the partition table and exit.
• Format the SSD:
  Once the SSD is partitioned, or if you're using it as a single unpartitioned device, you can format it with your desired file system. A common choice is ext4.
  To format the entire SSD with ext4, run the following command (replace /dev/nvme0n1 with your specific partition name, for example, /dev/nvme0n1p1):
  

  
  sudo mkfs.ext4 /dev/nvme0n1
  

  If you have multiple partitions, you must format each partition individually by replacing nvme0n1 with the appropriate partition number (for example, nvme0n1p1, nvme0n1p1 ...).
• Mount the SSD:
  Create and mount the directory:

  
  sudo mkdir /ssd
  sudo mount /dev/nvme0n1 /ssd
  

• Verify the SSD is Mounted:
  You can verify that the SSD is mounted correctly by running:

  
  df -h
  

  This command should list your NVMe SSD and its mount point, confirming that it is ready for use.

cd /ssd
dd if=/dev/zero of=./Testingfile bs=100M count=10 oflag=direct
dd if=./Testingfile of=/dev/zero bs=100M count=10 oflag=dsync

Configure Auto-Mount SSD on Boot

Add the SSD to fstab to ensure it auto-mounts on boot.

To boot your Raspberry Pi 5 from an NVMe SSD, follow these steps:

Boot from NVMe SSD

sudo rpi-eeprom-config --edit

BOOT_ORDER=0xf416

PCIE_PROBE=1

Important Notes:

• Only Raspberry Pi OS (Bookworm) is supported.
• Ensure the bootloader is updated and the boot order is set correctly.
• If cloning an existing OS that already has PCIe enabled, you don't need to enable PCIe again.

Flash Pi OS onto NVMe SSD

What is SSD Trim?

TRIM is a command in computing that helps Solid State Drives (SSDs) manage and optimize their storage. When you delete a file on an SSD, the file isn’t immediately erased from the storage cells. Instead, the space is marked as available, but the data remains until the SSD needs to overwrite it. This is different from how traditional Hard Disk Drives (HDDs) operate, where data can be overwritten directly.

TRIM tells the SSD which data blocks are no longer in use (because they've been deleted) so it can wipe those blocks and prepare them for future writes. This process helps maintain the SSD’s speed and efficiency over time.

Importance of the TRIM Function

1. Performance Maintenance:
   • Without TRIM, an SSD would slow down over time as it would have to perform additional steps to overwrite data in blocks that still contain old information. TRIM helps avoid this by preemptively clearing unused blocks, allowing the SSD to maintain optimal performance.
2. Longevity:
   • TRIM reduces the number of write operations to the SSD, which is crucial because SSDs have limited write cycles. By efficiently managing when data is erased, TRIM helps extend the lifespan of the SSD.
3. Efficient Use of Space:
   • With TRIM, the SSD can manage its storage space more efficiently, ensuring that deleted files don't unnecessarily occupy space, leading to more effective use of the available storage.
4. Wear Leveling:
   • SSDs use wear leveling to ensure that all memory cells are used evenly, preventing some cells from wearing out prematurely. TRIM contributes to this by providing the SSD with accurate information about which cells need to be cleared, aiding in better wear leveling.

TRIM is essential for maintaining the performance, efficiency, and lifespan of SSDs. Without it, SSDs would slow down over time and could wear out faster due to inefficient management of data. Therefore, enabling TRIM (if not already enabled by default) is highly recommended for any system using SSDs.

Enable Trim on a Raspberry Pi

Enabling TRIM on a Raspberry Pi 5 involves ensuring that your SSD supports TRIM and that the operating system is configured to use it. Here’s a step-by-step guide to enabling TRIM on a Raspberry Pi 5:

Step 1: Ensure Your SSD Supports TRIM

Before proceeding, make sure that your SSD supports the TRIM command. Most modern SSDs do, but it’s always good to confirm by checking the manufacturer's specifications.

• Find out whether your device already supports TRIM commands.

  
  lsblk --discard
  NAME        DISC-ALN DISC-GRAN DISC-MAX DISC-ZERO
  mmcblk0            0        4M   158.8G         0
  ├─mmcblk0p1        0        4M   158.8G         0
  └─mmcblk0p2        0        4M   158.8G         0
  nvme0n1            0      512B       2T         0
  

  Non-zero values in the DISC-GRAN and DISC-MAX indicate that the devices support TRIM. If the DISC-MAX value is 0B, then TRIM is not enabled.

Step 2: Verify the File System

TRIM is typically supported on file systems like ext4. If your Raspberry Pi uses a different file system, you may need to reformat or choose an appropriate one that supports TRIM.

lsblk -f
NAME        FSTYPE FSVER LABEL  UUID                                 FSAVAIL FSUSE% MOUNTPOINTS
mmcblk0
├─mmcblk0p1 vfat   FAT32 bootfs 9BE2-1346                             434.9M    15% /boot/firmware
└─mmcblk0p2 ext4   1.0   rootfs 12345678-889e-4060-b497-123456789012  102.7G     7% /
nvme0n1     ext4   1.0          9abcdef0-9cf5-46d5-8ef2-123456789012  868.3G     0% /ssd

Step 3: Update Your System

Make sure your Raspberry Pi’s operating system is up-to-date to ensure you have the latest features and bug fixes.

sudo apt-get update
sudo apt-get upgrade

Step 4: Check If TRIM is Already Enabled

• You can check if TRIM is enabled by running the following command:

  
  sudo fstrim -v /ssd
  /ssd: 915.8 GiB (983351111680 bytes) trimmed
  

  If TRIM is enabled, you should see output similar to the above output.
• Alternatively, you can create a Python script to check the TRIM status: (Reference: https://github.com/muhkuh-sys/raspberry_enable_trim)
  • Create a new Python file:

    nano trim.py

  • Add the following code to the trim.py file:

  • Save the file and then run the following command to check TRIM on your device (replace nvme0n1 with your device name):

    
    sudo python3 trim.py nvme0n1
    TRIM is enabled for nvme0n1.
    

    • If TRIM is enabled, the script will output "TRIM is enabled".
    • If you encounter the error message "The required command sg_vpd was not found in the path," you must install the sg3-utils package. Use the following command to do so:

      
      sudo apt-get install sg3-utils
      

Step 5: Enable TRIM (If Not Already Enabled)

When using an NVMe SSD on the Raspberry Pi 5 via a PCIe extension HAT, you may find the drive inaccessible or reporting a size of 0 B. This guide helps you understand why the controller fails to initialize and walks you through the necessary kernel parameter adjustments and verification steps to restore full SSD functionality..

1. Problem Description
   • Symptom 1: With the SSD plugged into a PCIe extension HAT (especially if another PCIe card is also attached), the SSD disappears, or lsblk shows it as 0 B.
   • Symptom 2: sudo nvme list returns no namespaces.
   • Symptom 3: Kernel logs reveal repeated controller resets, I/O errors, and power-state failures.

lsblk
NAME      MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
mmcblk0   179:0    0 238.3G  0 disk 
├─mmcblk0p1 179:1  0   512M  0 part /boot/firmware
└─mmcblk0p2 179:2  0 237.8G  0 part /
nvme0n1   259:0    0     0B  0 disk

sudo nvme list
No entries shown

dmesg | grep -i nvme
… nvme nvme0: min host memory (64 MiB) above limit (0 MiB).
… nvme nvme0: resetting controller due to persistent internal error
… Identify namespace failed (-4)
… Unable to change power state from D3cold to D0, device inaccessible
… Disabling device after reset failure: -19

2. Root Causes
   • Insufficient Host Memory Buffer
     • The kernel parameter nvme.max_host_mem_size_mb=0 restricts the NVMe driver to 0 MiB of host RAM for I/O queues, but it needs at least 64 MiB.
   • Faulty Power-Saving Transitions
     • By default, the Pi 5’s NVMe driver and PCIe link use ASPM (Active State Power Management) and power-saving modes that some SSDs handle poorly, causing the controller to drop into D3cold and fail to resume.

3. Solution Steps
   1. Edit Kernel Command Line

      
      sudo nano /boot/firmware/cmdline.txt
      

      • Remove any instance of nvme.max_host_mem_size_mb=0.
      • Add or set at least nvme.max_host_mem_size_mb=64.
      • Append the following to disable problematic ASPM and power-save features:

        nvme_core.default_ps_max_latency_us=0 pcie_aspm=off pcie_port_pm=off

      • Ensure the entire file remains one continuous line of space-separated parameters.
   2. Update Firmware and Kernel

      
      sudo apt update
      sudo apt full-upgrade
      # (Optional) sudo rpi-update
      

   3. Reboot

      sudo reboot

4. Verification
   1. Confirm Kernel Parameters

      
      cat /proc/cmdline
      # → Should include: nvme.max_host_mem_size_mb=64 nvme_core.default_ps_max_latency_us=0 pcie_aspm=off pcie_port_pm=off

   2. Check dmesg for NVMe Initialization

      dmesg | grep -i nvme

      • Good signs:
        • Allocated 64 MiB host memory buffer
        • nvme0: 4/0/0 default/read/poll queues
      • No longer present:
        • min host memory (64 MiB) above limit (0 MiB)
        • Power-state errors (D3cold, controller is down)
   3. Verify SSD Capacity and Functionality

      lsblk
      # → nvme0n1 should now show its true size (e.g. 500G)
      sudo nvme list
      # → Shows namespace, capacity, format, firmware version

   4. Partition and Format (if required)

      
      sudo parted -s /dev/nvme0n1 mklabel gpt
      sudo parted -s /dev/nvme0n1 mkpart primary 0% 100%
      sudo mkfs.ext4 -L data /dev/nvme0n1p1
      sudo mkdir -p /ssd
      sudo mount /dev/nvme0n1p1 /ssd

By increasing the host memory buffer and disabling problematic power-saving modes, the Pi 5’s NVMe controller can initialize reliably even when sharing the PCIe extension HAT with another device.

The AI Camera uses the Sony IMX500 sensor to run neural-network inference right on the sensor, delivering low-latency, high-performance AI and integrating seamlessly with the Raspberry Pi camera software stack, so you can easily deploy custom models.

1. Hardware Connection
   • With the Pi powered off, unlock the two plastic latches on the AI Camera module and insert the wider end of the ribbon cable (the side with the exposed "teeth") into the module's socket, then lock the latches.
   • Still powered off, unlock the CSI connector on the Pi board (labelled "CAM1" on a Pi 4 or "CAMERA" on a Pi 5).
   • Insert the other end of the ribbon cable into the Pi's CSI slot with the metal contacts facing the USB/Ethernet ports, ensuring it is straight and un-twisted, then lock the latch. Power the Pi back on.
2. System Update & Driver Installation
   • Open a terminal and update your system.

     sudo apt update && sudo apt full-upgrade

   • Install the AI Camera packages (including the IMX500 firmware, pre-trained models, and updated rpicam-apps):

     sudo apt install imx500-all

   • Reboot to load the new drivers:

     sudo reboot

3. Running the Built-In Examples with rpicam-apps
   • Object Detection

     rpicam-hello -t 0s --post-process-file /usr/share/rpi-camera-assets/imx500_mobilenet_ssd.json

     Point objects or gestures at the camera, and you’ll see bounding boxes and labels in the preview window.
   • Pose Estimation

     rpicam-hello -t 0s --post-process-file /usr/share/rpi-camera-assets/imx500_posenet.json

     Move in front of the camera to see a stick-figure skeleton overlay.
   • Recording Video with Overlays

     rpicam-vid -t 10s -o output.mp4 --post-process-file /usr/share/rpi-camera-assets/imx500_mobilenet_ssd.json

     Records a 10-second video with detection boxes and labels.
4. Controlling the AI Camera in Python (Picamera2)
   • Install the Python camera and image-processing packages:

     sudo apt update && sudo apt install python3-opencv python3-munkres

   • Clone the Picamera2 examples and navigate to the IMX500 folder:

     git clone https://github.com/raspberrypi/picamera2.git
     cd picamera2/examples/imx500

   • Run the object-detection demo:

     python imx500_object_detection_demo.py

   • Run the higher-HRNet pose estimation demo:

     python imx500_pose_estimation_higherhrnet_demo.py

Freenove Camera

Freenove offers two types of cameras that are compatible with Raspberry Pi devices:

For the camera to function correctly, you must modify the Raspberry Pi's configuration file to load the appropriate camera driver.

Here, use the IMX219 camera as an example:

1. Open the Configuration File:
   Use the following command to edit the configuration file:

   
   sudo nano /etc/firmware/config.txt
   

2. Disable Automatic Camera Detection:
   Locate the camera_auto_detect setting and change its value to 0:

   
   camera_auto_detect=0
   

3. Add Camera Driver Overlay:
   Scroll to the bottom of the file and add the appropriate overlay based on your Raspberry Pi model:
   
   • For Raspberry Pi 5

     
     dtoverlay=imx219,cam0
     

   • For Raspberry Pi 3/4

     
     dtoverlay=imx219
     

   Note:
   • If you use the OV5647 camera, replace imx219 with ov5647 in the overlay.
   • If your camera is connected to the CAM1 port instead of CAM0 on the Raspberry Pi 5, update the overlay to:

     
     dtoverlay=imx219,cam1
     

4. Save and Exit:
   Save the changes by pressing Ctrl+X, then Y, and Enter.
5. Reboot the Raspberry Pi:
   Apply the changes by rebooting:

   
   sudo reboot
   

Resources

• Freenove web site: https://freenove.com/
• Tutorial: https://freenove.com/tutorial
• FNK0056/B Camera: https://store.freenove.com/products/fnk0056
• Github: https://github.com/Freenove/Freenove_Camera_Module_for_Raspberry_Pi

Steps to Set Up and Use Python Virtual Environment on Raspberry Pi

1. Ensure Python is Installed:
   Python 3 comes pre-installed on Raspberry Pi OS. Verify it:

   
   python3 --version
   

2. Install venv Module
   Ensure the venv module is installed:

   
   sudo apt update
   sudo apt install python3-venv -y
   

3. Create a Virtual Environment:
   Navigate to your project directory or create one:

   
   mkdir MyProject
   cd MyProject 
   

   Create a virtual environment named env:

   
   python3 -m venv env
   

   • env is the name of the virtual environment. You can name it anything.
4. Activate the Virtual Environment:
   Activate the virtual environment to use its isolated Python environment:
   

   
   source env/bin/activate
   

   • Your terminal prompt will change to show the active environment (e.g., (env)).
5. Install Python Packages:
   Once the environment is active, install packages as needed. For example:

   
   pip install numpy
   pip install opencv-python
   

6. List Installed Packages:
   Check installed packages in the virtual environment:

   
   pip list
   

7. Deactivate the Virtual Environment:
   When done, deactivate the environment:

   
   deactivate
   

   This will return you to the Python system environment.
8. Remove a Virtual Environment:
   To delete the virtual environment, remove its directory:

   
   rm -rf env
   

To install multiple versions of Python on Ubuntu, you can use tools like apt, pyenv, or build Python versions manually. Here is how to set it up step-by-step:

Virtual environments provide a way to isolate dependencies and manage Python packages efficiently. Below are two common approaches to setting up and using virtual environments.

Choose the setup that best fits your workflow: per-project for isolated environments or per-user for shared configurations.

1. Download the latest version of Python from the official website.
   • Go to the Python download page: https://www.python.org/downloads/
   • Look for the second table on that page, "Looking for a specific release?":
     
   • Click on the "Download" link corresponding to the newer version. In this case, we select to install Python 3.13.0
   • Then, scroll to the bottom of the download page and find the list of download links:
     
   • Right-click on “Gzipped source tarball” and choose “Copy link address” from the browser contextual menu.
2. Open a terminal on Raspberry Pi OS
   • Download the latest Python file with:

     wget <URL>
     

     Replace the <URL> with the link you copied in the previous step:

     wget https://www.python.org/ftp/python/3.13.0/Python-3.13.0.tgz
     

   • Extract the file

     
     tar zxvf <filename>
     

     Change the Python version if you downloaded another one.

     tar zxvf Python-3.13.0.tgz
     

3. Configure and install Python latest version
   • Move to the folder that contains the extracted files:

     cd Python-3.13.0/

   • Run the configuration command:

     ./configure --enable-optimizations

   • Once done, run this command to install it:

     sudo make altinstall

4. Make Python 3 the default version on Raspberry Pi OS
   • Update the symbolic link for Python

     cd /usr/bin/
     sudo unlink python3
     sudo ln -s /usr/local/bin/python3.13 python3
     

Web Link: https://github.com/WiringPi

WiringPi is a library for the Raspberry Pi that provides a GPIO interface for interacting with the hardware pins on the Pi board. It is designed to make it easier for developers to control the GPIO pins using a familiar and straightforward programming model.

Key Functions and Features of WiringPi

• GPIO Pin Control:
  • Provides an easy-to-use interface to control GPIO (General Purpose Input/Output) pins.
  • Enables setting pins as input or output, reading pin states, and writing signals to the pins.
• Support for Peripheral Devices:
  • WiringPi includes support for common interfaces and peripherals, such as:
    • SPI (Serial Peripheral Interface)
    • I2C (Inter-Integrated Circuit)
    • UART (Universal Asynchronous Receiver-Transmitter)
  • Useful for connecting sensors, displays, motors, and other components.
• Hardware Interaction:
  • WiringPi allows direct access to the Raspberry Pi’s GPIO hardware.
  • Works with /dev/gpiomem or /dev/gpiochip for user-level GPIO access.
• Ease of Programming:
  • Provides bindings for multiple programming languages, including:
    • C (primary interface)
    • Python (through third-party libraries)
    • Bash scripts (via CLI utilities)
  • Simplifies prototyping and development for embedded systems and IoT projects.
• Pin Abstraction:
  Abstracts the physical GPIO pin layout into logical representations such as:
  • BCM mode (Broadcom chip numbering)
  • WiringPi mode (custom numbering system)
  • Physical mode (physical pin layout on the Pi header)
• Utility Commands:
  • Comes with CLI utilities such as gpio for quick testing and debugging of GPIO pins.
  • Examples include:
    • Checking pin states: gpio readall
    • Setting pin output: gpio write

The following steps outline the installation of WiringPi on a Raspberry Pi 5. This guide includes preparing your system, installing dependencies, and setting up WiringPi either by building from source or using prebuilt binaries.

Prerequisites

Before installing WiringPi, ensure your system is up-to-date:

sudo apt update && sudo apt upgrade -y

Ensure python3-apt is correctly installed:

sudo apt install python3-apt

Installing WiringPi

You can either build WiringPi from the source or use prebuilt binaries. Choose the method that suits your needs.

Verification

After completing the installation of WiringPi, you can verify its proper setup by checking the version and system details.

1. Run the following command to check the WiringPi version:

   
   gpio -v
   

   Expected Output: If the installation is successful, you should see output similar to this:

   
   gpio -v
   gpio version: 3.10
   Copyright (c) 2012-2024 Gordon Henderson and contributors
   This is free software with ABSOLUTELY NO WARRANTY.
   For details type: gpio -warranty
   
   Hardware details:
     Type: Pi 5, Revision: 00, Memory: 8192MB, Maker: Sony 
   
   System details:
     * Device tree present.
         Model: Raspberry Pi 5 Model B Rev 1.0
     * Does not support basic user-level GPIO access via memory.
     * Supports basic user-level GPIO access via /dev/gpiomem.
     * Supports basic user-level GPIO access via /dev/gpiochip (slow).
   

   • Note:
     Pay attention to the [Hardware details: Type] field. If it shows "Unknown" instead of "Pi 5", you need to update WiringPi on your Raspberry Pi.
2. List GPIO Pinout:
   Use the following command to display the GPIO pinout of your Raspberry Pi 5:

   
   gpio readall -h
    +-----+-----+---------+------+---+---Pi 5---+---+------+---------+-----+-----+
    | BCM | wPi |   Name  | Mode | V | Physical | V | Mode | Name    | wPi | BCM |
    +-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
    |     |     |    3.3v |      |   |  1 || 2  |   |      | 5v      |     |     |
    |   2 |   8 |   SDA.1 | ALT3 | 1 |  3 || 4  |   |      | 5v      |     |     |
    |   3 |   9 |   SCL.1 | ALT3 | 1 |  5 || 6  |   |      | 0v      |     |     |
    |   4 |   7 | GPIO. 7 |   IN | 0 |  7 || 8  | 1 | ALT4 | TxD     | 15  | 14  |
    |     |     |      0v |      |   |  9 || 10 | 1 | ALT4 | RxD     | 16  | 15  |
    |  17 |   0 | GPIO. 0 |   -  | 0 | 11 || 12 | 0 |  -   | GPIO. 1 | 1   | 18  |
    |  27 |   2 | GPIO. 2 |   -  | 0 | 13 || 14 |   |      | 0v      |     |     |
    |  22 |   3 | GPIO. 3 |   -  | 0 | 15 || 16 | 0 |  -   | GPIO. 4 | 4   | 23  |
    |     |     |    3.3v |      |   | 17 || 18 | 0 |  -   | GPIO. 5 | 5   | 24  |
    |  10 |  12 |    MOSI | ALT0 | 0 | 19 || 20 |   |      | 0v      |     |     |
    |   9 |  13 |    MISO | ALT0 | 0 | 21 || 22 | 0 |  -   | GPIO. 6 | 6   | 25  |
    |  11 |  14 |    SCLK | ALT0 | 0 | 23 || 24 | 1 | OUT  | CE0     | 10  | 8   |
    |     |     |      0v |      |   | 25 || 26 | 1 | OUT  | CE1     | 11  | 7   |
    |   0 |  30 |   SDA.0 |   IN | 1 | 27 || 28 | 1 | IN   | SCL.0   | 31  | 1   |
    |   5 |  21 | GPIO.21 |   -  | 0 | 29 || 30 |   |      | 0v      |     |     |
    |   6 |  22 | GPIO.22 |   IN | 0 | 31 || 32 | 0 |  -   | GPIO.26 | 26  | 12  |
    |  13 |  23 | GPIO.23 |   -  | 0 | 33 || 34 |   |      | 0v      |     |     |
    |  19 |  24 | GPIO.24 |   -  | 0 | 35 || 36 | 0 | IN   | GPIO.27 | 27  | 16  |
    |  26 |  25 | GPIO.25 |   -  | 0 | 37 || 38 | 0 |  -   | GPIO.28 | 28  | 20  |
    |     |     |      0v |      |   | 39 || 40 | 0 |  -   | GPIO.29 | 29  | 21  |
    +-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
    | BCM | wPi |   Name  | Mode | V | Physical | V | Mode | Name    | wPi | BCM |
    +-----+-----+---------+------+---+---Pi 5---+---+------+---------+-----+-----+
   

With the above steps, you can confirm that WiringPi is properly installed and ready for use.

libgpiod (LibGPIO for Devices) is the official Linux kernel interface for GPIO access via the character device model (/dev/gpiochip*). Unlike older libraries like RPi.GPIO or WiringPi, libgpiod is future-proof, supports event-driven GPIO handling, and works natively with modern kernels, making it ideal for the Raspberry Pi 5.

It offers both:

• A Python API (via python3-libgpiod)
• A C language interface (libgpiod-dev)

This allows flexible GPIO control in both rapid prototyping and low-level systems programming.

Installation

• For Python

  
  sudo apt update
  sudo apt install python3-libgpiod
  

• For C/C++

  
  sudo apt update
  sudo apt install libgpiod-dev
  

Verification

• To check the GPIO device

  
  gpiodetect
  gpioinfo  
  

Code Demonstration

• Python Example (LED Blink using GPIO 18)

  
  import gpiod
  import time
  
  chip = gpiod.Chip("gpiochip0")          # Open the first GPIO chip
  line = chip.get_line(18)                # Use GPIO pin 18 (BCM)
  
  # Request the line for output
  line.request(consumer="blink", type=gpiod.LINE_REQ_DIR_OUT)
  
  # Toggle the GPIO
  print("Blinking LED on GPIO 18")
  for i in range(5):
      line.set_value(1)
      time.sleep(0.5)
      line.set_value(0)
      time.sleep(0.5)
  
  line.release()
  
  

• C Example (LED Blink using GPIO 18)

  
  #include <gpiod.h>
  #include <unistd.h>
  #include <stdio.h>
  
  int main() {
      const char *chipname = "gpiochip0";
      struct gpiod_chip *chip;
      struct gpiod_line *line;
      int i;
  
      chip = gpiod_chip_open_by_name(chipname);
      if (!chip) {
          perror("Open chip failed");
          return 1;
      }
  
      line = gpiod_chip_get_line(chip, 18);
      if (!line) {
          perror("Get line failed");
          gpiod_chip_close(chip);
          return 1;
      }
  
      if (gpiod_line_request_output(line, "blink", 0) < 0) {
          perror("Request line as output failed");
          gpiod_chip_close(chip);
          return 1;
      }
  
      printf("Blinking LED on GPIO 18\n");
      for (i = 0; i < 5; i++) {
          gpiod_line_set_value(line, 1);
          usleep(500000);
          gpiod_line_set_value(line, 0);
          usleep(500000);
      }
  
      gpiod_chip_close(chip);
      return 0;
  }