Author	Nejat Hakan
eMail	nejat.hakan@outlook.de
PayPal Me	https://paypal.me/nejathakan

Raspberry Pi workshop - Basic Robot Car (2WD)

Welcome to this comprehensive guide on building your very own Raspberry Pi-controlled 2WD (Two-Wheel Drive) Basic Robot Car! This project is an excellent entry point into the exciting worlds of robotics, embedded systems, and programming with the Raspberry Pi. We will cover everything from selecting components and assembling the hardware to writing Python code for motor control and basic remote operation. By the end of this guide, you will have a functional robot car and a solid foundation for more advanced robotics projects.

Introduction

This project aims to demystify the process of building a simple robot. A 2WD robot car typically consists of a chassis, two independently driven wheels, a caster wheel for balance, a microcontroller (in our case, the Raspberry Pi), a motor driver to interface the Pi with the motors, and a power source. Building such a robot will provide you with hands-on experience in electronics, mechanics, and software development.

Learning Objectives:

Understand the fundamental components of a mobile robot.
Learn how to select appropriate hardware for a Raspberry Pi-based robot.
Gain proficiency in assembling a robot chassis and wiring electronic components.
Master the basics of Raspberry Pi GPIO (General Purpose Input/Output) programming using Python.
Understand the role and operation of an H-Bridge motor driver like the L298N.
Learn to control DC motors for movement, including direction and speed (via PWM).
Explore different power supply strategies for robots.
Implement a simple remote control mechanism using SSH and keyboard input.
Develop troubleshooting skills for common robotics project issues.
Gain insights into SD card preparation and operating system considerations for embedded applications.

Prerequisites:

Basic familiarity with the Raspberry Pi: You should know how to power it on, connect peripherals (if using a desktop environment), and have a general understanding of what a Raspberry Pi is.
Basic Linux command-line knowledge: Navigating directories (cd), listing files (ls), editing text files (e.g., with nano), and running commands will be necessary.
Fundamental Python programming skills: You should understand variables, data types, loops, conditional statements (if/else), and functions.
Access to a computer for flashing the SD card and connecting to the Raspberry Pi via SSH.

Safety Precautions:

Electricity: Always double-check your wiring before applying power. Incorrect wiring can damage your Raspberry Pi, motor driver, or other components. Work with low voltages whenever possible. Disconnect power before making changes to your circuit.
Batteries: Handle batteries with care. Do not short-circuit them, puncture them, or expose them to extreme temperatures. Use appropriate chargers for rechargeable batteries (especially Li-Po/Li-ion).
Motors: Motors can start unexpectedly if there's a software bug or wiring issue. Keep your hands and any loose items (like cables or clothing) away from the wheels when the robot is powered.
Soldering (if applicable): If you choose to solder components, use a well-ventilated area, wear safety glasses, and be careful with the hot soldering iron.
Tools: Use tools appropriately and carefully to avoid injury.

Let's embark on this exciting journey of building your Raspberry Pi robot car!

1. Gathering Your Components

The first step in any hardware project is to gather all the necessary components. A well-chosen set of parts will make the building process smoother and more enjoyable. Below is a detailed list of components required for your 2WD Raspberry Pi Robot Car, along with explanations of their roles.

Core Components:

Raspberry Pi:
- Recommendation: Raspberry Pi 3 Model B+, Raspberry Pi 4 Model B (any RAM variant), or Raspberry Pi Zero 2 W.
- Explanation: The Raspberry Pi will serve as the "brain" of your robot.
  - Pi 3B+/4B: Offer more processing power, built-in Wi-Fi and Bluetooth, and more USB ports, which can be beneficial for future expansions (e.g., adding a camera, more sensors). They have a standard 40-pin GPIO header.
  - Pi Zero 2 W: A smaller, lower-power option, also with Wi-Fi and Bluetooth. It's great for compact builds but has fewer USB ports (requires an adapter) and less processing power than the Pi 3/4. It also has a 40-pin GPIO header (often requiring you to solder the header pins yourself).
  - Avoid older models like the Pi 1, Pi 2, or original Pi Zero/Zero W if possible, as their performance might be limiting, especially if you plan to add more complex functionalities later.
Micro SD Card:
- Recommendation: Minimum 16GB, Class 10 / U1 or U3 A1/A2 rated.
- Explanation: This stores the Raspberry Pi's operating system, your code, and any other necessary software. A faster card (Class 10/U1 or higher, with A1/A2 rating for application performance) will lead to quicker boot times and better overall responsiveness. Brands like SanDisk or Samsung are generally reliable.
Power Supply for Raspberry Pi:
- Recommendation: An official Raspberry Pi power supply or a high-quality third-party supply rated for your Pi model (e.g., 5V 2.5A for Pi 3B+, 5V 3A for Pi 4).
- Explanation: The Raspberry Pi requires a stable and sufficient power source. Using an underpowered or poor-quality supply can lead to instability, SD card corruption, or random reboots, especially when peripherals or GPIO components draw current. For the robot, you might eventually power the Pi from a battery pack via a voltage regulator, but for initial setup and testing, a dedicated wall adapter is essential.
2WD Robot Car Chassis Kit:
- Recommendation: A generic "2WD Smart Robot Car Chassis Kit." These are widely available and affordable.
- Kit typically includes:
  - Acrylic or metal chassis base.
  - 2 x DC geared motors (often yellow, with gearboxes attached).
  - 2 x Wheels compatible with the motors.
  - 1 x Caster wheel (a free-swiveling wheel for balance).
  - Battery holder (usually for 4xAA batteries).
  - Screws, nuts, and standoffs for assembly.
- Explanation: The chassis forms the physical structure of your robot, holding all the components together. The DC motors provide a good balance of torque and speed for small robots.
Motor Driver:
- Recommendation: L298N module or DRV8833 module.
- Explanation: The Raspberry Pi's GPIO pins cannot directly power motors because motors require more current and often higher voltage than the GPIO pins can safely provide. A motor driver acts as an interface.
  - L298N: A very common and inexpensive H-bridge driver. It can control two DC motors independently (direction and speed via PWM). It's robust but has some voltage drop (meaning motors get slightly less voltage than the supply). It also tends to be larger.
  - DRV8833: A more modern and efficient H-bridge driver. It has lower voltage drop, is smaller, and often better suited for lower voltage motors (e.g., 3-6V). It can also control two DC motors.
  - For this guide, we will primarily focus on the L298N due to its widespread availability and common use in beginner kits.
Jumper Wires:
- Recommendation: A pack of mixed types: Male-to-Male (M-M), Male-to-Female (M-F), Female-to-Female (F-F).
- Explanation: These are used to connect components without soldering. You'll need M-F wires to connect Raspberry Pi GPIO pins to the motor driver and potentially other components. M-M or F-F might be useful depending on your specific motor driver module and breadboard usage.
Batteries for Motors (and potentially Pi):
- Recommendation:
  - For motors: 4 to 6 AA Alkaline or NiMH rechargeable batteries (providing 4.8V to 9V depending on type and number).
  - Alternative: A 2S LiPo battery (7.4V) or Li-ion battery pack (e.g., two 18650 cells in series providing ~7.4V), but these require specific chargers and more careful handling.
- Explanation: The motors need their own power source, separate from the Pi's direct supply, to provide sufficient current. The battery holder included in many chassis kits is often for AA batteries.
Battery Holder:
- Explanation: If not included in your chassis kit, or if you choose a different battery type, you'll need an appropriate holder (e.g., for 4xAA, 6xAA, or 18650 cells).

Optional but Recommended Tools and Components:

Small Phillips Head Screwdriver: For assembling the chassis and securing components.
Wire Strippers/Cutters: If you need to modify wires or solder.
Multimeter: Extremely useful for troubleshooting, checking voltages, continuity, and current.
Breadboard (small or half-size): Useful for temporarily prototyping circuits, especially if you plan to add sensors later. Not strictly necessary if you wire directly from Pi to the motor driver.
Soldering Iron and Solder: Some chassis kits come with motors that have pre-soldered wires. If yours don't, or if your Pi Zero 2 W doesn't have a pre-soldered GPIO header, you'll need to do some basic soldering.
USB Wi-Fi Dongle (if using an older Pi without built-in Wi-Fi and you need wireless connectivity).
USB Keyboard and HDMI Monitor (for initial Pi setup if not doing a headless setup).

Sourcing Components: Components can be sourced from various online retailers:

Amazon
Adafruit
SparkFun
Pimoroni
Local electronics stores
AliExpress or eBay (often cheaper, but with longer shipping times and variable quality)

It's often cost-effective to buy a "Raspberry Pi Robot Car Kit" that includes many of these items, but ensure it contains a compatible motor driver and chassis.

Workshop Component Check and Familiarization

Before diving into assembly or software setup, let's take a moment to identify and inspect your components. This will help you get acquainted with what you have and ensure everything is in order.

Objective:

To correctly identify all major components and visually inspect them.

Steps:

Unpack Everything: Carefully unpack all your components. Lay them out on a clean, well-lit workspace. If you have a kit, cross-reference the parts with the kit's inventory list if provided.
Identify the Raspberry Pi:
- Locate your Raspberry Pi board. Notice its key features: GPIO pins (the row of metal pins), USB ports, Ethernet port (if applicable), HDMI port, micro SD card slot, and power input.
Identify the Micro SD Card:
- This is a small, thin card. It might come with an SD card adapter.
Identify the Chassis Parts:
- Lay out the chassis base, motor mounts (if separate), screws, nuts, and standoffs.
- Identify the two DC motors. Note if they have wires pre-attached. Observe the gearbox.
- Find the two wheels and the caster wheel.
Identify the Motor Driver Module (e.g., L298N):
- This is a printed circuit board (PCB) usually with a large heatsink and screw terminals.
- Look for labels on the pins. Common L298N labels include:
  - OUT1, OUT2, OUT3, OUT4: For connecting to the motors.
  - +12V (or VMS, MOTOR_VCC, VS): For motor power supply input.
  - GND: Ground.
  - +5V (or VCC, LOGIC_VCC): For the driver's logic circuit power.
  - ENA, ENB: Enable pins for motor A and motor B (used for PWM speed control).
  - IN1, IN2, IN3, IN4: Control input pins for motor direction.
- Note any jumpers on the module (e.g., a jumper near the 5V regulator on the L298N).
Identify Jumper Wires:
- Examine your collection of jumper wires. Notice the different ends: male (pins) and female (sockets).
Identify Battery Holder and Batteries:
- Check the battery holder type and the batteries you plan to use.
Visual Inspection:
- Briefly inspect each component for any obvious physical damage (bent pins, cracked plastic, loose parts). If you find any significant damage, you may need to contact your supplier for a replacement.
- For the Raspberry Pi, pay close attention to the GPIO pins to ensure none are bent.
- For the motor driver, check that all components (capacitors, IC, heatsink, screw terminals) are securely attached to the board.

By the end of this workshop, you should feel more familiar with the individual parts of your robot car. Keep them organized, perhaps in small bags or compartments, until you need them for assembly. This simple step can save a lot of confusion later.

2. Preparing the Raspberry Pi

