Une vidéo du robot MRPiZ avec le capteur de gestes 3D Flick:

Le programme en langage python:

#!/usr/bin/env python
import sys
from mrpiZ_lib import *
import time
import flicklib
from copy import copy
import subprocess


def message(value):
  print value

@flicklib.move()
def move(x, y, z):
  global xyz
  xyz = [x,y,z]

def main():
  time_PasDetection = 0
  global xyz
  xyz = [0,0,0]
  old_xyz = [0,0,0]
  deplacement_axeX = 0

  print "Exemple"

  while True:
    if old_xyz != xyz:
      deplacement_axeX = xyz[0]
      deplacement_axeY = xyz[1]

    print "X", deplacement_axeX
    print "Y", deplacement_axeY

    if(deplacement_axeX < 0.35):
      print "avancer"
      forward(25)
    if(deplacement_axeX > 0.75):
      print "reculer"
      back(25)
    if((deplacement_axeY > 0.75)and(deplacement_axeX > 0.35)and(deplacement_axeX < 0.75)):
      print "tourner droite"
      turnRight(25)
    if((deplacement_axeY < 0.5)and(deplacement_axeX > 0.35)and(deplacement_axeX < 0.75)):
      print "tourner gauche"
      turnLeft(25)
    time.sleep(0.5)
    #stop()
    else:
      print "pas de detection"
      time_PasDetection = time_PasDetection + 1
    if(time_PasDetection > 5):
      stop()
      time_PasDetection = 0
    old_xyz = copy(xyz)
    time.sleep(0.2)

if __name__ == "__main__":
  main()

Ce tutorial présente l’implémentation d’un suivi de ligne pour le robot mobile MRPiZ.

Matériel nécessaire

• Un robot MRPiZ
• Une caméra compatible, idéalement grand angle.

Logiciels nécessaire

• Python 2.7 (déja installé par défaut),
• La bibliothèque Python MRPiZ (déja installée par défaut),
• OpenCV pour python

Activation de video4linux

Deux méthodes sont possibles pour accéder à la caméra:

1. PiCamera: la méthode la plus répandue, mais lente car il est nécessaire de transformer l’image pour la mettre au bon format,
2. v4l: qui s’interface directement avec OpenCV, c’est la méthode choisie pour ce tutorial.

Il nous faut donc activer v4l:

$ sudo modprobe bcm2835-v4l2

Le suivi de ligne

Le fichier complet se trouve dans Software/Python/tutorials/line_follower/line.py.

Importation des modules

import numpy as np
import cv2
import sys
from mrpiZ_lib import *

Paramétrés globaux

# image size
WIDTH = 640
HEIGHT = 480

# turn coeff
COEFF = 0.05
# base robot speed in straight line
SPEED = 30

Activation de la caméra

Pour améliorer les performances, la résolution est réduite à 640 pixels en largeur et 480 en hauteur.

video_capture = cv2.VideoCapture(0)
video_capture.set(3, WIDTH)
video_capture.set(4, HEIGHT)

Boucle principale

La boucle principale va fonctionner à l’infini, pour l’arrêter il faudra appuyer sur CTRL+C.

try:
    while(True):

Capture de l’image

Première étape, on commence par capturer une image.

# Capture the frames
ret, frame = video_capture.read()

Voici un exemple d’image capturée:

Suppression de la partie haute

Pour améliorer les performances, on ne va garder que la partie basse de l’image:

# Crop the image
# Keep the 100 lower pixels
crop_img = frame[379:480, 0:640]

Niveaux de gris

Ensuite on passe l’image en niveaux de gris:

# Convert to grayscale
gray = cv2.cvtColor(crop_img, cv2.COLOR_BGR2GRAY)

Flou

Un filtre afin de rendre flou les lignes de l’image est appliqué, il permet de rendre plus efficace les étapes suivantes:

# Gaussian blur
blur = cv2.GaussianBlur(gray,(5,5),0)

Seuillage

Ensuite on va filtrer les parties claires de l’image pour ne garder les parties noires, pour cela, un filtre de seuillage est appliqué:

# Color thresholding
ret,thresh = cv2.threshold(blur,60,255,cv2.THRESH_BINARY_INV)

Détection de contours

Ensuite, on va utiliser openCV pour détecter les contours:

# Find the contours of the frame
contours,hierarchy = cv2.findContours(thresh.copy(), 1, cv2.CHAIN_APPROX_NONE)

Extraction du plus gros contour

Il nous faut ensuite extraire la ligne la plus large trouvée afin d’éliminer les fausses détections:

# Find the biggest contour (if detected)
if len(contours) > 0:
    c = max(contours, key=cv2.contourArea)
    M = cv2.moments(c)

    # Skip to avoid div by zero
    if int(M['m00']) == 0:
        continue

Calcul du milieu de la ligne

Une fois les contours de la ligne détectée, on calcul le centre de la ligne, c’est la que l’on veut que le robot aille:

# Get the line center
cx = int(M['m10']/M['m00'])
cy = int(M['m01']/M['m00'])

Contrôle des moteurs

Une correction proportionnelle à la différence entre la position de la ligne et le milieu de l’image est calculée. Les moteurs sont ensuite commandés pour ralentir un des moteurs et accélérer l’autre, ceci afin de faire tourner le robot en direction du centre de la ligne.

delta = COEFF * (cx - 320)
motorRight(0, SPEED - delta)
motorLeft(0, SPEED + delta)

Clavier

Enfin, deux lignes de code permettent d’arrêter le robot quand on appuie sur CTRL+C.

except KeyboardInterrupt:
    stop()