compilation ARDUINO MEGA2560 ET ARDUINO DUE

Bonjour,

est il possible qu'une compilation soit bonne pour un arduino MEGA2560 et pas bonne pour un arduino DUE?
Car j'ai fait tout mon code sur 1.8.5 pour mon arduino MEGA2560 avec un ecran 7" et ca fonctionne et j'aurais voulu l'essayer sur mon arduino DUE

je met mon fichier INO en copie c'est pour la gestion d'une VMC et d'un PUIT CANADIEN.

merci la communauté

voici le code :slight_smile:

1.ino (18.5 KB)

voici la photo de l ecran :slight_smile:

est il possible qu'une compilation soit bonne pour un arduino MEGA2560 et pas bonne pour un arduino DUE?

La mega utilise un micro 8 bits d'architecture avr
La DUE utilise un micro 32 bits d'architecture ARM cortex M3

Ces deux phrases résument la difficulté.
Dans les deux cas les fonctions ou les classes portent le même nom mais leur code est différent.

Ce qu'on peut dire c'est que si les développeurs n'ont pas fait d'erreur cela ne devrait pas se produire , mais qui est infaillible ?
Et aussi il possible que des fonctions très spécifiques à une architecture ne soit pas transposable à 100 % dans une autre.

Tu es dans les limites de l' "universalité" d'arduino. Universalité qui est comme une asymptote en mathématique: on s'en approche de plus en plus sans jamais pouvoir l'atteindre.

Le code source de certaines classes sont totalement différentes entre le Due et le Mega
Notamment les classes Serial

Dans un de mes projets j'ai créé une classe perso qui avait pour but d'utiliser Serial Serial1 et Serial2 (communication avec le serial monitor, un afficheur Nextion et une autre carte Arduino)

Le code initial a été developpé pour une Mega. Mais avec pour objectif de remplacer la Mega par une Due. La Mega manquant de Ram et de vitesse pour le projet final.

Le code developpé pour la Mega se compilait et fonctionnait.
Quand j'ai changé la carte cible dans l'IDE, le code ne compilait plus et j'ai du redevelopper toute ma classe de communication

donc le probleme viens que de la classe serial!

mon code et beaucoup de morceau de copier coller de different tuto pour faire marcher mes capteurs divers donc je ne maitraise pas beaucoup l'arduino, est ce que dans mon code cela represente beaucoup de chose a changer?
je pense qu'un oeil averti pourrai me dire ca en 10secondes.peut on me guider sur les lignes a modifier?
je recherche deja des tuto sur les classe serial pour voir si je peut arriver a modifier cela mais on ne trouve pas beaucoup d'example de compilation avec une DUE donc ca va etre compliqué.
c'est bien dommage j'avais bien avancer!j'etais comptant de moi en sachant que c'est le premier post d'aide que j'ecris.

merci

pffff c’est pas gagner, on trouve pas beaucoup d’info exploitable a mon niveau de programmation sur la classe serial DUE/MEGA.

google est mon ami(ou mon pire ennemi, je sais plus!)

Je n'arrive pas à charger ton code du fait de son nom, mets-le entre balises.

Je doute que ton code réécrive la classe Serial, donc il n'y a pas de raison pour qu'une ligne du type Seria.print(...) ne compile pas pour un DUE. Les problèmes viennent certainement d'ailleurs, par exemple ton code Méga utilise le nom de registres du 328p.

Bonjour,

ard_newbie:
Je doute que ton code réécrive la classe Serial, donc il n'y a pas de raison pour qu'une ligne du type Seria.print(...) ne compile pas pour un DUE.

Je confirme: Serial.print sur une Mega ou sur une Due, c'est complètement transparent. Le problème n'est pas là.
D'ailleurs, quel est le problème ? Ca ne compile pas ou bien tu t'amuses à te faire peur par avance ? :wink:

non je confirme ca compile pas et ca televerse pas

je met le code en plusieur partie car trop long

//*********************************************************************//
//  Nom  : lcd 7pouces vmc et puit canadien                            //
//  Autheur  : Dirig Gael                                              //
//  Date    : 15 may, 2018                                             //
//  Version : 1.0                                                      //
//  Notes   :                                                          //
//          :                                                          //
//*********************************************************************//
//REMETRE DHT4 SUR LES BON LGNE
//REMETTTRE LES BONNE ADRESSE BYTE DES DS18B20





