小组成员分工

Here is a suggested division of labor for the project among the four group members:

Group Member Responsibilities:

1. Yaokun Zhang - Hardware Setup & Integration

   • Assemble the Raspberry Pi system with the car.
   • Connect and configure the components, including LCD, HC-SR04 distance sensor, and SG-90 servo motor.
   • Ensure proper power connections and hardware stability.

2. Ziqi Wang - Software & OpenCV Implementation

   • Develop and implement OpenCV-based image processing tasks.
   • Work on object recognition and template matching for line following and symbol detection.
   • Optimize real-time image processing to improve accuracy.

3. Yuanfan Jiang - Testing & Debugging

   • Conduct thorough testing of hardware and software integration.
   • Identify and fix bugs in sensor readings, motor control, and vision processing.
   • Ensure the system runs smoothly for the final demonstration.

4. Yijian Lin - Project Management & Documentation

   • Coordinate task distribution and ensure deadlines are met.
   • Maintain the project logbook and prepare reports.
   • Oversee the final showcase presentation and ensure clarity in the group’s demonstration.

Each team member will collaborate and support others as needed, ensuring a smooth and successful project execution. Let me know if you want any modifications!

To assemble the car for this project, you will need the following hardware components:

Required Hardware Components:

1. Raspberry Pi 3B – Main processing unit.
2. LCD1602 – Display module for showing recognized tasks.
3. HC-SR04 Distance Sensor – Used to measure distances for tasks like "Approach and Stop."
4. Level Shifter (4-channel) – Voltage level conversion for sensor integration.
5. Pi Power Connector – Provides power to the system.
6. Pi Camera – Captures images for OpenCV-based image processing.
7. SG-90 Servo Motor – Used for motorized angle control of the camera.
8. Audio Power Amplifier – Required for the "Play Music" task.
9. LEDs (Red & Blue) – Used for the "Alarm Flash" task.
10. Motorized Vehicle Chassis – Base platform for movement.

Assembly Steps:

1. Mount the Raspberry Pi

   • Secure the Raspberry Pi onto the vehicle chassis.
   • Connect the Pi Power Connector to provide power.

2. Install the Pi Camera

   • Attach the Pi Camera module to the Raspberry Pi.
   • Adjust its position so it can capture the track for line following.

3. Connect the Sensors & Components

   • HC-SR04 Distance Sensor: Connect to Raspberry Pi GPIO for measuring distances.
   • SG-90 Servo Motor: Connect to control the camera angle.
   • LCD1602 Display: Wire to Raspberry Pi to display recognized objects.
   • LEDs: Connect for visual feedback.

4. Set Up the Motorized Chassis

   • Connect the motors to the Raspberry Pi motor driver.
   • Ensure proper power supply and movement control.

5. Software Configuration & Testing

   • Install OpenCV on Raspberry Pi.
   • Implement template matching for object recognition.
   • Test each module (camera, distance sensor, LCD, and motors) to ensure functionality.

6. Final Adjustments & Calibration

   • Adjust camera resolution for optimal template matching.
   • Calibrate motor speeds for smooth movement.
   • Ensure line-following accuracy with the camera and OpenCV.

Functionality & Tasks:

• Line Following – Detect and follow different track types.
• Shape Counting – Identify and count specific shapes.
• Short Cuts – Adjust speed based on track colors.
• Play Music – Audio playback on command.
• Alarm Flash – LED signaling for alerts.
• Approach & Stop – Measure distance and halt before obstacles.
• Traffic Light Recognition – Stop and go based on detected light signals.
• Kick Football (Bonus) – Aim and strike a football into a goal.

Would you like a circuit diagram or code example for any of the components?

Installation Guide for Line Following Task

To assemble the car and ensure it can perform the line-following task, follow these steps:

---

1. Required Hardware Components

• Raspberry Pi 3B – Main processor to handle image processing.
• Pi Camera – Captures images of the track for OpenCV processing.
• Motorized Chassis – Base platform with motors for movement.
• Motor Driver (L298N or similar) – Controls the motors.
• HC-SR04 Ultrasonic Sensor – Measures distance to obstacles (for stopping).
• LCD1602 Display – Shows recognized symbols (not needed for line following).
• SG-90 Servo Motor – Adjusts camera angle if necessary.
• Power Supply – Battery pack or power bank (ensure proper voltage).
• LEDs – For indicator signals.

