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

MRPi1 robot navigation “cleaning algorithm”

https://youtu.be/2khTwDcWwGw

Le programme :

from mrpi1_lib import *
import time

obs_limit = 600


# main program
state = 1

while 1:
 x1 = proxSensor(3)
 x2 = proxSensor(4)

 if(( x1 > obs_limit)and( x2 > obs_limit)and(state == 1)):
   x1 = 0
   x2 = 0
   stop()
   time.sleep(1)
   state = 2
   controlEnable()
   turnRight_degree(10,90)
   forward_mm(10, 100)
   turnRight_degree(10,90)
 if(( x1 > obs_limit)and( x2 > obs_limit)and(state == 2)):
   x1 = 0
   x2 = 0
   stop()
   time.sleep(1)
   state = 2
   controlEnable()
   turnLeft_degree(10,90)
   forward_mm(10, 100)
   turnLeft_degree(10,90)
   state = 1
 else:
  forward(20)

Mise à jour du robot MRPi1

Une mise à jour pour le robot MRPi1 est disponible sur GitHub :

https://github.com/macerobotics/MRPi1

  • Pour mettre à jour le Firmware (version : 0.92) du robot MRPi1 :

Mise à jour firmware du microcontrôleur

  • Ensuite, mise à jour de la librairie Python  :

Puis transférer ces fichiers sur le robot avec FileZilla, puis installation  la librairie :

>> cd /home/pi/Desktop/MR_Projects/
>> sudo python setup.py install

Les nouvelles fonctions disponibles :

  • Lecture de la position du robot :
    • robotPositionX()
    • robotPositionY()

Retourne une valeur en millimètre.

De plus, le déplacement du robot à été améliorer avec les fonctions : forward(), back(), turnLeft(), turnRight().

Pour vérifier la version du  firmware avec Python :

>> firmwareVersion()
0.92

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));
 
}

Utiliser un capteur ultrason HC-SR04

Ce tutoriel présente l’utilisation du capteur HC-SR04 avec la carte Esus.

image_hc-sr04

Carte Esus + HC-SR04

Le câblage

Les caractéristiques techniques du capteur  HC-SR04  sont les suivantes :

  • Alimentation +5V
  • Consommation : 15 mA
  • Gamme de distance : 2 cm à 4 m.
  • Sortie : TTL

Pins du capteur:

  • VCC => sur + 5V de la carte Esus
  • Trig => sur IO2
  • Echo => sur IO3
  • GND => GND

Voici le schéma de câblage :

 

cablage_hc_sr04_v2Le capteur ultrason HC-SR04 fonctionne par l’envoi d’une impulsion sur la pin ‘Trig‘, puis un signal impulsionnelle est retourné sur la pin ‘Echo’ en fonction de la distance d’un obstacle. La durée de cette impulsion représente la distance de l’obstacle.

Distance en cm = ( durée de l’impulsion ‘Echo’ en µs ) / 58

signal_ultrason

Le programme en Arduino

#include <esusBoard.h>

// pins 
#define trig_pin 2
#define echo_pin 3

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

 // init liaison serie
 Serial.begin (9600);
 
 // init pin trig en sortie
 pinMode(trig_pin, OUTPUT);

 // init pin echo en entrer
 pinMode(echo_pin, INPUT);

 // init pin trig à l'état bas
 digitalWrite(trig_pin, LOW);

}

void loop() 
{  
long durer;
long distanceCm;  

  // mise à l'état haut de la pin trig
  digitalWrite(trig_pin, HIGH);
  
  // pause de 10µs
  delayMicroseconds(10);

  // mise à l'état bas de la pin trig
  digitalWrite(trig_pin, LOW);
  
  // mesure de la durée du niveau haut du signal echo
  durer = pulseIn(echo_pin, HIGH);
  
  // conversion de la durer en cm
  distanceCm = (durer/58);  

  // envoi sur le port série de la distance
  Serial.print("distance= "); 
  Serial.print(distanceCm);  
  Serial.println("cm"); 
 
  // pause 1 seconde
  delay(1000);
}

Le résultat

result_ultrason

Attention, pendant le téléchargement la pin IO3 doit être débrancher du capteur, car le téléchargement à besoin de cette pin (RX/IO3).

Fin du tuto !

Contrôle d’un robot avec un smartphone

Développeur>Tutoriels>Contrôle d’un robot avec un smartphone

Un tutoriel pour contrôler un robot avec l’aide d’un smartphone sous Android.

esus_robot_phone

Le Programme la carte Esus

Voici le programme pour le microcontrôleur ESP8266 :

#include <ESP8266WiFi.h>
#include <esusBoard.h>
 
const char* ssid = "yout_SSID";
const char* password = "your_PASSWORD";

