Partage
  • Partager sur Facebook
  • Partager sur Twitter

A l'aide pour mon vma437 (ecran oled)

    7 mai 2021 à 18:52:40

    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

    • Partager sur Facebook
    • Partager sur Twitter
      8 mai 2021 à 11:52:38

      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

      • Partager sur Facebook
      • Partager sur Twitter
        8 mai 2021 à 13:02:20

        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

        • Partager sur Facebook
        • Partager sur Twitter
          8 mai 2021 à 17:17:00

          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

          • Partager sur Facebook
          • Partager sur Twitter
            8 mai 2021 à 18:30:47

            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

            • Partager sur Facebook
            • Partager sur Twitter
              8 mai 2021 à 20:11:12

              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

              • Partager sur Facebook
              • Partager sur Twitter
                8 mai 2021 à 20:44:18

                "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

                • Partager sur Facebook
                • Partager sur Twitter
                  9 mai 2021 à 0:11:46

                  Il faudrait que tu nous montres ton code pour que l'on puisse voir où se situe l'erreur ;)
                  • Partager sur Facebook
                  • Partager sur Twitter
                    9 mai 2021 à 10:11:58

                    #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() );
                     
                    }

                    le vrai est code est assez long, je te l'envoie quand meme :
                    #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

                    • Partager sur Facebook
                    • Partager sur Twitter
                      9 mai 2021 à 22:03:35

                      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.

                      • Partager sur Facebook
                      • Partager sur Twitter
                        10 mai 2021 à 12:29:11

                        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.

                        • Partager sur Facebook
                        • Partager sur Twitter
                          5 juin 2021 à 14:43:27

                          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() );
                          
                          }



                          • Partager sur Facebook
                          • Partager sur Twitter
                            5 juin 2021 à 19:26:14

                            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

                            • Partager sur Facebook
                            • Partager sur Twitter
                              5 juin 2021 à 19:51:32

                              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() );
                              
                              }



                              • Partager sur Facebook
                              • Partager sur Twitter
                                6 juin 2021 à 1:27:16

                                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

                                • Partager sur Facebook
                                • Partager sur Twitter
                                  6 juin 2021 à 12:54:25

                                  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

                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    6 juin 2021 à 19:14:45

                                    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

                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      10 juin 2021 à 20:19:15

                                      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() );
                                          }
                                       
                                        
                                       
                                      }



                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        10 juin 2021 à 22:11:05

                                        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.

                                        • Partager sur Facebook
                                        • Partager sur Twitter

                                        A l'aide pour mon vma437 (ecran oled)

                                        × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                        • Editeur
                                        • Markdown