Bonjour !

J'ai récupéré à un ami un vma437 pour afficher la température de mon dht22.

Le problème étant que je ne comprend pas comment afficher une valeur, je m'attendais à ce que ce soi aussi facile qu'un écran lcd mais apparemment non.

Pour l'instant j'ai juste compris les connectiques :

Juste en dessous il y a le code mais il y en a tellement, pour l'instant j'ai fais ça mais je ne suis pas du tout sur de moi :

 
void draw(int t) {
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  //u8g.setFont(u8g_font_osb21);
  u8g.drawStr( 0, 22, "t");
}



void setup() {
//ecran
    pinMode(13, OUTPUT);
    digitalWrite(13, HIGH); 

    // flip screen, if required
  // u8g.setRot180();
  
  // set SPI backup if required
  //u8g.setHardwareBackup(u8g_backup_avr_spi);

  // assign default color value
  if ( u8g.getMode() == U8G_MODE_R3G3B2 ) {
    u8g.setColorIndex(255);     // white
  }
  else if ( u8g.getMode() == U8G_MODE_GRAY2BIT ) {
    u8g.setColorIndex(3);         // max intensity
  }
  else if ( u8g.getMode() == U8G_MODE_BW ) {
    u8g.setColorIndex(1);         // pixel on
  }
  else if ( u8g.getMode() == U8G_MODE_HICOLOR ) {
    u8g.setHiColorByRGB(255,255,255);
  }
  

}

void loop() {
float t = dht.readTemperature(); // j'ai enlevé le code pour le dht pour que se soit plus compréhensible

// picture loop
  u8g.firstPage();  
  do {
    draw(t);
  } while( u8g.nextPage() );
  
  // rebuild the picture after some delay
  //delay(50);
}

}

Dans le code, c'est le "firstPage()" et "nextpage()" que je ne comprend pas du tout :/

Je vous donne l'endroit ou j'ai trouvé tous les datasheets : https://whadda.com/product/1-3-inch-oled-screen-for-arduino-sh1106-driver-spi-vma437/

Je me suis aidé de cette page aussi pour trouver le code : https://openclassrooms.com/forum/sujet/arduino-ecran-oled

Merci du temps que vous allez consacrer pour mon topic

-
Edité par IteWaseMi 7 mai 2021 à 18:54:29

La lib U8glib doit se débrouiller avec les contraintes de l'écran ainsi que de l'arduino.

Par exemple, il se peut qu'elle ne puisse pas rafraichir l'écran en entier en une seule fois mais soit obligé de procéder en 2 parties en faisant d'abord la partie haute, puis la partie basse.

C'est pour cela qu'il y a ce système de boucle de dessin avec un do/while.

L'appel de firstPage permet d'initialiser la lib et lui indiquer que l'on souhaite redessiner tout l'écran.

Ensuite, il faut appeler toutes les fonctions de dessin tel  que setFont, drawStr, drawBox, etc... pour que la lib puisse faire ses dessins à l'écran.

Mais suivant les contraintes, il se peut que la lib ne considère qu'une partie des commandes et ne rafraichisse qu'une partie de l'écran.

Une fois toutes les commandes faite, un appel à nextPage permet de dire à la lib que l'on a finit de faire toutes les commandes de dessin.

Cette fonction nextPage renvoie un bool correspondant aux contrainte de la lib et indiquant si oui ou non il est nécessaire de refaire les appels des fonctions de dessin de façon à rafraichir une autre zone de l'écran.

Si elle renvoie false, c'est bon, il n'y a rien à faire.

Si elle renvoie true, alors il faut refaire tous les appels à setFont, drawStr, drawBox, etc... pour que la lib puisse à son tour mettre à jour la zone de l'écran qu'elle n'avait pas pu mettre à jour lors de la première passe.

Et ainsi de suite, il faudra refaire tous les dessins jusqu'à ce que nextPagerenvoie false.

Suivant le type d'écran, sa taille, la mémoire disponible et autres paramètres, il se peut qu'il y ai un nombre plus ou moins important de passes de dessin à faire pour rafraichir tout l'écran.

Du coup, pour simplifier la chose, il est courant de mettre toutes ces fonctions de dessins dans un fonction et d'appeler cette fonction dans une boucle do/while avec comme condition d'arrêt le fait que nextPage retourne false.

-
Edité par lorrio 8 mai 2021 à 11:56:04

Salut ! Merci pour toutes ces infos ! Mais du coup j'ai beaucoup cherché dans mon coin, et j'en suis arrivé à ce résultat :

il affichait Hello Word !

J'ai ensuite fais 2,3 manipulations et depuis peu l'écran ne veut plus changer il reste comme cela :

j'ai beau remettre le programme de Hello World qui marchait bah j'obtient aucun résultat, l'écran reste comme cela...

pour mon programme, j'étais bloqué à afficher une variable float :

#include "U8glib.h"
  U8GLIB_SH1106_128X64 u8g(0, 6, 1, 7); // SW SPI Com: SCK = 4, MOSI = 5, CS = 6, A0 = 7 (new blue HalTec OLED).

