vendredi 25 décembre 2015

ESP8266 Wifi ultrasonic distance logger

Envoi par wifi d'une mesure de distance à l'aide d'un capteur à ultrasons

J'ai besoin de mesurer la distance face à un obstacle qui peut survenir de manière aléatoire et de pouvoir disposer de cette mesure à distance.

L'idée est de faire aussi simple que possible et aussi d'apprendre à utiliser les composants à disposition.
Pour ce faire, il vous faut :


Pourquoi ces choix ?
Tout d'abord le coût, on ne peut pas faire plus bas, vraiment. Ensuite, ils ont été largement utilisés par les internautes, donc on en parle partout sur les forums et sites web, des exemples de programmation.
On apprend en s'amusant.

On apprend à programmer un Arduino, à connecter des liaisons séries, des commandes AT (commandes texte universelles pour dialoguer avec les modems, les périphériques séries), à envoyer des informations sur le Web par un petit dispositif électronique ! Internet des Objets, Internet of Things, IoT.

Il existe des sites web qui acceptent des requêtes de ce genres et vous permettent de stocker vos données, de vous les afficher et de les partager avec des proches ou en mode public. Regardez thingspeak.com

Tout d'abord il faut câbler l'Arduino nano V3 au module ultrason HC-SR04,.

J'ai choisi de souder directement ses 2 pins trig (demande logique d'envoi du signal us) et echo (signal logique indiquant qu'il a reçu l'écho us) sur les pins d'E/S 11 et 12

int trig = 11; 
int echo = 12; 
pinMode(trig, OUTPUT); 
digitalWrite(trig, LOW);
digitalWrite(trig, LOW);

Il faut connecter les 2 autres pins au +5V (attention le nano fonctionne sous 3.3V mais il a du 5V qui vient du connecteur USB) et à la masse (GND).

Pleins de tutoriaux expliquent le fonctionnement du capteur à ultrasons HC-SR04 :
http://tutorial.cytron.com.my/2012/10/11/testing-ultrasonic-ranging-module-sn-hc-sr04/
http://www.instructables.com/id/Easy-ultrasonic-4-pin-sensor-monitoring-hc-sr04/
http://www.instructables.com/id/Simple-Arduino-and-HC-SR04-Example/?ALLSTEPS
mais le plus simple, et c'est là d'ailleurs d'où j'ai pris les lignes du programme, est le site :
https://itechnofrance.wordpress.com/2013/03/12/utilisation-du-module-ultrason-hc-sr04-avec-larduino/


L'utilisation se fait dans la boucle qui s'exécute tout le temps, on mettra un délais d'une seconde ou plus entre deux lectures successives :
  digitalWrite(trig, HIGH); 
  delayMicroseconds(10); 
  digitalWrite(trig, LOW); 
  lecture_echo = pulseIn(echo, HIGH); 
  cm = lecture_echo / 58; 
  Serial.print("Distance (cm) : "); 
  Serial.println(cm); 

Ce qui correspond bien au schéma de la trame d'envoi et de réception :


Ensuite, on s'intéresse à la partie transmission de données à distance, via internet et donc le module Wifi ESP8266.

Il existe plusieurs modèles (cette page est très documentée), j'ai pris le plus répondu le ESP8266-01. Certains modules le -07 par exemple, ont en plus un connecteur SMA pour connecter une antenne extérieure afin d'augmenter la portée du wifi.
Le site de référence est : http://www.esp8266.com/

Plusieurs sites et tutoriaux existent aussi, je vous recommande
http://www.instructables.com/id/ESP8266-Wifi-Temperature-Logger/?ALLSTEPS
http://zeflo.com/2014/esp8266-weather-display/
et
http://www.les-electroniciens.com/videos/arduino-ep16-installation-du-module-wifi-esp8266
d'où j'ai puisé le code puis adapté.
La différence par rapport à mon application est que je veux utiliser le module comme client et non pas serveur. Je ne cherche pas à ce que des clients (Web browsers) se connectent sur mon ESP8266. Je veux juste que l'ESP8266 puisse se connecter à mon routeur Wifi puis envoyer des requêtes http et recevoir des informations (enfin pour l'instant je veux juste envoyer).

