Un article pour présenter une solution pour se connecter en ssh à une carte Raspberry Pi via un câble Ethernet en direct (pas de box internet).
Logiciel nécessaire:
- Putty
- IP : raspberrypi.local
- Port : 22
Une vidéo de présentation du robot MRPiZ :
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()
Un nouveau tutoriel pour le robot MRPiZ :
https://fr.macerobotics.com/developpeur/partie-1-tracking-dune-balle-coloree/
Ce tutorial présente l’implémentation d’un suivi de ligne pour le robot mobile MRPiZ.
Deux méthodes sont possibles pour accéder à la caméra:
Il nous faut donc activer v4l:
$ sudo modprobe bcm2835-v4l2
Le fichier complet se trouve dans Software/Python/tutorials/line_follower/line.py.
Warning
Utilisez CTRL+C pour arrêter le robot.
import numpy as np
import cv2
import sys
from mrpiZ_lib import *
# image size
WIDTH = 640
HEIGHT = 480
# turn coeff
COEFF = 0.05
# base robot speed in straight line
SPEED = 30
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)
La boucle principale va fonctionner à l’infini, pour l’arrêter il faudra appuyer sur CTRL+C.
try:
while(True):
Première étape, on commence par capturer une image.
# Capture the frames
ret, frame = video_capture.read()
Voici un exemple d’image capturée:
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]
Ensuite on passe l’image en niveaux de gris:
# Convert to grayscale
gray = cv2.cvtColor(crop_img, cv2.COLOR_BGR2GRAY)
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)
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)
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)
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
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'])
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)
Enfin, deux lignes de code permettent d’arrêter le robot quand on appuie sur CTRL+C.
except KeyboardInterrupt:
stop()
Voici un exemple de création d’une carte avec le robot MRPiZ en utilisant le capteur de distance laser VL53L0X :
from mrpiZ_lib import * import time, csv NameFile = 'carte.csv' def read_laser(): p3_1 = proxSensor(3) p3_2 = proxSensor(3) p3_3 = proxSensor(3) p3_4 = proxSensor(3) p3_5 = proxSensor(3) p3 = (p3_1 + p3_2 + p3_3 + p3_4 + p3_5)/5 return p3 ############################################# MAIN # wait init time.sleep(2) Fichier = open(NameFile,'w') Robot_tourne = 0 # enable asv control controlEnable() while 1: # read laser distance sensor distance = read_laser() # read robot orientation orientation = robotPositionO() # write in file Fichier.write(str(distance)) Fichier.write(";") Fichier.write(str(orientation)) Fichier.write("\r\n")# nouvelle ligne if(Robot_tourne == 0): turnLeftDegree(8,360) Robot_tourne = 1 Fichier.close() exit()
import numpy as np import math import matplotlib.pyplot as plt import numpy as np import csv liste_distance = [] liste_orientation = [] fichier = open("carte.csv", "r") c = 0 # lecture fichier while True: ligne = fichier.readline() if ligne =='': break # fin fichier # lecture de la distance (capteur distance) distance = ligne.split(';')[0] # lecture orientation orientation = ligne.split(';')[1] # correction de la distance par rapport au centre du robot et la position du capteur distance = float(distance) + 50 # conversion en radian if float(orientation) > 0: orientation = (float(orientation)*3.14)/180 liste_distance.append(float(distance)) liste_orientation.append(float(orientation)) c = c + 1 ax = plt.subplot(111, projection='polar') ax.plot(liste_orientation, liste_distance) ax.grid(True) plt.show()
Exemple d’affichage :
Imitation learning exemple with the MRPiZ robot :
The python code :
from mrpiZ_lib import * import time # acquisition frequency TIME_ACQ = 0.1 # acquisition time TEMPS_ACQ = 200 liste_mr = [] liste_ml = [] # main program # record loop c = 0 motorsDisable() time.sleep(1) while c < TEMPS_ACQ: ml = motorLeftSpeed() # read left motor speed mr = motorRightSpeed() # read right motor speed liste_mr.append(mr) liste_ml.append(ml) time.sleep(TIME_ACQ) print ml, mr, c c = c + 1 print "END RECORD -----------" time.sleep(2) c=0 cmd_right=0 cmd_left=0 dir_right = 0 dir_left = 0 # H-bridge enable motorsEnable() ########################################################## # imitation while c < TEMPS_ACQ: if liste_mr[c] >= 0: cmd_right = 2.8*liste_mr[c] dir_right = 0 elif liste_mr[c] < 0: cmd_right = 2.8*liste_mr[c] dir_right = 1 else: dir_right = 0 cmd_right = 0 if liste_ml[c] >= 0: cmd_left = 2.8*liste_ml[c] dir_left = 0 elif liste_ml[c] < 0: cmd_left = 2.8*liste_ml[c] dir_left = 1 else: cmd_left = 0 dir_left = 0 print cmd_left, cmd_right, c c= c + 1 # motors commands motorRight(dir_right,abs(cmd_right)) motorLeft(dir_left,abs(cmd_left)) time.sleep(TIME_ACQ) stop() # end
Promotion sur le robot MRPiZ version starter de -10% du 30/04/2018 au 14/05/2018.
Boutique : https://shop.macerobotics.com/
import sys from mrpiZ_lib import * import time time.sleep(5) controlEnable() forward_mm(10,220) turnLeft_degree(10,90) forward_mm(10,170) turnLeft_degree(10,90) forward_mm(10,170) turnRight_degree(10,90) forward_mm(10,290) turnRight_degree(10,90) forward_mm(10,375) turnRight_degree(10,90) forward_mm(10,450)