void setup() {
//ecran
    pinMode(7, OUTPUT);
    digitalWrite(7, HIGH); 

    // flip screen, if required
  // u8g.setRot180();
  
// flip screen, if required
  // u8g.setRot180();
  
  // set SPI backup if required
  //u8g.setHardwareBackup(u8g_backup_avr_spi);

  // assign default color value
  if ( u8g.getMode() == U8G_MODE_R3G3B2 ) {
    u8g.setColorIndex(255);     // white
  }
  else if ( u8g.getMode() == U8G_MODE_GRAY2BIT ) {
    u8g.setColorIndex(3);         // max intensity
  }
  else if ( u8g.getMode() == U8G_MODE_BW ) {
    u8g.setColorIndex(1);         // pixel on
  }
  else if ( u8g.getMode() == U8G_MODE_HICOLOR ) {
    u8g.setHiColorByRGB(255,255,255);
  }

}
void loop(){
// Lecture de la température en Celcius
  float t = dht.readTemperature(); // j'ai caché le code du dht, je suis sur qu'il est bon

 // picture loop
    u8g.firstPage();  
  do {
    // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  //u8g.setFont(u8g_font_osb21);
  u8g.drawStr( 0, 22, t); // on affiche t NORMALEMENT
  } while( u8g.nextPage() );
}

l'erreur qu'il m'affichait était : 

no matching function for call to 'U8GLIB_SH1106_128X64::drawStr(int, int, float&)'

-
Edité par IteWaseMi 8 mai 2021 à 15:33:28

L'écran qui affiche n'importe quoi, cela vient probablement d'un mauvais contact quelque part.

Quand à ton erreur de compilation, cela vient du fait que la fonction drawStr est prévue pour afficher une chaine de caractères (string) et non un float.

Dans ton cas, il faudrait fallut une fonction drawFloat mais je doute que ça existe.

En revanche, tu peux parfaitement utiliser sprintf pour formater une chaine de caractères à partir d'un float et un peu de texte pour ajouter le "°C" à la fin.

Exemple :

float temp = dht.readTemperature();
char buffer[16];
sprintf(buffer, "%.1f°C", temp);
u8g.drawStr(0, 22, buffer);

Ici, on utilise un buffer de 16 caractères maxi, largement suffisant pour afficher un truc du genre "32.4°C", on aurait même pu réduire mais on est pas à ça prêt pour un buffer temporaire.

Et l'affichage se fait avec un format "%.1f", soit un nombre flottant avec un seul digit après la virgule.

-
Edité par lorrio 8 mai 2021 à 17:18:08

Ok, bah maintenant je pense que j'ai plus qu'un problème avec la connectique :

 U8GLIB_SH1106_128X64 u8g(0, 6, 1, 7); // SW SPI Com: SCK = 4, MOSI = 5, CS = 6, A0 = 7 (new blue HalTec OLED)

Est ce que certains ports ne marche pas pour ce que je vais faire ? Parce que quand je fais mon branchement, ma carte arduino ne veut pas compiler

d'ailleurs à quoi correspond  A0 ?

mes pins sont : GND / VSS / CLK / MOSI / RES / DC / CS

Est ce que ce code corresponf bien au DC ? :

pinMode(0, OUTPUT);
digitalWrite(0, HIGH); 

Car pour l'instant j'ai beau refaire mon circuit, l'ecran reste comme il est, enfin lorsque je compile, il clignote une fois pour se remettre comme la photo

-
Edité par IteWaseMi 8 mai 2021 à 19:18:27

Alors, pour reprendre les questions dans l'ordre :

Concernant le A0, cela dépend de quel A0 tu parles.

Coté Arduino, A0 est une pin, que l'on peut utiliser soit en mode analogique (avec analogRead), soit en digital (avec digitalRead, digitalWrite).

Dans le cas d'une utilisation d'un bus SPI en mode Software, cette pin pourrait très bien servir de CLK, MOSI, MISO ou CS.

Coté écran, ce A0 est probablement une erreur de notation ou autre car quand on regarde des exemples de câblage, on voit que ce A0 correspond à la pin DC de l'écran.

Libre à toi de connecter cette pin DC sur n'importe quel pin de l'arduino et de le renseigner dans la création de l'objet U8GLIB_SH1106_128X64 en cachant que les numéros sont les suivants : U8GLIB_SH1106_128x64 u8g(sck, mosi, cs, a0 [, reset])

Dans ton cas, tu as mis U8GLIB_SH1106_128X64 u8g(0, 6, 1, 7); donc je suppose que tu as connecté cette pin DC à la pin 7 de ton arduino.

Attention avec les pins 0 et 1, il s'agit des pins RX/TX de l'arduino qui servent au Serial ainsi qu'à la reprogrammation de ta carte.

Si tu branches ton écrans sur ces pins, tu t'exposes clairement à des problèmes plus ou moins aléatoire (difficultés de reprogrammer l'arduino, glitch sur l'écran, etc...)

Je t'encourage vivement à utiliser d'autres pins.

