Réaliser un petit lidar avec un capteur Time-of-Flight

Cet article présente la réalisation d’un LIDAR avec un capteur laser Time-of-Flight (ToF) .

lidar1

Matériels nécessaire :

  • Une carte Esus
  • Un capteur VL53L0X de chez Pololu
  • Un servomoteur AX12

Logicielle:

  • Librairie pour le capteur VL53L0X, ici.
  • Processing
  • Arduino IDE

Synoptique

Le servomoteur AX12 est câblé sur la sortie Tx de la carte Esus. Puis le capteur VL53L0X, IO n°2 pour SDA et n°13 pour le signal SDL du bus I2C.

lidar_synoptique

L’alimentation doit être d’au moins 7 Volt pour faire fonctionner le servomoteur. La capteur laser est alimenté par une tension de 3.3V présente sur la carte Esus.

Le code de la carte Esus

La carte Esus contrôle le servomoteur pour le déplacement d’un angle de 0 à 300° aller-retour. De plus, elle gère l’acquisition de la distance obtenu par le capteur VL53L0X.

Voici le setup :

void setup() 
{
 // init serial   
 Serial.begin(9600);

 // init serial AX12
 swSer.begin(1000000);

 // init I2C
 Wire.begin(2, 13);//SDA, SCL

 // init VL53L0X
 sensor.init();
 sensor.setTimeout(500);

 state = 1;

}

La boucle infini :

