Compteur de j'aime Facebook sur Arduino

(deleted)

Après plusieurs essais sur Window, l'upload du programme sur l'esp passe une fois sur 2à en moyenne. Pensez-vous que cela puisse venir des mes câbles? Ce sont ceux de l'arduino stater kit fr (des câbles dupont je crois) qui sont assez fin.

(deleted)

Après plusieurs essais sur Window, l'upload du programme sur l'esp passe une fois sur 2à en moyenne. Pensez-vous que cela puisse venir des mes câbles? Ce sont ceux de l'arduino stater kit fr (des câbles dupont je crois) qui sont assez fin.

Il faut voir si en faisant un reset de l'ESP01 cela se passe mieux.

Quand je charge un ESP01 je le fais avec un FTDI. Mais j'ai deux boutons "RESET" et "BOOT" :

|500x334

Sur ce schéma il y a un peu d'électronique pour provoquer un reset automatique par le DTR du FTDI. N'y prête pas attention. Seuls les deux boutons sont importants.

Le principe est simple : Avec un montage comme celui-ci : - appuyer sur BOOT - appuyer sur RESET - relâcher RESET - relâcher BOOT - lancer le chargement

Dans ton cas, GPIO est déjà à la masse.

Il faudrait câbler un bouton poussoir RESET entre les pins RST et GND de l'ESP01.

Avant de charger appuies un petit coup sur le bouton.

J'ai trouvé comment faire marcher l'upload à chaque fois : Quand l'UNO est alimenté via USB et que donc que le module esp l'est aussi, avant d'uploader le programme, je déconnecte la broche d'alim 3.3V et la reconnecte.

Après je n'ai plus de soucis.

Cool, j'arrive maintenant à appeler ma page web qui me retourne le nombre de fans facebook. Mais un truc me turlupine : Si je comprends bien, le programme, je le balance sur le module ESP et non sur la uno. N'est-ce pas ?

Comment récupérer ensuite la valeur sur la uno et ensuite faire mon mic-mac avec l'afficheur ? C'est la passerelle entre UNO <=> ESP que je ne parviens pas à voir.

Dois-je écrire un nouveau programme, et l'uploader sur la UNO ? Si oui, comment communiquer la valeur récupérée par l'esp à mon arduino ?

J'espère être assez clair (?)

J'ai trouvé comment faire marcher l'upload à chaque fois : Quand l'UNO est alimenté via USB et que donc que le module esp l'est aussi, avant d'uploader le programme, je déconnecte la broche d'alim 3.3V et la reconnecte.

Cela revient à faire un reset de l'ESP01, sans le bouton que je conseillais plus haut.

Dois-je écrire un nouveau programme, et l'uploader sur la UNO ? Si oui, comment communiquer la valeur récupérée par l'esp à mon arduino ?

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.

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

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)

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 ?

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.

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.

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.

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

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

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

#include 
#include 
#include 

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.

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 ...

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)

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 ...

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

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.