Tout d'abord, la présentation de ce module magique.
Il est le moins cher sur le marché (1 à 3€) !
Le plus simple car il embarque la pile TCP/IP (routines...) dans son firmware et y a pas à la programmer sur le micro-contrôleur qui le gère (Arduino) contrairement  à d'autre modules wifi qui se pilotent pas une pile TCP/IP logicielle à inclure dans votre programme de uC, je citerai l'exemple du Microchip MRF24WB0MA et qui coûte 25 €.

Il faut brancher l'ESP8266 sur le port série de l'Arduino. Pas le port logiciel standard (9600 bds) qui nous sert pour le débogage via le FTDI et donc le port USB, mais il faut le brancher sur un port série supplémentaire qui va fonctionner à 115200 bds, la valeur par défaut du ESP8266.

Y aussi ceux qui ont voulu reprogrammer le firmware du module
http://www.xess.com/blog/esp8266-reflash/
http://hackaday.com/2015/03/18/how-to-directly-program-an-inexpensive-esp8266-wifi-module/

mais il vaut mieux laisser ça quand vous serez plus familier avec ce module

Regardons le pinout (brochage)
ESP8266 pinout

Le connecteur ne peut pas aller sur une plaque d'essai (M-board) de connexion mais on peut y souder des fils ou les wrapper.
Il faut connecter, en mode normal, le CH-PD à VCC à 3.3V (il n'accepte pas le 5V) ce qui convient bien à l'Arduino nano V3.
Connecter la masse à celle de l'Arduino et le TXD et RXD à des pins d'E/S que l'on raccordera, en croisant (RX avec TX et TX avec RX), au module UART de l'Arduino.

CH_PD (power down) permet de couper le module si elle passe à l'état bas.

Pour vous montrer les connections, un outil simple et gratuit est Fritzing. Il permet de dessiner les connexions entre les différents éléments et on trouve pratiquement tous les composants électroniques courants.
Voici donc le schéma de connexion :



Du point de vue programme la configuration de la liaison série se fait par :

SoftwareSerial ESP8266(9, 8); // 8 sur RX du ESP8266 9 sur TX du ESP8266

dans la routine Setup il faudra configurer le port série à 115200 bds puis appeler l'initialisation du module

ESP8266.begin(115200);
initESP8266();

Cette routine doit configurer le Wifi de manière à ce que le module se connecte à votre routeur.
Le module peut aussi être point d'accès ou serveur.
On envoie d'abord la commande de Reset
AT+RST

Qui le remet par défaut. Notons qu'il enregistre dans sa mémoire les connexions précédentes et la config d'avant.On choisit ensuite le mode client (1) par opposition au mode serveur (3)
AT+CWMODE=1
Puis le SSID et le PW du wifi de votre routeur (entre guillemets).
"AT+CWJAP=\""+ WifiSSID + "\",\"" + WifiPW +"\""

On peut lire après la connxion l'adresse IP attribuée par le routeur au module ESP8266 à l'aide de la commande
AT+CIFSR

Ensuite, il faut lui dire de n'accepter qu'une seule connexion
AT+CIPMUX=0

J'ai galéré sur cette instruction car avant j'étais en CIPMUX=1 et je n'arrivais pas à faire des requêtes TCP...

Les commandes AT sont résumées sur


ou sur ESP8266_WiFi_Module_Quick_Start_Guide_v_1.0.4.pdf


Une fois que le module est connecté au routeur et qu'une IP lui est attribuée (on se sert du moniteur de de liaison série FTDI pour voir ça), on peut alors à chaque lecture de distance, se connecter à un site web et envoyer la requête :
http://api.thingspeak.com/update?key=VOTRECLEF&field1=31

Cela se fait d'abord par une connexion au site web à l'aide de la commande
AT+CIPSTART
où l'IP ou le site web est donné
#define IP "thingspeak.com" // thingspeak.com

puis, une fois connecté, d'envoyer la commande
AT+CIPSEND
en faisant un GET avec la commande update propre au site web thingspeak
String GET = "GET /update?key=VOTRECLEF&field1=";




On peut lire les réponses, les analyser pour vérifier s'il y a une erreur ou non.
Il faut faire attention car le site peut être "busy" si vous le sollicitez trop fréquemment.
Si vous disposez de votre propre site web et d'une base de données MySQL, cela peut être tout aussi intéressant.
Cependant, le site thingspeak offre des affichages graphiques, des cadrants, le partage en mode public, privé, la possibilité d'enregistrer plusieurs champs dans le même canal (requête).
Voici un exemple d'affichage :


En parlant d'autonomie, on peut alimenter directement tout le montage à travers le mini USB de l'Arduino nano avec un chargeur de téléphone portable classique. L'utilisation de piles ne sera pas viable car le système est relativement gourmand en énergie. Il faut aussi faire attention au pic de consommation de l'ESP8266 par rapport à ce que peut fournir le régulateur de tension 3.3V de l'Arduino nano.

Voici le proto, auquel j'ai rajouté un speaker de téléphone portable pour créer des alertes sonores.




Pour finir, voici le programme complet.
Il faut remplacer les Votre... par les mots de passe et codes qui vous sont propres.

// capteur Ultrason HC-SR04 + ESP8266 + thingspeak

#include 
<Arduino.h> #include <SoftwareSerial.h> SoftwareSerial ESP8266(9, 8); // 8 sur RX du ESP8266 9 sur TX du ESP8266 String WifiSSID = "VotreSSID"; String WifiPW = "VotrePW"; #define IP "thingspeak.com" // thingspeak.com String GET = "GET /update?key=VOTRECLEF&field1=";
// définition des broches utilisées 
int trig = 11; 
int echo = 12; 
long lecture_echo; 
long cm;

void setup() 
{ 
  pinMode(trig, OUTPUT); 
  digitalWrite(trig, LOW); 
  pinMode(echo, INPUT); 
  Serial.begin(9600); 
  ESP8266.begin(115200);
  initESP8266();
}

void loop() 
{ 
  digitalWrite(trig, HIGH); 
  delayMicroseconds(10); 
  digitalWrite(trig, LOW); 
  lecture_echo = pulseIn(echo, HIGH); 
  cm = lecture_echo / 58; 
  Serial.print("Distance (cm) : "); 
  Serial.println(cm); 
  
  delay(5000); 
  updateDistance(String (cm, DEC));

  while(ESP8266.available())
    {    
    Serial.println(ESP8266.readString());
    }   
}

//---------------------------------------------------------------
//                Fonction qui initialise l'ESP8266             */
void initESP8266()
{  
  Serial.println("---------------------------------");  
  Serial.println("--  DEBUT DE L'INITIALISATION  --");
  envoieAuESP8266("AT+RST");
  recoitDuESP8266(2000);
  Serial.println("---------");
  /*envoieAuESP8266("AT+GMR");
  recoitDuESP8266(2000);
  Serial.println("---------");*/
  //envoieAuESP8266("AT+CWMODE=3");  // Serveur
  envoieAuESP8266("AT+CWMODE=1");  // Client
  recoitDuESP8266(5000);
  Serial.println("---------------------------------");  
  envoieAuESP8266("AT+CWJAP=\""+ WifiSSID + "\",\"" + WifiPW +"\"");
  recoitDuESP8266(10000);
  Serial.println("---------------------------------");  
  envoieAuESP8266("AT+CIFSR");
  recoitDuESP8266(1000);
  Serial.println("---------------------------------");  
  //envoieAuESP8266("AT+CIPMUX=1");  // ne marche pas en client 
  envoieAuESP8266("AT+CIPMUX=0");   
  recoitDuESP8266(1000);
  Serial.println("---------------------------------");  
  //envoieAuESP8266("AT+CIPSERVER=1,80");
  //recoitDuESP8266(1000);
  
  Serial.println("---------------------------------");  
  Serial.println("--  FIN DE L'INITIALISATION  --");
  Serial.println("---------------------------------");  
  Serial.println("");  
}

//---------------------------------------------------------------
//        Fonction qui envoie une commande à l'ESP8266 
void envoieAuESP8266(String commande)
{  
  ESP8266.println(commande);
}
//---------------------------------------------------------------
// Fonction qui lit et affiche les messages envoyés par l'ESP8266
void recoitDuESP8266(const int timeout)
{
  String reponse = "";
  long int time = millis();
  while( (time+timeout) > millis())
  {
    while(ESP8266.available())
    {
      char c = ESP8266.read();
      reponse+=c;
    }
  }
  Serial.print(reponse);   
}

//---------------------------------------------------------------
// Fonction qui envoie la nouvelle distance à thingspeak.com/channels/LEVOTRE/
void updateDistance(String distance)
{
  String cmd = "AT+CIPSTART=\"TCP\",\"";
  cmd += IP;
  cmd += "\",80";
  ESP8266.println(cmd);
  recoitDuESP8266(1000);
  delay(2000);
  if(ESP8266.find("Error")){
    Serial.print("erreur connection thingspeak");   
    return;
  }
  cmd = GET;
  cmd += distance;
  cmd += "\r\n";
  ESP8266.print("AT+CIPSEND=");
  
  ESP8266.println(cmd.length());
  if(ESP8266.find(">")){
    ESP8266.print(cmd);
  }else{
    ESP8266.println("AT+CIPCLOSE");
  }
}

jeudi 26 novembre 2015

Publication de mon Livre : Modélisation et Commande de la Machine Asynchrone


Mon livre a été publié

Modélisation et Commande de la Machine Asynchrone
LOTFI BAGHLI

RÉSUMÉ

Ce livre peut servir comme support de cours sur la commande de machine asynchrone. Il comporte une introduction à la modéli-sation de la machine asynchrone en régime transitoire et en régime permanent, une présentation de la commande scalaire et de la commande vectorielle. Le livre comporte également une partie concernant la régula-tion et le calcul des paramètres de régulation. L’aspect d’implémentation expérimentale est mis en exergue. Enfin, des exercices issus d’annales d’examens et de contrôles continus sont proposés afin d’aider l’étudiant à bien se préparer et aux enseignants de s’inspirer lors de la préparation des sujets de contrôle.

AUTEUR

BAGHLI Lotfi est un spécialiste de commande de machines. Il est ingénieur de l’Ecole Nationale Polytechnique d’Alger en Electrotechnique, en 1994. Après avoir obtenu sa thèse de Docto-rat en Génie Electrique à l’Université de Nancy 1, en 1999, il exer-ça pendant 10 ans en tant qu’enseignant-chercheur, Maître de Con-férences, à l’IUFM de Lorraine. Il est maintenant à l’Université de Tlemcen où il continue ses travaux de recherche et d’enseignement. Il est présent sur le net à travers son blog personnel https://baghli.blogspot.com et sur sa page web http://baghli.com


http://www.leseditionsdunet.com/scientifique/3920-modelisation-et-commande-de-la-machine-asynchrone-lotfi-baghli-9782312041049.html

Vous pouvez l'acheter directement sur le site web en version pdf ou au format livre.
Il est également disponible sur Amazon :
http://www.amazon.fr/Mod%C3%A9lisation-Commande-Machine-Asynchrone-Baghli/dp/2312041049



jeudi 12 novembre 2015

Apprenons à nos enfants la programmation

L'avenir se conjugue à la programmation.

Il est primordial de nos jours d'être capable de programmer comme il l'est de maîtriser les outils de bureautique (Word, Excel, Powerpoint).
Des gens louables ont passé du temps pour nous faire profiter, en open source, de leur travail, fruit d'une longue réflexion.



Programmation :

Je voudrai d'abord parler de Scratch

Ce projet du MIT est maintenant mature et utilisé dans de très nombreux collèges et écoles pour former à la programmation par une approche graphique et ludique.

Il y a des centaines de tutoriels sur leur site et sur Youtube.
Le logiciel et les instructions de programme ont été traduits en pratiquement toutes les langues, ce qui le rend accessible dès l'apprentissage de la lecture !

Essayez la version en ligne ou télécharger la version hors ligne qui vous permet de travailler sans connexion.


Robotique :
Pour aller plus loin et interagir avec les objets, rien de mieux que la robotique, il se trouve qu'il existe maintenant des extensions de Scratch qui s'utilisent avec des robots.

Le plus abouti à mon sens est : mblock
http://www.mblock.cc/download
Il reprend la programmation graphique de Scratch et crée, automatiquement, du code Arduino que l'on peut afficher ou cacher. Ensuite, on peut flasher (programmer la mémoire flash d') un micro-contrôleur pour réaliser la tâche expérimentalement.
Cela offre des possibilités infinies que l'on voit se concrétiser de manière réaliste devant les yeux émerveillés des apprenants.
Le robot le moins cher qui est compatible est le makeblock mbot (75 USD ou 79 €). Il comporte plusieurs périphériques (capteurs) et 2 moteurs




