Compteur de j'aime Facebook sur Arduino

International Français
#24

achappard: Après je n'ai plus de soucis.

:grin:

Mode taquin 8)

Peut etre simplement pour l'instant ? ;)

J'ai lu un peu "en diagonale"

Mais il semblerait que ta manip d'upload au travers du uno expose ton esp8226 (ESP01) à des niveaux excedant ce qui est toléré sur ses GPIO .

Si ça peut te rassurer, c'est comme çà que j'ai "programmé" mon/mes 1er esp8266 (ESP01) :sunglasses:

A l'epoque la doc dispo de chez espressif etait... éparse, succincte et ambigue en ce qui concerne ce point particulier de tolerance V des GPIO.

Je ne me souviens pas en avoir cuit (au moins à cause de çà :smiling_imp: ) , mais ce n'est pas une bonne pratique

#25

Coté ESP01 envoyer périodiquement la valeur par un Serial.println(), par exemple quand elle change.

Côté UNO lire la ligne série en permanence. Quand des caractères sont disponibles (voir Serial.available), lire ceux-ci dans un buffer. Quand ce caractère vaut '\n' terminer le buffer par un '\0' et l'envoyer à l'afficheur.

Du coup c'est bien 2 programmes si je comprends bien. Donc une fois mon programme sur le module ESP01, je peux déconnecter le RST<->GND de l'arduino ? Ouvrir un nouveau programme vierge et le balancer sur l'arduino ?

Je vais regarder les lignes série : je ne connais pas (encore)

#26

hbachetti: Il faut passer par une ligne série.

Coté ESP01 envoyer périodiquement la valeur par un Serial.println(), par exemple quand elle change.

Côté UNO lire la ligne série en permanence. Quand des caractères sont disponibles (voir Serial.available), lire ceux-ci dans un buffer. Quand ce caractère vaut '\n' terminer le buffer par un '\0' et l'envoyer à l'afficheur.

Côté UNO il vaut mieux utiliser un SoftwareSerial afin de ne pas mobiliser le Serial hardware, ce qui t'obligerait à débrancher l'ESP01 à chaque chargement de la UNO, et te priverait du terminal.

ça me semble bien compliqué pour le besoin initial ::) Enfin ça ne l'est peut-être pas..

Mais un ESP avec plus de pins aurait été tout à fait autonome à faire ce que tu souhaites, sans devoir brancher et faire communiquer un Arduino Uno avec un ESP-01

Ou me trompe-je ?

#27

Il est parfaitement possible de communiquer avec un TM1637 avec l'ESP01 seul, apparemment.

Voir mon post #3 : https://github.com/wrightmac/TestInTime/blob/master/ESP01_SimpleClock.ino

TM1637 tm1637(2,0);

Mais il n'y a que deux GPIOs, il ne faudra pas pas avoir d'autres besoins.

@achappard : si cela te tente, cela te permettrait d'aller plus vite. Cela devrait marcher.

#28

si cela te tente, cela te permettrait d'aller plus vite. Cela devrait marcher.

Le soucis c'est que je débute et que je ne vois pas comment alimenter l'ESP sans l'arduino

Je vais continuer de regarder pour faire le 2eme programme.

#29

Tu peux continuer à alimenter l'ESP01 avec la UNO, charger le programme ESP01 avec la UNO. Rien ne s'y oppose. Ensuite tu branches le TM1637 sur l'ESP01 au lieu de le brancher sur la UNO.

#30

J'avoue que je préférerai le faire en avec le SoftwareSerial pour le défi !

#31

A ta guise, donc. Essaie l'autre solution dans un deuxième temps. Elle tiendra beaucoup moins de place.

#32

En respectant le cablage de @hbachetti, j’ai uploadé le programme suivant qui marche bien :

#include <Arduino_JSON.h>
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>

const char* ssid = "MON_RESEAU_WIFI";
const char* password = "MON_PASS_WIFI";
unsigned int display_fan_count        = 0;
const String get_fans_count_url  = "http://mon-url-me-renvoyant-du-json.com";


void setup () {

  Serial.begin(115200);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {

    delay(1000);
    Serial.println("Connection au réseau WIFI...");

  }
  Serial.println("Connecté au WIFI !!!");
}

void loop() {

  if (WiFi.status() == WL_CONNECTED) { //Check WiFi connection status

    unsigned int current_fan_count = retrieve_fb_fan_count();
    if ( current_fan_count != display_fan_count) {
      display_fan_count = current_fan_count;
      update_display_fan_count(display_fan_count);
    }
    //Serial.println(current_fan_count);
  }

  delay(3000);    //Send a request every 30 seconds

}

void update_display_fan_count(int new_number) {
  Serial.println("Mise à jour du compteur : " + (String) new_number + " fans");
}

int retrieve_fb_fan_count() {
  HTTPClient http;  //Declare an object of class HTTPClient

  http.begin(get_fans_count_url);  //Specify request destination
  int httpCode = http.GET();                                                                  //Send the request

  if (httpCode > 0) { //Check the returning code

    String payload = http.getString();          //Get the request response payload
    JSONVar myObject = JSON.parse(payload);     // Convert to json

    if (JSON.typeof(myObject) == "undefined") {
      return 0; // erreur
    }
    if (myObject.hasOwnProperty("fan_count")) {
      return (int) myObject["fan_count"];
    }
  }
  http.end();   //Close connection
  return 0;
}

