多Raspberry Pi资源共享构建差分驱动机器人技术咨询

Great setup plan—using multiple Pis for specialized tasks makes total sense for a robot like this, and resource sharing will absolutely boost your system's efficiency. Here's a structured, practical approach to pull this off smoothly:

1. Core Communication Architecture (The "Nervous System") #

First, you need a reliable way for all Pis to talk to each other. A message-oriented bus is your best bet here:

• MQTT as the Primary Bus: Use a lightweight MQTT broker (like Mosquitto) running on your control node. All other nodes act as clients:
  • Vision nodes publish processed visual data/results to a robot/vision topic
  • Arduino sensor node publishes raw/formatted sensor readings to robot/sensors
  • Motor driver node subscribes to robot/motor_commands to receive movement instructions
  • Control node acts as the central hub, subscribing to all input topics and publishing commands
  • Install Mosquitto on the control node with sudo apt install mosquitto mosquitto-clients, then enable remote access by editing /etc/mosquitto/mosquitto.conf to allow connections from your local subnet.
• ZeroMQ for High-Speed Data: For large payloads like raw camera frames, use ZeroMQ's PUB/SUB pattern alongside MQTT. This avoids clogging the MQTT bus with heavy data while keeping low-latency communication between vision nodes and the control node.
• Static IPs: Assign fixed IPs to every Pi (e.g., 192.168.1.100 for control, 101-104 for others) so you don't have to deal with dynamic IP changes breaking connections.

2. Resource Sharing Strategies #

To maximize performance and reduce redundancy:

• Shared Storage with NFS:
  • Host a shared directory on your control node for all robot resources (models, config files, log data, etc.) so every Pi can access the same files without duplicating storage.
  • Setup steps on control node:

    sudo apt install nfs-kernel-server
    sudo mkdir /shared_robot_resources
    sudo chmod 777 /shared_robot_resources
    echo "/shared_robot_resources 192.168.1.0/24(rw,sync,no_subtree_check)" | sudo tee -a /etc/exports
    sudo exportfs -a
    

  • On each client Pi:

    sudo apt install nfs-common
    sudo mkdir /mnt/shared_robot
    sudo mount 192.168.1.100:/shared_robot_resources /mnt/shared_robot
    

  • Add the mount to /etc/fstab if you want it to persist on reboot.
• Distributed Computing with Celery:
  • Use Celery (with Redis as the broker) to offload compute-heavy tasks (like image preprocessing, sensor data fusion) to idle Pis. The control node acts as the task scheduler, while other nodes run Celery workers.
  • Install dependencies on all Pis: sudo apt install redis-server && pip install celery
  • Define tasks in a shared script (stored in the NFS directory), then start workers on client nodes with:

    celery -A robot_tasks worker --loglevel=info
    

• Shared Model Inference: If you're running ML models (e.g., object detection), split the workload between the two vision nodes—each can run a dedicated instance of the model on their camera feed, then send only the results (not raw frames) to the control node.

3. Node-Specific Implementation Tips #

• Vision Nodes:
  • Use OpenCV or Picamera2 to capture frames. Preprocess frames (resize, grayscale, edge detection) locally before sending data to reduce bandwidth.
  • For stereo vision, sync the two cameras' capture timestamps using GPIO triggers or network time sync (NTP) to ensure frame alignment.
• Arduino Sensor Node:
  • Connect the Pi to Arduino via USB serial or I2C. Use pyserial or smbus2 libraries to read analog sensor data (e.g., IR, ultrasonic, IMU).
  • Format sensor data into JSON before publishing to MQTT for easy parsing on the control node.
• Motor Driver Node:
  • Use a motor HAT (like the Adafruit DC & Stepper Motor HAT) or a driver board (L298N/TB6612) connected to the Pi's GPIO pins.
  • Listen for MQTT commands (e.g., {"left_speed": 50, "right_speed": 50}) and translate them into motor control signals. Add safety checks (e.g., stop motors if no command is received for 5 seconds) to prevent runaway behavior.
• Control Node + Web UI:
  • Build the Web UI with Flask/FastAPI (backend) and simple HTML/CSS/JS (frontend) for easy user control. Display real-time sensor data and vision feeds by pulling from MQTT topics.
  • Implement core logic here: sensor data fusion, path planning, obstacle avoidance, and translating user input into motor commands.

4. Reliability & Scalability #

• Systemd Services: Wrap all node scripts (MQTT clients, Celery workers, Web UI) into systemd services so they start automatically on boot and restart if they crash. Example service file for a vision node:

  [Unit]
  Description=Robot Vision Node Service
  After=network.target mosquitto.service
  
  [Service]
  User=pi
  WorkingDirectory=/home/pi/robot_vision
  ExecStart=/usr/bin/python3 /home/pi/robot_vision/vision_node.py
  Restart=always
  RestartSec=5
  
  [Install]
  WantedBy=multi-user.target
  

• Network Optimization: Use Ethernet cables for critical nodes (control, motor driver) or 5GHz WiFi to minimize latency. Disable unused network services on Pis to free up bandwidth.
• Logging: Centralize logs on the control node's shared storage so you can debug issues across all nodes without logging into each Pi individually.

This setup keeps your system modular—you can swap out or add Pis later without reworking the entire architecture. Start small: get MQTT communication working between two nodes first, then add resource sharing, then build out each node's functionality step by step.

内容的提问来源于stack exchange，提问作者Sam Hammamy