// serveur
WiFiServer server(80);

// adresse IP
IPAddress ip(192, 168, 1, 13); 
IPAddress gateway(192,168,1,1);
IPAddress subnet(255,255,255,0); 
 
void setup() 
{

  // initialisation de la carte Esus
  initEsusBoard();

  // initialisation du port serie
  Serial.begin(115200);
  delay(10);
 
  // Connection au reseau wifi
  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
 
  WiFi.begin(ssid, password);
  WiFi.config(ip, gateway, subnet);

  // attendre la connexion
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  // la carte Esus est connecter au reseau wifi
  Serial.println("");
  Serial.println("WiFi connected");
 
  // Démarrage du serveur
  server.begin();
  Serial.println("Server started");
 
  // Affichage de l'adresse IP sur le port serie
  Serial.print("Use this URL to connect: ");
  Serial.print("http://");
  Serial.print(WiFi.localIP());
  Serial.println("/");
 
}
 
void loop() 
{
  
  // vérification si un client est connecté
  WiFiClient client = server.available();

  // attendre la connexion d'un client
  while(client != true)
  {
    client = server.available();
    Serial.println("Attendre client...");
    delay(100);
  }
 
  // Un client est connecté
  Serial.println("new client");
  while(!client.available()){
    delay(1);
  }

  // lecture de la requete du client
  String request = client.readStringUntil('\r');
  
  Serial.println(request);
  client.flush();

  // commande avancer
  if (request.indexOf("/CMD=FOR") != -1) 
  {
    Serial.println("forward");
    motors1_set(1023,DIR_BACK);
    motors2_set(1023, DIR_BACK);
  }

  // commande reculer
  if (request.indexOf("/CMD=BAK") != -1) 
  {
    Serial.println("back");
    motors1_set(1023,DIR_FORWARD);
    motors2_set(1023, DIR_FORWARD);
  }

  // commande tourner a droite
  if (request.indexOf("/CMD=TR") != -1) 
  {
    Serial.println("turn right");
    motors1_set(1023,DIR_BACK);
    motors2_set(1023, DIR_FORWARD);
  }

  // commande tourner a gauche
  if (request.indexOf("/CMD=TL") != -1) 
  {
    Serial.println("turn left");
    motors1_set(1023,DIR_FORWARD);
    motors2_set(1023, DIR_BACK);
  }

  // commande tourner stop
  if (request.indexOf("/CMD=STP") != -1) 
  {
    Serial.println("turn left");
    motors1_set(0,DIR_FORWARD);
    motors2_set(0, DIR_BACK);
  }

  Serial.println("Client disonnected");
  Serial.println("");
 
}
  • Modifier votre SSID et password :
const char* ssid = "your_SSID";
const char* password = "your_PASSWORD";
  • Ensuite vous pouvez compiler et télécharger le programme dans la carte Esus.

L’application Android

Maintenant, nous allons réaliser l’application Android grâce à App Inventor développé par Google et basée sur une interface graphique similaire à Scratch.

cr_1

  • Vous devez arriver sur l’interface de votre application :

app3

  • Alignement horizontal de l’interface : centrer

app4

  • Ajouter un bouton :

app5

  • Modifier le texte du bouton : AVANCER
  • Ajouter d’autres boutons avec :

    • RECULER
    • DROITE
    • GAUCHE
  • Utiliser la disposition en tableau avec 3 colonnes et 3 lignes :

cr_2

  • Ajouter l’Afficheur Web :

cr_3

  • Rendre l’afficheur web non visible

Réalisation des blocs :

  • Voici le programme en bloc pour la gestion des boutons :

cr_5

Construction de l’application

  • Construction de l’application sur votre ordinateur :

app10

  • Transférer l’application sur votre smartphone.
  • Autoriser l’installation de l’application sur votre téléphone.

Allumer une led à une heure exacte avec Raspberry Pi 3

Un petit tutoriel pour allumer une led à une heure exacte avec une carte Raspberry Pi.

  • led sur GPIO18

Le programme en langage Python3 :

#!/usr/bin/python3
from datetime import datetime
import time
import RPi.GPIO as GPIO

# configuration GPIO 18 
GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT) 
GPIO.output(18, GPIO.LOW)

# saisir alarme
heure_alarme = input("Saisir heure :")
heure_alarme = int(heure_alarme) # conversion en nombre
minute_alarme = input("Saisir minute :")
minute_alarme = int(minute_alarme)

while True:
  date_heure = datetime.now() # heure du système
  if((date_heure.hour == heure_alarme) and (date_heure.minute == minute_alarme)):
    GPIO.output(18, GPIO.HIGH)
    print("LED ALLUMER")
    exit()

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