Makeblock mbot et son environnement de programmation



On peut tout aussi bien le programmer en mblock (Scratch like) ou en Arduino (très proche du C) et on s'initie à la programmation temps réels, les interruptions, les capteurs, l'électronique, la conversion analogique numérique, la commande des moteurs et des transistors de puissance via la Modulation de Largeur d'Impulsion (MLI ou PWM), les communications séries (UART, SPI,...), l'éthernet, l'USB, bus CAN,...






Electronique embarquée :
Pour les plus grands (formations universitaires par exemple), on peut aussi acheter des cartes de développement vraiment pas cher (5 cartes à 15 USD) permettant d'aller plus loin en concevant des projets embarqués et autonomes à base d'Arduino Nano (un successeur plus puissant que le Uno)
http://www.banggood.com/5Pcs-ATmega328P-Nano-V3-Controller-Board-For-Arduino-Improved-Version-p-951797.html

Arduino nano V3

Après, on peut aussi aller vers des systèmes professionnels à moindre coût comme les LaunchPad-XL de Texas Instruments, dont je conseille la famille C2000 pour le contrôle de moteurs et de processus industriels.
Texas Instruments ont compris ce qu'a réalisé l'Arduino dans la communauté et a calqué ce procédé en proposant des cartes de très faible coût mais très performante, puisqu'on est sur du 32 bits à virgule flottante (F28069M à 60 MHz, 25 USD), haute performance (F28377S à 200 MHz, 30 USD) ou du 32 bits à virgule fixe, entrée de gamme C2000 (F28027F à 17 USD).
http://www.ti.com/ww/en/launchpad/launchpads-c2000.html#tabs