void loop()
{
 
  // servomotor control
  AX12_GoalPosition(0xFE, angle, 1023);

  // read distance
  data = sensor.readRangeSingleMillimeters();

  // send distance
  Serial.write(data>>8);
  Serial.write(data);

  // send angle
  Serial.write(angle>>8);
  Serial.write(angle);

  // angle between 0 and 300 °
  if(( angle <= 300)and(state == 1))
  {
    angle = angle + 1; 
  }
  else
  {
    state = 2;
  }

  if(( angle >= 0)and(state == 2))
  {
    angle = angle - 1; 
  }
  else
  {
    state = 1;
  }
  

  delay(5);

Voici le programme complet, ici.

 

Le programme de visualisation

lidar2

Voici le programme Processing de visualisation :

import processing.serial.*;

Serial myPort;  
String val;     

int distance_mm, val_old;
int angle;
float radian;
float pox,poy;

int x=0;

void setup()
{
  size(400, 400);

 background(255);

  myPort = new Serial(this, "COM13", 9600);
  
}


void draw()
{

  if(myPort.available() >= 4)
  {
   
    val_old = distance_mm;
    
    distance_mm =  (myPort.read() << 8) | (myPort.read()); 
    print("Val1:");
    println(distance_mm);   
    
    distance_mm = distance_mm/2;
         
    angle =  (myPort.read() << 8) | (myPort.read()); 
    print("Angle:");
    println(angle);   
 
    myPort.clear();  
    
    if(angle <= 45)
    {
      angle = angle + 315;
    }
    else
    {
      angle = angle - 45;
    }
    
  }  
    
   // conversion degre radian
   radian = (angle * 3.14)/180;
   pox = int(cos(radian)*distance_mm);
   poy = int(sin(radian)*distance_mm);
  
   clear();
   background(255);

   stroke(0, 0, 0);
   
   // grille
   line(200,0,200,400);
   line(0,200,400,200);
   
   stroke(255, 0, 0);
   
   line(200,200,int(pox)+200,200-int(poy));
   
}

Améliorations

  • Vitesse
  • Retour de l’angle du servomoteur AX12

 

 

Contrôle moteurs avec la carte Esus

Un tutoriel pour contrôler deux moteurs à courant continu avec la carte Esus.

image_motors

Contrôle de deux moteurs

Vous avez besoin :

  • Une carte Esus,
  • Une alimentation ou une batterie,
  • Deux moteurs CC.

Attention , le courant maximum de sortie des ponts en H est de 1.2 A !

Le branchement

  • Les moteurs sont à connecter sur le bornier ci dessous :

esus_bornier_motors

Ce bornier est relié au composant L293, c’est un double pont en H.

Contrôle des moteurs

Pour contrôler un moteur avec la carte Esus, il faut utiliser la fonction :

void motors1_set(unsigned int speed, boolean direction);

void motors2_set(unsigned int speed, boolean direction);

Un peu d’explication pour ces fonctions:

  • motors1_set : permet de contrôlé la vitesse et la direction d’un moteur. Cette fonction gère un moteur sur la bornier gauche de la carte Esus.

esus_bornier_motor1

  • motors2_set : permet de contrôlé la vitesse et la direction d’un moteur. Cette fonction gère un moteur sur la bornier droit de la carte Esus.
  • La vitesse varie entre 0 et 1023.
  • La direction est de type boolean (true ou false) :
    • DIR_FORWARD = true
    • DIR_BACK = false

Contrôle d’un moteur

  • Initialisation de la carte Esus :
#include <esusBoard.h>

void setup() 
{
  // initialisation de la carte Esus
  initEsusBoard();
 
}

void loop() 
{

}
  • Ensuite, appel de la fonction de la commande moteur :
void loop() 
{
  // commande moteur avec la vitesse max
  motors1_set(1023, true);
}
  • Et, maintenant pour contrôler deux moteurs :
void loop() 
{
  // commande moteur avec la vitesse max
  motors1_set(1023, DIR_FORWARD);

  motors2_set(1023, DIR_BACK);
}

Exercice

Réaliser un programme pour faire avancer deux moteurs dans un sens, puis après 2 secondes dans un autre sens. Avec une vitesse de 50% de la vitesse maximum.

Réponse :

void loop() 
{
  motors1_set(1023/2, DIR_FORWARD);

  motors2_set(1023/2, DIR_FORWARD);

  delay(1000);
  
  motors1_set(1023/2, DIR_BACK);

  motors2_set(1023/2, DIR_BACK);

  delay(1000);
}

Campagne Kickstarter pour la carte Esus

Une campagne participative est aujourd’hui lancé pour la carte Esus sur la célèbre plateforme Kickstarter.

C’est quoi la carte Esus ?

La carte Esus est une carte de contrôle de robot mobile ou de projet IoT avec une communication Wifi. De plus, elle est facilement programmable avec l’IDE Arduino.

esus_pres_kick

Vous souhaitez plus d’informations : ici

 

 

Les maths avec le robot MRduino !

L’apprentissage des mathématiques avec le robot mobile MRduino avec la programmation graphique (Blockly).

 


Les distances

Le premier exemple est le concept de distance.

Cet exemple permet de faire avancer le robot en ligne droite de 20 cm.

“Comment faire avancer MRduino d’une distance de 20 cm ?”

Voici l’algorithme pour faire avancer le robot de 20 cm :

  • Initialiser le robot MRduino,
  • Activer le contrôle : ceci permet d’activer le contrôle en distance et orientation du robot,
  • Appel du bloc avancer distance,

 

Étape n°1

Initialisation du robot MRduino avec l’ajout du bloc “Initialisation robot MRduino” :

math1

Étape n°2

Activation du contrôle, pour gérer les distances et les angles.

math2

Étape n°3

Appel du bloc “Avancer distance” avec en paramètre le nombre 20, afin d’avancer le robot de 20 cm.

math4


Les angles

Cette deuxième partie présente les angles géométriques :

“Comment faire tourner MRduino d’un angle de 90° ?”

C’est très simple !

Il faut appeler le bloc “Tourner à gauche degré” avec en paramètre l’angle de 90 °.

  • Voici le programme en Blockly pour tourner à gauche de 90° :

math5

Un autre exemple :

  • tourner à gauche de 45°,
  • allumer la led n°1
  • tourner droite de 180°
  • allumer la led n°2

math6


Forme géométrique

Maintenant, place à la réalisation d ‘une forme géométrique avec le robot MRduino :

Exercice n°1 :

Réaliser un carré de 10 cm de coté.

Réponses de l’exercice n°1:

math7

 

 

 

ROS Partie 1 : Créer votre robot

Dans ce tutoriel vous allez créer votre propre modélisation de robot mobile avec l’aide d’un fichier URDF. Ce tutoriel nécessite l’installation de ROS sur Ubuntu.

Système :

Crée votre workspace

Une fois sur Ubuntu, vous pouvez ouvrir un terminal.

La première chose à faire et de créer votre workspace pour la création de votre robot.

  • Commande pour crée le dosser MyRobot_ws :
$ mkdir -p ~/MyRobot_ws/src
$ cd ~/MyRobot_ws/src
  • Commande pour initialiser le workspace :
$ catkin_init_workspace

Crée votre package

  • Commande pour crée le package MyRobot :
$ cd ~/MyRobot_ws/src
$ catkin_create_pkg MyRobot

Maintenant que votre environnement est près vous pouvez crée la modélisation du robot.

Modélisation du robot

Cette partie va vous permettre de réaliser la modélisation du petit robot mobile de type différentielle :

  • 2 roues
  • 1 ball-caster
  • 1 chassis

Modélisation du châssis

  • Crée un fichier de type URDF (Unified Robot Description Format) :
$ gedit ~/MyRobot_ws/src/MyRobot/MyRobot.urdf
  • Fichier MyRobot.urdf :
<?xml version="1.0"?>
<robot name="MyRobot">

<link name="base_link">
   <visual>
    <geometry>
     <cylinder length="0.035" radius="0.05"/>
    </geometry>
    <material name="white">
      <color rgba="1 1 1 1"/>
    </material>
   </visual>
 </link>

</robot>
  • Enregistrer le fichier
  • Commande pour visualisez le châssis en 3D avec l’outils Rviz :
$ roslaunch urdf_tutorial display.launch model:=MyRobot.urdf

Imge_rviz

Modélisation des roues du robot mobile

  • Modélisation de la roue droite :
 <link name="right_wheel"> 
    <visual> 
      <geometry> 
        <cylinder length="0.005" radius="0.016"/> 
      </geometry> 
      <material name="black"> 
        <color rgba="0 0 0 1"/> 
      </material> 
    </visual> 
  </link>
  • Modélisation du lien entre la roue droite et le châssis :
 <joint name="right_wheel_joint" type="continuous"> 
    <axis xyz="0 0 1"/> 
    <parent link="base_link"/> 
    <child link="right_wheel"/> 
    <origin rpy="0 -1.5708 0" xyz="0.05 0 -0.0105"/> 
  </joint>
  • Modélisation de la roue gauche :
 <link name="left_wheel"> 
    <visual> 
      <geometry> 
        <cylinder length="0.005" radius="0.016"/> 
      </geometry> 
      <material name="black"> 
        <color rgba="0 0 0 1"/> 
      </material> 
    </visual> 
  </link>
  • Modélisation du lien entre la roue gauche et le châssis :
  <joint name="left_wheel_joint" type="continuous"> 
    <axis xyz="0 0 1"/> 
    <parent link="base_link"/> 
    <child link="left_wheel"/> 
    <origin rpy="0 -1.5708 0" xyz="-0.05 0 -0.0105"/> 
  </joint>
  • Visualisation du résultat avec Rviz :
$ roslaunch urdf_tutorial display.launch model:=MyRobot.urdf

Imge_rviz_2

Avec Rviz vous pouvez visualiser le robot avec les deux roues.

Modélisation de la ball caster

  • Modélisation de la ball-caster :
  <link name="caster_wheel"> 
    <visual> 
      <geometry> 
        <sphere radius="0.0045"/> 
      </geometry> 
      <material name="black"/> 
    </visual> 
  </link>
  • Modélisation du lien entre la roue gauche et le châssis :
  <joint name="caster_wheel_joint" type="fixed"> 
    <parent link="base_link"/> 
    <child link="caster_wheel"/> 
    <origin rpy="0 0 0" xyz="0 0.025 -0.022"/> 
  </joint>
  • Visualisation du résultat avec Rviz :
$ roslaunch urdf_tutorial display.launch model:=MyRobot.urdf

Imge_rviz_3

Fin de la partie n°1.

Programmer le robot MRPi1 en langage C

Dans ce tutorial vous allez apprendre à programmer le robot MRPi1 en langage C.

Télécharger la librairie C

  • Télécharger la librairie C sur Github :

https://github.com/macerobotics/MRPi1/tree/master/Software/C

Transférer les fichiers avec FileZilla.

  • Placez le fichier MRPi1.h dans le dossier header :
cd /home/pi/Descktop/MR_Projects/C/header
  • Placez le fichier MRPi1.c dans le dossier sources:
cd /home/pi/Descktop/MR_Projects/C/sources

Hello MRPi1

Voici un petit programme ‘main.c‘ :

#include "MRPi1.h"

int main(int argc, char* argv[])
{
  // initialisation du robot MRPi1
  init();
  printf("Hello MRPi1\n");

  // Allumer les leds du robot MRPi1
  led(1,1);
  led(2,1);
  led(3,1);
  
}
  • Placez ce fichier main.c dans le répertoire sources
  • Compilation :
>> cd /home/pi/Desktop/MR_Projects/C
>> gcc sources/*.c -I header -o Hello_MRPi1
  • Exécution :
>> ./Hello_MRPi1

Les 3 leds du robot MRPi1 doivent s’allumer.

Gestion des déplacements

Voici un exemple de programme pour gérer les déplacements du robot MRPi1.

#include "MRPi1.h"

int main(int argc, char* argv[])
{
  // Initialisation du robot MRPi1
  init(); 

  // avancer avec une vitesse de 10% sur une distance de 150 mm
  forward_mm(10, 150);

  // pause de 2 secondes
  sleep(2);

  // tourner a droite
  turnRight(30);

  // pause de 4 secondes
  sleep(4);

  // arret du robot
  stop();
  
}

Ce petit programme permet :

  • de faire avancer le robot MRPi1 pendant 2 secondes
  • de tourner à droite pendant 4 secondes
  • puis de s’arrêter.

Lien pour l’API C

Connecter MRPi1 à Internet

Dans ce tutorial vous allez apprendre à connecter le robot MRPi1 à Internet. Par défaut le robot MRPi1 est configuré en point d’accès, une configuration pour se connecter à votre réseau est donc nécessaire.

img7_tuto

Fichier interfaces

  • Ouvrir le fichier interfaces avec l’éditeur nano :
$ sudo nano /etc/network/interfaces 

img1_tuto

Modifier ce fichier pour qu’il ressemble à ceci :

  • Avec votre SSID et mot de passe de votre réseau.

img2_tuto

  • Enregistrer le fichier puis quitter :
    • ctrl + X
    • Y

Arrêt du daemon hostapd

  • Ouvrir le fichier hostapd avec l’éditeur nano :
sudo nano /etc/default/hostapd 

img3_tuto

  • Mettez en commentaire cette ligne  :

img4_tuto

La ligne devient donc :

img5_tuto

  • Enregistrer le fichier puis quitter.

Modification du fichier rc.local

  • Ouvrir le fichier hostapd avec l’éditeur nano :
sudo nano /etc/rc.local
  • Placer en commentaire les deux lignes suivantes :
ifconfig wlan0 192.168.42.1
 etc/init.d/isc-dhcp-server start

Le fichier devient donc :

img6_tuto

  • Enregistrer le fichier puis quitter.

Maintenant, vous pouvez redémarrer le système pour la prise en compte des modifications :

sudo reboot

Voilà, votre robot peut se connecter à votre box internet. Une adresse IP va lui être affecter automatiquement. Pour connaitre cette adresse pour pouvez utiliser le logiciel Advanced IP Scanner.

Programmer le microcontrôleur esp8266 avec l’IDE Arduino

Ce tutorial va vous permettre de programmer le module Wifi ESP8266 avec le célèbre logiciel Arduino. Ceci vous permettra de réaliser des robots ou objets connecté avec ce module comme contrôleur principal.

Ce tutoriel utilise :

  • Une carte Esp8266 ESP-12e
  • L’IDE Arduino version 1.6.8

ESP_photo

Carte ESP8266 -ESP-E12e

C’est quoi l’ESP8266 ?

L’ESP8266 est un microcontrôleur low-cost avec une connexion Wifi développé par le fabricant Chinois Espressif.

Voici ces caractéristiques techniques :

  • CPU : 80 Mhz – 32 bits
  • IEEE 802.11 b/g/n Wi-Fi
  • 16 GPIO
  • UART, SPI, I2C, I2S
  • 1xADC 10 bits

Par défaut, le microcontrôleur ESP8266 contient un firmware de gestion des commandes AT. Afin de programmer le microcontrôleur avec l’IDE Arduino, il est nécessaire de changer le firmware.

Étape n°1 : configuration

La première étape est la configuration de l’IDE Arduino pour la prise en compte de la carte Esp8266.

  • Ouvrir l’IDE Arduino.
  • Ensuite :
    • Fichier->Préférences

esp_1

  • Dans la boite de dialogue des préférences, au champs intitulé “URL de gestionnaire de cartes supplémentaires“, vous pouvez coller l’adresse suivante :

http://arduino.esp8266.com/stable/package_esp8266com_index.json

esp_2

  • Validez cette modification avec le bouton OK.

Étape n°2 : installation

  • Puis, dans le menu : Outils->Type de carte->Gestionnaire de cartes :

esp_3

  • Ensuite, dans le champs de recherche, recherchez “esp8266” :

esp_4

  • Installez “esp8266 by ESP8266 Community” :

esp_5Installation en cours

Étape n°3 : test

Après quelque minutes d’installation, vous pouvez sélectionner la nouvelle carte dans :

  • Outils->Type de carte

esp8266

Maintenant, vous pouvez tester un exemple de sketches conçus pour le microcontrôleur ESP8266.

esp_7

Un petit exemple pour faire clignoter une led :

esp_8

  • Vérifier & télécharger le programme après avoir sélectionner le bon port.

esp_9

Voilà, fin du tuto !