Dans ton premier message, tu indiquais utiliser les pins 4,5,6,7 pour le raccordement de ton écran alors pourquoi avoir modifier ces pins 4 et 6 par les pins 0 et 1 ?

-
Edité par lorrio 8 mai 2021 à 20:12:39

"Dans ton premier message, tu indiquais utiliser les pins 4,5,6,7 pour le raccordement de ton écran alors pourquoi avoir modifier ces pins 4 et 6 par les pins 0 et 1 ?"

L'espace était pris, j'ai du faire du rangement mais mtn c'est bon j'ai déplacé ceux qui était en 0 et 1 en 8 et 9

Déjà merci pour toutes tes infos, sans toi ça aurait été difficile de réussir à le configurer 

Grace a tes infos j'ai réussi à le faire marcher mais il reste un tout petit problème : au lieu d'afficher la température, il affiche des caractères spéciaux une solution ?

-
Edité par IteWaseMi 8 mai 2021 à 21:02:10

#include "U8glib.h"
  U8GLIB_SH1106_128X64 u8g(8, 6, 9, 7); // SW SPI Com: SCK = 0, MOSI = 6, CS = 1, A0 = 7 (new blue HalTec OLED).
   
void draw(void) {
  // graphic commands to redraw the complete screen should be placed here 
  u8g.setFont(u8g_font_unifont);
  //u8g.setFont(u8g_font_osb21);
  float temp = dht.readTemperature();
  char buffer[16];
  sprintf(buffer, "%.2f°C", temp);
  u8g.drawStr(0, 22, "temperature :");
  u8g.drawStr(0, 45, buffer);
}
 
void setup() {
  Serial.begin(9600);
//ecran
    pinMode(7, OUTPUT);
 
    // flip screen, if required
  // u8g.setRot180();
   
// flip screen, if required
  // u8g.setRot180();
   
  // set SPI backup if required
  //u8g.setHardwareBackup(u8g_backup_avr_spi);
 
  // assign default color value
  if ( u8g.getMode() == U8G_MODE_R3G3B2 ) {
    u8g.setColorIndex(255);     // white
  }
  else if ( u8g.getMode() == U8G_MODE_GRAY2BIT ) {
    u8g.setColorIndex(3);         // max intensity
  }
  else if ( u8g.getMode() == U8G_MODE_BW ) {
    u8g.setColorIndex(1);         // pixel on
  }
  else if ( u8g.getMode() == U8G_MODE_HICOLOR ) {
    u8g.setHiColorByRGB(255,255,255);
  }
 
}
 
void loop() {

   
   // picture loop
  u8g.firstPage(); 
  do {
    draw();
  } while( u8g.nextPage() );
 
}

#include <LiquidCrystal.h>

 //ventilo
  #define VENTILO 4

  //chauffage 
  #define chauff 3

  //dht22
  #include "DHT.h"   // Librairie des capteurs DHT
  #define DHTPIN 2    // Changer le pin sur lequel est branché le DHT
  #define DHTTYPE DHT22      // DHT 22  (AM2302)
  DHT dht(DHTPIN, DHTTYPE);  



   #include "U8glib.h"
  U8GLIB_SH1106_128X64 u8g(8, 6, 9, 7); // SW SPI Com: SCK = 0, MOSI = 6, CS = 1, A0 = 7 (new blue HalTec OLED).
  
void draw(void) {
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  //u8g.setFont(u8g_font_osb21);
  float temp = dht.readTemperature();
  char buffer[16];
  sprintf(buffer, "%.2f°C", temp);
  u8g.drawStr(0, 22, "temperature :");
  u8g.drawStr(0, 45, buffer);
}
void setup() {
  Serial.begin(9600);

    
  //ventilo
    pinMode ( VENTILO ,  OUTPUT );

  // hauffage
    pinMode ( chauff  ,  OUTPUT );

  //detecteur de température & d'humidité 
    dht.begin();

    //ecran
    pinMode(7, OUTPUT);

    // flip screen, if required
  // u8g.setRot180();
  
// flip screen, if required
  // u8g.setRot180();
  
  // set SPI backup if required
  //u8g.setHardwareBackup(u8g_backup_avr_spi);

  // assign default color value
  if ( u8g.getMode() == U8G_MODE_R3G3B2 ) {
    u8g.setColorIndex(255);     // white
  }
  else if ( u8g.getMode() == U8G_MODE_GRAY2BIT ) {
    u8g.setColorIndex(3);         // max intensity
  }
  else if ( u8g.getMode() == U8G_MODE_BW ) {
    u8g.setColorIndex(1);         // pixel on
  }
  else if ( u8g.getMode() == U8G_MODE_HICOLOR ) {
    u8g.setHiColorByRGB(255,255,255);
  }

}