/****************/
/* Déclarations */
/****************/

/** DHT22Broche "DATA" du capteur */
const byte DHT1 = 3;
const byte DHT2 = 4;
const byte DHT3 = 5;
const byte DHT4 = 6;
const byte DHT5 = 7;

//const byte BROCHE_CAPTEURSALLE = 5;
/* Code d'erreur de la fonction readDHT11() et readDHT22() */
const byte DHT_SUCCESS = 0;        // Pas d'erreur
const byte DHT_TIMEOUT_ERROR = 1;  // Temps d'attente dépassé
const byte DHT_CHECKSUM_ERROR = 2; // Données reçues erronées
//const byte DHT_SUCCESSSALLE = 0;        // Pas d'erreur
//const byte DHT_TIMEOUT_ERRORSALLE = 1;  // Temps d'attente dépassé
//const byte DHT_CHECKSUM_ERRORSALLE = 2; // Données reçues erronées





#include <OneWire.h> //LIBRAIRIE ONEWIRE
OneWire ds(2); //Bus One Wire sur la pin 2 de l'arduino

#include <UTFT.h> //LIBRAIRIE DE L ECRAN TFT 7 POUCES
UTFT myGLCD(TFT01_70,38,39,40,41); // Ecran TFT LCD7 pouces

extern uint8_t SmallFont[];//LIBRAIRIE UTFT
extern uint8_t BigFont[];// LIBRAIRIE UTFT
extern uint8_t SevenSegNumFont[];//LIBRAIRIE UTFT
extern uint8_t SevenSegmentFull[];//LIBRAIRIE A METTRE DANS DOSSIER
extern uint8_t Grotesk24x48[];//LIBRAIRIE A METTRE DANS DOSSIER
extern uint8_t SixteenSegment64x96Num[];//LIBRAIRIE A METTRE DANS DOSSIER
extern uint8_t GroteskBold32x64[];//LIBRAIRIE A METTRE DANS DOSSIER
extern uint8_t hallfetica_normal[];//LIBRAIRIE A METTRE DANS DOSSIER
extern uint8_t Inconsola[];//LIBRAIRIE A METTRE DANS DOSSIER

byte addr1[8] = {0x28, 0xFF, 0x50, 0x18, 0x86, 0x16, 0x04, 0x6D};//ADRESSE DES DIFFERENT DS18B20
byte addr2[8] = {0x28, 0xFF, 0xBD, 0xD9, 0x86, 0x16, 0x05, 0xB3};
byte addr3[8] = {0x28, 0xFF, 0x4B, 0xF2, 0x86, 0x16, 0x05, 0x6D};
byte addr4[8] = {0x28, 0xFF, 0x50, 0x18, 0x86, 0x16, 0x04, 0x6D};
byte addr5[8] = {0x28, 0xFF, 0x50, 0x18, 0x86, 0x16, 0x04, 0x6D};
byte addr6[8] = {0x28, 0xFF, 0x50, 0x18, 0x86, 0x16, 0x04, 0x6D};
byte addr7[8] = {0x28, 0xFF, 0x50, 0x18, 0x86, 0x16, 0x04, 0x6D};
byte addr8[8] = {0x28, 0xFF, 0x50, 0x18, 0x86, 0x16, 0x04, 0x6D};

int SignBit = 0;
int RendementVmc;
int RendementGlobal;
int RendementPuit;