Texas Instrument LaunchPad F28027F et F28069M

L'avantage est de pouvoir plugger (brancher) des "booster pack" l'équivalent des "shields" de l'Arduino, par dessus les LaunchPad, de manière à doter ces cartes de fonctionnalités avancées, tel que les onduleurs triphasés, le wifi, l'afficheur LCD...
Onduleur triphasé BOOSTXL-DRV8301 (10A nominal, 6 à 24V)
Permettant de piloter des moteurs synchrones BLDC ou MAS

Ces systèmes ont des environnements de programmation dédiés assez compliqués mais complets et professionnels tels que Code Composer Studio (gratuit uniquement pour ces cartes) et Matlab / Simulink - Embedded coder avec l'extension C2000.




Que vous soyez, élève, parents, étudiants ou enseignants-chercheurs, j'espère que ce petit tour d'horizon des technologies actuelles disponibles (12/11/2015) vous donnera envie d'aller vers la programmation puis la programmation embarqué.















mercredi 4 novembre 2015

circuit à base de dspic pour piloter un servo

On a des fois besoin de tester un servo ou un variateur de vitesse en (aéro)modélisme sans brancher sur la radio.
On peut l'acheter dans le commerce mais c'est aussi très simple à fabriquer avec un dspic 30F3010 ou 30F4012.