void loop() {
    // Délai de 2 secondes entre chaque mesure. La lecture prend 250 millisecondes
  delay(2000);

  // Lecture du taux d'humidité
  float h = dht.readHumidity();
  // Lecture de la température en Celcius
  float t = dht.readTemperature();
  // Pour lire la température en Fahrenheit
  float f = dht.readTemperature(true);
  
  // Stop le programme et renvoie un message d'erreur si le capteur ne renvoie aucune mesure
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println("Echec de lecture !");
    return;
  }

  // Calcul la température ressentie. Il calcul est effectué à partir de la température en Fahrenheit
  // On fait la conversion en Celcius dans la foulée
  float hi = dht.computeHeatIndex(f, h);
  

  Serial.print("Humidite: "); 
  Serial.print(h);
  Serial.print(" %\t");
  Serial.print("Temperature: "); 
  Serial.print(t);
  Serial.print(" *C ");
  Serial.print("Temperature ressentie: ");
  Serial.print(dht.convertFtoC(hi));
  Serial.println(" *C");

  

  if (t < 23) {
     digitalWrite(chauff, HIGH);
     digitalWrite(VENTILO, LOW);
     Serial.println("cauffage allumé");
     Serial.println("Ventilo eteint car temps < 23"); 
  }

  if (t > 25) {
     digitalWrite(chauff, LOW);
     Serial.println("cauffage eteint");
  }
  if (t > 28) {
     digitalWrite(VENTILO, HIGH);
     Serial.println("ventilo allumé car temps > 28");
  }

  
   // picture loop
  u8g.firstPage();  
  do {
    draw();
  } while( u8g.nextPage() );

}

-
Edité par IteWaseMi 9 mai 2021 à 10:49:45

Je ne suis pas certain que forcer la pin 7 associé à l'écran en OUTPUT soit une bonne idée...

A moins que ce ne soit dans les code d'exemple de l'écran et dans ce cas, ce serait Ok.

-----

Une première explication de ton affichage étrange pourrait venir d'un caractère inconnu sur l'unité de °C.

En effet, le petit rond de degré ne fait pas partie des caractères ASCII de base, il se peut qu'il mettre le bordel.

Dans un premier temps, essaye de le retirer et/ou le remplacer par autre chose comme une étoile par exemple.

-----

Une seconde explication pourrait venir du fait que tu fais une lecture de la température dans la fonction draw utilisé le do/while de gestion de l'écran.

Comme je te le disais, la lib peut avoir besoin de faire plusieurs passe pour rafraichir l'écran en entier.

Maintenant, supposons que dans ton cas, la lib procède en 4 fois avec d'abord le coin en haut à gauche, puis le coin en haut à droite, puis gauche gauche et bas droite... (je dis "supposons" car je ne sais pas comment la lib va procéder).

Si ton capteur oscille un peu et te donne un coup 20.5°C, un coup 20.6°C, je te laisse imaginer le bordel que cela va mettre...

Tu vas te retrouver avec un bout d'image qui affiche 20.5°C dans un coin de l'écran, couplé à un autre bout qui affiche 20.6°C dans un autre coin de l'écran.

Il est impératif que la fonction draw dessine toujours la même chose dans une même boucle.

Pour cela, il faudrait que tu fasses ta mesure AVANT la boucle et que ta fonction draw affiche toujours cette même mesure.

lorrio a écrit:

Je ne suis pas certain que forcer la pin 7 associé à l'écran en OUTPUT soit une bonne idée...

A moins que ce ne soit dans les code d'exemple de l'écran et dans ce cas, ce serait Ok.

Dans les codes d'exemple, c'est 

u8g.begin();

qui se charge d'initialiser les broches, et d'autres trucs, mais cet appel est optionnel pour u8glib contrairement à u8g2. D'ailleurs dans u8g2, il n'y a pas de "picture loop", donc pas de firstPage/nextPage et d'appels multiple à draw par affichage.

Ok parfait tout fonctionne merci !

J'ai juste un petit dernier détaille : la valeur de ma température s'affiche pas correctement, il met : ? C

je vous donne le code :

#include <LiquidCrystal.h>
   #include "U8glib.h"

 //ventilo
  #define VENTILO 4

  //chauffage 
  #define chauff 3

  //dht22
  #include "DHT.h"   // Librairie des capteurs DHT
  #define DHTPIN 2    // Changer le pin sur lequel est branché le DHT
  #define DHTTYPE DHT22      // DHT 22  (AM2302)
  DHT dht(DHTPIN, DHTTYPE);  

  //ecran oled
  U8GLIB_SH1106_128X64 u8g(8, 6, 9, 7); // SW SPI Com: SCK = 0, MOSI = 6, CS = 1, A0 = 7 (new blue HalTec OLED).
  
int draw(float temp) {
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  //u8g.setFont(u8g_font_osb21);
  char buffer[16];
  sprintf(buffer, "%.2f C", temp);
  u8g.drawStr(0, 22, "temperature :");
  u8g.drawStr(0, 45, buffer);
}

void drawnegmore(void){
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "ALED trop froid");
}

void drawneg(void){
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "un peu froid");
}

void drawequ(void){
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "parfa;it");
}

void drawpos(void){
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "un peu chaud");
}

void drawposmore(void){
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "ALED trop chaud");
}

