Home » BLOG » Tutoriel

Category: Tutoriel

MRPiZ – suivie de ligne avec openCV & python

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

Warning

Cette commande est a effectuer à chaque redémarrage.

 

Le suivi de ligne

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

Warning

Utilisez CTRL+C pour arrêter le robot.

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:

0_init.jpg

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]

1_crop.jpg

Niveaux de gris

Ensuite on passe l’image en niveaux de gris:

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

2_gray.jpg

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)

3_blur.jpg

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)

4_thresh.jpg

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)

5_contour.jpg

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

Dessin avec MRduino2 & Blockly

Tutoriel pour faire dessiner le robot MRduino2.

Matériel nécessaire:

  • Un feutre de couleur

 

Dessiner un petit cercle

Un simple programme pour faire un cercle :

  • Le robot tourne sur lui-même vers la droite à une vitesse de 25%.

 

 

Dessiner un grand cercle

Une autre manière de faire un cercle plus grand en utilisant un seul moteur :

Petit exercice,comment dessiner un très grand cercle ?

La réponse :

Dessiner des vagues

Un petit programme Blockly pour dessiner des vagues avec le robot MRduino2:

Dessiner un carré (un peu près !)

Un programme pour dessiner un carré :

 

Fin du tuto, à vous de réaliser vos propres dessins.

 

Configuration Wifi de la carte Pi Zero W

Article pour la configuration de la communication Wifi de la carte Pi Zero W en ligne de commande.

Version Raspian : April 2017 (Raspian Jessie Lite)

  • Ouvrir avec le terminal le fichier wpa_supplicant.conf :
sudo nano /etc/wpa_supplicant/wpa_supplicant.conf
  • Modifier ce fichier comme ci-dessous :
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=GB

network={
    ssid="YOUR_SSID"
    psk="YOUR_PASSWORD"
    key_mgmt=WPA-PSK
}
  • Enregistrer et redémarrer votre carte Raspberry Pi:
sudo reboot

Programmer MRduino Wireless en Wifi

Le robot MRduino Wireless a la possibilité de transférer le programme du PC vers le robot en communication Wifi.

Le programme

Ce programme permet d’activer le téléversements OTA (Over The Air) sur l’ESP8266 du robot.

  1. Ouvrer l’Arduino IDE et insérer ce programme :

En modifiant :

  • VOTRE_SSID : le nom de votre réseau sans fil.
  • VOTRE_MOT_DE_PASSE : le mot de votre réseau sans fil.
#include <mrduino.h>
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>

const char* ssid = "VOTRE_SSID"; 
const char* password = "VOTRE_MOT_DE_PASSE"; 

void setup() 
{
   // initialisation du wifi
   WiFi.begin(ssid, password);

   // connexion wifi
   while (WiFi.waitForConnectResult() != WL_CONNECTED)
   {
     delay(1500);
     ESP.restart();
   }

  ArduinoOTA.setHostname("Robot_MRduinoW"); 
  
  // initialisation de l'Over The Air
  ArduinoOTA.begin(); 

}

void loop()
{
  ArduinoOTA.handle();
}

Après avoir vérifié ce programme Arduino, vous pouvez le téléverser vers le robot via un câble micro-USB.

img2

Transfére en Wifi

Maintenant que vous avez programmer le robot, vous pouvez fermer le logiciel Arduino IDE et le redémarrez afin d’avoir une nouvelle option de programmation.

  • Ouvrez l’onglet Tools->Port :

img1

  • Sélectionner le port : monMRduinoW

Vous pouvez débrancher le câble série de type micro-USB entre votre robot et  le PC; et téléverser à nouveau le programme. Cette fois-ci, le téléversement  fonctionne en Wifi.

Fin du tuto !

 

 

 

 

 

 

Envoyer un SMS avec la carte Esus

Envoyer un SMS avec la carte Esus en utilisant le système de notification de Free mobile.

photo_esus_smsV2

Vous avez besoin de votre identifiant Free mobile et de la clé d’identification au service :

Free_sms_V2

Ceci est disponible sur votre espace abonné de Free mobile.

Le programme

Vous devez modifier ces constantes :

  • VOTRE_SSID : le nom du réseau sans Wifi auquel votre carte Esus sera connecter.
  • VOTRE_PASS : le mot de passe de votre réseau Wifi.
  • IDENTIFIANT_FREE : votre identifiant Free mobile.
  • CLE_ID : votre clé d’identification au service.
#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>

WiFiClientSecure client;
  
const char* ssid = "VOTRE_SSID";
const char* password ="VOTRE_PASS";

const char* host = "smsapi.free-mobile.fr";
const int https_Port = 443;

String url, message_SMS;

void setup()
{
  Serial.begin(9600);
  
  Serial.println();
  
  Serial.print("connexion à ");
  
  Serial.println(ssid);
  
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  
  Serial.println("Connexion Wifi");
  Serial.println("Adresse IP:");
  Serial.println(WiFi.localIP());

  Serial.print("connection a ");
  Serial.println(host);
  
  if (!client.connect(host, https_Port))
  {
    Serial.println("Erreur de connexion Wifi");
  }

  url = "/sendmsg?user=IDENTIFIANT_FREE&pass=CLE_ID&msg=";
  message_SMS = "Test envoi SMS par la carte Esus!";

  url = url + message_SMS;
  
  Serial.print("URL: ");
  Serial.println(url);

  client.print(String("GET ") + url + " HTTP/1.1\r\n" +
               "Host: " + host + "\r\n" +
               "User-Agent: BuildFailureDetectorESP8266\r\n" +
               "Connection: close\r\n\r\n");


}