Voici un schéma simple et le programme qui va avec.
L'idée est de générer un signal PWM de période 20 ms mais qui est assez bref :
0.9 ms au minimum
1.5 ms pour la commande neutre (point milieu)
2.1 ms pour la maximum

UN potentiomètre permet de faire varier le rapport cyclique du signal PWM, donc le temps pendant lequel le signal est à 5V par rapport au reste du temps de la période des 20 ms pendant lequel il reste à 0V.

Nous implantons ce programme sur un dspic 30F3010 ou 30F4012 (pin compatible, il est juste plus puissant est a un bus CAN)

Le header P2 permet d'alimenter le circuit avec le UBEC du variateur de vitesse mais sans utiliser l'entrée du variateur (commande) afin d'utiliser le Header P1 pour sortir l'information servo_pulse vers le servo.

Si on doit justement faire varier la vitesse du moteur BLDC alors on ne branche que le Header P1 sur le UBEC et bien sûr on branche la batterie Lipo et le moteur sur le variateur.


Vous pouvez télécharger le


Remarquez que j'ai eu des difficultés initialement à démarrer le dspic sur son oscillateur interne FRC avec une PLL x8, il fallait le réinitialiser (Reset sur la pin MCLR) manuellement à chaque fois pour qu'il démarre après avoir été alimenté.