int pinmoteur = 12;
void setup()
{
  
  pinMode(12, OUTPUT);//mise sortie de la broche pwm du variateur
  
  
 Serial.begin(9600); //Permet la communication en serial
 
 Serial.println(F("Demo DHT11 et DHT22")); // DHT22
 pinMode(DHT1, INPUT_PULLUP);/* DHT22 Place la broche du capteur en entrée avec pull-up */
 //pinMode(BROCHE_CAPTEURSALLE, INPUT_PULLUP);/* DHT22 Place la broche du capteur en entrée avec pull-up */
   
  myGLCD.InitLCD(0);
  myGLCD.clrScr();
  myGLCD.setColor(255, 255, 255);//couleur des fils, rectangle
   myGLCD.fillScr(10, 10, 10);// couleur fond d ecran
  myGLCD.setBackColor(10, 10, 10);//couleur de fond de texte 
  }
  int tc_100(byte* addr){
int HighByte, LowByte, TReading;
byte data[12];
byte i;
 
ds.reset();
ds.select(addr);
ds.write(0x44,1); // start conversion, with parasite power on at the end
 
delay(1000); // maybe 750ms is enough, maybe not
// we might do a ds.depower() here, but the reset will take care of it.
 
ds.reset();
ds.select(addr);
ds.write(0xBE); // Read Scratchpad
 
for ( i = 0; i < 9; i++) { // we need 9 bytes
data[i] = ds.read();
}
LowByte = data[0];
HighByte = data[1];
TReading = (HighByte << 8) + LowByte;
SignBit = TReading & 0x8000; // test most sig bit
if (SignBit) // negative
{
TReading = (TReading ^ 0xffff) + 1; // 2's comp
}
return (6 * TReading) + TReading / 4; // multiply by (100 * 0.0625) or 6.25
}
 
void mypr(int Tc_100) {
int Whole, Fract;
 
Whole = Tc_100 / 100; // separate off the whole and fractional portions
Fract = Tc_100 % 100;
 
if (SignBit) // If its negative
{
Serial.print("-");
}
Serial.print(Whole);
Serial.print(".");
if (Fract < 10)
{
Serial.print("0");
}
Serial.print(Fract);
 
Serial.print("\n");
  
  
  
  
  
  myGLCD.drawRect(5,5,475,795);
  myGLCD.drawRect(4,4,476,796);

  
  
  myGLCD.drawLine(5,50,475,50);
  myGLCD.drawLine(5,170,475,170);
 myGLCD.drawLine(240,267,240,50);
 myGLCD.drawLine(5,80,475,80);
 myGLCD.drawLine(5,231,475,231);
 myGLCD.drawLine(5,267,475,267);
 myGLCD.drawLine(5,360,475,360);
 myGLCD.drawLine(5,453,475,453);
  myGLCD.drawLine(5,546,475,546);
  
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(BigFont);
  myGLCD.print("Gestion VMC et Puit Cannadien", CENTER, 10);
  
  myGLCD.setColor(VGA_WHITE);
  myGLCD.setFont(SmallFont);
  myGLCD.print("Developpe by Gael DIRIG  -  V 1.0", CENTER, 30);
    
  myGLCD.setFont(BigFont);
  myGLCD.print("VMC", 100, 57, 0);
  myGLCD.print("PUIT CANADIEN", 250, 57, 0);

  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(BigFont);
  myGLCD.print("%", 170, 100);
  
  myGLCD.setFont(BigFont);
  myGLCD.print("%", 400, 100);
  
  myGLCD.setColor(VGA_WHITE);
  myGLCD.setFont(SmallFont);
  myGLCD.print("Rendement ", 10, 90, 0);
  myGLCD.print("Rendement ", 245, 90, 0);
  
  myGLCD.setColor(VGA_WHITE);
  myGLCD.setFont(SmallFont);
  myGLCD.print("Temperature echangeur", 10, 180);
  myGLCD.print("Temperature echangeur", 245, 180);
  
   myGLCD.setColor(VGA_WHITE);
  myGLCD.setFont(SmallFont);
  myGLCD.print("Extrait:", 10, 205);
  myGLCD.print("Insuffle:", 122, 205);
  myGLCD.print("Entree:", 245, 205); 
  myGLCD.print("Sortie:", 364, 205); 
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(BigFont);
  myGLCD.setFont(hallfetica_normal);
  myGLCD.print("`", 103, 202); 
  myGLCD.print("`", 224, 202);
  myGLCD.print("`", 329, 202);
  myGLCD.print("`", 450, 202);
  
   
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(BigFont);
  myGLCD.print("ON", 90, 241); 
  myGLCD.setColor(VGA_RED);
  myGLCD.print("OFF", 325, 241);
  
  myGLCD.setColor(VGA_WHITE);
  myGLCD.setFont(BigFont);
  myGLCD.print("EXTERIEURE", CENTER, 277);
  
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(GroteskBold32x64);
  myGLCD.print(",", 92, 295);
      
  myGLCD.setFont(SmallFont);
  myGLCD.print("O", 165, 300);
  myGLCD.setFont(BigFont);
  myGLCD.print("C", 175, 300);
  //myGLCD.setFont(SevenSegNumFont);
  //myGLCD.print("64", 330, 304, 0);
  myGLCD.setFont(BigFont);
  myGLCD.print("%", 400, 304);
  
  myGLCD.setColor(VGA_WHITE);
  myGLCD.setFont(BigFont);
  myGLCD.print("SALLE A MANGER", CENTER, 370);
  
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(GroteskBold32x64);
  myGLCD.print(",", 92, 388);
    
  myGLCD.setFont(SmallFont);
  myGLCD.print("O", 165, 393);
  myGLCD.setFont(BigFont);
  myGLCD.print("C", 175, 393);
 // myGLCD.setFont(SevenSegNumFont);
  //myGLCD.print("44", 330, 399, 0);
  myGLCD.setFont(BigFont);
  myGLCD.print("%", 400, 399);
  myGLCD.setColor(VGA_FUCHSIA);
  
  
   myGLCD.setColor(VGA_WHITE);
  myGLCD.setFont(BigFont);
  myGLCD.print("CHAMBRES", CENTER, 460);
  
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(GroteskBold32x64);
  myGLCD.print(",", 92, 478);
     
  myGLCD.setFont(SmallFont);
  myGLCD.print("O", 165, 486);
  myGLCD.setFont(BigFont);
  myGLCD.print("C", 175, 486);
 
  myGLCD.setFont(BigFont);
  myGLCD.print("%", 400, 489);
  myGLCD.setColor(VGA_FUCHSIA);
   
  myGLCD.setColor(VGA_WHITE);
  myGLCD.setFont(SmallFont);
  myGLCD.print("CONSOMATION:", CENTER, 556);
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(Grotesk24x48);
  myGLCD.print("15W", CENTER, 580);
    
  myGLCD.setColor(VGA_WHITE);
  myGLCD.setFont(SmallFont);
  myGLCD.print("Changement des filtres G4 et F7", 10, 650);
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(BigFont);
  myGLCD.print("NON", 380, 650);
  
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(Grotesk24x48);
  myGLCD.print("Rendement", 10, 680);
  myGLCD.print("Global", 10, 740);
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(BigFont);
  myGLCD.print("%", 400, 690);
  
  }