void setup() {
  Serial.begin(9600);

    
  //ventilo
    pinMode ( VENTILO ,  OUTPUT );

  // hauffage
    pinMode ( chauff  ,  OUTPUT );

  //detecteur de température & d'humidité 
    dht.begin();

    //ecran
    pinMode(7, OUTPUT);
    if ( u8g.getMode() == U8G_MODE_R3G3B2 ) {
      u8g.setColorIndex(255);     // white
    }
    else if ( u8g.getMode() == U8G_MODE_GRAY2BIT ) {
      u8g.setColorIndex(3);         // max intensity
    }
    else if ( u8g.getMode() == U8G_MODE_BW ) {
      u8g.setColorIndex(1);         // pixel on
    }
    else if ( u8g.getMode() == U8G_MODE_HICOLOR ) {
      u8g.setHiColorByRGB(255,255,255);
    }

}

void loop() {
    // Délai de 2 secondes entre chaque mesure. La lecture prend 250 millisecondes
  delay(2000);

  // Lecture du taux d'humidité
  float h = dht.readHumidity();
  // Lecture de la température en Celcius
  float t = dht.readTemperature();
  // Pour lire la température en Fahrenheit
  float f = dht.readTemperature(true);
  
  // renvoie un message d'erreur si le capteur ne renvoie aucune mesure
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println("Echec de lecture !");
  }

  // Calcul la température ressentie. Il calcul est effectué à partir de la température en Fahrenheit
  // On fait la conversion en Celcius dans la foulée
  float hi = dht.computeHeatIndex(f, h);
  

  Serial.print("Humidite: "); 
  Serial.print(h);
  Serial.print(" %\t");
  Serial.print("Temperature: "); 
  Serial.print(t);
  Serial.print(" *C ");
  Serial.print("Temperature ressentie: ");
  Serial.print(dht.convertFtoC(hi));
  Serial.println(" *C");

  

  if (t < 23) {
     digitalWrite(chauff, HIGH);
     digitalWrite(VENTILO, LOW);
     Serial.println("cauffage allumé");
     Serial.println("Ventilo eteint car temps < 23"); 
  }

  if (t > 25) {
     digitalWrite(chauff, LOW);
     Serial.println("chauffage eteint");
  }
  if (t > 28) {
     digitalWrite(VENTILO, HIGH);
     Serial.println("ventilo allumé car temps > 28");
  }

  
   // picture loop
  u8g.firstPage();  
  do {
    draw(t);
    if(t<18){
      drawnegmore();
    }
    if (t>=18 && t<22){
      drawneg();
    }
    if (t>=22 && t<=28){
      drawequ();
    }
    if (t>28 && t<= 32){
      drawpos();
    }
    if(t>32){
      drawposmore();
    }
  } while( u8g.nextPage() );

}

Pour des raisons d'optimisation, il semblerait que la gestion des float ai été désactivée dans sprintf sur arduino.

C'est pas totalement ilogique car les calculs sur des float sont assez lourd, et pas vraiment adapté aux petits processeurs.

Tu peux contourner le problème en utilisant des nombres entier avec une virgule fixe.

Par exemple, pour 2 digits après la virgule, il te suffit de faire une multiplication/division/modulo par 100.

// Décomposition :
long int valDP2 = (temp*100.0);    // Nombre entier, multiplié par 100 (exemple: 12.43°C=1243)
int valN = (valDP2/100);           // Partie entière  (exemple: 12.43°C=12)
int valF = (valDP2%100);           // Partie décimale (exemple: 12.43°C=43)
// Formatage
char buffer[16];
sprintf("%2d.%2d *C", buffer, valN, valF);
// Affichage :
...

-
Edité par lorrio 5 juin 2021 à 19:27:22

alors avant il affichait seulement un "?" mais maintenant il affiche "si" le tout dans un rectangle

je vous redonne le code modifié :

#include <LiquidCrystal.h>
   #include "U8glib.h"

 //ventilo
  #define VENTILO 4

  //chauffage 
  #define chauff 3

  //dht22
  #include "DHT.h"   // Librairie des capteurs DHT
  #define DHTPIN 2    // Changer le pin sur lequel est branché le DHT
  #define DHTTYPE DHT22      // DHT 22  (AM2302)
  DHT dht(DHTPIN, DHTTYPE);  

  //ecran oled
  U8GLIB_SH1106_128X64 u8g(8, 6, 9, 7); // SW SPI Com: SCK = 0, MOSI = 6, CS = 1, A0 = 7 (new blue HalTec OLED).
  
int draw(long int valDP2, int valN, int valF) {
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  //u8g.setFont(u8g_font_osb21);



  // Formatage
  char buffer[16];
  sprintf("%2d.%2d *C", buffer, valN, valF);
  
  u8g.drawStr(0, 22, "temperature :");
  u8g.drawStr(0, 45, buffer);
}

void drawnegmore(void){
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "ALED trop froid");
}

void drawneg(void){
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "un peu froid");
}

void drawequ(void){
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "parfa;it");
}

void drawpos(void){
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "un peu chaud");
}