Seulement, lorsque je débranche le RST du Ground de l’arduino et le GPI0 de l’ESP01 du Ground (pour dire à l’ESP01 : c’est bon j’ai fini de te programmé), je n’ai plus de débug.

#33

Bien entendu, c'est la UNO qui reprend la ligne série pour son propre compte. C'est l'inconvénient de la solution UNO + ESP01.

Il est certainement possible de brancher un FTDI sur GPIO2 de l'ESP01 (TX uniquement, pas besoin de RX) avec un SoftwareSerial à initialiser dans le code ESP01 et ensuite utiliser ce SoftwareSerial à la place de Serial pour afficher le debug.

Ça commence à ressembler à une usine à gaz ...

#34

Whoua, je m’y perds :o . Pas si facile! Je pensais que c’était plus simple. C’est con, le programme tourne bien sur l’esp01. Je pense que une fois le programme ci dessous uploadé sur l’ESP, il faut faire un branchement différent sur la UNO. Mais je ne sais pas où trouver le détail de ces branchements.

Je vais m’inspirer de cette vidéo : c’est exactement ce que je cherche( je ne sais pas pourquoi il branche sur du 5V, je vais rester sur le 3.3V)

#35

Une ligne série ne se partage pas.
Pour charger du code dans la UNO, le bootloader a besoin de la ligne série.
Donc il faut débrancher l’ESP01 du RX/TX de la UNO pour que cela puisse se faire.

Ensuite, il a un besoin de communication entre la UNO et l’ESP01 (transmettre une valeur de compteur).

Le RX/TX de l’ESP01 est utilisé pour communiquer avec la UNO, auquel cas le debug va aussi suivre le même chemin, ce que le programme de la UNO ne va pas comprendre.

Imaginons qu’il y ait un canal de communication entre RX/TX ESP01 et un SoftwareSerial sur la UNO.

Il est possible d’adopter une convention :

  • si l’ESP01 envoie une ligne commençant par un mot clé : facebook=valeur, la valeur est affichée sur le TM1637
  • si l’ESP01 envoie autre chose, les caractères (le debug) sont envoyés sur Serial
    Cela revient à faire une espèce de routage avec un protocole hyper-simplifié.
    Donc au final, le debug de l’ESP01 et le debug de la UNO seront affichés sur la console.

Cela convient-il ?

La solution du TM1637 sur l’ESP01 est plus simple …

#36

Bonjour, Deux articles sur le sujet dans Hackable n° 29 pages 14 et 24

#37

La solution du TM1637 sur l'ESP01 est plus simple ...

Après plusieurs jours d'essai, je pense que je vais partir sur cette solution. Je me plie à votre expérience. Cependant, dans l'idée de faire évoluer le projet, je voudrais avoir plus de broche de dispo (Deux pour l'afficheur TM1637 + eventuellement d'autre (pkoi pas commander un servo moteur levant un drapeau à chaque nouveau "J'aime Facebook"?

Du coup je pensais partir sur une carte ESP8266 NodeMcu WiFi Development Board

Pensez-vous que cela soit faisable ? Si oui cette carte délivre du 3.3V : ce voltage sera-t-il suffisant pour piloter le TM1637 ou autre composant (comme un simple servo) ?

Merci de vos réponses.

#38

"Si oui cette carte délivre du 3.3V : ce voltage sera-t-il suffisant pour piloter le TM1637 " La réponse est mitigée: Normalement, un niveau logique du TMS 1637 devrait depasser 0.7* Vdd : si le TMS1637 est alimenté en 5 volts, 3volts ne suffisent pas; mais, selon http://www.microcontroller.it/english/Tutorials/Elettronica/componenti/TM1637.htm One final note concerns the supply voltage: if TM1637 can be supplied from 3 to 5V (this is not explained in the data sheet), it is the minimum conduction voltage of the LEDs that determines the minimum supply value. Thus, blue LEDs will not be able to be powered at less than 5V.

Une solution serait de ne pas alimenter le TMS sous 5v, mais sous 5v -0.7v (la chute d'une diode dans le sens passant type 1N4001) ; là, des niveaux logiques de 4.2*0.7 = 2.8 pour le 1 sont acceptables (et il faut espèrer que les diodes bleues seront allumables). Une autre solution serait d'utiliser des adaptateurs de niveaux bidirectionnels.

Pour les servomoteurs, la commande doit avoir un niveau haut au delà de 2.5v volts (pas de problème, si mon pari et ma mémoire sont fidèles)

#39

La datasheet du TM1637 ne précise pas le minimum de tension d'alimentation. Mais je vois beaucoup de projets à base de TM1637 alimentés en 3.3V : https://github.com/bitbank2/tm1637 http://www.esp8266learning.com/tm1637-7-segment-display-example.php

#40

J'ai reçu mon ESP12E aujourd'hui : je le branche, upload mon programme sans soucis ! Tout marche bien ! J'attends maintenant mon TM1637 pour faire l'affichage.

Merci @hbachetti pour les conseils !

#41

Super ! Bonne continuation.

#42

Et voilà le résultat ! Merci à tous pour vos contributions !

#43

Merci pour votre réalisation, décrite clairement dans le lien que vous avez mis ci dessus.