void loop() 
{
  // rien
}

Fin du tuto !

Contrôle de relais avec la carte Esus

Un petit tutoriel pour le contrôle de relais 12V – 230V avec la carte Esus.

Matériels nécessaires :

  • Relais électromécaniques,
  • Une carte Esus,
  • Une batterie ou alimentation 11.8V

Le branchement

Le relais est branché sur une sortie de commande moteur de la carte Esus:

relais_V2

La carte Esus doit être alimenté avec une tension de 11.8V (tension max de la carte).

Exemple de programme n°1

Pour contrôler le relais il suffit simplement d’appeler la fonction de contrôle moteur n°1 de la carte Esus :

#include <esusBoard.h>

void setup() 
{
  // init esus board
  initEsusBoard();

  
}

void loop() 
{

  Activer_relais1();

  delay(2000);

  Desactiver_relais1();

  delay(2000);

}

void Activer_relais1(void)
{
  // sortie relais = 12V
  motors1_set(1024, DIR_FORWARD);
}

void Desactiver_relais1(void)
{
  // sortie relais = 12V
  motors1_set(0, DIR_FORWARD);
}

Contrôle de 2 relais

Le deuxième relais est branché sur la deuxième sortie de commande moteur de la carte Esus:

2relais_V2

Exemple de programme n°2

#include <esusBoard.h>

void setup() 
{
  // init esus board
  initEsusBoard();

  
}

void loop() 
{

  Activer_relais1();
  Desactiver_relais2();

  delay(2000);

  Desactiver_relais1();
  Activer_relais2();

  delay(2000);

}

void Activer_relais1(void)
{
  // sortie relais = 12V
  motors1_set(1024, DIR_FORWARD);
}

void Desactiver_relais1(void)
{
  // sortie relais = 0V
  motors1_set(0, DIR_FORWARD);
}


void Activer_relais2(void)
{
  // sortie relais = 12V
  motors2_set(1024, DIR_FORWARD);
}

void Desactiver_relais2(void)
{
  // sortie relais = 0V
  motors2_set(0, DIR_FORWARD);
}


Capteur VL53L0X avec la carte Esus

Petit programme afin d’interfacer le capteur VL53L0X avec la carte Esus. Le capteur est relié par I2C à la carte Esus.

  • SDA : pin 2
  • SCL : pin 13

#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup()
{
 Serial.begin(9600);

 Wire.begin(2, 13);//SDA, SCL
 
 // initialisation du capteur
 sensor.init();
 sensor.setTimeout(500);

}

void loop() 
{
  Serial.print("Distance mm =");

  // affichage de la distance en mm
  Serial.print(sensor.readRangeSingleMillimeters());

  if (sensor.timeoutOccurred())
  { 
    Serial.print(" TIMEOUT"); 
  }

  Serial.println();
}

source : https://github.com/pololu/vl53l0x-arduino/tree/master/examples/Single

Résultat :

com_mm

Utiliser un timer

Ce tutoriel présente l’utilisation d’un timer avec la carte Esus. La fréquence du microcontrôleur ESP8266 est de 80Mhz soit 12.5ns le cycle processeur.

TSD-free -zone-starts by netalloy

Exemple n°1

L’exemple n°1 permet de faire clignoter une led toute les secondes. La led est câble sur la sortie IO2 de la carte Esus.

#include <esusBoard.h>

// (80Mhz frequence ESP8266) 1 cycle = 12.5ns => 1seconde/12.5ns = 80000000 
const int timer_period=80000000;

void setup() 
{
  initEsusBoard();

  // sortie 2 pour la led
  pinMode(2, OUTPUT);

  noInterrupts();
 
  // initialisation timer 0 avec interruption
  timer0_isr_init();

  // spécifie la fonction à appeler lorsqu'une interruption du timer survient  
  timer0_attachInterrupt(handler);

  // période du timer
  timer0_write(ESP.getCycleCount() + timer_period); 
  interrupts();

}

void loop()
{

}

void handler(void)
{
 timer0_write(ESP.getCycleCount() + timer_period);

 // toggle sortie 2
 digitalWrite(2, !digitalRead(2));
 
}

Exemple n°2

L’exemple n°2 permet de faire clignoter une led toute les 5 secondes. La led est câblé sur la sortie IO2 de la carte Esus.

#include <esusBoard.h>

// (80Mhz frequence ESP8266) 1 cycle = 12.5ns => 1seconde/12.5ns = 80000000 
const int timer_period=80000000;

void setup() 
{
  initEsusBoard();

  // sortie 2 pour la led
  pinMode(2, OUTPUT);

  noInterrupts();
  timer0_isr_init();
  timer0_attachInterrupt(handler);

  timer0_write(ESP.getCycleCount() + timer_period); 
  interrupts();

}

void loop()
{

}

void handler(void)
{
 timer0_write(ESP.getCycleCount() + timer_period);

 // toggle sortie 2
 digitalWrite(2, !digitalRead(2));
 
}

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 !