void drawposmore(void){
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "ALED trop chaud");
}

void setup() {
  Serial.begin(9600);

    
  //ventilo
    pinMode ( VENTILO ,  OUTPUT );

  // hauffage
    pinMode ( chauff  ,  OUTPUT );

  //detecteur de température & d'humidité 
    dht.begin();

    //ecran
    pinMode(7, OUTPUT);
    if ( u8g.getMode() == U8G_MODE_R3G3B2 ) {
      u8g.setColorIndex(255);     // white
    }
    else if ( u8g.getMode() == U8G_MODE_GRAY2BIT ) {
      u8g.setColorIndex(3);         // max intensity
    }
    else if ( u8g.getMode() == U8G_MODE_BW ) {
      u8g.setColorIndex(1);         // pixel on
    }
    else if ( u8g.getMode() == U8G_MODE_HICOLOR ) {
      u8g.setHiColorByRGB(255,255,255);
    }

}

void loop() {
    // Délai de 2 secondes entre chaque mesure. La lecture prend 250 millisecondes
  delay(2000);

  // Lecture du taux d'humidité
  float h = dht.readHumidity();
  // Lecture de la température en Celcius
  float t = dht.readTemperature();
  // Pour lire la température en Fahrenheit
  float f = dht.readTemperature(true);
  
  // renvoie un message d'erreur si le capteur ne renvoie aucune mesure
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println("Echec de lecture !");
  }

  // Calcul la température ressentie. Il calcul est effectué à partir de la température en Fahrenheit
  // On fait la conversion en Celcius dans la foulée
  float hi = dht.computeHeatIndex(f, h);
  

  Serial.print("Humidite: "); 
  Serial.print(h);
  Serial.print(" %\t");
  Serial.print("Temperature: "); 
  Serial.print(t);
  Serial.print(" *C ");
  Serial.print("Temperature ressentie: ");
  Serial.print(dht.convertFtoC(hi));
  Serial.println(" *C");

  

  if (t < 23) {
     digitalWrite(chauff, HIGH);
     digitalWrite(VENTILO, LOW);
     Serial.println("cauffage allumé");
     Serial.println("Ventilo eteint car temps < 23"); 
  }

  if (t > 25) {
     digitalWrite(chauff, LOW);
     Serial.println("chauffage eteint");
  }
  if (t > 28) {
     digitalWrite(VENTILO, HIGH);
     Serial.println("ventilo allumé car temps > 28");
  }

long int valDP2 = (t*100.0);    // Nombre entier, multiplié par 100 (exemple: 12.43°C=1243)
  int valN = (valDP2/100);           // Partie entière  (exemple: 12.43°C=12)
  int valF = (valDP2%100);           // Partie décimale (exemple: 12.43°C=43)
  
   // picture loop
  u8g.firstPage();  
  do {
    draw(valDP2, valN, valF);
    if(t<18){
      drawnegmore();
    }
    if (t>=18 && t<22){
      drawneg();
    }
    if (t>=22 && t<=28){
      drawequ();
    }
    if (t>28 && t<= 32){
      drawpos();
    }
    if(t>32){
      drawposmore();
    }
  } while( u8g.nextPage() );

}

Autant pour moi, il manque un zero dans le formatage.

Cela devrait être : sprintf("%02d.%02d *C", buffer, valN, valF);

Tu devrais aussi faire un Serial.print de façon à voir si c'est le buffer qui contient n'importe quoi ou si c'est l'écran qui n'affiche pas correctement la valeur.

Exemple :

int draw(long int valDP2, int valN, int valF) {

	// Formatage
	char buffer[16];
	sprintf("%02d.%02d *C", buffer, valN, valF);

	// Debug
	Serial.print("valN=");
	Serial.prinln(valN);
	Serial.print("valF=");
	Serial.prinln(valF);
	Serial.print("buffer=");
	Serial.prinln(buffer);

	// Affichage
	u8g.setFont(u8g_font_unifont);
	u8g.drawStr(0, 22, "temperature :");
	u8g.drawStr(0, 45, buffer);

}

-
Edité par lorrio 6 juin 2021 à 1:27:29

Malheureusement cela ne marche toujours pas, je te donne l'affiche et le code :

Pour info, tu as oublié les 't' dans println (sauf si tu as fait expres)

#include <LiquidCrystal.h>
   #include "U8glib.h"

 //ventilo
  #define VENTILO 4

  //chauffage 
  #define chauff 3

  //dht22
  #include "DHT.h"   // Librairie des capteurs DHT
  #define DHTPIN 2    // Changer le pin sur lequel est branché le DHT
  #define DHTTYPE DHT22      // DHT 22  (AM2302)
  DHT dht(DHTPIN, DHTTYPE);  

  //ecran oled
  U8GLIB_SH1106_128X64 u8g(8, 6, 9, 7); // SW SPI Com: SCK = 0, MOSI = 6, CS = 1, A0 = 7 (new blue HalTec OLED).
  
