Geautomatiseerde Visuele Object-tracking met Raspberry Pi en OpenCV

Een pan/tilt-servo-systeem dat automatisch kleurobjecten volgt met behulp van computer vision.

Verhaal

Inleiding

In de vorige tutorial leerden we hoe je een pan/tilt-servo kunt besturen om een Raspberry Pi-camera te positioneren. Vandaag breiden we die opstelling uit zodat de camera autonoom een gekleurd object kan volgen.

Dit is mijn eerste hands-on ervaring met OpenCV, en ik ben al verbijsterd over deze open-source computer-vision-bibliotheek.

OpenCV is gratis voor academisch en commercieel gebruik, biedt C++, C, Python, en Java-interfaces, en draait op Windows, Linux, macOS, iOS, en Android. In deze serie richten we ons op de Raspberry Pi (Raspbian) en Python, omdat OpenCV gebouwd is voor computationele efficiëntie en real-time toepassingen — precies wat je nodig hebt voor physical-computing-projecten.

Stap 1: BOM – Stuklijst

Hoofdonderdelen:

• Raspberry Pi V3 – US$ 32,00
• 5 MP 1080p OV5647 Mini Camera Video Module – US$ 13,00
• TowerPro SG90 9G 180-graden Micro Servo (2 ×) – US$ 4,00
• Mini Pan/Tilt Camera Platform Anti-Trilling Mount w/ 2 Servos (*) – US$ 8,00
• Rode LED
• Weerstand 220 Ω
• Weerstand 1 kΩ (2 ×) – Optioneel
• Diversen: metalen onderdelen, banden, etc. (voor het bouwen van een eigen pan/tilt-mechanisme)

(*) Je kunt een compleet pan/tilt-platform met servos kopen of zelf bouwen.

Stap 2: OpenCV 3 Installeren

Op een Raspberry Pi V3 met de nieuwste Raspbian Stretch, is de betrouwbaarste methode om Adrian Rosebrock's tutorial te volgen (Raspbian Stretch: Install OpenCV 3 + Python op je Raspberry Pi). Het begeleidt je door het bouwen van OpenCV vanaf bron en stelt een speciale Python-virtuele omgeving in.

Na het voltooien van de tutorial, activeer de virtuele omgeving en bevestig de installatie:

source ~/.profile
workon cv
python
import cv2
print(cv2.__version__)

Je zou versie 3.3.0 of nieuwer moeten zien. De uitvoer bevestigt dat OpenCV klaar is voor gebruik binnen de cv virtuele omgeving.

Stap 3: Je Camera Testen

Met OpenCV geïnstalleerd, verifieer dat de PiCamera correct streamt. Draai het volgende script (of download simpleCamTest.py):

import cv2
cap = cv2.VideoCapture(0)
while True:
    ret, frame = cap.read()
    frame = cv2.flip(frame, -1)  # Verticaal flippen indien nodig
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    cv2.imshow('frame', frame)
    cv2.imshow('gray', gray)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

Druk q of Ctrl+C om af te sluiten. Een succesvolle run toont zowel kleur- als grijswaarden-feeds.

Stap 4: Kleurdetectie in Python met OpenCV

OpenCV werkt in de HSV (Tint, Verzadiging, Waarde) ruimte, wat beter aansluit bij menselijke kleurperceptie. Om een specifieke kleur te detecteren, bepaal je eerst de BGR-waarden, converteer dan naar HSV en stel onder/upper-bounds in.

Voorbeeld: Een geel object tracken. Met een kleurkiezer (bijv. PowerPoint) vond je de BGR-waarden (71, 234, 213). Converteer ze naar HSV met het onderstaande script (of download bgr_hsv_converter.py):

import sys, numpy as np, cv2
blue, green, red = int(sys.argv[1]), int(sys.argv[2]), int(sys.argv[3])
color = np.uint8([[[blue, green, red]]])
hsv = cv2.cvtColor(color, cv2.COLOR_BGR2HSV)
hue = hsv[0][0][0]
print('Ondergrens:', [hue-10, 100, 100])
print('Bovengrens:', [hue+10, 255, 255])

Het uitvoeren van python bgr_hsv_converter.py 71 234 213 print:

Ondergrens: [24, 100, 100]
Bovengrens: [44, 255, 255]

Gebruik deze bounds om de kleur in een afbeelding te maskeren:

import cv2, numpy as np
img = cv2.imread('yellow_object.JPG', 1)
img = cv2.resize(img, (0,0), fx=0.2, fy=0.2)
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
lower = np.array([24, 100, 100], dtype=np.uint8)
upper = np.array([44, 255, 255], dtype=np.uint8)
mask = cv2.inRange(hsv, lower, upper)
cv2.imshow('mask', mask)
cv2.imshow('image', img)
while True:
    k = cv2.waitKey(0)
    if k == 27:
        break
cv2.destroyAllWindows()

Bewaar het script als colorDetection.py en draai python colorDetection.py (zorg dat de afbeelding in dezelfde map staat).

Stap 5: Real-time Object-tracking

Opbouwend op de masker, kunnen we het object's centroid frame-voor-frame tracken. De onderstaande code leent van Adrian Rosebrock's Ball Tracking tutorial en incorporeert de HSV-bounds die we eerder definieerden.

Eerst, zorg dat de imutils bibliotheek geïnstalleerd is:

pip install imutils

Draai dan ball_tracking.py:

python ball_tracking.py

Het script flip de frame verticaal (indien nodig) en past de masker toe. Wanneer het object gedetecteerd wordt, worden een cirkel en centroid getekend.

Stap 6: De GPIO's Testen

Nu voegen we een rode LED toe aan de Pi en bevestigen dat we het via GPIO kunnen besturen.

Bedrading: Verbind de LED-kathode met GPIO 21, de anode met massa via een 220 Ω-weerstand.

Als RPi.GPIO nog niet geïnstalleerd is in de cv omgeving, installeer het:

pip install RPi.GPIO

Testscript (LED_simple_test.py):

import sys, time, RPi.GPIO as GPIO
led = int(sys.argv[1])
freq = int(sys.argv[2])
GPIO.setmode(GPIO.BCM)
GPIO.setup(led, GPIO.OUT)
GPIO.setwarnings(False)
print(f'LED knipperen op GPIO {led} elke {freq}s, 5 keer.')
for _ in range(5):
    GPIO.output(led, GPIO.LOW)
    time.sleep(freq)
    GPIO.output(led, GPIO.HIGH)
    time.sleep(freq)
GPIO.cleanup()

Voer uit met python LED_simple_test.py 21 1 om de LED vijf keer per seconde te laten knipperen.

Stap 7: Kleurherkenning & GPIO-interactie

Combineer de tracking-logica met GPIO-besturing zodat de LED oplicht wanneer de doelkleur gedetecteerd wordt. De kerntoevoegingen zijn:

import RPi.GPIO as GPIO
led = 21
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(led, GPIO.OUT)
GPIO.output(led, GPIO.LOW)
ledOn = False

Binnen de detectielus, na het bevestigen van een geldige straal, voeg toe:

if not ledOn:
    GPIO.output(led, GPIO.HIGH)
    ledOn = True

Volledig script: object_detection_LED.py. Draai met python object_detection_LED.py. De LED gaat alleen aan wanneer de objectkleur binnen de HSV-bounds valt.

Stap 8: Het Pan/Tilt-mechanisme

Met OpenCV en GPIO werkend, bevestig de servos aan een externe 5 V-voeding. Bedraad de datapinnen als volgt:

• GPIO 17 → Kantel-servo
• GPIO 27 → Draai-servo

Deel de massa tussen de Pi, servos, en voeding. Optioneel een 1 kΩ-weerstand in serie tussen de Pi-GPIO en servo-datapin plaatsen om de Pi te beschermen tegen stroompieken.

Test servo-besturing met angleServoCtrl.py:

from time import sleep
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
def setServoAngle(servo, angle):
    pwm = GPIO.PWM(servo, 50)
    pwm.start(8)
    duty = angle / 18. + 3.
    pwm.ChangeDutyCycle(duty)
    sleep(0.3)
    pwm.stop()
if __name__ == '__main__':
    import sys
    servo = int(sys.argv[1])
    GPIO.setup(servo, GPIO.OUT)
    setServoCtrl(servo, int(sys.argv[2]))
    GPIO.cleanup()

Voorbeeld: python angleServoCtrl.py 17 45 beweegt de kantel-servo naar 45°.

Stap 9: De Real-time Positie van het Object Bepalen

Om de camera op het doel te centreren, hebben we eerst de centroid-coördinaten van het object nodig. Wijzig objectDetect_LED.py om de x en y waarden te printen:

def mapObjectPosition(x, y):
    print(f'[INFO] Objectcentrum op X={x}, Y={y}')

De coördinaten variëren van 0–500 (links-naar-rechts) voor x en 0–350 (boven-naar-beneden) voor y. Beweeg het object en observeer de live-uitvoer.

Stap 10: Object-positie-tracking-systeem

Definieer een "gecentreerd" gebied (bijv. 220 < x < 280 en 160 < y < 210). Als het object erbuiten valt, pas de pan- en tilt-servos dienovereenkomstig aan:

def mapServoPosition(x, y):
    global panAngle, tiltAngle
    if x < 220:
        panAngle = min(panAngle + 10, 140)
        positionServo(panServo, panAngle)
    if x > 280:
        panAngle = max(panAngle - 10, 40)
        positionServo(panServo, panAngle)
    if y < 160:
        tiltAngle = min(tiltAngle + 10, 140)
        positionServo(tiltServo, tiltAngle)
    if y > 210:
        tiltAngle = max(tiltAngle - 10, 40)
        positionServo(tiltServo, tiltAngle)

De helper positionServo(servo, angle) roept simpelweg angleServoCtrl.py aan:

import os
def positionServo(servo, angle):
    os.system(f'python angleServoCtrl.py {servo} {angle}')
    print(f'[INFO] Positioneren servo GPIO {servo} naar {angle}°')

Alle scripts staan in dezelfde map; download de complete implementatie van objectDetectTrack.py.

Stap 11: Conclusie

Dit project demonstreert hoe je OpenCV, Raspberry Pi GPIO, en een pan-tilt-servomontage combineert om een autonoom kleuren-object-tracking-systeem te creëren. Voel je vrij om te experimenteren met verschillende kleuren, vormen, en servo-snelheden.

Volledige code en extra bronnen zijn beschikbaar op GitHub en de MJRoBot.org blog.

Bedankt voor het lezen — tot de volgende tutorial!