IMAGE BitMap ... étrange comportement

Je veux afficher un logo WIFI clignotant pendant toute la durée de la recherche réseau

Tout fonctionne parfaitement excepté une bizarrerie :
Au démarrage le logo clignote 3 fois (et toujours 3 fois)
Puis j'ai un écran noir de 1seconde environ
Puis cela recommence à clignoter un nombre indéterminé de fois selon le temps plus ou moins long de la réussite de la connexion

Question : pourquoi ces 3 clignotements de départ?


//-------------------- attente signal WiFi
  while (WiFi.status() != WL_CONNECTED )
  {   
    affichagelogoWifi() ;                         // appel sous-programme affichage logowifi clignotant
  }
  digitalWrite(ledPin, HIGH);
}

void affichagelogoWifi(void)
{

  //------------------ effacement écran buffer
  ecranOLED.clearDisplay(); // effacer le buffer
  ecranOLED.display(); 

  //------------------ affichage logo WIFI
  //drawBitmap(x position, y position, bitmap data, bitmap width, bitmap height, color)
  ecranOLED.drawBitmap(50, 20, logoWIFI, 38, 32, WHITE);            // dessin et position du logo placés dans le buffer
  ecranOLED.display();                                              // affichage sur l'écran du contenu du buffer
  delay(600);                                                       // durée logo visible

  //------------------ Extinction logo WIFI
  ecranOLED.clearDisplay();                                         // dessin et position du logo placés dans le buffer
  ecranOLED.display();                                              // affichage sur l'écran du contenu du buffer
  delay(300);                                                       //durée logo éteint
}

Pas besoin de

après

J'ai peur que tes delay gênent la recherche du réseau. Essaye de remplacer delay(600) par :

unsigned long chrono = millis();
while (millis() - chrono < 600) yield();

Même chose pour le delay(300)...

Moi je ferais ça :

//------------------ effacement écran buffer
  ecranOLED.clearDisplay(); // effacer le buffer
//-------------------- attente signal WiFi
  while (WiFi.status() != WL_CONNECTED ) affichagelogoWifi() ;   // appel sous-programme affichage logowifi clignotant
  digitalWrite(ledPin, HIGH);
}

void affichagelogoWifi(void)
{
  //------------------ affichage logo WIFI
  //drawBitmap(x position, y position, bitmap data, bitmap width, bitmap height, color)
  ecranOLED.drawBitmap(50, 20, logoWIFI, 38, 32, WHITE);            // dessin et position du logo placés dans le buffer
  ecranOLED.display();                                              // affichage sur l'écran du contenu du buffer
  unsigned long chrono = millis();
  while (millis() - chrono < 600) yield();                                                      // durée logo visible

  //------------------ Extinction logo WIFI
  ecranOLED.clearDisplay();                                         // dessin et position du logo placés dans le buffer
  ecranOLED.display();                                              // affichage sur l'écran du contenu du buffer
  chrono = millis();
  while (millis() - chrono < 300) yield();                                                     //durée logo éteint
}

Pas de changement de comportement .. toujours ce long écran noir qui s'est réduit mais est tjrs présent

//------------------ affichage logo WIFI
//drawBitmap(x position, y position, bitmap data, bitmap width, bitmap height, color)
ecranOLED.drawBitmap(50, 20, logoWIFI, 38, 32, WHITE); // dessin et position du logo placés dans le buffer
ecranOLED.display(); // affichage sur l'écran du contenu du buffer
unsigned long chrono = millis();
while (millis() - chrono < 600) yield(); // durée logo visible

//------------------ Extinction logo WIFI
ecranOLED.clearDisplay(); // dessin et position du logo placés dans le buffer
ecranOLED.display(); // affichage sur l'écran du contenu du buffer
chrono = millis();
while (millis() - chrono < 300) yield(); //durée logo éteint
}

Vous dépendez de la durée d’appel à status

Il faudrait que le code de clignotement soit une petite machine à états non bloquante, un peu comme blink without delay.

C’est ce que fait delay() non?

Oui.

Ne me demandez pas pourquoi mais l'écran noir a disparu après avoir ajouté un délai avant de lancer la boucle d'attente du signal ... je dirai même plus, la reconnexion est plus rapide

//-------------------- attente signal WiFi
unsigned long chrono = millis(); // remplace la fonction delai
while (millis() - chrono < 4000) yield();

while (WiFi.status() != WL_CONNECTED )
{
affichagelogoWifi() ; // appel sous-programme affichage logowifi clignotant
}
digitalWrite(ledPin, HIGH);
}

C'est ce que j'ai fait avec yield.
@jo_6466 n'a pas précisé quel Arduino il utilise : j'ai supposé (un peu rapidement peut-être) un ESP32. Sur l'ESP32, le premier coeur exécute le code C, le second s'occupe de la connexion. Mais tout ça est géré par l'OS, et si le premier coeur prend trop de ressource ou bloque l'OS (avec delay par exemple), le second ne fait pas son job. yield() permet de rendre la main au second coeur.

Evidemment, si ce n'est pas un ESP32, cette solution ne devrait pas fonctionner.

Un ESP8285

D'où l'intérêt de bien préciser tout dès le premier message (y compris le type de carte utilisée), ça m'évite de dire des c**ries...

Et pourtant on en apprend beaucoup avec tes pseudos c...s

cool :grin:

Je ne crois pas mais avoir compris comment alors - c’est un appel de fonction bloquant que vous faites dans les while

Le problème est pour moi réglé
Autre question ...Je sais comment ajouter une bibliothèque .h venant de chez Github lorsqu'il s'agit d'un code zip mais je ne sais pas comment on fait lorsqu'il s'agit d'un simple fichier

Je voudrais rajouter la bibliothèque HTTPClient.h que j'ai trouvé ici : arduino-esp32/HTTPClient.h at master · espressif/arduino-esp32 · GitHub

Répondu ici : évite les doubles posts...

Bonsoir

sur ESP8266 et son petit frère ESP8285 la fonction delay() est particulière, pas totalement bloquante, car elle contient un yield()... ne pas généraliser, tenir compte des spécificités des diverses architectures.

delay(0) y est d'ailleurs équivalent à yield()

Rien ne différencie l'usage de bibliothèque et la programmation en fichiers séparés.
Ou si peu.

Une bibliothèque est rangée dans un endroit connu à l'avance du compilateur pour être accessible de n'importe quel projet.
C'est la configuration de l'IDE qui lui donne l'adresse où regarder.

Si tu mets les fichiers *.h et *.cpp dans le même dossier que le programme principal et qu'au lieu d'écrire :
#include<machin.h>
tu écris :
#include"machin.h"

A la vue des guillemets le compilateur ira chercher en priorité le fichier machin.h dans le même dossier que celui du fichier principal.

Bien évidement, dans ce cas, les fichiers "bibliothèques" ne seront accessibles qu'à l'intérieur du projet. Ce n'est pas toujours un inconvénient, cela évite les conflits de biothèques.

Merci! ... Les nuances sont très intéressantes

Autre question :
Où trouve-t-on les commandes disponibles et leur explication lors de l'usage d'une librairie?

Les « commandes disponibles » ce sont les fonctions publiées, elles sont donc souvent dans le .h que vous importez

Les bonnes bibliothèques ont une documentation et/ou des exemples qu’il faut analyser