int draw(long int valDP2, int valN, int valF) {
 
    // Formatage
    char buffer[16];
    sprintf("%02d.%02d *C", buffer, valN, valF);
 
    // Debug
    Serial.print("valN=");
    Serial.println(valN);
    Serial.print("valF=");
    Serial.println(valF);
    Serial.print("buffer=");
    Serial.println(buffer);
 
    // Affichage
    u8g.setFont(u8g_font_unifont);
    u8g.drawStr(0, 22, "temperature :");
    u8g.drawStr(0, 45, buffer);
 
}

void drawnegmore(void){
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "ALED trop froid");
}

void drawneg(void){
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "un peu froid");
}

void drawequ(void){
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "parfa;it");
}

void drawpos(void){
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "un peu chaud");
}

void drawposmore(void){
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "ALED trop chaud");
}

void setup() {
  Serial.begin(9600);

    
  //ventilo
    pinMode ( VENTILO ,  OUTPUT );

  // hauffage
    pinMode ( chauff  ,  OUTPUT );

  //detecteur de température & d'humidité 
    dht.begin();

    //ecran
    pinMode(7, OUTPUT);
    if ( u8g.getMode() == U8G_MODE_R3G3B2 ) {
      u8g.setColorIndex(255);     // white
    }
    else if ( u8g.getMode() == U8G_MODE_GRAY2BIT ) {
      u8g.setColorIndex(3);         // max intensity
    }
    else if ( u8g.getMode() == U8G_MODE_BW ) {
      u8g.setColorIndex(1);         // pixel on
    }
    else if ( u8g.getMode() == U8G_MODE_HICOLOR ) {
      u8g.setHiColorByRGB(255,255,255);
    }

}

void loop() {
    // Délai de 2 secondes entre chaque mesure. La lecture prend 250 millisecondes
  delay(2000);

  // Lecture du taux d'humidité
  float h = dht.readHumidity();
  // Lecture de la température en Celcius
  float t = dht.readTemperature();
  // Pour lire la température en Fahrenheit
  float f = dht.readTemperature(true);
  
  // renvoie un message d'erreur si le capteur ne renvoie aucune mesure
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println("Echec de lecture !");
  }

  // Calcul la température ressentie. Il calcul est effectué à partir de la température en Fahrenheit
  // On fait la conversion en Celcius dans la foulée
  float hi = dht.computeHeatIndex(f, h);
  

  Serial.print("Humidite: "); 
  Serial.print(h);
  Serial.print(" %\t");
  Serial.print("Temperature: "); 
  Serial.print(t);
  Serial.print(" *C ");
  Serial.print("Temperature ressentie: ");
  Serial.print(dht.convertFtoC(hi));
  Serial.println(" *C");

  

  if (t < 23) {
     digitalWrite(chauff, HIGH);
     digitalWrite(VENTILO, LOW);
     Serial.println("cauffage allumé");
     Serial.println("Ventilo eteint car temps < 23"); 
  }

  if (t > 25) {
     digitalWrite(chauff, LOW);
     Serial.println("chauffage eteint");
  }
  if (t > 28) {
     digitalWrite(VENTILO, HIGH);
     Serial.println("ventilo allumé car temps > 28");
  }

  long int valDP2 = (t*100.0);    // Nombre entier, multiplié par 100 (exemple: 12.43°C=1243)
  int valN = (valDP2/100);           // Partie entière  (exemple: 12.43°C=12)
  int valF = (valDP2%100);           // Partie décimale (exemple: 12.43°C=43)
   // picture loop
  u8g.firstPage();  
  do {
    draw(valDP2, valN, valF);
    if(t<18){
      drawnegmore();
    }
    if (t>=18 && t<22){
      drawneg();
    }
    if (t>=22 && t<=28){
      drawequ();
    }
    if (t>28 && t<= 32){
      drawpos();
    }
    if(t>32){
      drawposmore();
    }
  } while( u8g.nextPage() );

}

Pour l'affichage de l'écran, maintenant ça affiche DC2 dans un rectangle

-
Edité par IteWaseMi 6 juin 2021 à 12:55:20

C'est étonnant que le compilateur ne t'es pas donné une erreur de const correctness là.

J'ai inversé le chaine de buffer et la chaine du format dans les argument du sprintf du code que je t'ai proposé.

Il te faut mettre : sprintf(buffer, "%02d.%02d *C", valN, valF);

A la place de : sprintf("%02d.%02d *C", buffer, valN, valF);

-
Edité par lorrio 6 juin 2021 à 19:16:16

Alors la plus rien ne d'affiche Enfin la température ne s'affcuhe plus, je t'envoie le code :

#include <LiquidCrystal.h>
   #include "U8glib.h"
 
 //ventilo
  #define VENTILO 4
 
  //chauffage
  #define chauff 3
 
  //dht22
  #include "DHT.h"   // Librairie des capteurs DHT
  #define DHTPIN 2    // Changer le pin sur lequel est branché le DHT
  #define DHTTYPE DHT22      // DHT 22  (AM2302)
  DHT dht(DHTPIN, DHTTYPE); 
 
  //ecran oled
  U8GLIB_SH1106_128X64 u8g(8, 6, 9, 7); // SW SPI Com: SCK = 0, MOSI = 6, CS = 1, A0 = 7 (new blue HalTec OLED).
   