---

2. Physical Assembly

Step 1: Mount the Raspberry Pi

• Attach the Raspberry Pi securely to the chassis.
• Connect a power source but don’t power it on yet.

Step 2: Attach the Motors & Wheels

• Secure the motors to the chassis.
• Connect the motors to the motor driver.
• Ensure the left and right wheels are aligned properly.

Step 3: Install the Pi Camera

• Mount the Pi Camera at the front of the car.
• Angle it slightly downward to capture the track clearly.
• If needed, attach the SG-90 servo motor to adjust the camera angle dynamically.

Step 4: Connect the Motor Driver

• Connect the motor driver to the Raspberry Pi’s GPIO pins.
• Provide power to the motor driver using the battery pack.
• Wire the motor outputs to the left and right motors.

Step 5: Set Up the Ultrasonic Sensor (Optional)

• If obstacle detection is required, attach the HC-SR04 sensor at the front.
• Connect it to the Raspberry Pi.

Step 6: Connect Additional Components

• If using an LCD, LEDs, or audio amplifier, connect them to the Raspberry Pi GPIO.
• Check wiring to ensure there are no loose connections.

---

3. Software Configuration

Step 1: Install Required Libraries

bash
sudo apt update
sudo apt install python3-opencv
pip install numpy RPi.GPIO

Step 2: Camera Configuration

• Enable the Pi Camera:

bash
sudo raspi-config

• Go to Interfacing Options → Enable Camera → Reboot.

Step 3: Implement Line Following Algorithm

Use OpenCV to detect the track:

python
import cv2
import numpy as np

