基于Raspberry Pi与Python的避障小车传感器中断主线程方案问询

Hey there! Let's walk through building your obstacle-avoiding Raspberry Pi car with Python, including a virtual sensor simulation you can test on any machine (no hardware needed) and practical optimization tips.

Core Idea Breakdown #

Your plan to use a dedicated sensor thread makes total sense—separating continuous obstacle monitoring from the main motor control thread ensures fast response times without blocking the car's movement logic. Instead of force-interrupting the main thread (which can cause messy resource leaks), we'll use a thread-safe Event signal to trigger an immediate stop when an obstacle is detected.

Virtual Sensor Simulation (Test Without Hardware) #

Here's a complete, runnable example that simulates both the sensor and motor system. You can tweak the obstacle detection probability to test different scenarios:

import threading
import time
import random

# Virtual obstacle sensor (mimics ultrasonic/IR sensors)
class VirtualObstacleSensor:
    def __init__(self, obstacle_probability=0.2):
        self.obstacle_probability = obstacle_probability  # Chance to detect an obstacle
        self.obstacle_detected = False

    def check_obstacle(self):
        # Randomly simulate obstacle detection for testing
        self.obstacle_detected = random.random() < self.obstacle_probability
        return self.obstacle_detected

# Virtual motor controller (simulates car movement)
class VirtualCarMotor:
    def __init__(self):
        self.is_running = False

    def start_forward(self):
        self.is_running = True
        print("🚗 Car moving forward...")

    def stop_immediately(self):
        self.is_running = False
        print("🛑 Car stopped! Obstacle detected ahead.")

def sensor_monitoring_thread(sensor, motor, stop_event):
    """Dedicated thread to monitor non-stop for obstacles"""
    while not stop_event.is_set():
        if sensor.check_obstacle():
            print("⚠️ Sensor picked up an obstacle!")
            motor.stop_immediately()
            stop_event.set()  # Signal main thread to halt
        time.sleep(0.5)  # Simulate sensor sampling interval

if __name__ == "__main__":
    # Initialize components
    sensor = VirtualObstacleSensor(obstacle_probability=0.15)
    motor = VirtualCarMotor()
    stop_event = threading.Event()

    # Start the sensor thread (daemon=True means it exits when main thread does)
    sensor_thread = threading.Thread(
        target=sensor_monitoring_thread,
        args=(sensor, motor, stop_event)
    )
    sensor_thread.daemon = True
    sensor_thread.start()

    try:
        # Main thread: Control car movement
        motor.start_forward()
        while motor.is_running:
            # Add your main control logic here (e.g., speed adjustments, turns)
            time.sleep(0.1)
    except KeyboardInterrupt:
        print("\n🔌 Program stopped manually.")
        motor.stop_immediately()
        stop_event.set()

How This Works: #

• The sensor_monitoring_thread runs independently, checking for obstacles every 0.5 seconds.
• When an obstacle is detected, it stops the motor and triggers the stop_event, which tells the main thread to exit its loop.
• The daemon thread ensures clean shutdown if you manually stop the program with Ctrl+C.

Adapting to Real Raspberry Pi Hardware #

To move this to physical hardware, modify the sensor and motor classes to interact with GPIO pins:

Example HC-SR04 Ultrasonic Sensor Class #

import RPi.GPIO as GPIO

class HCSR04Sensor:
    def __init__(self, trig_pin=23, echo_pin=24, obstacle_threshold=10):
        self.trig_pin = trig_pin
        self.echo_pin = echo_pin
        self.obstacle_threshold = obstacle_threshold  # Stop if obstacle is within 10cm
        GPIO.setmode(GPIO.BCM)
        GPIO.setup(trig_pin, GPIO.OUT)
        GPIO.setup(echo_pin, GPIO.IN)

    def check_obstacle(self):
        # Send trigger pulse
        GPIO.output(self.trig_pin, GPIO.LOW)
        time.sleep(0.000002)
        GPIO.output(self.trig_pin, GPIO.HIGH)
        time.sleep(0.00001)
        GPIO.output(self.trig_pin, GPIO.LOW)

        # Measure echo time
        while GPIO.input(self.echo_pin) == 0:
            signal_off = time.time()
        while GPIO.input(self.echo_pin) == 1:
            signal_on = time.time()

        # Calculate distance in cm
        time_passed = signal_on - signal_off
        distance = (time_passed * 34300) / 2
        return distance < self.obstacle_threshold

Motor Control with L298N Driver #

For motor control, use GPIO pins to signal the driver board to start/stop the motors. Add error handling to clean up GPIO pins on shutdown (e.g., in a finally block) to avoid hardware issues.

Key Optimization Tips #

• Thread Safety: If you're modifying shared variables (e.g., motor speed) across threads, use threading.Lock to prevent race conditions.
• Sensor Debouncing: Real sensors can have noisy readings—add a check that requires 2-3 consecutive obstacle detections before triggering a stop.
• Graceful Shutdown: Never force-kill threads. Use Event or a shared boolean flag to let threads exit cleanly (critical for releasing GPIO pins).
• Priority Tuning: Set the sensor thread to a higher priority with sensor_thread.priority = threading.Thread.MAX_PRIORITY (where supported) to ensure obstacle detection takes precedence.
• Error Handling: Wrap hardware interactions in try-except blocks to catch GPIO errors, sensor disconnections, or power issues.
• Power Stability: Use a separate power supply for motors (don't rely on the Pi's USB port) to avoid voltage drops that cause sensor misreads.

内容的提问来源于stack exchange，提问作者mohammad noh