void loop()
{
  
  //DS18B20
  byte i;
byte data[12];
int Tc_1001;//temperature air extrait vmc
int Tc_1002;//temperature air insufle vmc
int Tc_1003;//temperature d entree eau puit canadien
int Tc_1004;//temperature de sortie d'air puit canadien
int Tc_1005;//temperature air exterieur
int Tc_1006;//temperature d'air salle a manger
int Tc_1007;//temperature d'air chambres

 
 Tc_1001 = tc_100(addr1);
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(BigFont);
  myGLCD.printNumI((Tc_1001)/100, 74, 202);
Serial.print("Air extrait: ");
mypr(Tc_1001);

 
 Tc_1002 = tc_100(addr2);
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(BigFont);
  myGLCD.printNumI((Tc_1002)/100, 192, 202);
Serial.print("Air insufle: ");
mypr(Tc_1002);
 
Tc_1003 = tc_100(addr3);
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(BigFont);
  myGLCD.printNumI((Tc_1003)/100, 300, 202);
  Serial.print("Entree d'eau puit canadien: ");
mypr(Tc_1003);

int RendementVmc = Tc_1002/((Tc_1001)/100);
int RendementGlobal = (Tc_1002/((Tc_1001)/100))+3;
int RendementPuit = (Tc_1004/100)/Tc_1003;

Tc_1004 = tc_100(addr4);
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(BigFont);
  myGLCD.printNumI((Tc_1004)/100, 418, 202);
 Serial.print("Sortie d'air puit canadien: ");
mypr(Tc_1004);


myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(SevenSegNumFont);
  myGLCD.printNumI((RendementVmc), 100, 100);
  Serial.print("Rendement Vmc: ");
  mypr(RendementVmc*100);
  
myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(SevenSegNumFont);
  myGLCD.printNumI((RendementPuit), 304, 100);
  Serial.print("Rendement puit canadien: "); 
  mypr(RendementPuit*100);
  
myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(SixteenSegment64x96Num);
  myGLCD.printNumI((RendementGlobal), 260, 690); 
  Serial.print("Rendement Global: ");
  mypr(RendementGlobal*100);
  
  

Tc_1005 = tc_100(addr1);
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(GroteskBold32x64);
  myGLCD.printNumI((Tc_1005)/100, 31, 295);
  myGLCD.printNumI((((Tc_1005)%100)/10), 120, 295);
Serial.print("Temperature Exterieur: ");
mypr(Tc_1005);
 
 Tc_1006 = tc_100(addr2);
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(GroteskBold32x64);
  myGLCD.printNumI((Tc_1006)/100, 31, 388);
  myGLCD.printNumI((((Tc_1006)%100)/10), 120, 388);
Serial.print("Temperature salle a manger: ");
mypr(Tc_1006);
 
Tc_1007 = tc_100(addr3);
  myGLCD.setColor(VGA_LIME);
  myGLCD.setFont(GroteskBold32x64);
  myGLCD.printNumI((Tc_1007)/100, 31, 478);
  myGLCD.printNumI((( (Tc_1007)%100)/10), 120, 478);
Serial.print("Temperature chambres: ");
mypr(Tc_1007);

 
 
 //DHT22 

 float tempext, humext; 
 float tempsalle, humsalle; 
 float tempchambre, humchambre; 
 float tempwc1, humwc1; 
 float tempwc2, humwc2;
 
  //1 Lecture exterieur de la température et de l'humidité, avec gestion des erreurs
    switch (readDHT22(DHT3, &tempext, &humext)) {
  case DHT_SUCCESS: 
     
    // Affichage de la température et du taux d'humidité 
    Serial.print(F("Humidite exterieur (%): "));
    Serial.println(humext, 2);
        myGLCD.setColor(VGA_LIME);
    myGLCD.setFont(SevenSegNumFont);
    myGLCD.printNumI((humext), 330, 305, 0);


    break;
 
  case DHT_TIMEOUT_ERROR: 
    Serial.println(F("Pas de reponse exterieur!")); 
    break;
 
  case DHT_CHECKSUM_ERROR: 
    Serial.println(F("Pb de communication exterieur!")); 
    break;
  }
  delay(1000);



//2 Lecture salle a manger de la température et de l'humidité, avec gestion des erreurs
switch (readDHT22(DHT3, &tempsalle, &humsalle)) {
  case DHT_SUCCESS: 
     
    // Affichage de la température et du taux d'humidité 
    Serial.print(F("Humidite salle à manger(%): "));
    Serial.println(humsalle, 2);
        myGLCD.setColor(VGA_LIME);
    myGLCD.setFont(SevenSegNumFont);
    myGLCD.printNumI((humsalle), 330, 397, 0);
          if((((35<= humsalle )&&(humsalle <=55))&&(((Tc_1006)/100)<=20))  || (((35<= humsalle )&&(humsalle <=66))&&((((Tc_1006)/100)<=23)&&(((Tc_1006)/100)>20))) || (((40<= humsalle )&&(humsalle <=70))&&(((Tc_1006)/100)>23))) 
{
  myGLCD.setColor(VGA_FUCHSIA);
  myGLCD.setFont(BigFont);
  myGLCD.print("CONFORT", 195, 426);
}
else
{
  myGLCD.setColor(VGA_RED);
  myGLCD.setFont(BigFont);
  myGLCD.print("INCONFORT", 170, 426);
}
    break;
 
  case DHT_TIMEOUT_ERROR: 
    Serial.println(F("Pas de reponse salle à manger!")); 
    break;
 
  case DHT_CHECKSUM_ERROR: 
    Serial.println(F("Pb de communication salle à manger!")); 
    break;
  }
  delay(1000);
  
  
//3 Lecture chambre de la température et de l'humidité, avec gestion des erreurs
 switch (readDHT22(DHT3, &tempchambre, &humchambre)) {
  case DHT_SUCCESS: 
     
    // Affichage de la température et du taux d'humidité 
    Serial.print(F("Humidite chambre (%): "));
    Serial.println(humchambre, 2);
        myGLCD.setColor(VGA_LIME);
    myGLCD.setFont(SevenSegNumFont);
    myGLCD.printNumI((humchambre), 330, 489, 0);
       if((((35<= humchambre )&&(humchambre <=55))&&(((Tc_1007)/100)<=20))  || (((35<= humchambre )&&(humchambre <=65))&&((((Tc_1007)/100)<=23)&&(((Tc_1007)/100)>20))) || (((40<= humchambre )&&(humchambre <=70))&&(((Tc_1007)/100)>23))) 
{
  myGLCD.setColor(VGA_FUCHSIA);
  myGLCD.setFont(BigFont);
  myGLCD.print("CONFORT", 195, 519);
}
else
{
  myGLCD.setColor(VGA_RED);
  myGLCD.setFont(BigFont);
  myGLCD.print("INCONFORT", 170, 519);
}
    break;
 
  case DHT_TIMEOUT_ERROR: 
    Serial.println(F("Pas de reponse chambre!")); 
    break;
 
  case DHT_CHECKSUM_ERROR: 
    Serial.println(F("Pb de communication chambre!")); 
    break;
  }
  delay(1000);



//4 Lecture wc1 de la température et de l'humidité, avec gestion des erreurs
switch (readDHT22(DHT4, &tempwc1, &humwc1)) {
  case DHT_SUCCESS: 
     
    // Affichage de la température et du taux d'humidité 
    Serial.print(F("Humidite wc1 (%): "));
    Serial.println(humwc1, 2);
        myGLCD.setColor(VGA_LIME);            

      if (humwc1 >70 )
{
  analogWrite(pinmoteur, 255);
 
}

     if ((humwc1 >65 && humwc1 >=70) || (humwc2 >65 && humwc2 >=70))
{
  analogWrite(pinmoteur, 200);
}

     if ((humwc1 >60 && humwc1 >=65) || (humwc2 >60 && humwc2 >=65))
{
  analogWrite(pinmoteur, 120);
}

     if ((humwc1 >55 && humwc1 >=60) || (humwc2 >55 && humwc2 >=60))
{
  analogWrite(pinmoteur, 60);
}

else
{
  analogWrite(pinmoteur, 0);
}
break;
 
  case DHT_TIMEOUT_ERROR: 
    Serial.println(F("Pas de reponse wc brigitte!")); 
    break;
 
  case DHT_CHECKSUM_ERROR: 
    Serial.println(F("Pb de communication wc brigitte!")); 
    break;
  }
  delay(1000);


//5 Lecture wc2 de la température et de l'humidité, avec gestion des erreurs
switch (readDHT22(DHT5, &tempwc2, &humwc2)) {
  case DHT_SUCCESS: 
     
    // Affichage de la température et du taux d'humidité 
    Serial.print(F("Humidite wc2 (%): "));
    Serial.println(humwc2, 2);
        myGLCD.setColor(VGA_LIME);
          if (humwc2 >55)
{
  
}
else
{
  
}
    break;
 
  case DHT_TIMEOUT_ERROR: 
    Serial.println(F("Pas de reponse wc invite!")); 
    break;
 
  case DHT_CHECKSUM_ERROR: 
    Serial.println(F("Pb de communication wc invite!")); 
    break;
  }
  delay(1000);


}