int draw(long int valDP2, int valN, int valF) {
  
    // Formatage
    char buffer[16];
    sprintf(buffer, "%02d.%02d *C", valN, valF);
  
    // Debug
    Serial.print("valN=");
    Serial.println(valN);
    Serial.print("valF=");
    Serial.println(valF);
    Serial.print("buffer=");
    Serial.println(buffer);
  
    // Affichage
    u8g.setFont(u8g_font_unifont);
    u8g.drawStr(0, 22, "temperature :");
    u8g.drawStr(0, 45, buffer);
  
}
 
void drawnegmore(void){
  // graphic commands to redraw the complete screen should be placed here 
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "ALED trop froid");
}
 
void drawneg(void){
  // graphic commands to redraw the complete screen should be placed here 
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "un peu froid");
}
 
void drawequ(void){
  // graphic commands to redraw the complete screen should be placed here 
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "parfa;it");
}
 
void drawpos(void){
  // graphic commands to redraw the complete screen should be placed here 
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "un peu chaud");
}
 
void drawposmore(void){
  // graphic commands to redraw the complete screen should be placed here 
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr(0, 60, "ALED trop chaud");
}
 
void setup() {
  Serial.begin(9600);
 
     
  //ventilo
    pinMode ( VENTILO ,  OUTPUT );
 
  // hauffage
    pinMode ( chauff  ,  OUTPUT );
 
  //detecteur de température & d'humidité
    dht.begin();
 
    //ecran
    pinMode(7, OUTPUT);
    if ( u8g.getMode() == U8G_MODE_R3G3B2 ) {
      u8g.setColorIndex(255);     // white
    }
    else if ( u8g.getMode() == U8G_MODE_GRAY2BIT ) {
      u8g.setColorIndex(3);         // max intensity
    }
    else if ( u8g.getMode() == U8G_MODE_BW ) {
      u8g.setColorIndex(1);         // pixel on
    }
    else if ( u8g.getMode() == U8G_MODE_HICOLOR ) {
      u8g.setHiColorByRGB(255,255,255);
    }
 
}
 
void loop() {
    // Délai de 2 secondes entre chaque mesure. La lecture prend 250 millisecondes
  delay(2000);
 
  // Lecture du taux d'humidité
  float h = dht.readHumidity();
  // Lecture de la température en Celcius
  float t = dht.readTemperature();
  // Pour lire la température en Fahrenheit
  float f = dht.readTemperature(true);
   
  // renvoie un message d'erreur si le capteur ne renvoie aucune mesure
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println("Echec de lecture !");
    digitalWrite(VENTILO, LOW);
    digitalWrite(chauff, LOW);
  }
  else {
    long int valDP2 = (t*100.0);    // Nombre entier, multiplié par 100 (exemple: 12.43°C=1243)
    int valN = (valDP2/100);           // Partie entière  (exemple: 12.43°C=12)
    int valF = (valDP2%100);           // Partie décimale (exemple: 12.43°C=43)

    // Calcul la température ressentie. Il calcul est effectué à partir de la température en Fahrenheit
    // On fait la conversion en Celcius dans la foulée
    float hi = dht.computeHeatIndex(f, h);
     
   
    Serial.print("Humidite: ");
    Serial.print(h);
    Serial.print(" %\t");
    Serial.print("Temperature: ");
    Serial.print(t);
    Serial.print(" *C ");
    Serial.print("Temperature ressentie: ");
    Serial.print(dht.convertFtoC(hi));
    Serial.println(" *C");
   
     
   
    if (t < 23) {
       digitalWrite(chauff, HIGH);
       digitalWrite(VENTILO, LOW);
       Serial.println("cauffage allumé");
       Serial.println("Ventilo eteint car temps < 23");
    }
   
    if (t > 25) {
       digitalWrite(chauff, LOW);
       Serial.println("chauffage eteint");
    }
    if (t > 28) {
       digitalWrite(VENTILO, HIGH);
       Serial.println("ventilo allumé car temps > 28");
    }
   
    
     // picture loop
    u8g.firstPage(); 
    do {
      draw(valDP2, valN, valF);
      if(t<18){
        drawnegmore();
      }
      if (t>=18 && t<22){
        drawneg();
      }
      if (t>=22 && t<=28){
        drawequ();
      }
      if (t>28 && t<= 32){
        drawpos();
      }
      if(t>32){
        drawposmore();
      }
    } while( u8g.nextPage() );
    }
 
  
 
}

Ce serait bien de nous envoyer aussi ce que tu vois d'écrit dans la console.

Si il n'y a strictement rien d'écrit, il faut se poser la question : "est-ce que l'arduino fonctionne réellement ?"

Théoriquement, ton code doit forcément afficher quelque chose, même si le capteur est mal cablé, tu devrais au moins voir "Echec de lecture !" dans la console arduino.

je te donne le message de la console au cas ou mais je suis un peu deg x)