====== Wagons ESP8266 ======
Commandes de wagons par un ESP8266, marche/arrêt/avant/arrière/vitesse dans un premier temps.
C'est une installation faite avec Dominique Leroy
http://www.lightzoomlumiere.fr/realisation/circuit-de-david-rolland/
Le wagon reçois ses ordres en WIFI/OSC et émet la lecture de balise de positionnement présentes sur les voies.
**Le matériel choisi:**
- [[https://www.olimex.com/Products/IoT/ESP8266-EVB/open-source-hardware | Olimex ESP8266-EVB ]]
- [[https://github.com/OLIMEX/ESP8266/blob/master/HARDWARE/MOD-WIFI-ESP8266-DEV/MOD-WIFI-ESP8266-DEV_schematic.pdf|MOD-WIFI-ESP8266-DEV_schematic.pdf]]
- https://github.com/OLIMEX/ESP8266/blob/master/HARDWARE/ESP8266-EVB/ESP8266-EVB_Rev_A.pdf
- [[https://www.olimex.com/Products/RobotParts/MotorDrivers/BB-L298/open-source-hardware| Olimex BB-L298 ]] commande de moteur
===== Préparation =====
- Commencer par enlever le strap IO0JP sur la platine ESP pour pouvoir flasher à volonté la bêbête.
- cf [[https://www.olimex.com/Products/IoT/MOD-WIFI-ESP8266-DEV/resources/MOD-WIFI-ESP8266-DEV_jumper_reference.pdf]], (c'est celui de gauche des 3 strap quand l'antenne est vers le bas)
- pour flasher il faut allumer la platine en maintenant le bouton enfoncé
- avoir une chaine de compilation, je prends celle d'arduino qui fonctionne pour moi cf autres pages la dessus ( https://github.com/esp8266/Arduino )
- librairies à utiliser
- http://cnmat.berkeley.edu/oscuino ou https://github.com/CNMAT/OSC ??
- https://github.com/sandeepmistry/esp8266-OSC
- info la dessus http://trippylighting.com/teensy-arduino-ect/touchosc-and-arduino-oscuino/
===== Code de test =====
Attention ce n'est pas un arduino, le PWM évolue entre 0 et 1023, c'est sur 10bits ;-)
moteur à 40%
===== Projet LOCO-DOM =====
* TP-link sur 192.168.0.80
* SSID = LOCOMO
* loco-1
* ip=192.168.0.81
* port=9081
* loco-2
* ip-192.168.0.82
* port=9081
* etc
* test oscsend 192.168.0.81 9081 /moteur ii 500 30
===== Connexions =====
en travoooo
==== Mesure ADC tension batterie 12V ====
avec un pont diviseur de tension pour coller entre 1.3V et 3.2V sur 1024, grosso modo
__Vin
|
R1=31k ( orange brun orange )
+---->ADC-ESP
|
R2=10k ( orange noir orange )
|
__GND
source calcul du pont http://www.electronique-radioamateur.fr/elec/schema/calcul-diviseur-tension.php
, analogRead(A0) me donne 745 avec une batterie chargée...
==== Batterie plomb 12V ====
les lithium sont trop fragiles pour garantir un bon fonctionnement sur plusieurs années , avec les montages/démontages de l'installation. Nous passons sur de 'bonnes vieilles' plomb en tampon, toujours avec un circuit de maintient de charge. Leur capacité sera en gros d 1Ah, le circuit des rails fournissant suffisamment bien la charge en temps normal. A priori ce sont des vitesses lentes qui seront utilisées donc des consommations de 300 à 400 mA.
* le meme circuit de diode Schottky isolant le chargeur et la batterie des retours
* un booster qui monte le 12v a 16V pour une base de charge du plomb
* http://www.ebay.fr/itm/XL6009-LM2596S-DC-DC-Step-Up-Down-Boost-Buck-Voltage-Power-Converter-Module/262467051468?hash=item3d1c415fcc:g:4gcAAOSwNSxVRlyx
* un régulateur de charge 12V alimenté par le booster http://www.e44.com/rechercher/?q=m083
* https://www.kemo-electronic.de/en/Transformer-Dimmer/Controller/Modules/M083-Battery-charging-regulator-12-V-DC.php
===== Connexions =====
|Olimex-ESP8266 | BBL-298| Signal |
|con3 | | |
|1 | 1| +5 |
|2 | 8| GND |
Si exploitation de 2 moteurs
| Olimex UEXT pad | pin | BBL-298| Signal |
| 1 | 3.3V| | nc |
| 2 | GND | | console debug GND |
| 3 | gpio 1 | TXD | console debug rx |
| 4 | gpio 3 | RXD | console debug tx |
| 5 | gpio 4 | 6 | in 3 |
| 6 | gpio 2 | 7 | in 4|
| 7 | gpio 12 |4 | in 2 |
| 8 | gpio 13 |3 | in 1 |
| 9 | gpio 14 |2 | enable A |
| 10 | gpio 15 |5 | enable B |
Si un moteur et une entree serie (rfid)sur UEXT Olimex ESP-DEV
| 1 | 3.3V| | nc |
| 2 | GND | | console debug GND |
| 3 | gpio 1 | TXD | console debug rx |
| 4 | gpio 3 | RXD | console debug tx |
| 5 | gpio 4 | 6 | nc |
| 6 | gpio 2 | 7 | nc |
| 7 | gpio 12 |4 | in 2 |
| 8 | gpio 13 |3 | in 1 |
| 9 | gpio 14 |2 | enable A |
| 10 | gpio 15 |5 | rfid tx | ( marche pas...)
1 moteur sur ESP-12
Connexions ESP-12 BBL-298
|- | ESP-12 | | -|
|- | RST | TXD| -|
| LDR | ADC | RXD| - |
|- | CH_P | GPIO4 | 1 RFID |
| 4 BBL | GPIO16 | GPIO5 | -|
| 3 BBL | GPIO14 | GPIO0 | -|
|led bleu2 BBL-298| GPIO12 | GPIO2 | -|
|led verte | GPIO13 | GPIO15 |led rouge|
|- | VCC 3V | GND| -|
ok pour
* http://www.seeedstudio.com/wiki/index.php?title=125Khz_RFID_module_-_UART
lecture rfid par [[esp8266:uart]] ok vitesse de lecture suffisante
* http://www.seeedstudio.com/depot/125khz-rfid-module-uart-p-171.html?cPath=84_85
* {{:esp8266:rdm630.gif?200|}}
P1
PIN 1 TX
PIN 2 RX
PIN 3 - nc
PIN 4 - Ground
PIN 5 - 5 V
P2
PIN1 - antenne
PIN1 - antenne
P3 - led option
https://github.com/OLIMEX/ESP8266/blob/master/HARDWARE/ESP8266-EVB/ESP8266-EVB_Rev_A.pdf
Avec NodeCU : {{ :esp8266:nodemcu_pinout.png?200|}}
| DRIVER| | NodeCU |GPIO¦
| E1-2 | 2 | D4 | GPIO 02 |
| I2 | 3 | D5 | GPIO 14 |
| I1 | 4 | D6 | GPIO 12 |
| RFID TX | |
| | D7 | GPIO 13 |
| mesure batterie | A0 | Entrée Analogique |
===== préparation =====
le nommage des loco est fait par leur adresse IP. Donc il est nécessaire de paramétrer le dhcp de l'AP pour que celle-ci affecte les bonnes IP à chaque adresse MAC.
IP => LOCO-No ou No = IP4-80, 192.168.0.81 -80 => LOCO-1
**coder**
* ordre **/ALLER ii position temps** , aller au tag no position en tant de seconde
* prevoir acceleration/deceleration
* prévoir si vitesse négative la marche arrière
* renvoi à cricket les tag lu au passage /LOCO-x i tag
* ordre **/INIT** se positionne sur le tag 0, fait le tour vitesse 1000
* liste tous les tag qui sont normalement séparés régulièrement dans un tableau (no tag, identité du tag)
* retient le temps totale pour une boucle
* ordre /OU renvoi le dernier tag lu, donne une position approximative
*
msgIN.dispatch("/stop", ArretMoteur); // stop le moteur immediatement commande=0
msgIN.dispatch("/moteur", MoteurControl); // moteur vitesse 0-1000 acceleration commande=1
// acceleration
// si <0: marche arriere
// > 500 , par defaut rampe_moyenne
// 20 rampe moyenne
// 0 brutal
// /init fait un tour pour decouvrir les puces, inittableau nbr_de_puce
// /inittableau i nbr_de_puce
msgIN.dispatch("/inittableau", Initialisation_Tableau); // commande=2
// /init fait un tour pour apprendre les temps de parcours
msgIN.dispatch("/initvitesse", Initialisation_Vitesse); // commande=19 /initvitesse i 0-5
// 1 = vitesse 1000
// 2 = 800
// 3 = 500 4 = -1000 5 =-800 6 =-500
// 99 = init des tableaux a 0
// /goto iii puce temps(ms) +/-rampe (av/arr) va à la puce dans le temps donne milliseconde
msgIN.dispatch("/goto", Rendezvous); // commande=3
// /aller iii puce vitesse rampe
msgIN.dispatch("/aller", SeRendre); // commande=4
// /lit renvoi le code de la derniere puce lue
msgIN.dispatch("/lit", LitPuce); // commande=6
// /puces rempli le tableau avec les puce presentees devant la boucle a larret
msgIN.dispatch("/puces", InitTableauPuces1par1); // commande=7
// /sauvepuces enregistre le tableau dans la flash
msgIN.dispatch("/sauveflash", SauveFlash); // commande=8
// /donnepuces renvoi les données de la flash
msgIN.dispatch("/donneflash", DonneFlash); // commande=13
// /ou renvoi la derniere puce lu
msgIN.dispatch("/ou", Ou); // commande=9
// /zou renvoi perdiodiquement des info (toggle) commande = 10
msgIN.dispatch("/zou", Zou);
// /sauveip i IPD change IPD, enregistre la flash et reboot commande= 14 // marche pas trop !
msgIN.dispatch("/sauveip", SauveIPD); // commande=14
// /sauvevitessemini i vitesse_mini enregistre la vitesse_mini
msgIN.dispatch("/sauvevitessemini", SauveVitessemini); // commande=15
// /sauvenbrpuce i nbr_de_puce, enregistre
msgIN.dispatch("/sauvenbrpuce", SauveNbrPuce); // commande=17
// /vbatterie // renvoi le temoin batterie
msgIN.dispatch("/batterie", Recup_Tension); // commande=18
==== Usage habituel ====
* il faut toujours commencer par placer la loco sur une puce après l'allumage
* **/aller iii 1 1000 1** est donc obligatoire pour qu'elle se situe , ensuite
* /goto iii no_puce temps_s accel + ou -
* si le temps est trop long, elle se met en pause et par a la vitesse mini
* /aller iii no_puce vitesse accel + ou -
* /stop
==== Mise en route ====
__Reconnaissance de toutes les puces présentes sur le circuit__
- **/inittableau i nbr_total_de_puce**
- /inittableau i 99 = RAZ total de tous les tableaux puces et vitesses
- ex /inittableau i 8 = fait le tour pour enregistrer 8 puces
- max 15 puces
- l'inittableau fait un tour pour apprendre la présence des puces,
- il flash le tableau principal, sur lequel on ne revient plus, donc pas de modif de l'ordre des puces ensuite ! ( la distance elle peut etre modifiée).
__Apprentissage des temps de déplacement entre chaque puce__
- **/initvitesse i 99** RAZ tableau vitesse ( option puisque inittableau 99 deja fait )
- **/aller iii 1 500 -10** pour se positionner juste sur la 1
- **/initvitesse i 1** rempli le tableau de la vitesse rapide (1000) en avant
- **/aller iii 1 500 -10** revient juste sur la 1
- **/initvitesse i 2** rempli le tableau de la vitesse rapide (1000) en arrière
- **/aller iii 1 500 -10**
ancient : puisque il ne reste plus que 2 tableaux a 500
- **/initvitesse i 3** rempli le tableau de la vitesse moyenne (800) en avant
- **/initvitesse i 4**
- **/initvitesse i 5** rempli le tableau de la vitesse moyenne-lente (500) en avan
- **/initvitesse i 6**
Il est possible d'arreter une initialisation en cours et de la recommencer ( /stop ), il suffit de se re positionner sur la puce 1.
Il est donc possible de reprendre un tableau sans changer les autres.
* Ensuite faire des tests avec **/moteur ii 300 10** et **/moteur ii 250 10** pour voir si la loco peut faire un tour complet à vitesse lente sans trop brouter
* mini 200 par défaut
* La vitesse la plus lente sera aussi celle qui sert à recalculer les temps nécessaires pour atteindre des puces. Une fois la vitesse la plus lente trouvée, : **/sauvevitessemini i vitesse_mini**
==== Autres commandes ====
* **/stop** stop une commande en cours
* remet tous les compteurs en cours à 0
* ne change rien aux tableaux flashés
* **/donneflash** renvoi les info flashées
* **/sauveflash** reflash ( à priori pas nécessaire )
* **/aller iii no_de_puce vitesse rampe_direction**
* vitesse entre vitesse_mini et 1000
* rampe : si 0 => avant rapide
* <20 pas de rampe
* >20 et <100 effectif
* <0 en arrière
* si la commande est envoyée 2 fois , la loco fait un tour de plus
* ex, on est deja sur la puce 2,
* ///aller 2 500 10// fait 1 tour complet
* /encore ///aller 2 500 10// fait 2 tours complet
* **/goto iii no-puce temps_en_seconde rampe_direction**
* ex ///goto iii 5 20 10// => met la loco sur la puce 5 en 20 s en avant avec un démarrage rapide
* ex// /goto iii 5 20 -1// => met la loco sur la 5 en 20 s dans l'autre sens (arrière)
* **/goto iii no-puce temps_plus_long dir** : si le temps est plus grand que celui permit par la vitesse_mini alors la loco attend 1/3 du temps pour un tour a vitesse mini et refait le calcul pour démarrer
* ex //goto iii 5 160 10// => va peut etre attendre 2 minutes avant d'aller à la vitesse lente.
* ensuite à chaque lecture de puce , la loco ajuste sa vitesse par rapport au temps restant à faire.
* **/vbatterie** renvoi le niveau batterie, de 300 a 800,
* 780= batterie chargée
* si < 300 => **alarme** , il faut absolument recharger la batterie
* **/zou** déclenche le renvoi toutes les 10 s des infos loco ou l’arrête
* //cmd_en_cours dernière_puce_lue vitesse_en_cours niveau_batterie temps_pause_restante(seconde)// temps_absolu_depuis_mise_en_route(millis)
* **/ou** donne dernière_puce_lue
==== Phase d'init exemple ====
/inittableau -i 99
# se mettre juste avant la puce 1
# pour 11 puces
/inittableau i 11
# verifier en retournant juste avant la puce 1
/goto iii 1 1000 -20
/donneflash
# doit retourner un tableau correcte
# puis init des vitesse ( maintenant juste 2 tableaux )
# puisque placée juste avant puce 1
/initvitesse i 1
/initvitesse i 2
/initvitesse i 3
/initvitesse i 4
/initvitesse i 5
/initvitesse i 6
/donneflash doit retourner un tableau correcte
On peut entrer / corriger les puces une par une, le tableau est reflashé
/pucecode si tag nopuce
===== Sources =====
* sur ESP Nodecu
* ... plein de versions ....
* {{:esp8266:locomo-dom-rfid-63.ino|}}
* ré alignement tableau json, correction init, lecture flash
* test lecture tableau de 20 puces rfid
* recalcule du temps de pause avant depart
* simplification puisque 2 tableaux au lieu de 6
* test ok /goto sur 12 puces
* {{:esp8266:locomo-dom-rfid-64.ino|}}
* calcul affiné, et autre vérif en cours
* nom pour les loco 11 et 12 en ip 91 et 92
* {{:esp8266:locomo-dom-rfid-65.ino|}}
* modif vitesse moyenne en cas de pause
* {{:esp8266:locomo-dom-rfid-66.ino|}}
* correction pause et modif variables de temps
* ajout commande " /pucecode si tag nopuce " et correction flashage
* {{:esp8266:locomo-dom-rfid-67.ino|}}
* sup notion de tour
* clean lecture tableau rfid et autre tableau (recadrage)
* {{:esp8266:locomo-dom-rfid-70.ino|}}
* modif vitesse init a 400
* {{:esp8266:locomo-dom-rfid-80.ino|}}, essais grandeur nature , 10 mobiles, dont 3 doubles , nickel :-)
* ajout /pucetemps iii tableau puce temps pour pouvoir corriger un element d'un des tableaux
* nombreuses corrections
Librairies nécessaires:
* ArduinoJson {{:esp8266:arduinojson.tgz|}} ( option , si pas deja présente )
* esp8266-OSC {{:esp8266:esp8266-osc.tgz|}}
* softserial {{:esp8266:espsoftwareserial-master.zip|}} de https://github.com/plerup/espsoftwareserial