With your components gathered, the next crucial step is to prepare the Raspberry Pi. This involves installing an operating system, configuring it for headless operation (so you don't need a dedicated monitor and keyboard for the robot), and installing necessary software. We'll also delve into some important considerations for SD card setup in embedded systems.

Choosing an Operating System (OS)

The official operating system for the Raspberry Pi is Raspberry Pi OS (formerly Raspbian), which is a derivative of Debian Linux. It comes in a few flavors:

Raspberry Pi OS with desktop and recommended software: Full-featured, includes a graphical desktop environment and many pre-installed applications. This is good for general use but consumes more resources (RAM, SD card space, processing power).
Raspberry Pi OS with desktop: Includes the graphical desktop environment but fewer pre-installed applications.
Raspberry Pi OS Lite: This is a minimal image without a graphical desktop. You interact with it solely through the command line (usually via SSH).

Recommendation for Robotics: Raspberry Pi OS Lite.

Why Lite?
- Resource Efficiency: Robots are often resource-constrained (power, processing). A Lite OS consumes less RAM and CPU, leaving more resources for your robotics applications.
- Faster Boot Times: Fewer services to start means the Pi boots up quicker.
- Reduced SD Card Wear: Fewer background processes writing to the SD card (though this can be further optimized).
- Headless Operation: Robots typically operate headlessly (without a monitor/keyboard attached), and the command line is perfectly suited for this.

Flashing the OS onto the SD Card

The process of writing the OS image file to the micro SD card is called "flashing." The easiest way to do this is using the Raspberry Pi Imager tool.

Download Raspberry Pi Imager:
- Go to the official Raspberry Pi website: https://www.raspberrypi.com/software/
- Download and install the Imager for your computer's operating system (Windows, macOS, or Ubuntu/Linux).
Prepare for Headless Setup (Optional but Recommended):
- Before flashing, or immediately after, you can pre-configure Wi-Fi and enable SSH. This allows your Pi to connect to your network and be accessible remotely as soon as it boots.
- The Raspberry Pi Imager has an "Advanced Options" menu (Ctrl+Shift+X or a gear icon) where you can:
  - Enable SSH: Essential for remote access.
  - Set hostname: Give your Pi a unique name on the network (e.g., robotcar).
  - Set username and password: Change from the default pi / raspberry for security.
  - Configure Wi-Fi: Enter your Wi-Fi network's SSID (name) and password.
  - Set locale settings: Timezone and keyboard layout.
Flashing Steps using Raspberry Pi Imager:
- Insert your micro SD card into your computer (you might need an SD card reader or adapter).
- Open Raspberry Pi Imager.
- CHOOSE OS: Click this button. Select "Raspberry Pi OS (other)" and then "Raspberry Pi OS Lite (32-bit)" or "(64-bit)". (32-bit is fine for most robotics; 64-bit can be used if you have specific needs and a compatible Pi like Pi 3/4/Zero2W).
- CHOOSE STORAGE: Click this button and select your micro SD card. Be very careful to select the correct drive, as this process will erase all data on it.
- CONFIGURE (Advanced Options): Before clicking "WRITE", access the advanced options (gear icon or Ctrl+Shift+X):
  - Check "Enable SSH". Choose "Use password authentication".
  - Set a username (e.g., robotadmin) and a secure password.
  - Check "Configure wireless LAN". Enter your Wi-Fi SSID and password. Select your Wi-Fi country.
  - Optionally, set a hostname (e.g., myrobotpi).
  - Set your Locale settings (Time zone, Keyboard layout).
  - Click "SAVE".
- WRITE: Click the "WRITE" button. Confirm that you want to erase the SD card. The Imager will download the OS image (if not already cached) and write it to the card, then verify it. This may take several minutes.
Eject Safely: Once the Imager says "Write Successful," you can remove the SD card from your computer.

Understanding SD Card Architectures and File Systems for Embedded Systems

The micro SD card in your Raspberry Pi is more than just storage; it's the primary "hard drive" for the device. Understanding its structure and how the OS interacts with it is crucial, especially for embedded applications like robots where reliability and longevity can be important.

SD Card Partitions: When Raspberry Pi OS is flashed, the SD card is typically divided into at least two partitions:
1. Boot Partition (/boot or /boot/firmware in newer OS versions): A small partition formatted with FAT32. This partition contains essential files for the Raspberry Pi to boot up, including the bootloader, kernel images, and configuration files (like config.txt and cmdline.txt). FAT32 is used because it's widely compatible and readable by the Pi's initial boot firmware.
2. Root Partition (/): A larger partition formatted with a Linux filesystem, typically ext4. This partition holds the rest of the operating system, user files, applications, and libraries.
The ext4 Filesystem:
- Journaling: ext4 is a journaling filesystem. Journaling helps protect the integrity of the filesystem in case of unexpected power loss or system crashes. Before changes are committed to the main filesystem, they are first recorded in a "journal." If a crash occurs, the system can replay the journal upon reboot to bring the filesystem to a consistent state, reducing the risk of data corruption. This is beneficial but involves more write operations.
- Permissions and Ownership: Like other Linux filesystems, ext4 supports standard Unix-style permissions (read, write, execute for owner, group, and others) and file ownership.
- Performance: ext4 offers good performance for general-purpose use on the Raspberry Pi.
Considerations for Embedded Systems (like your Robot):
- SD Card Lifespan: SD cards have a finite number of write cycles. Frequent write operations (e.g., logging, temporary files, swap usage) can wear out the card over time, potentially leading to corruption or failure. This is a significant concern for unattended or long-running embedded systems.
- Power Loss Corruption: While journaling helps, abrupt power loss (common in battery-powered robots if batteries die suddenly) can still sometimes lead to filesystem corruption on SD cards.
Optimizing for Reliability and Longevity:
1. Read-Only Root Filesystem:
  - Concept: One advanced technique is to configure the root filesystem (/) to mount as read-only. This dramatically reduces writes to the SD card, increasing its lifespan and making the system more resilient to power-loss corruption.
  - How it works: An overlay filesystem (like overlayfs) is often used. The original root filesystem remains read-only, and any writes are directed to a temporary filesystem in RAM (tmpfs). Changes made are lost on reboot unless explicitly committed.
  - Benefits: Significantly improved SD card longevity; system state remains consistent unless intentionally changed.
  - Drawbacks: More complex to set up; applications needing to write persistent data require specific configurations (e.g., writing to a separate read-write partition or external storage). For a basic robot car, this is likely overkill but good to be aware of for future, more critical projects. Tools like raspi-config (under Advanced Options > Overlay FS) can help enable this.
2. Minimizing Writes:
  - Disable unnecessary logging: Configure services to log less or log to RAM (e.g., using log2ram).
  - Mount temporary directories in RAM: Directories like /tmp and /var/log can be mounted as tmpfs. Some of this is done by default in modern Raspberry Pi OS.
  - Careful with applications: Be mindful of how your Python scripts or other applications write data.
Swap Space on Raspberry Pi:
- What is Swap? Swap space is a portion of a storage drive (in this case, the SD card) that the operating system uses as virtual memory when physical RAM (Random Access Memory) becomes full. If the system runs out of RAM, it moves less-used "pages" of memory from RAM to the swap space on the SD card, freeing up RAM for active processes.
- Pros:
  - Can prevent system crashes due to out-of-memory errors if your applications are very memory-intensive.
  - Allows the system to run more applications or larger applications than physical RAM alone would permit.
- Cons for Raspberry Pi:
  - SD Card Wear: Swap involves frequent read/write operations to the SD card, which significantly accelerates wear and reduces the lifespan of the card. This is the primary reason to be cautious with swap on SD cards.
  - Performance Degradation: SD cards are much slower than RAM. When the system heavily relies on swap (a condition known as "swapping" or "thrashing"), performance will degrade dramatically, making the system feel sluggish or unresponsive.
- Default Swap on Raspberry Pi OS: Raspberry Pi OS often configures a swap file (managed by dphys-swapfile) by default. Its size is typically dynamic, often set to a multiple of available RAM or a fixed amount.
- To Use or Not to Use?
  - For most typical Raspberry Pi robot projects (like this 2WD car), especially with a Pi 3B+ or Pi 4 with 1GB+ RAM, you can often operate without swap or with a very small swap file, provided your code is reasonably memory-efficient.
  - If you are running memory-hungry applications (e.g., complex computer vision, large datasets), you might need swap, but be aware of the trade-offs.
- Checking Current Swap Configuration:
  - Open a terminal and use the commands:
```
swapon -s
free -h
```
    swapon -s will show active swap partitions/files. free -h will show total, used, and free RAM and swap.
- Modifying or Disabling Swap (using dphys-swapfile):
  1. Stop the swap service: sudo dphys-swapfile swapoff
  2. Edit the configuration file: sudo nano /etc/dphys-swapfile
    - To disable swap generation, you can set CONF_SWAPSIZE=0.
    - To change the size, set CONF_SWAPSIZE to a specific value in megabytes (e.g., CONF_SWAPSIZE=100 for 100MB).
  3. Uninstall the old swap file (optional but good practice if resizing/disabling): sudo dphys-swapfile uninstall (This command might not exist on all versions or might be part of the stop script logic. The key is that the system should not use an old file if configuration changes). Often, simply reconfiguring and restarting the service is enough. A more robust way is to remove the file: sudo rm /var/swap (if that's the default location).
  4. Re-generate and activate the new swap (if not disabling): sudo dphys-swapfile setup
  5. Start the swap service: sudo dphys-swapfile swapon
  6. Alternatively, to completely disable dphys-swapfile from running at boot:
```
sudo dphys-swapfile swapoff
sudo dphys-swapfile uninstall
sudo systemctl disable dphys-swapfile
```
- Alternatives to SD Card Swap:
  - zram (or zswap): Compresses data in RAM before it would otherwise be swapped out. This effectively increases usable RAM without writing to the SD card. It uses CPU cycles for compression/decompression but is often a better trade-off than SD card swap. Raspberry Pi OS may use zram by default in some configurations. You can install and configure zram-tools.
  - Optimize Code: The best approach is often to write memory-efficient code and choose lightweight alternatives for software.
Hibernation (Suspend-to-Disk):
- What is Hibernation? Hibernation is a power-saving state where the entire current state of the system (contents of RAM, open applications, etc.) is saved to a persistent storage device (like an SSD or hard drive, or in theory, an SD card). The system then powers down completely. When powered back on, it reloads the saved state from disk back into RAM, restoring the system to exactly where it left off.
- Is it Practical for a Raspberry Pi Robot? Generally, no, true OS-level hibernation is not a practical or commonly used feature on Raspberry Pi for several reasons:
  - SD Card Performance/Wear: Writing the entire RAM contents (e.g., 1GB, 2GB, 4GB, or 8GB for a Pi 4) to an SD card during hibernation and reading it back during resume would be very slow and cause significant wear on the SD card.
  - Complexity and Support: Linux kernel support for hibernation on ARM-based Single Board Computers (SBCs) like the Raspberry Pi can be tricky to configure and may not be fully stable or supported by the default Pi kernel and bootloader. A dedicated swap partition (not just a swap file) is usually required, properly sized to hold the RAM image.
  - Boot Time vs. Resume Time: For many robot applications, a clean boot (which is relatively fast on a Pi with a good SD card) might be comparable to or even faster and more reliable than a hibernation resume cycle, especially considering the SD card I/O.
  - Power Management IC (PMIC): The Raspberry Pi's power management is relatively simple. True hibernation requires intricate coordination with hardware power states, which might not be fully implemented or controllable in the way it is on laptops.
- Focus on Other Power-Saving Techniques for Robots: Instead of hibernation, for battery-powered robots, you would typically focus on:
  - Efficient Code: Minimizing CPU usage when idle.
  - Powering Down Peripherals: Turning off motors, sensors, or other modules when not in use.
  - CPU Frequency Scaling: The Pi's CPU automatically scales its frequency down when idle to save power (this is usually enabled by default with the ondemand or schedutil governor).
  - Disabling Unused Hardware Interfaces: If you're not using HDMI, Wi-Fi, or Bluetooth, these can sometimes be programmatically disabled or their power consumption reduced (e.g., tvservice -o to turn off HDMI).
  - Sleep Modes (Light Sleep): Some microcontrollers offer light sleep modes where the CPU halts but RAM contents are preserved, allowing for a quick wake-up. The Raspberry Pi (as a full Linux system) doesn't have a simple "sleep" button like a laptop that's easily leveraged for deep power saving while maintaining state for instant resume in the same way. Shutting down the OS (sudo poweroff) is the most common way to "turn off" the Pi to save significant power, requiring a full reboot to resume.

Initial Boot-up and Configuration

Insert SD Card and Power On:
- Carefully insert the flashed micro SD card into your Raspberry Pi.
- Connect any peripherals you might need for a non-headless first boot (keyboard, mouse, HDMI monitor), though if you configured headless setup in Imager, these aren't strictly necessary.
- Connect the power supply to the Raspberry Pi. It should boot up. You'll see activity lights.
Connecting via SSH (Headless):
- If you configured headless setup, your Pi should connect to your Wi-Fi network. You need to find its IP address.
  - Router's Client List: Log in to your Wi-Fi router's admin page and look for a list of connected devices. You should see the hostname you set (e.g., robotcar or myrobotpi).
  - Network Scanner: Use a network scanning tool on your computer (e.g., nmap on Linux/macOS, "Advanced IP Scanner" on Windows) to find devices on your network.
  - If using Raspberry Pi OS with a desktop on another machine, you might be able to use ping myrobotpi.local (if Avahi/Bonjour is working).
- Once you have the IP address (e.g., 192.168.1.123), open a terminal (on Linux/macOS) or an SSH client like PuTTY (on Windows).
- Connect using SSH:
```
ssh your_username@PI_IP_ADDRESS
# Example: ssh robotadmin@192.168.1.123
# Or: ssh robotadmin@myrobotpi.local
```
- You might see a host key authenticity warning on the first connection. Type yes to continue.
- Enter the password you set during the Imager configuration.
Running sudo raspi-config:
- Even if you used advanced options in Imager, it's good practice to run the Raspberry Pi configuration tool:
```
sudo raspi-config
```
- Navigate using arrow keys, Tab, and Enter.
  - (Optional) System Options > Password: Change your password if you haven't already or want to update it.
  - (Optional) Localisation Options: Verify or set Locale, Timezone, Keyboard Layout, WLAN Country. (Imager should have handled this).
  - Interface Options: This is important.
    - Ensure SSH is enabled (it should be if you're connected via SSH).
    - Later, you might need to enable other interfaces like I2C or SPI if you add sensors that use them. For basic motor control with L298N using GPIOs, these are not strictly needed yet, but it's good to know where they are. GPIO access is generally enabled by default.
  - (Optional) Advanced Options > Expand Filesystem: This ensures the OS uses the entire SD card space. Modern Raspberry Pi OS images usually do this automatically on first boot, but it's worth checking. If the option is there, select it.
- When done, select <Finish> and reboot if prompted.
Updating and Upgrading the System:
- It's crucial to keep your system up-to-date with the latest security patches and software versions.
- Run the following commands:
```
sudo apt update
sudo apt upgrade -y
```
  - sudo apt update: Refreshes the list of available packages from the repositories.
  - sudo apt upgrade -y: Upgrades all installed packages to their newest versions. The -y automatically confirms prompts. This can take some time.

Installing Essential Software

Python 3: Raspberry Pi OS comes with Python 3 pre-installed. You can verify this:
```
python3 --version
```
pip (Python Package Installer): pip for Python 3 is also usually pre-installed. Verify:
```
pip3 --version
```
If for some reason it's missing, you can install it:
```
sudo apt install python3-pip -y
```
GPIO Library: You'll need a library to control the Raspberry Pi's GPIO pins from Python. Two popular choices:
- RPi.GPIO: A traditional, widely used library. It's powerful but can be a bit more verbose for simple tasks.
- gpiozero: A newer library designed to be more user-friendly and intuitive, especially for beginners and common use cases like controlling LEDs, buttons, and motors. It provides higher-level abstractions. Recommendation for this project: gpiozero. It simplifies motor control significantly.
- Install gpiozero:
```
sudo apt install python3-gpiozero -y
# Or, if you prefer using pip and want the latest version:
# sudo pip3 install gpiozero
```
- gpiozero often depends on RPi.GPIO or other underlying libraries (pigpio) to function, so installing it usually brings in what's needed.

Your Raspberry Pi should now be set up with the OS, configured for remote access, updated, and have the necessary Python tools for GPIO control.

Workshop Raspberry Pi Setup

Objective: To flash Raspberry Pi OS Lite, configure it for headless operation, connect via SSH, update the system, and install gpiozero.

Materials:

Raspberry Pi
Micro SD card (16GB+ recommended)
Power supply for Raspberry Pi
Computer with SD card reader and Raspberry Pi Imager installed
Wi-Fi network credentials (SSID and password)

Steps:

Download and Install Raspberry Pi Imager:
- If you haven't already, go to https://www.raspberrypi.com/software/ and download Raspberry Pi Imager for your computer's OS. Install it.
Flash Raspberry Pi OS Lite with Headless Configuration:
- Insert your micro SD card into your computer.
- Open Raspberry Pi Imager.
- Click "CHOOSE OS" -> "Raspberry Pi OS (other)" -> "Raspberry Pi OS Lite (32-bit)" (or 64-bit if preferred and your Pi supports it).
- Click "CHOOSE STORAGE" and select your micro SD card. Double-check you've selected the correct drive!
- Click the gear icon (Advanced options) or press Ctrl+Shift+X.
  - Set a hostname: e.g., robotpi
  - Enable SSH: Choose "Use password authentication".
  - Set username and password: Choose a secure username (e.g., robouser) and password. Remember these!
  - Configure wireless LAN: Enter your Wi-Fi SSID and Password. Select your Wi-Fi country.
  - Configure locale settings: Set your Time zone and Keyboard layout.
  - Click "SAVE".
- Click "WRITE". Confirm any prompts. Wait for the writing and verification process to complete.
- Once done, safely eject the SD card from your computer.
Boot the Raspberry Pi:
- Insert the flashed micro SD card into your Raspberry Pi.
- Do NOT connect a monitor, keyboard, or mouse (we're aiming for headless).
- Connect the power supply to the Raspberry Pi. Allow it a minute or two to boot up and connect to your Wi-Fi network.
Find Pi's IP Address and Connect via SSH:
- Log in to your Wi-Fi router's administration page and find the list of connected clients. Look for the hostname you set (e.g., robotpi) and note its IP address.
- Alternatively, use a network scanner on your computer.
- Open a terminal (Linux/macOS) or PuTTY (Windows).
- Connect using SSH: ssh robouser@YOUR_PI_IP_ADDRESS (replace robouser with your chosen username and YOUR_PI_IP_ADDRESS with the actual IP).
  - Example: ssh robouser@192.168.1.105
- Accept the host key fingerprint if prompted (type yes).
- Enter the password you set. You should now be logged into your Raspberry Pi's command line.
Run raspi-config (Optional Check):
- Type sudo raspi-config.
- Navigate to "Interface Options". Verify "SSH" is enabled. You don't need to change anything else for now.
- Select <Finish>. If it asks to reboot, you can choose "No" for now as we will update next.

Update and Upgrade System:

In the SSH terminal, run:

sudo apt update
sudo apt list --upgradable # Optional: see what will be upgraded
sudo apt upgrade -y

This might take several minutes.

Install gpiozero:
- Once the upgrade is complete, install gpiozero:
```
sudo apt install python3-gpiozero -y
```
(Optional) Check Swap Configuration:
- Let's see the default swap setup.
```
free -h
swapon -s
```
- Note the current swap size. For now, we will leave it as default. You can revisit the "Swap Space on Raspberry Pi" section earlier if you wish to modify it later, but for basic motor control, it's unlikely to be an issue.
Reboot (Good Practice After Major Updates):
```
sudo reboot
```
- Your SSH session will close. Wait a minute or two for the Pi to reboot, then reconnect via SSH using the same command as before.

You have now successfully set up your Raspberry Pi for the robot car project! It's running Raspberry Pi OS Lite, is accessible over your network via SSH, and has the necessary software for controlling its GPIO pins.

3. Assembling the Robot Car Chassis

Now for the hands-on part: assembling the physical structure of your robot. Most 2WD robot car chassis kits are relatively straightforward to assemble, but they often come with minimal instructions. This section provides general guidance. Always refer to any specific instructions or diagrams that came with your kit if available.

General Assembly Tips:

Clear Workspace: Work on a clean, flat surface with good lighting.
Organize Parts: Lay out all screws, nuts, standoffs, and chassis pieces. A small tray or magnetic mat can be helpful for keeping track of small metal parts.
Read Instructions First: If your kit has an assembly guide (even a simple one-page diagram), review it before starting.
Don't Overtighten: Tighten screws firmly but avoid overtightening, especially with acrylic chassis, as they can crack.
Peel Protective Film: Acrylic chassis parts often come with a protective paper or plastic film on both sides. Peel this off before assembly for a cleaner look. This can sometimes be the most time-consuming part!

Typical Assembly Steps for a 2WD Chassis Kit:

The exact order might vary slightly depending on your specific kit design.

Attach Motor Mounts/Brackets (if separate):
- Some kits have separate brackets that hold the motors. Attach these to the main chassis plate first, using the provided small screws and nuts.
Mount the DC Motors:
- Position the DC geared motors onto the chassis or into their brackets.
- Secure them using the appropriate screws. The motor shaft should point outwards, where the wheels will be attached.
- Ensure the motors are aligned and securely fastened. The solder tabs/terminals for connecting wires should be accessible.
- Note: Some motors have wires pre-soldered. If yours don't, you might need to solder wires to the motor terminals now or later. It's often easier to do this before mounting if access is tight.
Attach the Wheels:
- The wheels usually press-fit directly onto the motor shafts.
- Align the D-shaped hole on the wheel hub with the D-shaped motor shaft and push firmly until the wheel is seated. Some kits might have a small screw to secure the wheel to the shaft.
- Ensure the wheels spin freely without wobbling excessively.
Attach the Caster Wheel:
- The caster wheel provides a third point of support and allows the robot to turn easily.
- Assemble the caster wheel itself if it comes in parts (usually a ball or wheel in a housing).
- Mount the caster wheel assembly to the designated end of the chassis (usually the front or back, opposite to the main drive wheels, depending on your desired "front"). Use screws and nuts, and sometimes standoffs to give it proper clearance.
Mount the Battery Holder:
- Find a suitable location on the chassis for the battery holder. Often this is on the top plate or underneath if there's enough clearance.
- Secure it using screws, double-sided tape, or zip ties. Ensure the battery wires can reach where your motor driver will be.
Plan Placement for Raspberry Pi and Motor Driver:
- Before permanently mounting the Raspberry Pi and motor driver, temporarily place them on the chassis.
- Consider:
  - Weight Distribution: Try to keep the center of gravity low and balanced.
  - Accessibility: Ensure you can easily access the Pi's SD card slot, USB ports, and power connector.
  - Wiring: Think about how wires will run between the Pi, motor driver, motors, and battery pack. Keep wire lengths as short as practical and try to avoid a tangled mess.
  - Clearance: Make sure components don't interfere with wheel movement or the caster.
Mount the Raspberry Pi:
- The Raspberry Pi usually mounts on top of the chassis.
- Use plastic or metal standoffs (spacers) to lift the Pi slightly off the chassis, preventing short circuits and allowing airflow.
- Align the Pi's mounting holes with corresponding holes on the chassis and secure it with screws.
Mount the Motor Driver (e.g., L298N):
- Find a convenient spot for the motor driver, typically close to both the Raspberry Pi (for signal wires) and the motors/battery pack (for power wires).
- Secure it using screws and standoffs, or strong double-sided mounting tape if screw holes aren't available/convenient. Ensure the screw terminals and input pins are accessible.

Cable Management Considerations:

Once components are mounted, think about routing your wires neatly.
Use small zip ties or Velcro straps to bundle wires together.
Keep wires away from moving parts like wheels and motor shafts.
Proper cable management not only looks better but also prevents accidental disconnections and makes troubleshooting easier.

Workshop Chassis Assembly

Objective: To assemble the robot car chassis, mount motors, wheels, caster, battery holder, Raspberry Pi, and motor driver.

Materials:

Your 2WD Robot Car Chassis Kit (chassis plate(s), motors, wheels, caster, battery holder, screws, nuts, standoffs)
Raspberry Pi
L298N Motor Driver (or your chosen driver)
Screwdriver appropriate for the screws in your kit
Pliers (can be helpful for holding nuts, optional)
(Optional) Soldering iron and solder if motor wires need attaching

Steps:

As chassis kits vary, these steps are a general guide. Adapt them to your specific kit.

Prepare Your Workspace and Kit:
- Lay out all chassis components on a clean, well-lit surface.
- If your acrylic parts have protective film, carefully peel it off all pieces. This can be tedious but improves the final look.
Motor Wires (If Necessary):
- Check your DC motors. If they do not have wires pre-attached to their solder terminals:
  - Cut two lengths of wire (e.g., red and black, about 10-15 cm long) for each motor.
  - Strip about 5mm of insulation from one end of each wire.
  - "Tin" the stripped wire ends and the motor terminals by applying a small amount of solder.
  - Solder one wire to each terminal on both motors. It's good practice to be consistent (e.g., red wire to the terminal marked '+' or with a red dot, if present, though for DC motors it mainly affects initial direction which can be swapped in software).
Mount Motors to Chassis:
- Identify the motor mounting holes on the chassis plate.
- If your kit uses motor brackets, attach these to the chassis first.
- Secure each motor to the chassis/brackets using the provided screws and nuts. Ensure they are firmly attached and aligned. The motor shafts should face outwards.
Attach Wheels to Motors:
- Take one wheel and press it onto a motor shaft. It should be a snug fit. Ensure it's pushed on straight and as far as it will comfortably go.
- Repeat for the other wheel and motor.
- Spin the wheels by hand to ensure they rotate freely and don't rub against the chassis.
Mount the Caster Wheel:
- Assemble the caster wheel if it's not already assembled.
- Identify the mounting point for the caster wheel on the chassis (usually at the end opposite the driven wheels).
- Attach the caster wheel using the appropriate screws, nuts, and possibly standoffs to ensure it has clearance and swivels freely.
Mount the Battery Holder:
- Choose a location for the battery holder. Common spots are on the top deck of the chassis or slung underneath if there's sufficient ground clearance.
- Secure it using screws or strong double-sided tape. Position it so the wires can conveniently reach the motor driver later.
Position and Mount the Raspberry Pi:
- Place the Raspberry Pi on the chassis, typically on the top deck.
- Use standoffs between the Pi and the chassis to prevent shorts and provide space.
- Align the Pi's mounting holes with holes on the chassis and secure it with screws. Ensure ports (USB, Ethernet, power, SD card) are accessible.
Position and Mount the Motor Driver (L298N):
- Place the L298N module on the chassis. A good location is often near the Raspberry Pi (for easy connection of control signal wires) and also reasonably close to the motors and battery holder.
- Secure it using standoffs and screws if your chassis has suitable mounting holes, or use strong double-sided tape. Ensure the screw terminals for motor and power connections, as well as the input pins, are easily accessible.
Initial Inspection:
- Once everything is mounted, give the robot a visual check:
  - Are all components securely fastened?
  - Do the wheels spin freely?
  - Does the caster wheel swivel correctly?
  - Is there reasonable space for wiring?

Your robot chassis is now assembled! It might look a bit bare without wires, but the mechanical structure is complete. In the next section, we'll dive into understanding and wiring the motor driver.

4. Understanding and Wiring the L298N Motor Driver

The Raspberry Pi's GPIO pins are fantastic for sending control signals, but they are not designed to power motors directly. Motors require significantly more current than GPIO pins can safely supply, and often operate at different voltage levels. Attempting to drive a motor directly from a GPIO pin will likely damage your Raspberry Pi. This is where a motor driver, like the L298N module, comes in.

What is an H-Bridge? Why Do We Need a Motor Driver?

DC Motors and Direction Control: A simple DC motor spins in one direction if current flows through it one way, and in the opposite direction if the current polarity is reversed. To control both the speed and direction of a motor, we need a circuit that can switch the direction of current flow.
The H-Bridge Circuit: An H-Bridge is an electronic circuit that enables a voltage to be applied across a load (like a DC motor) in either direction. It's called an H-Bridge because it typically uses four switches (transistors or MOSFETs) arranged in a configuration that resembles the letter "H", with the motor placed in the center (the "bridge" part).
- By closing two specific switches, current flows one way through the motor.
- By closing the other two specific switches, current flows the opposite way.
- By opening all switches, or closing switches on the same side, the motor can be made to stop (either coasting or braking, depending on the configuration).
PWM for Speed Control: Pulse Width Modulation (PWM) is a technique used to control the average power delivered to an electrical device. By rapidly switching the power to the motor ON and OFF at a high frequency, and varying the "duty cycle" (the proportion of time the power is ON), we can effectively control the motor's speed. A higher duty cycle means more average power and a faster motor.
Motor Driver ICs (like L298N): The L298N is an integrated circuit (IC) that contains two full H-Bridges. This means a single L298N chip can control two DC motors independently, or one bipolar stepper motor. The L298N modules commonly available typically include the L298N IC, along with necessary protection diodes, capacitors, screw terminals, and sometimes an onboard 5V regulator.

Detailed Explanation of L298N Module Pins

L298N modules are very common and generally have similar pinouts, though exact labeling can vary slightly. Refer to the markings on your specific module.

Motor Power Connections:
- OUT1, OUT2: Connection terminals for Motor A.
- OUT3, OUT4: Connection terminals for Motor B.
Power Supply Inputs:
- VMS / VS / MOTOR_VCC / +12V (often labeled as +12V but can accept 6V-35V typically): This is where you connect the positive terminal of your motor power supply (e.g., your AA battery pack: 4xAA ≈ 6V, 6xAA ≈ 9V). The L298N has a voltage drop, so your motors will receive about 1.4V to 2V less than what you supply here.
- GND: Ground connection. This must be connected to the negative terminal of your motor power supply AND also to a ground (GND) pin on your Raspberry Pi (this is called a common ground and is crucial for signal integrity).
- VCC / +5V / LOGIC_VCC / VL: This is the power supply for the L298N's internal logic circuits.
  - Onboard 5V Regulator Jumper: Many L298N modules have an onboard 5V linear regulator (often a 78M05).
    - If Motor Supply (VMS) is > 7V (approx) AND the jumper is IN PLACE: The L298N module will generate its own 5V logic power from the motor supply. In this case, this VCC pin can actually output 5V, which some people might use to power the Raspberry Pi. This is generally NOT recommended for powering the Pi because the regulator on the L298N is not very robust, has limited current capacity, and can overheat. It's much safer to power the Pi separately. If the jumper is in and VMS is high, do not connect this pin to the Pi's 5V output as you'd be connecting two power sources together.
    - If Motor Supply (VMS) is < 7V OR the jumper is REMOVED: The onboard regulator is disabled (or won't work effectively). You must supply 5V to this VCC pin from an external source, such as a 5V output pin from your Raspberry Pi. This is the safer and more common configuration when your motor voltage is around 6V (like 4xAA batteries).
Logic Control Inputs (from Raspberry Pi GPIOs):
- IN1, IN2: Control inputs for Motor A.
  - IN1=HIGH, IN2=LOW: Motor A spins one direction.
  - IN1=LOW, IN2=HIGH: Motor A spins the opposite direction.
  - IN1=LOW, IN2=LOW: Motor A brakes (stops quickly).
  - IN1=HIGH, IN2=HIGH: Motor A brakes (stops quickly, some drivers might behave differently, usually low/low is preferred for stop).
- IN3, IN4: Control inputs for Motor B (operate similarly to IN1, IN2 for Motor B).
Enable Pins (for PWM Speed Control):
- ENA (Enable A): Controls Motor A. If this pin is HIGH (or connected to 5V via a jumper if present), Motor A is enabled and will respond to IN1/IN2. If LOW, Motor A is disabled (coasts). To control speed with PWM, you connect a PWM signal from the Raspberry Pi to this pin. Many L298N modules come with a jumper on ENA (and ENB). If you want to use PWM for speed control, REMOVE this jumper. If you leave the jumper on, ENA is permanently HIGH, and the motor will run at full speed (for the given VMS voltage).
- ENB (Enable B): Controls Motor B similarly to ENA for Motor A. Remove the jumper if using PWM for Motor B.

Wiring Diagram Overview: Pi to L298N

(A text-based diagram is hard to make perfect, but here's the concept. Always double-check with your L298N module's specific pin labels.)

MOTOR BATTERY PACK (e.g., 4-6 AA batteries, 6V-9V)
  (+) ----> L298N VMS (Motor Power Input)
  (-) ----> L298N GND
       |
       `----> Raspberry Pi GND (any GND pin)  <--- CRITICAL COMMON GROUND

Raspberry Pi:
  GPIO X (e.g., GPIO17) ----> L298N IN1
  GPIO Y (e.g., GPIO27) ----> L298N IN2
  GPIO Z (e.g., GPIO22) ----> L298N IN3
  GPIO W (e.g., GPIO23) ----> L298N IN4

  (For PWM Speed Control - Jumpers on ENA/ENB on L298N REMOVED)
  GPIO A (PWM capable, e.g., GPIO12) ----> L298N ENA
  GPIO B (PWM capable, e.g., GPIO13) ----> L298N ENB

  (For L298N Logic Power - Jumper for 5V Regulator on L298N REMOVED or VMS < 7V)
  Raspberry Pi 5V ----> L298N VCC/LOGIC_VCC/+5V input

Motors:
  Motor A Terminal 1 ----> L298N OUT1
  Motor A Terminal 2 ----> L298N OUT2
  Motor B Terminal 1 ----> L298N OUT3
  Motor B Terminal 2 ----> L298N OUT4

Powering Considerations - The L298N 5V Jumper:

Scenario 1: Motor Supply Voltage (VMS) is > 7V (e.g., 9V from 6xAA or 7.4V LiPo)
- You can leave the 5V regulator jumper ON the L298N module.
- The L298N module will generate its own 5V for its logic.
- The VCC/+5V pin on the L298N will output 5V. DO NOT connect this to the Raspberry Pi's 5V output pin.
- You still need a common ground between the Pi and the L298N.
Scenario 2: Motor Supply Voltage (VMS) is < 7V (e.g., 6V from 4xAA)
- The onboard 5V regulator will not work reliably or at all.
- You MUST REMOVE the 5V regulator jumper (if present).
- You MUST SUPPLY 5V to the L298N's VCC/+5V logic input pin. This 5V typically comes from one of the Raspberry Pi's 5V output pins.
- This is the recommended setup for most beginner projects using 4xAA batteries, as it's more predictable.

Crucial: Common Ground No matter how you power the L298N's logic, you MUST connect a Ground (GND) pin from the Raspberry Pi to the Ground (GND) terminal on the L298N module that is also connected to your motor battery pack's negative terminal. Without a common ground reference, the logic signals from the Pi to the L298N will not be interpreted correctly, and the motors will not work or will behave erratically.

Workshop Wiring the Motor Driver

Objective: To correctly wire the L298N motor driver to the Raspberry Pi, motors, and motor power supply.

Materials:

Assembled robot chassis with Raspberry Pi and L298N module mounted.
Motors (already mounted, wires possibly attached).
Battery pack for motors (e.g., 4xAA batteries, providing ~6V).
Jumper wires (Male-to-Female for Pi to L298N inputs, potentially Female-to-Female or Male-to-Male for motor connections if motors have pins/sockets).
Screwdriver for L298N screw terminals.
(Your chosen Raspberry Pi GPIO pins for control - decide these now).

Recommended Raspberry Pi GPIO Pins (using BCM numbering):

For L298N IN1: GPIO 17
For L298N IN2: GPIO 27
For L298N IN3: GPIO 22
For L298N IN4: GPIO 23
For L298N ENA (Motor A Speed PWM): GPIO 12 (Hardware PWM capable)
For L298N ENB (Motor B Speed PWM): GPIO 13 (Hardware PWM capable)

(You can choose other GPIO pins, but these are conveniently located and gpiozero handles PWM on non-hardware PWM pins using software PWM if needed. However, for best performance, hardware PWM pins are preferred for ENA/ENB.)

Wiring Steps (Carefully! Double-check each connection):

ASSUMPTION for this workshop: You are using a motor power supply around 6V (e.g., 4xAA batteries). Therefore, we will REMOVE the 5V regulator jumper on the L298N and power its logic from the Pi's 5V.

Safety First! Ensure your Raspberry Pi is powered OFF and the motor battery pack is DISCONNECTED or batteries removed.
L298N Jumper Configuration:
- Locate the jumper on the L298N module that enables/disables the onboard 5V regulator (usually near the VCC/+5V/LOGIC_VCC pin). REMOVE this jumper.
- Locate the jumpers on ENA and ENB. REMOVE both of these jumpers. This allows us to control speed via PWM.
Connect Motors to L298N Output Terminals:
- Motor A (e.g., left motor):
  - Connect one wire from Motor A to the OUT1 screw terminal on the L298N.
  - Connect the other wire from Motor A to the OUT2 screw terminal.
  - (Don't worry too much about which wire goes to OUT1 vs OUT2 yet; if the motor spins the wrong way later, you can swap these two wires or change it in software.)
- Motor B (e.g., right motor):
  - Connect one wire from Motor B to the OUT3 screw terminal.
  - Connect the other wire from Motor B to the OUT4 screw terminal.
Connect Motor Power Supply to L298N:
- Take your motor battery pack (e.g., 4xAA holder).
- Connect the positive (+) wire from the battery pack to the VMS (or +12V, MOTOR_VCC) screw terminal on the L298N.
- Connect the negative (-) wire (ground) from the battery pack to one of the GND screw terminals on the L298N.
Connect L298N Logic Power (from Raspberry Pi):
- Use a Male-to-Female jumper wire.
- Connect the female end to a 5V pin on the Raspberry Pi (Pin 2 or Pin 4 on the 40-pin header).
- Connect the male end to the VCC (or +5V, LOGIC_VCC) pin on the L298N module (the pin where you removed the 5V regulator jumper).
Connect Common Ground (CRUCIAL):
- Use a Male-to-Female jumper wire.
- Connect the female end to a GND pin on the Raspberry Pi (e.g., Pin 6, 9, 14, 20, 25, 30, 34, 39).
- Connect the male end to another GND pin/terminal on the L298N module (this GND should be common with the motor battery pack's negative terminal).
Connect L298N Control Inputs to Raspberry Pi GPIOs:
- Use Male-to-Female jumper wires for each connection:
  - Pi GPIO 17 (Pin 11) <---> L298N IN1
  - Pi GPIO 27 (Pin 13) <---> L298N IN2
  - Pi GPIO 22 (Pin 15) <---> L298N IN3
  - Pi GPIO 23 (Pin 16) <---> L298N IN4
Connect L298N Enable Pins to Raspberry Pi GPIOs (for PWM):
- Use Male-to-Female jumper wires:
  - Pi GPIO 12 (Pin 32) <---> L298N ENA
  - Pi GPIO 13 (Pin 33) <---> L298N ENB

Final Wiring Check:

POWER OFF!
Carefully review every single connection. Compare it to your diagram and the steps above.
Common Mistakes to Look For:
- No common ground between Pi and L298N motor power supply.
- Motor power connected to Pi's 5V or GPIOs (don't do this!).
- Pi's 5V connected to L298N's VMS/Motor Power Input.
- Incorrect GPIO pins used.
- Loose connections in jumper wires or screw terminals.
- Short circuits (e.g., bare wires touching).

Once you are absolutely confident in your wiring, you can proceed to the next section where we'll write Python code to test the motors. For the first test, it's advisable to have the robot wheels off the ground, just in case it tries to run away unexpectedly! You can prop the robot up on a small box or block.

5. Basic Motor Control with Python

With the hardware assembled and wired, it's time to bring your robot to life with code! We'll use Python and the gpiozero library to control the motors. gpiozero provides a very intuitive way to interact with common components like motors.

Introduction to GPIO Programming with gpiozero

GPIO Pins: The Raspberry Pi's General Purpose Input/Output (GPIO) pins can be configured as inputs (to read signals from sensors) or outputs (to send signals to control devices like LEDs or motor drivers).
gpiozero Library: This library abstracts away many of the low-level details of GPIO control. For motors, it offers a Motor class that makes it easy to control direction and speed.
BCM vs. Board Pin Numbering:
- BCM (Broadcom SOC Channel): Refers to the GPIO numbering scheme used by the Broadcom chip on the Pi. This is the preferred scheme for gpiozero and most Python GPIO libraries as it's consistent across different Pi board revisions (for the main GPIOs). E.g., GPIO17, GPIO27.
- Board: Refers to the physical pin numbers on the 40-pin header (1-40). This can be confusing as the numbering is not directly related to the GPIO function.
- We will use BCM numbering for our gpiozero scripts.

The gpiozero.Motor Class

The Motor class in gpiozero can be initialized in a few ways. For controlling a motor with separate forward and backward pins (like IN1/IN2 on the L298N), you provide two GPIO pin numbers.

Basic Usage for One Motor (without PWM enable pin initially): If you were controlling direction with IN1 and IN2, and had ENA hard-wired to HIGH (jumper on), you'd tell gpiozero which GPIOs are connected to IN1 and IN2.

from gpiozero import Motor
from time import sleep

# Assuming L298N IN1 is connected to GPIO17, IN2 to GPIO27
motor_a = Motor(forward=17, backward=27)

print("Motor A Forward")
motor_a.forward()  # IN1=HIGH, IN2=LOW
sleep(2)

print("Motor A Backward")
motor_a.backward() # IN1=LOW, IN2=HIGH
sleep(2)

print("Motor A Stop")
motor_a.stop()     # IN1=LOW, IN2=LOW
sleep(1)

Using Motor with an Enable Pin for PWM Speed Control: The Motor class also accepts an enable parameter for the GPIO pin connected to the L298N's ENA (or ENB) pin. When an enable pin is provided, the forward() and backward() methods can take a speed argument (a value from 0.0 to 1.0). gpiozero will then use PWM on the enable pin to control the motor's speed.

from gpiozero import Motor
from time import sleep

# Motor A: L298N IN1=GPIO17, IN2=GPIO27, ENA=GPIO12
motor_a = Motor(forward=17, backward=27, enable=12)

print("Motor A Forward at half speed")
motor_a.forward(speed=0.5) # Speed is 0.0 to 1.0
sleep(2)

print("Motor A Backward at full speed")
motor_a.backward(speed=1.0)
sleep(2)

print("Motor A Stop")
motor_a.stop()
sleep(1)

print("Motor A Forward, ramping speed")
motor_a.forward() # Defaults to full speed if no speed arg given after an enable pin is set
for i in range(101):
    current_speed = i / 100.0
    motor_a.value = current_speed # .value can be -1.0 to 1.0 for bi-directional speed
    print(f"Speed: {current_speed:.2f}")
    sleep(0.05)
sleep(1)

motor_a.stop()

Note: motor_a.value is a powerful property. Setting motor_a.value = 0.5 means forward at half speed. Setting motor_a.value = -0.5 means backward at half speed. motor_a.value = 0 means stop.

Python Script to Control Both Motors

Let's define our motors based on the wiring from the previous workshop:

Motor A (e.g., Left): IN1=GPIO17, IN2=GPIO27, ENA=GPIO12
Motor B (e.g., Right): IN3=GPIO22, IN4=GPIO23, ENB=GPIO13

# full_robot_control.py
from gpiozero import Motor
from time import sleep

# Define motors with BCM GPIO numbers
# Left motor (Motor A on L298N)
motor_left_forward_pin = 17  # Connected to IN1
motor_left_backward_pin = 27 # Connected to IN2
motor_left_enable_pin = 12   # Connected to ENA (PWM)

# Right motor (Motor B on L298N)
motor_right_forward_pin = 22 # Connected to IN3
motor_right_backward_pin = 23# Connected to IN4
motor_right_enable_pin = 13  # Connected to ENB (PWM)

# Initialize Motor objects
# Note: If your motors spin the 'wrong' way for 'forward',
# you can swap the forward and backward pin numbers in the Motor() constructor,
# e.g., Motor(forward=motor_left_backward_pin, backward=motor_left_forward_pin, ...)
# OR swap the physical wires at OUT1/OUT2 (or OUT3/OUT4)
motor_left = Motor(forward=motor_left_forward_pin, backward=motor_left_backward_pin, enable=motor_left_enable_pin)
motor_right = Motor(forward=motor_right_forward_pin, backward=motor_right_backward_pin, enable=motor_right_enable_pin)

def move_forward(speed=0.7):
    print(f"Moving Forward at speed {speed}")
    motor_left.forward(speed=speed)
    motor_right.forward(speed=speed)

def move_backward(speed=0.7):
    print(f"Moving Backward at speed {speed}")
    motor_left.backward(speed=speed)
    motor_right.backward(speed=speed)

def turn_left(speed=0.6):
    print(f"Turning Left at speed {speed}")
    motor_left.backward(speed=speed) # Left motor backward
    motor_right.forward(speed=speed) # Right motor forward

def turn_right(speed=0.6):
    print(f"Turning Right at speed {speed}")
    motor_left.forward(speed=speed)  # Left motor forward
    motor_right.backward(speed=speed)# Right motor backward

def stop_motors():
    print("Stopping Motors")
    motor_left.stop()
    motor_right.stop()

# Main test sequence
if __name__ == "__main__":
    try:
        print("Robot Motor Test Sequence")

        move_forward(0.5) # Forward at half speed
        sleep(2)

        move_backward(0.5) # Backward at half speed
        sleep(2)

        turn_left(0.4) # Turn left at slower speed
        sleep(1.5)

        turn_right(0.4) # Turn right at slower speed
        sleep(1.5)

        stop_motors()
        print("Test sequence complete.")

    except KeyboardInterrupt:
        print("Program terminated by user")
    finally:
        stop_motors() # Ensure motors are stopped on exit
        print("Motors stopped. GPIO cleanup will happen automatically by gpiozero.")

Understanding PWM for Speed Control

How PWM Works: PWM works by switching a digital signal ON and OFF very rapidly. The "duty cycle" is the percentage of time the signal is ON during one period of the signal. For example:
- 0% duty cycle: Signal is always OFF (motor gets no power).
- 50% duty cycle: Signal is ON for half the time and OFF for half the time (motor gets half power).
- 100% duty cycle: Signal is always ON (motor gets full power).
gpiozero and PWM: When you provide an enable pin to the Motor class and use the speed parameter (0.0 to 1.0), gpiozero handles generating the PWM signal on that enable pin.
- If the enable pin is a hardware PWM pin on the Pi (like GPIO12, GPIO13, GPIO18, GPIO19 on most Pis), gpiozero will try to use hardware PWM, which is more precise and uses less CPU.
- If it's not a hardware PWM pin, gpiozero uses software PWM, which can work well but uses more CPU resources and might be slightly less stable at very high frequencies or very low duty cycles. For our L298N (which typically operates at PWM frequencies of a few hundred Hz to a few kHz), software PWM is often acceptable if hardware PWM pins are unavailable. We've chosen GPIO12 and GPIO13 which are hardware PWM capable.
L298N and PWM: The ENA and ENB pins on the L298N are designed for this. When ENA is HIGH, Motor A is "active". When ENA is fed a PWM signal, the average voltage effectively applied to Motor A (and thus its speed) is controlled by the duty cycle of the PWM signal.

Workshop First Motor Test

Objective: To write and run Python scripts to test individual motor control, then combined robot movements, including speed control.

Materials:

Your fully assembled and wired robot car.
Raspberry Pi powered on and accessible via SSH.
Motor battery pack connected to L298N and batteries inserted.
Robot propped up so wheels are off the ground for initial tests.

Steps:

Prepare Robot for Test:
- Prop your robot up on a small box, book, or inverted bowl so that its wheels can spin freely without moving the robot. This is a safety measure for the first tests.
- Ensure your motor battery pack is connected to the L298N and has fresh batteries.
- Power on your Raspberry Pi (if it's not already on).
Connect to Raspberry Pi via SSH:
- ssh your_username@PI_IP_ADDRESS
Create a Project Directory:
- It's good practice to keep your code organized.
```
mkdir ~/robot_car
cd ~/robot_car
```

Write the Single Motor Test Script (Optional, but good for initial check):

Let's create a very simple script to test one motor, say the left motor.
nano test_left_motor.py

Enter the following code (adjust GPIO pins if you used different ones):

from gpiozero import Motor
from time import sleep

# Left motor: IN1=GPIO17, IN2=GPIO27, ENA=GPIO12
motor_left = Motor(forward=17, backward=27, enable=12)

print("Testing Left Motor...")
try:
    print("Forward at 30% speed")
    motor_left.forward(speed=0.3)
    sleep(2)

    print("Backward at 60% speed")
    motor_left.backward(speed=0.6)
    sleep(2)

    print("Forward at 100% speed")
    motor_left.forward(speed=1.0)
    sleep(2)

    print("Stopping motor")
    motor_left.stop()
    sleep(1)
    print("Test complete.")

except KeyboardInterrupt:
    print("Program stopped by user")
finally:
    motor_left.stop()
    print("Motor stopped, cleanup by gpiozero.")

Save the file (Ctrl+O, Enter) and exit nano (Ctrl+X).

Run the Single Motor Test Script:
- python3 test_left_motor.py
- Observe:
  - Does the left motor spin forward, then backward, then forward at full speed, then stop?
  - Does it respond to the different speed settings?
  - Listen for any unusual noises.
- Troubleshooting:
  - No movement:
    - Double-check all wiring (Pi to L298N, L298N to motor, L298N power).
    - Is the motor battery pack charged and connected correctly?
    - Is the common ground connected?
    - Are the L298N jumpers for ENA/ENB and 5V logic correctly removed/set as per our workshop instructions? (ENA/ENB jumpers removed, 5V regulator jumper removed, Pi 5V connected to L298N logic VCC).
    - Are GPIO pin numbers correct in the script?
  - Motor spins but in the wrong direction for "forward":
    - You can either swap the forward=17, backward=27 to forward=27, backward=17 in the Motor() constructor for motor_left.
    - OR, power everything down and physically swap the two wires connecting that motor to the L298N (e.g., swap wires at OUT1 and OUT2).
  - Only moves at full speed (PWM not working): Ensure ENA jumper is removed from L298N and GPIO12 is correctly wired to ENA.
Write the Full Robot Control Script:
- nano full_robot_control.py
- Copy and paste the full_robot_control.py code provided earlier in this section (the one with move_forward, turn_left, etc. functions).
- Save and exit.
Run the Full Robot Control Script:
- python3 full_robot_control.py
- Observe:
  - Do both motors operate together for forward and backward movements?
  - When turn_left is called, does the left motor spin backward and the right motor spin forward (or vice-versa, resulting in a turn)?
  - When turn_right is called, does it perform the opposite turn?
  - Do the motors respond to the speed settings in the functions?
- Adjusting for Correct Movement:
  - If robot spins instead of going forward: One motor is likely wired/defined backward relative to the other. For example, if for move_forward, one motor goes forward and the other goes backward, identify which motor is "wrong" for forward motion and either swap its wires at the L298N or swap its forward and backward pin assignments in the Motor() constructor in your Python script.
  - If turns are reversed (turn_left makes it turn right): You need to swap the logic within your turn_left and turn_right functions, or adjust which motor is considered "left" vs "right" in your script. This often takes a bit of trial and error to get intuitive control. A common convention is:
    - move_forward(): Both motors spin to propel the chassis forward.
    - turn_left() (pivot turn): Left motor backward, Right motor forward.
    - turn_right() (pivot turn): Left motor forward, Right motor backward.
Test on the Ground (Cautiously!):
- Once you're confident the basic movements are working correctly with the wheels off the ground, you can try it on a clear, flat surface.
- Be ready to stop the script (Ctrl+C in the SSH terminal) if it behaves unexpectedly.
- Run python3 full_robot_control.py again.
- Observe its movement on the ground. You might find that speeds that worked well off the ground need adjustment due to friction and weight.

Congratulations! You've successfully controlled your robot car's motors using Python. You can now experiment by changing speeds, creating more complex movement sequences, or modifying the turn behaviors (e.g., one motor stopped, other forward for a wider turn).

6. Powering Your Robot

A reliable power source is critical for any mobile robot. Your robot has two main components that need power: the Raspberry Pi and the motors (via the L298N motor driver). It's generally best practice to power these separately or with careful consideration for current demands.

Battery Options:

AA Alkaline/NiMH Batteries:
- Pros: Readily available, relatively inexpensive, easy to find holders for. NiMH are rechargeable.
- Cons:
  - Alkaline: Not rechargeable, voltage drops significantly under load and as they discharge. Lower current capability compared to Li-ion/LiPo.
  - NiMH: Rechargeable, better current capability than alkaline, but lower nominal voltage per cell (1.2V vs 1.5V for alkaline). So, 4xAA NiMH is 4.8V, 5xAA is 6V, 6xAA is 7.2V.
- Usage: Typically used for powering the motors. A pack of 4-6 AA batteries (providing 4.8V to 9V) is common for L298N-based robots.
Lithium-ion (Li-ion) / Lithium Polymer (LiPo) Batteries:
- Pros: High energy density (more power in a smaller, lighter package), high discharge rates (can provide lots of current), rechargeable. LiPo batteries come in various shapes and sizes. Common Li-ion cells are 18650s (3.7V nominal).
- Cons:
  - Safety: Require more care. Overcharging, over-discharging, or puncturing can lead to fire or explosion.
  - Charger: Need a specific Li-ion/LiPo balance charger.
  - Protection Circuitry: Should ideally be used with a Battery Management System (BMS) or protection circuit to prevent over-discharge, over-charge, and over-current.
- Usage: A 2S (2 cells in series) LiPo or Li-ion pack (nominal 7.4V) is a popular choice for powering both motors (directly or via L298N) and the Raspberry Pi (via a voltage regulator).
USB Power Banks:
- Pros: Convenient, provide a regulated 5V output, often have built-in protection circuits, rechargeable via USB.
- Cons:
  - Current Limits: May not supply enough sustained current to power both the Raspberry Pi and high-torque motors simultaneously, especially during motor startup or stalls.
  - Auto-Shutdown: Some power banks have an auto-shutdown feature if the current draw is too low (e.g., if the Pi is idle), which can be problematic. Others may shut down if the current draw is too high.
  - Two Needed?: You might use one for the Pi and a separate battery pack for motors, or find a high-current power bank capable of handling both (less common for beginner setups).
- Usage: Excellent for powering the Raspberry Pi. Can sometimes power very small motors or low-power motor drivers if the current output is sufficient (e.g., 2A+).

Powering the Raspberry Pi:

Via its USB-C/Micro-USB Port: This is the standard and safest way. Connect it to:
- A dedicated USB wall adapter (during development/testing).
- A USB power bank (for mobile operation).
- A 5V output from a voltage regulator (if deriving power from a higher voltage motor battery).
Via GPIO 5V Pins (Pins 2 & 4):
- You can power the Pi by supplying a stable, regulated 5V directly to these pins.
- Caution: This bypasses the Pi's built-in input protection circuitry (polyfuse, power management components). If you apply incorrect voltage or polarity, you can permanently damage the Pi.
- Only do this if you are confident your 5V source is clean and reliable.
- The GND pin used must be one of the Pi's GND pins.

Powering the Motors (via L298N):

The L298N's VMS (motor power) input typically expects a voltage between 6V and 12V (up to 35V for the chip itself, but modules may have other limitations).
Commonly powered by:
- 4xAA batteries (4x1.5V alkaline = 6V; 4x1.2V NiMH = 4.8V, which might be a bit low after L298N voltage drop).
- 6xAA batteries (6x1.5V alkaline = 9V; 6x1.2V NiMH = 7.2V). This is often a good range.
- A 2S LiPo/Li-ion battery pack (7.4V nominal).

Separate vs. Single Power Source Strategy:

Separate Power (Recommended for Simplicity & Stability Initially):
- Raspberry Pi: Powered by a USB power bank or its own dedicated regulated 5V source.
- Motors: Powered by a separate battery pack (e.g., AA batteries) connected to the L298N.
- Crucial: You still need a common ground connection between the Raspberry Pi's ground and the motor driver/motor battery ground.
Single Power Source (More Advanced):
- Use one higher voltage battery pack (e.g., 7.4V LiPo or 9V from 6xAA) for the entire robot.
- Motors: Connect this battery pack directly to the L298N VMS.
- Raspberry Pi: Use a voltage regulator (buck converter) to step down the battery voltage (e.g., 7.4V or 9V) to a stable 5V for the Pi. An LM2596-based buck converter module is a common choice.
  - The output of the buck converter then powers the Pi (either via its USB port or carefully via the 5V GPIO pins).
- Pros: Only one battery pack to manage and charge.
- Cons: More complex wiring; a poorly regulated 5V can cause Pi instability. Electrical noise from motors can potentially affect the Pi if not filtered properly.

Voltage Regulation (Buck Converters):

If you use a single battery pack with a voltage higher than 5V (e.g., 7.4V LiPo, 9V from AAs), you need to reduce this voltage to a stable 5V for the Raspberry Pi.
A buck converter (or step-down regulator) is an efficient way to do this.
LM2596 Modules: These are widely available, inexpensive, and usually adjustable. You connect the battery to their input and use a small potentiometer on the module to adjust the output to precisely 5V (measure with a multimeter before connecting to the Pi!).
Wiring an LM2596:
- IN+ (Input Positive) <--> Battery Pack Positive (+)
- IN- (Input Negative) <--> Battery Pack Negative (-)
- OUT+ (Output Positive) --> Raspberry Pi 5V input (e.g., USB port or 5V GPIO pin)
- OUT- (Output Negative) --> Raspberry Pi GND (common ground)

Estimating Power Consumption and Battery Life (Brief Overview):

Raspberry Pi: Idle consumption varies by model (Pi 3B+ ~400-500mA, Pi 4 ~600-700mA). Under load, it can draw 1A to 2A+, especially with peripherals.
Motors: Highly variable. Small DC motors might draw 100-300mA each when free-running, but can draw 1A or more each when stalled or under heavy load. The L298N can typically handle up to 2A per channel.
Battery Capacity: Measured in milliampere-hours (mAh) or ampere-hours (Ah). A 2000mAh battery can theoretically supply 2000mA (2A) for 1 hour, or 1000mA (1A) for 2 hours.
Calculating Run Time (Very Rough): Run Time (hours) ≈ Battery Capacity (mAh) / Average Current Draw (mA)
- This is an oversimplification. Battery voltage drops as it discharges, and discharge characteristics are not linear.
- For a robot, average current draw is hard to predict as it depends on how much the motors are used.

Safety with Power:

Polarity: Always double-check positive (+) and negative (-) connections before applying power. Reversing polarity can instantly destroy components.
Short Circuits: Ensure no bare wires are touching each other or conductive parts of the chassis. A short circuit can drain batteries quickly, cause overheating, and damage components.
Battery Handling:
- Store batteries properly.
- Use the correct charger for rechargeable batteries.
- Do not puncture, crush, or incinerate batteries, especially Li-ion/LiPo.
- Inspect batteries for damage before use.
Fuses: For more permanent or critical projects, consider adding fuses to protect against overcurrent situations.

Workshop Powering Strategy and Test

Objective: To implement a chosen power strategy for your robot and test its operation under battery power. For this workshop, we will assume a separate power strategy for simplicity: a USB power bank for the Pi, and a 4xAA battery pack for the motors.

Materials:

Your assembled and wired robot car.
USB Power Bank (charged, capable of at least 2A output for the Pi).
USB-A to Micro-USB or USB-C cable (depending on your Pi model).
4xAA battery holder with 4 fresh AA batteries (Alkaline or charged NiMH).
Multimeter (optional, but highly recommended for checking battery voltage).

Steps:

Decide on Your Power Strategy (Confirmation):
- We are using:
  - Raspberry Pi: Powered by a USB power bank via its standard power input port.
  - Motors (via L298N): Powered by a 4xAA battery pack (~6V for alkaline, ~4.8V for NiMH) connected to the VMS and GND of the L298N.
- Crucial Reminder: The common ground between the Pi's GND and the L298N's GND (which is also the motor battery's GND) must already be in place from the wiring workshop.
Prepare Power Sources:
- Ensure your USB power bank is charged.
- Insert 4 fresh AA batteries into the battery holder, observing correct polarity.
- (Optional but Recommended) Check Motor Battery Voltage: Use a multimeter to measure the voltage across the output terminals of your AA battery pack.
  - 4 new Alkalines should give ~6.0V to ~6.4V.
  - 4 charged NiMH should give ~4.8V to ~5.2V (NiMH voltage may appear lower but can deliver current well).
Connect Power to the Robot:
- Motors First (No Pi Power Yet):
  - Ensure the L298N is wired to the motors and the motor battery pack (VMS and GND). The L298N should also be connected to the Pi's GPIOs for control signals, 5V logic power, and common ground.
  - At this stage, with only motor power connected and Pi off, the motors should not move (as the L298N inputs from the Pi are not yet active or are floating, which usually keeps motors off).
- Power on the Raspberry Pi:
  - Connect the USB power bank to the Raspberry Pi's power input port using the USB cable.
  - Allow the Pi to boot up. Wait for it to connect to your Wi-Fi network if you plan to SSH.
Test Robot Operation on Battery Power:
- Connect to your Raspberry Pi via SSH.
- Navigate to your project directory: cd ~/robot_car
- Run your motor control script: python3 full_robot_control.py
- Observe:
  - Does the robot perform its programmed movements?
  - Do the motors seem to have enough power? (4xAA NiMH at 4.8V might result in slower speeds due to L298N voltage drop, especially if batteries are not fully charged).
  - Does the Raspberry Pi remain stable, or does it reboot or show low-voltage warnings (unlikely if powered by a decent power bank, but good to watch for)? A lightning bolt icon on the screen (if you had a monitor) indicates low voltage to the Pi.
  - Run the robot for a few minutes. Are there any signs of components overheating (L298N might get warm, which is normal; motors might get warm with prolonged use)?
Experiment (If Using 6xAA for Motors - Optional):
- If you have a 6xAA battery holder and want more motor power:
  - Power everything OFF. Disconnect the Pi's power bank. Remove batteries from the 4xAA holder.
  - Swap to a 6xAA holder (providing ~9V with alkaline, ~7.2V with NiMH).
  - Connect the 6xAA pack to the L298N VMS and GND.
  - L298N 5V Logic Jumper Consideration:
    - If using 6xAA Alkaline (9V): You could put the 5V regulator jumper back ON the L298N and disconnect the Pi's 5V wire from the L298N logic input. The L298N would then generate its own 5V logic power.
    - If using 6xAA NiMH (7.2V) or if you prefer to keep it simple: Keep the 5V regulator jumper OFF the L298N and continue to power the L298N logic from the Pi's 5V pin. This is generally safer and more predictable. For this workshop, let's stick to the latter: keep 5V jumper OFF, L298N logic powered by Pi 5V.
  - Reconnect the Pi's power bank.
  - Retest the full_robot_control.py script. Motors should now be noticeably faster/stronger.
Shutdown Procedure:
- Always stop your Python script (Ctrl+C if running).
- Properly shut down the Raspberry Pi: sudo poweroff
- Wait for the Pi's activity lights to stop blinking (or go completely off), then disconnect its power bank.
- You can then disconnect/remove the motor batteries.

You have now successfully powered your robot using batteries! This is a major step towards making it truly mobile. Consider how long your chosen batteries last and think about whether your current strategy meets your needs for run time and performance. For longer or more demanding use, Li-ion/LiPo batteries with a buck converter for the Pi become attractive options.

7. Remote Control Basics

So far, our robot executes a pre-programmed sequence of movements. To make it truly interactive, we need a way to control it remotely. There are many ways to achieve this, from Bluetooth game controllers to web interfaces or custom mobile apps. For this "basic" robot car, we'll implement a simple but effective method: keyboard control via an SSH terminal.

This method leverages the existing SSH connection you use for programming the Pi. We'll write a Python script that listens for specific key presses and translates them into robot actions.

Options for Remote Control (Brief Overview):

SSH with Keyboard Commands (This Section's Focus):
- Pros: Simple to implement, uses existing SSH infrastructure, no extra hardware needed.
- Cons: Requires a laptop/computer with an SSH client, range limited by Wi-Fi, text-based interface.
Bluetooth Controller (e.g., PS3/PS4, generic Bluetooth gamepad):
- Pros: Intuitive gamepad control, wireless.
- Cons: Requires Bluetooth setup on Pi, Python libraries for event handling (e.g., evdev), pairing process.
Web Interface (e.g., using Flask or Bottle Python web frameworks):
- Pros: Accessible from any device with a web browser on the same network (phone, tablet, computer), can create a graphical interface.
- Cons: More complex to program (HTML, CSS, JavaScript, backend Python).
Mobile App (e.g., using BlueDot Python library for simple Bluetooth control from an Android app, or custom app development):
- Pros: Custom UI on phone/tablet.
- Cons: Requires app development or specific libraries, Bluetooth/Wi-Fi communication setup.

Keyboard Control via SSH using readchar

To read single key presses in a terminal without requiring the user to press Enter, we can use a library like readchar. The standard input() function in Python waits for Enter.

Installing readchar: If you don't have it, install it on your Raspberry Pi:
```
sudo pip3 install readchar
```
(Note: The keyboard library is another option, but it often requires root privileges or specific user group permissions to access keyboard events system-wide, which can be more complex to set up securely. readchar works well within the context of the terminal running the script.)

Mapping Keys to Robot Movements:

We'll define a simple mapping:

w: Move Forward
s: Move Backward
a: Turn Left
d: Turn Right
x: Stop Motors
q: Quit the program

Python Script for Keyboard Control:

Let's adapt our previous motor control functions.

# keyboard_robot_control.py
from gpiozero import Motor
from time import sleep
import readchar # For reading single key presses

# --- Motor Definitions (same as before) ---
# Left motor (Motor A on L298N)
motor_left_forward_pin = 17
motor_left_backward_pin = 27
motor_left_enable_pin = 12

# Right motor (Motor B on L298N)
motor_right_forward_pin = 22
motor_right_backward_pin = 23
motor_right_enable_pin = 13

motor_left = Motor(forward=motor_left_forward_pin, backward=motor_left_backward_pin, enable=motor_left_enable_pin)
motor_right = Motor(forward=motor_right_forward_pin, backward=motor_right_backward_pin, enable=motor_right_enable_pin)

# --- Movement Functions (can be simplified for direct control) ---
current_speed = 0.7 # Default speed

def move_forward():
    print(f"Forward (speed: {current_speed})")
    motor_left.forward(speed=current_speed)
    motor_right.forward(speed=current_speed)

def move_backward():
    print(f"Backward (speed: {current_speed})")
    motor_left.backward(speed=current_speed)
    motor_right.backward(speed=current_speed)

def turn_left():
    print(f"Left (speed: {current_speed})")
    motor_left.backward(speed=current_speed * 0.8) # Slightly reduce turn speed for maneuverability
    motor_right.forward(speed=current_speed * 0.8)

def turn_right():
    print(f"Right (speed: {current_speed})")
    motor_left.forward(speed=current_speed * 0.8)
    motor_right.backward(speed=current_speed * 0.8)

def stop_motors():
    print("Stop")
    motor_left.stop()
    motor_right.stop()

# --- Main Control Loop ---
if __name__ == "__main__":
    print("Robot Keyboard Control Active!")
    print("Controls:")
    print("  w: Forward")
    print("  s: Backward")
    print("  a: Turn Left")
    print("  d: Turn Right")
    print("  x: Stop Motors")
    print("  q: Quit")
    print("---------------------------")
    print("Press a key to control the robot...")

    try:
        while True:
            key = readchar.readkey() # Read a single key press

            if key == 'w':
                move_forward()
            elif key == 's':
                move_backward()
            elif key == 'a':
                turn_left()
            elif key == 'd':
                turn_right()
            elif key == 'x':
                stop_motors()
            elif key == 'q':
                print("Quitting program.")
                break # Exit the loop
            else:
                print(f"Key '{key}' not mapped.")

            # Optional: stop motors after a short delay if no new key is pressed
            # This would make it 'press-to-move' rather than 'press-to-change-state'
            # For now, it changes state until another command is given or 'x' is pressed.

    except KeyboardInterrupt:
        print("\nProgram terminated by user (Ctrl+C)")
    finally:
        stop_motors()
        print("Motors stopped. GPIO cleanup by gpiozero.")

Explanation:

Import readchar: We import the necessary library.
Motor Definitions: Same as our previous script.
Movement Functions: These are largely the same, but you might notice I slightly reduced turn speed (current_speed * 0.8) as sharp turns at full speed can be jerky.
Main Loop (while True):
- The script enters an infinite loop, waiting for key presses.
- key = readchar.readkey(): This is the core of the input method. It blocks (waits) until a single key is pressed and returns that key as a string.
- Conditional Logic (if/elif/else): It checks which key was pressed and calls the corresponding robot movement function.
- 'q': Breaks out of the loop, leading to the finally block.
try...except...finally Block:
- try: Contains the main control loop.
- except KeyboardInterrupt: Allows you to stop the script gracefully by pressing Ctrl+C in the terminal.
- finally: This block always executes when the try block is exited (either normally by 'q' or by an exception like Ctrl+C). It's crucial for ensuring the motors are stopped. gpiozero also handles cleaning up GPIO resources automatically when the script ends.

Workshop Keyboard Remote Control via SSH

Objective: To control your robot car in real-time using keyboard presses in an SSH terminal.

Materials:

Your fully assembled, wired, and powered robot car.
Raspberry Pi booted and accessible via SSH.
Computer with an SSH client.

Steps:

Install readchar (if not already done):
- Connect to your Raspberry Pi via SSH.
- Run: sudo pip3 install readchar
Navigate to Project Directory:
- cd ~/robot_car
Create the Keyboard Control Script:
- nano keyboard_robot_control.py
- Carefully type or copy-paste the keyboard_robot_control.py code provided above into the nano editor.
- Double-check the GPIO pin numbers match your wiring.
- Save the file (Ctrl+O, Enter) and exit nano (Ctrl+X).
Prepare Robot and Environment:
- Place your robot on a clear, flat floor space with room to maneuver.
- Ensure both the Pi and the motors are powered on.
Run the Script:
- In your SSH terminal, execute:
```
python3 keyboard_robot_control.py
```
- You should see the "Robot Keyboard Control Active!" message and the list of controls.
Test Control:
- Press w: The robot should move forward.
- Press s: The robot should move backward.
- Press a: The robot should turn left.
- Press d: The robot should turn right.
- Press x: The robot should stop.
- The robot will continue its last commanded action until you issue a new command (e.g., x to stop, or another movement key).
- Press q to quit the script. The motors should stop.
Troubleshooting/Refinements:
- No Response to Keys:
  - Is the script running? Any error messages?
  - Is readchar installed correctly?
  - Is your SSH terminal window "active" or "in focus" when you press the keys?
- Movement Not As Expected (e.g., turns wrong way, forward is backward):
  - Refer back to the full_robot_control.py workshop. You need to ensure your motor_left and motor_right definitions correctly map to the physical motors and their wiring for forward motion.
  - If "forward" (w) makes the robot go backward, you can swap the forward and backward pin assignments for both motors in their Motor(...) initializations.
  - If "turn left" (a) makes it turn right, you likely need to swap the actions within the turn_left and turn_right functions, or reconsider which motor instance (motor_left, motor_right) corresponds to the physical left and right sides of your robot.
- Adjusting Speed:
  - Modify the current_speed variable at the top of the script.
  - You could even add keys to increase/decrease speed dynamically (e.g., + and - keys).
- "Press-to-Move" Behavior (Advanced):
  - If you want the robot to move only while a key is held down and stop when released, the logic would be more complex. readchar reads a single press. You might need to investigate libraries that can detect key down/key up events (like pynput or keyboard, though these can have more dependencies or root requirements) or implement a timeout where if no key is pressed for, say, 0.2 seconds, the motors stop. For this basic workshop, the current "stateful" control is simpler.

You now have a basic remote-controlled robot! This opens up many possibilities for interactive projects. You can practice driving it around, and perhaps set up a small obstacle course.

8. Troubleshooting Common Issues

Building robots involves many interconnected parts (hardware, software, power), so encountering issues is a normal part of the learning process. This section outlines common problems and systematic approaches to diagnose and fix them.

General Troubleshooting Strategy:

Stay Calm and Be Systematic: Don't randomly change things. Think about what could be wrong.
Simplify: If something complex isn't working, break it down into smaller, testable parts. For example, if the whole robot isn't moving, test one motor first.
Check the Obvious: Loose wires, low batteries, typos in code, incorrect GPIO pins.
Observe Symptoms Carefully: What exactly is happening or not happening? Are there any error messages? Any unusual sounds or smells (like burning electronics - power off immediately!)?
Make One Change at a Time: When testing solutions, change only one thing and re-test. This helps you isolate the cause.
Consult Documentation/Resources: Refer to datasheets (e.g., for L298N), pinout diagrams, and online forums.

Common Issues and Solutions:

A. Motors Not Spinning or Spinning Erratically

Symptom: One or both motors don't spin at all, spin very weakly, or behave unpredictably.
Possible Causes & Checks:
1. Power Supply to Motors (L298N VMS):
  - Check: Are motor batteries fresh/charged? Is the battery pack correctly connected to L298N VMS (positive) and GND (negative)?
  - Tool: Use a multimeter to measure voltage at the L298N VMS and GND terminals. It should be your expected battery voltage (e.g., ~6V for 4xAA).
2. L298N Logic Power (VCC or +5V pin):
  - Check: If you removed the 5V regulator jumper on L298N (as recommended for <7V motor supply), is the L298N VCC pin correctly connected to a Raspberry Pi 5V pin?
  - Tool: Multimeter to check for ~5V at the L298N VCC pin.
3. Common Ground (CRITICAL):
  - Check: Is a Raspberry Pi GND pin firmly connected to an L298N GND terminal (which is also connected to the motor battery negative)? Without this, logic signals are meaningless.
4. Wiring Connections (Pi to L298N, L298N to Motors):
  - Check:
    - Are GPIO pins from Pi (IN1-IN4, ENA, ENB) securely connected to the correct L298N input pins? A loose wire or one-off error is common.
    - Are motor wires securely connected to L298N OUTx terminals?
    - No short circuits (bare wires touching).
5. L298N Jumpers (ENA, ENB, 5V Regulator):
  - Check: For PWM control, ENA and ENB jumpers must be REMOVED.
  - If powering L298N logic from Pi 5V, the 5V regulator jumper must be REMOVED.
6. Software/Code Issues:
  - Check:
    - Are the GPIO pin numbers in your Python script (Motor(forward=X, backward=Y, enable=Z)) correct according to your wiring? Use BCM numbering.
    - Are you calling the motor functions correctly (e.g., motor.forward(speed=0.5))?
    - Is the speed value reasonable (0.0 to 1.0)? A very low speed might not be enough to overcome friction.
7. Motor Itself:
  - Test: Disconnect a motor from L298N and briefly touch its wires directly to the motor battery pack terminals. Does it spin? (Be careful with polarity). If not, the motor might be faulty.
8. L298N Module Faulty: Less common, but possible. If everything else checks out, the module itself could be damaged.
9. Raspberry Pi GPIO Issue: Very rare, but a GPIO pin could be damaged if previously misused. Try a different GPIO pin (and update code) for testing.

B. Raspberry Pi Not Booting or Behaving Erratically

Symptom: Pi doesn't power on (no lights), power light blinks, doesn't connect to Wi-Fi/SSH, reboots randomly.
Possible Causes & Checks:
1. Power Supply to Raspberry Pi:
  - Check: Are you using an adequate power supply (e.g., official Pi PSU, good quality power bank with sufficient amperage - 2.5A to 3A recommended)?
  - USB cable quality matters too; a thin, cheap cable can cause voltage drop.
  - If powering via GPIO, ensure a stable, regulated 5V.
  - Indicator: Look for the red PWR LED on the Pi. If it's off or blinking, it's likely a power issue. A lightning bolt icon on a connected display also indicates low voltage.
2. SD Card Issues:
  - Check: Is the SD card properly inserted?
  - Try re-flashing the OS image to the SD card. The card might be corrupted.
  - Try a different, known-good SD card. SD cards can fail.
3. Overheating (Less likely with Pi Lite and no heavy processing yet):
  - Check: Is the Pi in an enclosed space with no airflow? Is it unusually hot to touch?
  - Command to check CPU temperature (via SSH): vcgencmd measure_temp
4. Short Circuits on Pi or Peripherals:
  - Check: Inspect wiring carefully. Is anything metallic touching the Pi's PCB?
5. Software Crash / Kernel Panic:
  - If you have a monitor connected, look for error messages during boot or operation.

C. Robot Moves Unpredictably (e.g., spins, one wheel faster)

Symptom: Robot doesn't go straight, turns are wrong, one wheel seems to have more/less power.
Possible Causes & Checks:
1. Incorrect Motor Wiring/Definition in Code:
  - Check: If "forward" makes it spin, one motor's direction is reversed relative to the other. Swap its wires at L298N OUTx terminals OR swap its forward and backward pin assignments in the Motor() constructor in your code.
2. Mechanical Issues:
  - Check: Are wheels securely attached? Is anything rubbing against a wheel or motor? Is the caster wheel swiveling freely?
  - Uneven weight distribution can also affect movement.
3. Motor Differences:
  - Cheap DC motors are often not perfectly matched. One might naturally spin slightly faster or have more torque than the other at the same PWM signal.
  - Solution (Advanced): Implement motor encoders and a PID control loop to precisely control each wheel's speed. This is beyond "basic" but the ultimate solution for accurate movement.
  - Solution (Simpler): Experimentally find slightly different speed values for motor_left.forward(speed_L) and motor_right.forward(speed_R) to make it go straighter.
4. Loose Connections: A wire making intermittent contact can cause jerky or unpredictable behavior. Re-seat all jumper wires. Tighten L298N screw terminals.
5. Low Battery (Motors): As batteries drain, performance will degrade, often unevenly.

D. SSH Connection Issues

Symptom: Cannot connect to Pi via SSH. "Connection refused," "Connection timed out," "No route to host."
Possible Causes & Checks:
1. Pi Not Powered On or Not Booted: Obvious, but check.
2. Incorrect IP Address:
  - Check: Has the Pi's IP address changed (if using DHCP)? Verify its current IP from your router's client list or a network scanner.
  - Consider setting a static IP address on the Pi for more reliability (can be done via dhcpcd.conf or router settings).
3. Pi Not Connected to Wi-Fi:
  - Check: Was Wi-Fi configured correctly during OS flashing or via raspi-config? Correct SSID and password?
  - If you have monitor/keyboard access, use ifconfig or ip a to check network interface status.
4. SSH Service Not Running on Pi:
  - Check: Was SSH enabled in Raspberry Pi Imager or raspi-config?
  - If you have monitor/keyboard access, check service status: sudo systemctl status ssh
5. Firewall Issues:
  - Is there a firewall on your computer or network blocking outgoing SSH connections (Port 22)? (Less common on typical home networks).
6. Network Problems: Router issues, Wi-Fi interference. Try pinging the Pi's IP address from your computer: ping PI_IP_ADDRESS.

E. Python Script Errors

Symptom: Script crashes with an error message (Traceback).
Possible Causes & Checks:
1. Read the Error Message Carefully! Python tracebacks tell you the file, line number, and type of error.
2. Syntax Errors: Typos, incorrect indentation, missing colons, unmatched parentheses/quotes.
3. NameErrors: Using a variable or function name that hasn't been defined (often a typo).
4. AttributeErrors: Trying to access a method or property that doesn't exist for an object (e.g., motor.forword() instead of motor.forward()).
5. ImportErrors: Library not installed (e.g., gpiozero, readchar) or typo in import statement. Install with sudo pip3 install <library_name>.
6. Permission Errors (e.g., for GPIO access if not using gpiozero properly, or for some keyboard library functions): gpiozero generally handles permissions well. If using other libraries, you might need sudo python3 your_script.py, but this should be avoided if possible by setting up correct user group permissions (e.g., adding user to gpio group, though gpiozero often works without this for standard users).

Workshop Debugging Challenge

Objective: To practice systematic troubleshooting by intentionally introducing and then fixing common faults.

Instructions: For each scenario below, make the described "faulty" change to your working robot setup or code. Then, try to run your keyboard_robot_control.py script (or a simpler motor test script if more appropriate for the fault). Observe the symptoms and try to diagnose the problem as if you didn't know what you changed. Then, fix it.

Robot Setup: Use your fully assembled robot, powered by batteries (Pi by power bank, motors by AA pack). Ensure it's in a safe area or wheels off the ground.

Scenarios:

Fault Scenario 1: Loose Motor Wire
- Introduce Fault: Carefully loosen (but don't completely disconnect) one of the motor wires at an L298N screw terminal (e.g., OUT1).
- Test: Run your keyboard control script. Try to make the robot move.
- Observe Symptoms: What happens? Does one motor not work? Does it work intermittently?
- Diagnose & Fix: Check physical connections. Tighten the screw terminal.
Fault Scenario 2: Swapped Motor Control Pins in Code
- Introduce Fault: In your keyboard_robot_control.py (or a simpler test script), for motor_left, swap the GPIO numbers assigned to forward and backward. For example, if it was Motor(forward=17, backward=27, ...) change it to Motor(forward=27, backward=17, ...).
- Test: Run the script. Try to move forward.
- Observe Symptoms: What does the robot do when you press 'w'? Does it spin? Go backward?
- Diagnose & Fix: Review code, compare to intended motor direction logic. Revert the pin assignments.
Fault Scenario 3: Missing Common Ground
- Introduce Fault: CAREFULLY POWER EVERYTHING OFF FIRST (Pi and motors). Disconnect the jumper wire that connects a Raspberry Pi GND pin to the L298N GND.
- Test: Power everything back on. Run your keyboard control script.
- Observe Symptoms: Do motors respond at all? Do they behave very erratically? (This can sometimes lead to unpredictable behavior because logic levels are not correctly referenced).
- Diagnose & Fix: POWER OFF AGAIN. Check all fundamental wiring, especially power and ground. Realize the common ground is missing and reconnect it.
Fault Scenario 4: Low Motor Batteries (Simulated)
- Introduce Fault: If using 4xAA batteries for motors, remove one or two of the cells from the battery holder (so it's running on significantly reduced voltage, e.g., 3V or 4.5V instead of 6V).
- Test: Run the script. Try to move the robot.
- Observe Symptoms: Are motors very weak? Do they struggle to move the robot or not move at all? Do they make a humming noise?
- Diagnose & Fix: Suspect power issue. Measure motor battery voltage with a multimeter (if available). Replace/recharge batteries or ensure correct number of cells.
Fault Scenario 5: Incorrect ENA/ENB Jumper
- Introduce Fault: (If your L298N had jumpers on ENA/ENB that you removed for PWM). Put the jumper back ON ENA.
- Test: Run your script. Try to control speed or move the motor connected to ENA.
- Observe Symptoms: Does the motor now only run at full speed, regardless of the speed parameter in motor.forward(speed=...)?
- Diagnose & Fix: Check L298N jumper settings. Realize ENA jumper needs to be off for PWM. Remove it.

This workshop should give you a better feel for how different issues manifest and reinforce a methodical approach to debugging. Troubleshooting is a key skill in robotics!

Conclusion

Congratulations on successfully building and programming your Raspberry Pi 2WD Basic Robot Car! Throughout this extensive guide, you have embarked on a significant learning journey, covering a wide array of concepts and practical skills essential in the fields of robotics, electronics, and software development.

Recap of What You've Learned:

Component Selection: You learned to identify and understand the role of key components like the Raspberry Pi, motor driver (L298N), DC motors, chassis, and power supplies.
Raspberry Pi Preparation: You gained experience in setting up a Raspberry Pi for an embedded project, including flashing Raspberry Pi OS Lite, configuring it for headless SSH access, updating the system, and understanding crucial aspects of SD card architecture, file systems (ext4), swap management, and why traditional hibernation isn't typical for Pi robots.
Mechanical Assembly: You practiced assembling a robot chassis, mounting motors, wheels, and electronic components.
Electronics and Wiring: You delved into the workings of an H-Bridge motor driver (L298N), learned how to wire it to the Raspberry Pi and motors, and understood the critical importance of aspects like common ground and appropriate power for logic and motors.
Python Programming for Robotics: You utilized the gpiozero library to write Python scripts for controlling DC motors, implementing functions for forward, backward, turning movements, and PWM-based speed control.
Power Management: You explored different battery options and strategies for powering both the Raspberry Pi and the motors, including the use of separate power sources.
Basic Remote Control: You implemented a simple keyboard-based remote control system using Python and SSH.
Troubleshooting: You learned to anticipate, diagnose, and resolve common issues encountered in robotics projects.

This project has laid a strong foundation. The skills you've developed—interfacing hardware, writing control software, and debugging complex systems—are highly transferable and valuable.

Next Steps and Further Enhancements:

Your basic robot car is a platform ripe for expansion. Here are some ideas to take your project to the next level:

Adding Sensors for Autonomous Behavior:
- Ultrasonic Distance Sensor (HC-SR04): Enable your robot to detect obstacles and avoid collisions.
- Infrared (IR) Line Follower Sensors: Program your robot to follow a black line on a white surface (or vice-versa).
- IR Proximity Sensors: Another option for short-range obstacle detection.
More Advanced Remote Control:
- Bluetooth Game Controller: Use a PS3/PS4 controller or a generic Bluetooth gamepad for more intuitive control.
- Web Interface: Create a web page hosted on the Raspberry Pi, allowing control from any browser on your network (using Flask or Django).
- Smartphone App: Develop a custom app or use existing ones (like BlueDot) to control the robot via Bluetooth or Wi-Fi.
Computer Vision:
- Add a Raspberry Pi Camera Module.
- Use libraries like OpenCV to implement:
  - Object detection and tracking.
  - Color following.
  - Lane detection.
Improved Movement and Navigation:
- Motor Encoders: Add rotary encoders to your motors for precise feedback on wheel rotation. This allows for more accurate distance travel, speed control, and turns (e.g., using PID controllers).
- Inertial Measurement Unit (IMU): Sensors like the MPU-6050 (accelerometer/gyroscope) can help with orientation, balancing (for more advanced robots), or dead reckoning.
Voice Control:
- Integrate a USB microphone and use speech recognition services or libraries to control your robot with voice commands.
GPS Module:
- For outdoor robots, a GPS module can provide location data for navigation tasks.
Enhanced Power System:
- Move to LiPo/Li-ion batteries for better power density and runtime.
- Implement a robust single-battery system with a buck converter for the Pi and proper battery monitoring.

The world of robotics is vast and continuously evolving. We encourage you to keep experimenting, learning, and building. The challenges you overcome will be your most valuable lessons. Happy roboteering!

Appendix A GPIO Pinout Diagrams

Understanding the Raspberry Pi's GPIO (General Purpose Input/Output) header is fundamental for connecting external hardware. Similarly, knowing the pinout of your motor driver is crucial for correct wiring.

Raspberry Pi 40-Pin GPIO Header (All Models B+, 2B, 3B, 3B+, 4B, Zero with Header)

The diagram below shows the physical layout of the 40-pin header and the primary function of each pin. Note both the Board (Physical) Pin Numbers and the BCM (Broadcom/GPIO) Numbers. gpiozero and most Python libraries prefer BCM numbering.

                                (Outer Row - Pins toward edge of Pi)
                                 +-----+-----+
3.3V PWR  (Pin 1)  <-----> O   O <-----> (Pin 2)   5V PWR
GPIO2 (SDA)(Pin 3) <-----> O   O <-----> (Pin 4)   5V PWR
GPIO3 (SCL)(Pin 5) <-----> O   O <-----> (Pin 6)   GND
GPIO4 (GPCLK0)(Pin 7) <--> O   O <-----> (Pin 8)   GPIO14 (TXD)
          GND(Pin 9) <-----> O   O <-----> (Pin 10)  GPIO15 (RXD)
GPIO17      (Pin 11) <-----> O   O <-----> (Pin 12)  GPIO18 (PCM_CLK)
GPIO27      (Pin 13) <-----> O   O <-----> (Pin 14)  GND
GPIO22      (Pin 15) <-----> O   O <-----> (Pin 16)  GPIO23
3.3V PWR    (Pin 17) <-----> O   O <-----> (Pin 18)  GPIO24
GPIO10 (MOSI)(Pin 19) <----> O   O <-----> (Pin 20)  GND
GPIO9 (MISO)(Pin 21) <----> O   O <-----> (Pin 22)  GPIO25
GPIO11 (SCLK)(Pin 23) <----> O   O <-----> (Pin 24)  GPIO8 (CE0)
          GND(Pin 25) <-----> O   O <-----> (Pin 26)  GPIO7 (CE1)
ID_SD (GPIO0)(Pin 27) <----> O   O <-----> (Pin 28)  ID_SC (GPIO1)
GPIO5       (Pin 29) <-----> O   O <-----> (Pin 30)  GND
GPIO6       (Pin 31) <-----> O   O <-----> (Pin 32)  GPIO12 (PWM0)
GPIO13 (PWM1)(Pin 33) <----> O   O <-----> (Pin 34)  GND
GPIO19 (PCM_FS)(Pin 35) <--> O   O <-----> (Pin 36)  GPIO16
GPIO26      (Pin 37) <-----> O   O <-----> (Pin 38)  GPIO20 (PCM_DIN)
          GND(Pin 39) <-----> O   O <-----> (Pin 40)  GPIO21 (PCM_DOUT)
                                 +-----+-----+
                                (Inner Row - Pins toward center of Pi)

Key Pins Used in This Project (Example):

5V PWR: Pins 2, 4 (Used to power L298N logic in our recommended setup)
GND: Pins 6, 9, 14, 20, 25, 30, 34, 39 (Used for common ground with L298N)
GPIO17 (BCM): Pin 11 (Example for L298N IN1)
GPIO27 (BCM): Pin 13 (Example for L298N IN2)
GPIO22 (BCM): Pin 15 (Example for L298N IN3)
GPIO23 (BCM): Pin 16 (Example for L298N IN4)
GPIO12 (BCM): Pin 32 (Example for L298N ENA - Hardware PWM capable)
GPIO13 (BCM): Pin 33 (Example for L298N ENB - Hardware PWM capable)

Note on PWM Pins:

Hardware PWM capable pins on most Raspberry Pi models include:

GPIO12 (PWM0)
GPIO13 (PWM1)
GPIO18 (PWM0) - Often used by audio
GPIO19 (PWM1) - Often used by audio

gpiozero can perform software PWM on any GPIO pin, but hardware PWM is generally preferred for precision and lower CPU usage.

L298N Motor Driver Module Pinout (Typical)

L298N modules are common, but slight variations exist. Always check the silk-screen labels on your specific module.

Generic L298N Module Layout (Conceptual):

          +---------------------------------------+
          |        Heatsink for L298N IC          |
          +---------------------------------------+

Screw Terminals for Power & Motors:
  OUT1 | |<-- Motor A Connection 1
  OUT2 | |<-- Motor A Connection 2
  VMS  | |<-- Motor Power Supply (+) (e.g., 6V-12V from batteries)
  GND  | |<-- Motor Power Supply (-) AND Common Ground with Pi
  OUT3 | |<-- Motor B Connection 1
  OUT4 | |<-- Motor B Connection 2

Logic Pins & Jumpers (usually a header block):

  ENA ---O O--- Jumper for Motor A Enable (Remove for PWM)
         |      (Connect to Pi GPIO for PWM speed control of Motor A)
  IN1 ----      (Connect to Pi GPIO for Motor A Direction)
  IN2 ----      (Connect to Pi GPIO for Motor A Direction)
  IN3 ----      (Connect to Pi GPIO for Motor B Direction)
  IN4 ----      (Connect to Pi GPIO for Motor B Direction)
  ENB ---O O--- Jumper for Motor B Enable (Remove for PWM)
         |      (Connect to Pi GPIO for PWM speed control of Motor B)

Logic Power Section (may vary slightly):

  VCC/LOGIC_VCC/+5V Input ---- (Connect to Pi 5V IF 5V_EN JUMPER IS REMOVED)
  5V_EN JUMPER  ---O O--- (Connects onboard 5V regulator output to VCC.
                           REMOVE if VMS < ~7V OR if supplying 5V externally to VCC.
                           LEAVE ON if VMS > ~7V AND you want L298N to self-power its logic.
                           If ON, VCC pin becomes a 5V OUTPUT - DO NOT connect Pi 5V to it then!)
  GND --------------------- (Another ground pin, common with motor GND)

Key L298N Connections Summary (Our Workshop Setup):

Motor A Wires: OUT1, OUT2
Motor B Wires: OUT3, OUT4
Motor Battery Pack Positive (+): VMS
Motor Battery Pack Negative (-): GND (this GND is also connected to Pi GND)
Raspberry Pi 5V Output: VCC/LOGIC_VCC (with 5V_EN jumper REMOVED)
Raspberry Pi GPIO for ENA: ENA pin (with ENA jumper REMOVED)
Raspberry Pi GPIO for IN1: IN1 pin
Raspberry Pi GPIO for IN2: IN2 pin
Raspberry Pi GPIO for IN3: IN3 pin
Raspberry Pi GPIO for IN4: IN4 pin
Raspberry Pi GPIO for ENB: ENB pin (with ENB jumper REMOVED)

Always refer to these diagrams and double-check your wiring to prevent damage and ensure your robot functions as expected.