byte readDHT22(byte pin, float* tempext, float* humext) {
  
  /* Lit le capteur */
  byte data[5];
  byte ret = readDHTxx(pin, data, 1, 1000);
  
  /* Détecte et retourne les erreurs de communication */
  if (ret != DHT_SUCCESS) 
    return ret;
    
  /* Calcul la vraie valeur de la température et de l'humidité */
  float fh = data[0];
  fh *= 256;
  fh += data[1];
  fh *= 0.1;
  *humext = fh;
 
  return DHT_SUCCESS;
 }

/**
 * Fonction bas niveau permettant de lire la température et le taux d'humidité (en valeurs brutes) mesuré par un capteur DHTxx.
 */
byte readDHTxx(byte pin, byte* data, unsigned long start_time, unsigned long timeout) {
  data[0] = data[1] = data[2] = data[3] = data[4] = 0;
  // start_time est en millisecondes
  // timeout est en microsecondes
 
  /* Conversion du numéro de broche Arduino en ports / masque binaire "bas niveau" */
  uint8_t bit = digitalPinToBitMask(pin);
  uint8_t port = digitalPinToPort(pin);
  volatile uint8_t *ddr = portModeRegister(port);   // Registre MODE (INPUT / OUTPUT)
  volatile uint8_t *out = portOutputRegister(port); // Registre OUT (écriture)
  volatile uint8_t *in = portInputRegister(port);   // Registre IN (lecture)
  
  /* Conversion du temps de timeout en nombre de cycles processeur */
  unsigned long max_cycles = microsecondsToClockCycles(timeout);
 
  /* Evite les problèmes de pull-up */
  *out |= bit;  // PULLUP
  *ddr &= ~bit; // INPUT
  delay(100);   // Laisse le temps à la résistance de pullup de mettre la ligne de données à HIGH
 
  /* Réveil du capteur */
  *ddr |= bit;  // OUTPUT
  *out &= ~bit; // LOW
  delay(start_time); // Temps d'attente à LOW causant le réveil du capteur
  // N.B. Il est impossible d'utilise delayMicroseconds() ici car un délai
  // de plus de 16 millisecondes ne donne pas un timing assez précis.
  
  /* Portion de code critique - pas d'interruptions possibles */
  noInterrupts();
  
  /* Passage en écoute */
  *out |= bit;  // PULLUP
  delayMicroseconds(40);
  *ddr &= ~bit; // INPUT
 
  /* Attente de la réponse du capteur */
  timeout = 0;
  while(!(*in & bit)) { /* Attente d'un état LOW */
    if (++timeout == max_cycles) {
        interrupts();
        return DHT_TIMEOUT_ERROR;
      }
  }
    
  timeout = 0;
  while(*in & bit) { /* Attente d'un état HIGH */
    if (++timeout == max_cycles) {
        interrupts();
        return DHT_TIMEOUT_ERROR;
      }
  }

  /* Lecture des données du capteur (40 bits) */
  for (byte i = 0; i < 40; ++i) {
 
    /* Attente d'un état LOW */
    unsigned long cycles_low = 0;
    while(!(*in & bit)) {
      if (++cycles_low == max_cycles) {
        interrupts();
        return DHT_TIMEOUT_ERROR;
      }
    }

    /* Attente d'un état HIGH */
    unsigned long cycles_high = 0;
    while(*in & bit) {
      if (++cycles_high == max_cycles) {
        interrupts();
        return DHT_TIMEOUT_ERROR;
      }
    }
    
    /* Si le temps haut est supérieur au temps bas c'est un "1", sinon c'est un "0" */
    data[i / 8] <<= 1;
    if (cycles_high > cycles_low) {
      data[i / 8] |= 1;
    }
  }
  
  /* Fin de la portion de code critique */
  interrupts();
 
  /*
   * Format des données :
   * [1, 0] = humidité en %
   * [3, 2] = température en degrés Celsius
   * [4] = checksum (humidité + température)
   */
   
  /* Vérifie la checksum */
  byte checksum = (data[0] + data[1] + data[2] + data[3]) & 0xff;
  if (data[4] != checksum)
    return DHT_CHECKSUM_ERROR; /* Erreur de checksum */
  else
    return DHT_SUCCESS; /* Pas d'erreur */
    
    
    
    
}

Salut a tous je viens de lancer un topic ;;; pourais je avoir un peut d'aide svp j'ai un soucis assez important
merci a tout les volontaires

@ gbdf1

Post aussi les messages d'erreurs renvoyés par le compilateur.

Il y a beaucoup de code spécifique qui effectivement doit poser problème.

Je commencerais par trouver des bibliothèques qui soient compatibles avec la carte DUE, par exemple il existe une multitude de bibliothèques Onewire.h dont la plupart ne compilent pas sur la DUE. Dans ce topic tu trouveras une bibliothèque écrite pour la DUE:

Tu essayes les exemples qui vont avec et tu adaptes le code à tes besoins.

Tu fais de même pour UTFT.h et tu regardes d'abord si les 2 bibliothèques compilent ensemble sans poser de problèmes. Il y a donc probablement pas mal d'essais à faire avant que tout fonctionne.