# Open the Pi Camera
cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    if not ret:
        continue
    
    # Convert to grayscale
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
    # Apply threshold to detect the line
    _, binary = cv2.threshold(gray, 100, 255, cv2.THRESH_BINARY_INV)

    # Find contours (track edges)
    contours, _ = cv2.findContours(binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
    
    if contours:
        # Find the largest contour (assumed to be the line)
        c = max(contours, key=cv2.contourArea)
        M = cv2.moments(c)

        if M["m00"] != 0:
            cx = int(M["m10"] / M["m00"])
            cy = int(M["m01"] / M["m00"])

            # Determine direction to move
            if cx < frame.shape[1] // 2 - 20:
                print("Turn Left")
            elif cx > frame.shape[1] // 2 + 20:
                print("Turn Right")
            else:
                print("Move Forward")

    cv2.imshow("Binary", binary)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

---

4. Testing & Adjustments

1. Adjust Camera Angle

   • Ensure the track is visible in the camera feed.
   • Modify the height and tilt angle if needed.

2. Fine-tune Thresholding

   • Adjust the binary threshold for better track detection.

3. Optimize Motor Speed

   • Test different speeds to ensure smooth movement.

---

5. Running the Car

• Run the Python script and place the car on the black track.
• The car should:
  • Detect the track using OpenCV.
  • Adjust motor movement to follow the line.
  • Stop when required (if integrated with an obstacle detection sensor).

Would you like a more advanced version, such as PID control for smoother movement?

要实现树莓派小车的黑线识别和运动控制，您需要明确以下两个方面：

1. 描述黑线识别任务：向AI解释如何利用树莓派的小车实现黑线识别。
2. 控制小车运动的指令：了解如何编写代码来控制小车的前进、后退、左转和右转。

1. 描述黑线识别任务

当向AI描述黑线识别任务时，您可以这样表达：

• 任务目标：开发一个基于树莓派的小车，利用摄像头和OpenCV库，实现对地面黑色线路的实时检测和跟踪。
• 技术细节：
  • 图像捕捉：使用树莓派摄像头模块连续捕捉地面图像。
  • 图像处理：将捕捉到的图像转换为灰度图，然后应用二值化处理，以突出显示黑色线路。
  • 轮廓检测：使用OpenCV的findContours函数检测图像中的轮廓，识别出黑线的位置和形状。
  • 路径规划：根据检测到的黑线位置，调整小车的运动方向，使其沿着黑线行驶。

2. 控制小车运动的指令

要控制小车的运动，您需要使用树莓派的GPIO引脚，通过电机驱动模块（如L298N）来控制直流电机。以下是一个使用Python和RPi.GPIO库的示例代码，演示如何控制小车的前进、后退、左转、右转和停止：

python
import RPi.GPIO as GPIO
import time

# 定义电机控制引脚
IN1 = 11  # 左电机前进
IN2 = 12  # 左电机后退
IN3 = 13  # 右电机前进
IN4 = 15  # 右电机后退
ENA = 18  # 左电机使能PWM
ENB = 16  # 右电机使能PWM

def setup():
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup([IN1, IN2, IN3, IN4, ENA, ENB], GPIO.OUT)
    global pwmA, pwmB
    pwmA = GPIO.PWM(ENA, 1000)
    pwmB = GPIO.PWM(ENB, 1000)
    pwmA.start(0)
    pwmB.start(0)

def set_speed(speed):
    pwmA.ChangeDutyCycle(speed)
    pwmB.ChangeDutyCycle(speed)

def forward():
    GPIO.output(IN1, GPIO.HIGH)
    GPIO.output(IN2, GPIO.LOW)
    GPIO.output(IN3, GPIO.HIGH)
    GPIO.output(IN4, GPIO.LOW)

def backward():
    GPIO.output(IN1, GPIO.LOW)
    GPIO.output(IN2, GPIO.HIGH)
    GPIO.output(IN3, GPIO.LOW)
    GPIO.output(IN4, GPIO.HIGH)

def turn_left():
    GPIO.output(IN1, GPIO.LOW)
    GPIO.output(IN2, GPIO.HIGH)
    GPIO.output(IN3, GPIO.HIGH)
    GPIO.output(IN4, GPIO.LOW)

def turn_right():
    GPIO.output(IN1, GPIO.HIGH)
    GPIO.output(IN2, GPIO.LOW)
    GPIO.output(IN3, GPIO.LOW)
    GPIO.output(IN4, GPIO.HIGH)

def stop():
    GPIO.output(IN1, GPIO.LOW)
    GPIO.output(IN2, GPIO.LOW)
    GPIO.output(IN3, GPIO.LOW)
    GPIO.output(IN4, GPIO.LOW)

def cleanup():
    pwmA.stop()
    pwmB.stop()
    GPIO.cleanup()

if __name__ == "__main__":
    try:
        setup()
        set_speed(50)  # 设置速度为50%
        forward()
        time.sleep(2)
        turn_left()
        time.sleep(1)
        forward()
        time.sleep(2)
        stop()
    except KeyboardInterrupt:
        pass
    finally:
        cleanup()

代码说明：

• 引脚定义：根据树莓派的GPIO引脚布局，定义电机控制引脚。
• setup函数：设置GPIO模式并初始化PWM。
• set_speed函数：通过改变PWM的占空比来调整电机速度。
• 运动控制函数：forward、backward、turn_left、turn_right和stop函数分别控制小车的前进、后退、左转、右转和停止。
• cleanup函数：停止PWM并清理GPIO设置。

请确保在实际连接时，电机和L298N驱动模块的接线与代码中的引脚定义相匹配。

通过上述描述，您可以向AI清晰地表达黑线识别的实现方法，并了解如何编写代码来控制树莓派小车的运动。

是的，您可以通过编写代码来控制树莓派小车的各个部件。树莓派提供了多种接口和库，使得与硬件组件的交互变得相对简单。

主要部件及其控制方法：

1. 电机（用于驱动小车前进、后退、转向）：

   • 电机驱动模块（如L298N）： 树莓派的GPIO引脚连接到电机驱动模块的控制引脚，通过设置GPIO引脚的高低电平，控制电机的转动方向和速度。
   • 控制库： 使用RPi.GPIO库或gpiozero库来控制GPIO引脚的输出，从而实现对电机的控制。

2. 摄像头模块（用于图像处理，如黑线识别）：

   • 连接方式： 树莓派官方摄像头模块通过CSI接口连接，USB摄像头通过USB接口连接。
   • 控制库： 使用picamera库（针对官方摄像头模块）或OpenCV库来捕获和处理图像。

3. 超声波传感器（如HC-SR04，用于测距）：

   • 连接方式： 将超声波传感器的触发和回响引脚连接到树莓派的GPIO引脚。
   • 控制方法： 通过GPIO引脚发送触发信号，接收回响信号，计算时间差以测量距离。

4. LED灯（用于指示或照明）：

   • 连接方式： 将LED的正极连接到GPIO引脚，负极连接到地。
   • 控制方法： 通过设置GPIO引脚的高低电平来控制LED的亮灭。

示例代码：

以下是一个使用RPi.GPIO库控制电机的小示例：

python
import RPi.GPIO as GPIO
import time

# 设置GPIO模式为BOARD模式
GPIO.setmode(GPIO.BOARD)

# 定义电机控制引脚
IN1 = 11
IN2 = 12
ENA = 13

# 设置引脚模式为输出
GPIO.setup(IN1, GPIO.OUT)
GPIO.setup(IN2, GPIO.OUT)
GPIO.setup(ENA, GPIO.OUT)

# 设置PWM，频率为1000Hz
pwm = GPIO.PWM(ENA, 1000)
pwm.start(50)  # 占空比为50%，即电机以50%的速度运行

# 前进
GPIO.output(IN1, GPIO.HIGH)
GPIO.output(IN2, GPIO.LOW)
time.sleep(2)

# 停止
GPIO.output(IN1, GPIO.LOW)
GPIO.output(IN2, GPIO.LOW)
time.sleep(1)

# 后退
GPIO.output(IN1, GPIO.LOW)
GPIO.output(IN2, GPIO.HIGH)
time.sleep(2)

# 停止并清理GPIO设置
GPIO.output(IN1, GPIO.LOW)
GPIO.output(IN2, GPIO.LOW)
pwm.stop()
GPIO.cleanup()

注意事项：

• 硬件连接： 确保各个部件正确连接到树莓派的对应引脚。
• 电源供给： 确保为电机等耗电部件提供足够的电源，避免因电压不足导致的故障。
• 库的安装： 在使用前，需要安装相应的Python库，如RPi.GPIO、picamera、opencv-python等。

通过以上方法，您可以编写代码来控制树莓派小车的各个部件，实现如线追踪、避障等功能。

是的，您的树莓派小车上的 SG90 舵机 (Servo Motor) 可以通过代码进行控制。它的主要作用是 调整摄像头的角度，用于 线追踪任务和符号识别任务之间的切换。

---

如何控制 SG90 舵机

SG90 舵机的控制原理基于 PWM (脉宽调制) 信号，不同的脉宽会使舵机旋转到不同的角度：

• -90° (最左) ：** 1.0ms** 的脉冲
• 0° (中间) ：** 1.5ms** 的脉冲
• 90° (最右) ：** 2.0ms** 的脉冲
• PWM 周期 通常设为 20ms

---

树莓派 SG90 代码示例

使用 RPi.GPIO 或 pigpio 库可以控制 SG90 舵机的角度。

方法 1：使用 RPi.GPIO

python
import RPi.GPIO as GPIO
import time

SERVO_PIN = 18  # 连接 SG90 的 GPIO 端口

def setup():
    GPIO.setmode(GPIO.BCM)  # 使用 BCM 编号模式
    GPIO.setup(SERVO_PIN, GPIO.OUT)
    global pwm
    pwm = GPIO.PWM(SERVO_PIN, 50)  # 50Hz PWM
    pwm.start(0)  # 初始占空比为 0

def set_angle(angle):
    duty = 2.5 + (angle / 180.0) * 10  # 计算占空比
    pwm.ChangeDutyCycle(duty)
    time.sleep(0.5)  # 让舵机完成旋转
    pwm.ChangeDutyCycle(0)  # 避免持续供电导致抖动

def cleanup():
    pwm.stop()
    GPIO.cleanup()

if __name__ == "__main__":
    try:
        setup()
        set_angle(0)    # 中间位置
        time.sleep(1)
        set_angle(-90)  # 左转
        time.sleep(1)
        set_angle(90)   # 右转
        time.sleep(1)
    except KeyboardInterrupt:
        pass
    finally:
        cleanup()

方法 2：使用 pigpio（更精准）

RPi.GPIO 在 PWM 控制舵机时可能存在 抖动，可以改用 pigpio 库：

python
import pigpio
import time

SERVO_PIN = 18  # 连接 SG90 的 GPIO 端口

pi = pigpio.pi()  # 初始化 pigpio
pi.set_mode(SERVO_PIN, pigpio.OUTPUT)

def set_angle(angle):
    pulse_width = 1000 + (angle + 90) * 5.56  # 将角度转换为脉冲宽度 (1000-2000µs)
    pi.set_servo_pulsewidth(SERVO_PIN, pulse_width)

try:
    set_angle(0)    # 中间
    time.sleep(1)
    set_angle(-90)  # 左转
    time.sleep(1)
    set_angle(90)   # 右转
    time.sleep(1)
finally:
    pi.set_servo_pulsewidth(SERVO_PIN, 0)  # 停止舵机
    pi.stop()

---

如何在树莓派小车项目中使用 SG90

1. 安装舵机，固定摄像头，让 SG90 控制摄像头的角度，使其能拍摄到 黑线（巡线任务）和 符号（符号识别任务）。
2. 调整舵机角度：
   • 角度 0°：普通巡线任务
   • 角度 -90° 或 90°：抬起摄像头进行符号识别
3. 在 OpenCV 代码中结合舵机控制：
   • 检测到黑线 → 保持摄像头向下
   • 检测到需要识别的符号（如交通标志）→ 旋转摄像头
   • 识别完成后，恢复巡线

示例：

python
if detect_line():  # 发现黑线
    set_angle(0)  # 角度归位，继续巡线
elif detect_symbol():  # 发现符号
    set_angle(-90)  # 旋转摄像头，进行符号识别

---

总结

• SG90 舵机 可通过 PWM (1ms - 2ms) 进行角度控制。
• 树莓派支持两种库 (RPi.GPIO 或 pigpio)，推荐 pigpio 控制更稳定。
• 实际应用：
  • 巡线时保持摄像头向下
  • 识别符号时调整角度
  • 结合 OpenCV 进行自动切换

这样，您的树莓派小车就可以 自动调整摄像头，实现更智能的巡线和符号识别任务！

如果您想让 AI 帮助您编写 C 语言代码 来 检测并计数圆形、三角形和正方形，可以这样描述您的需求：

---

任务描述

目标：

• 使用 OpenCV 和 C 语言 在树莓派上实现形状检测任务。
• 从摄像头获取图像，并检测并计数圆形、三角形和正方形。
• 在 LCD 上显示 计数结果，例如：C:2 T:3 S:1，表示 2 个圆形、3 个三角形、1 个正方形。

技术要求：

1. 图像获取：使用树莓派摄像头捕获图片。
2. 图像预处理：
   • 转换为灰度图 (cv::cvtColor)。
   • 使用 cv::GaussianBlur 进行降噪。
   • 使用 cv::Canny 进行边缘检测。
3. 形状检测：
   • 使用 cv::findContours 查找轮廓。
   • 使用 cv::approxPolyDP 计算形状角点数量：
     • 3 个角点：三角形
     • 4 个角点：正方形
     • >5 个角点（或圆形拟合）：圆形
4. 在 LCD 屏幕上显示形状数量。
5. 忽略最外层的粉色边框。

---

示例 C 语言代码

c
#include <opencv2/opencv.hpp>
#include <stdio.h>

using namespace cv;
using namespace std;

int main() {
    // 打开摄像头
    VideoCapture cap(0);
    if (!cap.isOpened()) {
        printf("无法打开摄像头\n");
        return -1;
    }

    Mat frame, gray, blurred, edged;
    vector<vector<Point>> contours;
    vector<Vec4i> hierarchy;

    while (true) {
        cap >> frame; // 读取摄像头画面
        if (frame.empty()) break;

        // 预处理：灰度化、去噪、边缘检测
        cvtColor(frame, gray, COLOR_BGR2GRAY);
        GaussianBlur(gray, blurred, Size(5, 5), 0);
        Canny(blurred, edged, 50, 150);

        // 查找轮廓
        findContours(edged, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE);

        int circles = 0, triangles = 0, squares = 0;

        for (size_t i = 0; i < contours.size(); i++) {
            vector<Point> approx;
            double peri = arcLength(contours[i], true);
            approxPolyDP(contours[i], approx, 0.04 * peri, true);

            if (approx.size() == 3) {
                triangles++; // 三角形
            } else if (approx.size() == 4) {
                squares++; // 正方形
            } else {
                // 使用圆拟合检查是否是圆形
                float radius;
                Point2f center;
                minEnclosingCircle(contours[i], center, radius);
                if (radius > 10) { // 避免误识别小噪点
                    circles++;
                }
            }
        }

        // 显示结果
        printf("C: %d T: %d S: %d\n", circles, triangles, squares);

        // 显示图像
        imshow("Shapes", frame);
        if (waitKey(30) >= 0) break;
    }

    cap.release();
    destroyAllWindows();
    return 0;
}

---

如何使用

1. 安装 OpenCV：

   bash
   sudo apt update
   sudo apt install libopencv-dev

2. 编译代码：

   bash
   g++ -o shape_counter shape_counter.cpp `pkg-config --cflags --libs opencv4`

3. 运行代码：

   bash
   ./shape_counter

---

扩展功能

• LCD 显示： 可以将结果输出到 LCD（使用 wiringPi 库）。
• 忽略粉色外框： 在 findContours 之前，筛选出 最外层的轮廓 并排除它。
• 提升精度： 通过 cv::contourArea 排除噪声小轮廓。

---

总结

1. 使用 OpenCV 进行图像处理。
2. 基于轮廓角点数量区分形状。
3. 实时统计并显示结果。
4. 可以扩展至 LCD 显示和更精确的形状识别。

这样描述，AI 就可以理解您的需求，并编写出完整的 C 语言代码！

从课件内容来看，该树莓派小车使用的是 Raspberry Pi Camera (Pi Camera) 进行图像采集。这是一款 CSI 接口的官方摄像头模块，适用于树莓派的 OpenCV 任务，比如巡线和形状识别。

可能使用的 Pi Camera 版本

1. Raspberry Pi Camera Module v1

   • 500 万像素
   • 最高 1080p 30fps 视频
   • OV5647 传感器
   • 适用于基础任务

2. Raspberry Pi Camera Module v2

   • 800 万像素
   • 最高 1080p 30fps 视频
   • Sony IMX219 传感器
   • 提供更清晰的图像，适合 OpenCV 处理

3. Raspberry Pi HQ Camera (高质量摄像头)

   • 1200 万像素
   • 可更换镜头
   • Sony IMX477 传感器
   • 适合高精度任务

如何检查当前树莓派摄像头

在终端运行：

bash
vcgencmd get_camera

如果输出：

bash
supported=1 detected=1

说明摄像头已连接。

如何在代码中使用 Pi Camera

方法 1：使用 picamera (适用于 v1/v2)

python
from picamera import PiCamera
import time

camera = PiCamera()
camera.resolution = (640, 480)
camera.start_preview()
time.sleep(2)  # 等待摄像头稳定
camera.capture('/home/pi/image.jpg')
camera.stop_preview()

方法 2：使用 OpenCV 处理实时图像

python
import cv2

cap = cv2.VideoCapture(0)  # 0 代表第一个摄像头
while True:
    ret, frame = cap.read()
    if not ret:
        break
    cv2.imshow("Camera", frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):  # 按 'q' 退出
        break
cap.release()
cv2.destroyAllWindows()

---

如何优化摄像头用于巡线

1. 调整分辨率

   python
   camera.resolution = (320, 240)  # 低分辨率提高处理速度

2. 优化曝光和对比度

   python
   camera.brightness = 50
   camera.contrast = 50

3. 灰度处理 (提高识别精度)

   python
   gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

---

总结

• 树莓派小车 使用官方 Pi Camera (可能是 v1/v2) 进行巡线和形状识别任务。
• 通过 OpenCV 或 picamera 进行图像采集和处理。
• 适当调整 分辨率、曝光、对比度 可以优化巡线性能。

如果您不确定使用的是 v1 还是 v2，可以运行：

bash
vcgencmd get_camera

或者查看 摄像头的物理标签 来确认型号！

是的，从课件来看，您的项目需要使用 OpenCV 来实现计算机视觉任务，并明确提到使用 C/C++ 库。这意味着：

1. C 语言的 OpenCV API：

   • 旧版 OpenCV (如 2.x 或 3.x) 支持 C 语言 API，但 OpenCV 4.x 已移除 C API，必须使用 C++ 进行开发。
   • 如果您的树莓派安装的是 OpenCV 4.x，而示例代码使用的是旧的 C API（如 cvCaptureFromCAM()），那么您必须改写为 C++ 代码，使用 cv::VideoCapture 进行摄像头操作。

2. OpenCV C++ API（推荐）：

   • OpenCV 4.x 主要使用 C++，例如：

     cpp
     cv::Mat frame;
     cv::VideoCapture cap(0);
     cap.read(frame);

   • 如果您用的是 OpenCV 4.x，建议直接用 C++ API 而不是老旧的 C API。

3. 树莓派兼容性：

   • 课件中提到使用 Raspberry Pi 3B，并未限制特定 OpenCV 版本，但如果您的树莓派运行的是 Raspberry Pi OS（基于 Debian），默认软件仓库可能提供 OpenCV 3.x 或 4.x。
   • 您可以运行以下命令检查 OpenCV 版本：

     bash
     python3 -c "import cv2; print(cv2.__version__)"

结论

• 如果您使用 OpenCV 4.x 及以上版本，C 语言 API 将不可用，必须使用 C++ 代码。
• 如果 OpenCV 版本较低（如 2.x 或 3.x），仍然可以使用 C 语言 API，但不推荐，因为官方已停止支持。
• 建议使用 C++ 进行 OpenCV 开发，以确保代码的可维护性和兼容性。

如果您确认需要 C++ 代码，我可以帮您将 C 语言示例转换为 C++ 代码，以便在 OpenCV 4.x 上运行。

是的，从课件的任务描述来看，形状识别任务（Count Shapes）和线追踪任务（Line Following）是两个独立的任务，但它们在运行过程中可能会结合在一起。也就是说，小车在执行形状识别任务时，仍然需要进行线追踪，以保持其在轨道上移动。

任务之间的关系

1. 线追踪 (Line Following)

   • 主要目标是让小车沿着黑色轨迹移动。
   • 需要使用 OpenCV 识别黑线并控制电机调整方向。
   • 这个任务是所有其他任务的基础，因为小车的移动依赖于它。

2. 形状识别 (Count Shapes)

   • 任务要求识别模板，并检测其中的圆形、三角形和正方形数量。
   • 需要使用 OpenCV 进行模板匹配（Template Matching）或轮廓检测（Contour Detection）。
   • LCD 显示检测到的形状数量（例如："C:2 T:3 S:1"）。
   • 形状识别任务不要求小车移动，但小车需要先到达指定区域才能进行识别。

3. 二者的结合

   • 小车在正常巡线时，遇到形状识别区域（模板），需要短暂停止，然后进行形状识别。
   • 识别完成后，小车恢复线追踪，继续前进。

任务执行流程

1. 启动线追踪

   • 摄像头向下，检测黑线，沿轨道前进。

2. 检测到形状识别模板

   • 可能使用超声波传感器（HC-SR04）检测模板区域并停车。
   • 摄像头调整角度（如果需要）。

3. 执行形状识别

   • 使用 OpenCV 进行轮廓检测或模板匹配，计算形状数量。
   • 识别结果显示在 LCD 上。

4. 恢复线追踪

   • 形状识别完成后，小车继续沿黑线前进。

代码实现逻辑

• 线追踪部分：OpenCV 处理黑线，调整电机方向。
• 形状识别部分：检测模板，执行形状计数，LCD 显示。
• 结合逻辑：遇到模板区域暂停，识别完成后继续追踪黑线。

总结

形状识别任务本身不包含线追踪，但在实验过程中，小车需要先沿线移动到指定位置才能执行形状识别。因此，形状识别和线追踪需要结合使用，并通过摄像头、OpenCV 以及电机控制实现自动化。