J'ai changé et enlevé la PLL, il n'utilise que le FRC, ce qui est plus stable mais plus lent et donc on perd en résolution de la PWM, mais cela suffit amplement pour cette application, puisque j'ai 
1935-829 = 1106 valeurs différentes entre le min et le max, soit plus que la résolution de l'ADC 10 bits qui est de 1024 !

jeudi 25 juin 2015

Texas Instruments GUI Composer

Pour le pilotage des programmes qui s'exécutent sur les cartes DSC C2000 de TI, il existe le GUI Composer.
Il est en 2 formes, le Designer et le Runtime

http://processors.wiki.ti.com/index.php/Category:GUI_Composer

Plus spécifiquement pour les LaunchPadXL ou similaires pour le contrôle moteur, il existe une partie
http://www.ti.com/tool/instaspinuniversalgui

Alors afin que ça puisse marcher et comme la doc fournie est vraiment ridicule, voici la procédure :
- A l'aide de Code Composer CCS (Version 6 ou 5) compiler, charger et lancer le .out sur le target
- Déconnecter (Disconnect Target : CTRL ALT C) dans CCS
- Copier le .out généré vers le directory ..\guicomposer\webapps\  par exemple    e:\ti\guicomposer\webapps\InstaSPIN_F2806xM_UNIVERSAL\
- Lancer le InstaSPIN_UNIVERSAL.exe, il se connctera et on pourra modifier les variables.

mercredi 7 janvier 2015

TUTORIAL : BibTeX, Zotero et gestion des références bibliographiques


La gestion des références bibliographique est très importante pour les doctorants et les chercheurs permanents.
Le plus intéressant outil actuellement est le format BibTeX
il s'agit d'un format libre de droit et très intéressant et peuvent être aussi combiné avec d'autres outils libres (Zotero, JabRef  ).

L’intérêt est que IEEE XPlore ou ScienceDirecte, propose dans les résultats de recherche des articles, de télécharger directement au format .bib (avec même le résumé de l'article)







Ensuite 2 possibilités :
Zotero qui est un outil tout intégré (marche bien sous MS Word)
https://www.zotero.org/download/
une fois installé la version Stand Alone (et non pas firefox)
vous pouvez importer les .bib dans sa bibliothèque interne





Automatiquement il me met les références au format IEEE ou autre, et si je change d'ordre de citation, ça réordonne !
Je recherche une citation, il la cherche automatiquement pour moi, sans quitter Word, il suffit de commencer à écrire une partie du titre ou auteur, pourvu qu'elle soit dans ma base de donnée Zotero !

2ème possibilités :
un peu moins souple (à installer), c'est
JabRef  + MikTeX   +  Bibtex4Word
http://www.ee.ic.ac.uk/hp/staff/dmb/perl/b4w_bibtex.html

http://sourceforge.net/projects/jabref/files/latest/download?source=files

qui permet de gérer les fichier .bib des références, trier, modifier d'une manière simple.

ou le passage par le LateX pour ceux qui comme moi préfèrent MS Word, il y a des passerelles via MikTeX   et Bibtex4Word
http://miktex.org/download
http://www.ee.ic.ac.uk/hp/staff/dmb/perl/
mais ceux qui travaillent directement en LateX peuvent l'utiliser directement, sinon on ajoute la macro Bibtex4Word .

To use Bibtex4Word, you must be using a PC (it does not work on a Mac) running Word 2002 or later (32 or 64 bit) and you need to install three pieces of free software:
  1. A reference manager that will allow you to enter, or download, the citation details of a published document and which stores them in BibTeX format. There are several suitable reference managers available; I strongly recommend JabRef .
  2. The MikTeX wordprocessing package. This is a PC implementation of a wordprocessor called LateX  which includes the BibTeX program as one of its components. We only use a tiny part of MikTeX but it is easiest to install the whole package.
  3. The Bibtex4Word macro itself.
je vous  invite à ajouter le style IEEE qui n'est pas installé par défaut


J'espère que cela vous aidera à utiliser plus facilement les références bibliographiques dans vos articles et mémoires.