Envoyer un SMS avec la carte Esus
Envoyer un SMS avec la carte Esus en utilisant le système de notification de Free mobile.
Vous avez besoin de votre identifiant Free mobile et de la clé d’identification au service :
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:
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:
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
- Librairie nécessaire : https://github.com/pololu/vl53l0x-arduino
#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 :
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 :
- Télécharger les fichiers __init__.py et mrpi1.py sur GitHub.
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.
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.
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 :
Le 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
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
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 !
EsusRover
EsusRover = Esus board + 4 motors + LiPo battery
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.
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.
- Rendez-vous ici : http://appinventor.mit.edu/explore/
- Crée un nouveau projet : robot_control
- Vous devez arriver sur l’interface de votre application :
- Alignement horizontal de l’interface : centrer
- Ajouter un bouton :
- 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 :
- Ajouter l’Afficheur Web :
- Rendre l’afficheur web non visible
Réalisation des blocs :
- Voici le programme en bloc pour la gestion des boutons :
Construction de l’application
- Construction de l’application sur votre ordinateur :
- Transférer l’application sur votre smartphone.
- Autoriser l’installation de l’application sur votre téléphone.