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 !

MRduino à l’Euro 2016 !

Le robot MRduino joue au football pour l’Euro 2016.

MRduino est équipé d’un bras avec deux servomoteurs SG90 :

  • Alimentation des servomoteurs avec le +BATT

FootEuro2016

Vidéo :

 

Le programme :

#include <Servo.h>
#include <mrduino.h>

Servo Servo1;
Servo Servo2;

int reception;
 
void setup()
{
    Servo1.attach(2, 1000, 2000);
    Servo2.attach(4, 1000, 2000);

    Servo1.write(90);
    Servo2.write(180);

    delay(500);

    Serial.begin(115200);
}

void loop() {


   // read IR reception sensor
  reception = irReceiver();

  // read command
  switch(reception)
  {
    case 2:
      forward(30);// Forward
    break;

    case 6:
      turnRight(30);// turn right
    break;

    case 4:
      turnLeft(30);// turn left
    break;

    case 8:
      back(30);// back
    break;

    case 5:
      stop();// stop
    break;

    case 7:
     Servo1.write(160);
     Servo2.write(90);
    break;

    case 9:
     Servo1.write(90);
     Servo2.write(180);
    break;
  }


}