Voici un exemple de création d’une carte avec le robot MRPiZ en utilisant le capteur de distance laser VL53L0X :

Le programme python de la création d’une carte :

• Le robot tourne à 360° et lit le capteur de distance,
• Enregistrement de l’orientation du robot et de la distance du capteur dans un fichier csv.

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()

Le programme de lecture et d’affichage de la carte  :

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 :

• record the speed of the two motors
• repead the speed of the motors

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

La gestion des robots en parallèle est gérer par fabric (www.fabfile.org). Un outil SSH permettant d’envoyer plusieurs commandes SSH en parallèle. Chaques robots MRPiZ est identifié par une adresse IP unique:

• IP du robot n°1: 192.168.1.41
• IP du robot n°2: 192.168.1.37
• IP du robot n°3: 192.168.1.47

Le script de contrôle des robots :

#!/usr/bin/env python
import fabric
from fabric.api import run, env, task
from fabric.api import *
import time


env.hosts = ['192.168.1.41', '192.168.1.37', '192.168.1.47']

env.user = 'pi'
env.password = 'raspberry'

@parallel
def hello():
 run('python /home/pi/MRPiZ/Dance.py')

Le script python pour les robots :

#!/usr/bin/env python

import sys
from mrpiZ_lib import *
import time

controlEnable()
while 1:
 forward_mm(13,120)
 back_mm(11,100)
 forward_mm(11,100)
 turnRight_degree(25,360)
 time.sleep(1)
 turnRight_degree(15,90)
 turnLeft_degree(15,180)
 turnRight_degree(15,90)
 back_mm(12,90)