Problème RTC et OLED I2c

Bonjour alors j'ai un petit problème je réalise un système qui possède un écran OLED SSD1306 et un module RTC que j'ai fabriqué moi même que vous pouvais voir ci-dessous :

|500x375

Tout deux sont réliés en I2C sur une carte arduino Uno R3.

Lorsque j'ai codé les modules de manière séparée, les 2 modules se sont très bien comportés et se comportent encore bien sur le montage finale lorsque je les exécute 1 par 1.

Cependant à partir du moment où j'implémente le code final aucun des 2 ne présente le fonctionnent voulu l’écran est constellé de pixels blanc et voici ce que renvoi le rtc :

|500x281

Je pense que l'écran ne doit pas libéré le I2c et ainsi les données des deux modules sont corrompues.Mais je ne sais pas comment validé cette hypothèse ni y remédier.

Voici les partis du codes qui concerne ces deux modules :

Le code en plusieurs partis :

/* ===============================================================
      Project:  BB060817
       Author: Julien Turpin
      Created: 29/07/2017
  Arduino IDE: 1.8.3
================================================================== */


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*----- dépendence du code ------*/
#include <OneWire.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*---- définition du code ----*/ 
#define bouton1 4 // connection du digital Pin 4 de l'Arduino UNO à bouton1
#define boutontemp 3 // connection du digital Pin 5 de l'Arduino UNO à boutontemp 5
#define boutonheure 6 // connection du digital Pin 6 de l'Arduino UNO à boutontemp 6 
#define bouton2 7 // connection du digital Pin 7 de l'Arduino UNO à bouton2
#define DS1307_ADDRESS  0x68 // addresse du capteur de temp
#define DS1307_CONTROL  0x07 // Registre 

/*--------------------------------------------------------------------------------------------------*/

#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);

#if (SSD1306_LCDHEIGHT != 32)
#error("Height incorrect, please fix Adafruit_SSD1306.h!");
#endif

/*--------------------------------------------------------------------------------------------------*/


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


/*--------------------------------------------------------------------------------------------------*/

// défintion des variables globales 


/*Modes */

int btemp;
int bheure;


/*Date et heure*/

//On déclare une structure de données qui a pour but de contenir 
//les informations de date et heure en provenance ou à destination du module d'horloge. 

typedef struct {
  uint8_t secondes; 
  uint8_t minutes; 
  uint8_t heures; 
  uint8_t pm; 
  uint8_t jour_de_la_semaine; 
  uint8_t jours; 
  uint8_t mois; 
  uint8_t annees; 
} DateandTime_t;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//définition des fonctions 

/*--------------------------------------------------------------------------------------------------*/

// Fonction de conversion BCD -> decimal 
byte bcd_decimal(byte bcd) {
  return (bcd / 16 * 10) + (bcd % 16); 
}

/*--------------------------------------------------------------------------------------------------*/

// Fonction de conversion decimal -> BCD 
byte decimal_bcd(byte decimal) {
  return (decimal / 10 * 16) + (decimal % 10);
}

/*--------------------------------------------------------------------------------------------------*/

// fonction permettant de lire l'heure
// Si le module d'horloge est arrêté, la fonction retourne un 1 

byte lecture(DateandTime_t *datetime) {
  
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write((byte) 0); // Lecture mémoire à l'adresse 0x00
  Wire.endTransmission(); // Fin de la transaction I2C
 
  // Lit 7 octets depuis la mémoire du module d'horloge  \\
  Wire.requestFrom(DS1307_ADDRESS, (byte) 7);
  byte raw_secondes = Wire.read();
  datetime->secondes = bcd_decimal(raw_secondes);
  datetime->minutes = bcd_decimal(Wire.read());
  byte raw_heures = Wire.read();
  datetime->heures = bcd_decimal(raw_heures & 63);
  datetime->pm = 0;
  datetime-> jour_de_la_semaine = bcd_decimal(Wire.read());
  datetime-> jours = bcd_decimal(Wire.read());
  datetime-> mois = bcd_decimal(Wire.read());
  datetime-> annees = bcd_decimal(Wire.read());
    return raw_secondes & 128; // lecture du 7e bit des secondes, il s'agit de CH. Si CH est à 1 le module d'horloge est arrêté. 
}

/*--------------------------------------------------------------------------------------------------*/
// fonction de réglage de l'heure et de la date (possible que l'horloge de redémarrer 

void ecriture(DateandTime_t *datetime) {
  
  /* Début de la transaction I2C */
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write((byte) 0); // Ecriture mémoire à l'adresse 0x00
  Wire.write(decimal_bcd(datetime->secondes) & 127); // CH = 0
  Wire.write(decimal_bcd(datetime->minutes));
  Wire.write(decimal_bcd(datetime->heures) & 63); // Mode 24h
  Wire.write(decimal_bcd(datetime->jour_de_la_semaine));
  Wire.write(decimal_bcd(datetime->jours));
  Wire.write(decimal_bcd(datetime->mois));
  Wire.write(decimal_bcd(datetime->annees));
  Wire.endTransmission(); // Fin de transaction I2C
}

/*--------------------------------------------------------------------------------------------------*/
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 
initialisation

void setup(void) {
  Serial.begin(115200);
  Serial.println("------------------* Initialtialisation programme *---------------") ; // commande pour observer le bon lancement du prog à l'odinateur 
  Serial.println();
  Serial.println("                   DEBUT Itération Prog ");  // début de la recherche de composant et de son adresse 
  
/*--------------------------------------------------------------------------------------------------*/

  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialise avec l'adresse I2C 0x3C (128x32)
  // init Ok
  display.clearDisplay();

/*--------------------------------------------------------------------------------------------------*/

// Affichage message d'acceuil 
  display.setTextSize(2);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.println("Hello, world!");
  delay(100);
  display.clearDisplay();

/*--------------------------------------------------------------------------------------------------*/
  
  // Définir la fonction (INPUT ou OUTPUT) des Pins Arduino utilisés
  
/*interface provisoire*/

  pinMode(bouton1, INPUT);
  pinMode(bouton2, INPUT);
  pinMode(boutontemp, INPUT);
  pinMode(boutonheure, INPUT);



/*--------------------------------------------------------------------------------------------------*/

  // placer les pins en position init
 int etatb1 = HIGH;
 int etatb2 = HIGH;
 int etattemp = HIGH;
 int etatheure = HIGH;

/*--------------------------------------------------------------------------------------------------*/
// test et init du module horloge 

  Wire.begin();
  DateandTime_t now;
  if (lecture(&now)) {
    Serial.println("le module ne fonctionne pas");
  
    
    now.secondes = 00;
    now.minutes = 00;
    now.heures = 00; // 00h 00min 00sec
    now.jour_de_la_semaine = 1; //lundi
    now.jours = 1; 
    now.mois = 01;
    now.annees = 18; // 1 janv 2018
    ecriture(&now);
 
  }
  
}
void loop(void) {

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// définition des variables locales de la fonction 

/* interface*/

 int etatb1;
 int etatb2;
 int etattemp;
 int etatheure;

/* Const pour le capteur de temp*/ 

 byte i;
 byte present = 0;
 byte type_s;
 byte data[12];
 byte addr[8];
 float celsius;
 byte crc;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------------------------------------------------Acquisiontion de la date et de l'heure-----------------------------------------------------------\\

// Là on procède à la lecture de l'heure, l'affichage et la modification 
 /* Lit la date et heure courante */
 DateandTime_t now;
 // lecture des boutons de l'état du module horloge : Nul, Affichage, Modification(jour,mois,année,heure,minute,seconde)
 lecture(&now);
 Serial.print("Date : ");
 Serial.print(now.jours);
 Serial.print("/");
 Serial.print(now.mois);
 Serial.print("/");
 Serial.print(now.annees + 2000);
 Serial.print("  Heure : ");
 Serial.print(now.heures);
 Serial.print(":");
 Serial.print(now.minutes);
 Serial.print(":");
 Serial.println(now.secondes);

 switch (bheure) {                              /* le nombre d'appuis sur la touche horloge va modifier le mode, chaque mode est décrit par chacun des cas si dessous */
   
   case 0:                                       /* dans ce cas on affiche l'utilisateur travail sur la température ou le OLED est en veille. Ici la pression sur le bt horloge va faire bascule l'utilisateur de la température à toutes les fonctions d'horloge*/
     etatheure = digitalRead(boutonheure);
     if (etatheure == LOW){
       bheure=1;
       btemp=0;
     }
     break;
   case 1:                                       /*Ici affichage de la date et de l'heure. Une pression sur le bt horloge va nous diriger vers le mode de modification du jour */
     display.setTextSize(1);
     display.setTextColor(WHITE);  
     display.println(now.jours);
     display.println("/");
     display.println(now.mois);
     display.println("/");
     display.println(now.annees+ 2000);
     display.setTextSize(2);
     display.setTextColor(WHITE);
     display.println(now.heures);
     display.println(":");
     display.println(now.minutes);
     display.println(":");
     display.println(now.secondes);
     delay(100);
     
     display.clearDisplay();
     etatheure = digitalRead(boutonheure);
     if (etatheure == LOW){
       bheure=2;
     }
     break;
   case 2:                                   /*Ici modification du jour, le système reste figé durant la modification . Une pression sur le bt horloge va nous diriger vers le mode de modification du moi */
     while (bheure==2){
       display.setTextSize(2);
       display.setTextColor(WHITE);  
       display.println(now.jours);
       display.println("/");
       display.println(now.mois);
       display.println("/");
       display.println(now.annees + 2000);
       int etatb1 = digitalRead(bouton1);
       etatb2 = digitalRead(bouton2);
       if (etatb1 == LOW and etatb2 == HIGH){
          now.jours = now.jours + 1;
          ecriture(&now); 
       }
       if (etatb1 == HIGH and etatb2 == LOW){
        now.jours = now.jours - 1;
        ecriture(&now); 
       }
       etatheure = digitalRead(boutonheure);
       if (etatheure == LOW){
       bheure=3;
       }
       delay(100);
       display.clearDisplay();
     }
     break;

   .........

   case 7:                                   /*Ici modification des secondes, le système reste figé durant la modification . Une pression sur le bt horloge va nous rediriger vers l'affichage normale de l'heure*/
     while (bheure==7){
      display.setTextSize(2);
      display.setTextColor(WHITE);
      display.println(now.heures);
      display.println(":");
      display.println(now.minutes);
      display.println(":");
      display.println(now.secondes);
     
       etatb1 = digitalRead(bouton1);
       etatb2 = digitalRead(bouton2);
       if (etatb1 == LOW and etatb2 == HIGH){
       now.secondes = now.secondes + 1;
       ecriture(&now);
       }
       if (etatb1 == HIGH and etatb2 == LOW){
       now.secondes = now.secondes - 1;
       ecriture(&now);
       }
       etatheure = digitalRead(boutonheure);
       if (etatheure == LOW){
       bheure=1;
       }
       delay(100);
       display.clearDisplay();
     }
     break;
     return;
 }  
 switch(btemp){
   case 0:                                       /* dans ce cas on affiche l'utilisateur travail sur la température ou le OLED est en veille. Ici la pression sur le bt horloge va faire bascule l'utilisateur de la température à toutes les fonctions d'horloge*/
     etattemp = digitalRead(boutontemp);
     if (etattemp == LOW){
       bheure=0;
       btemp=1;
     }
     delay(100);
   case 1 :
     display.clearDisplay();
     display.setTextSize(1);
     display.setTextColor(WHITE);
     display.println("      Temperature = ");
     display.setTextSize(2);
     display.setTextColor(WHITE);
     display.println(celsius);
     
     etattemp = digitalRead(boutontemp);
       if (etattemp == LOW){
       btemp = 2 ;
       delay(100);
     }
     break;

   case 2 :
       while ( etattemp == 2 ){
     
       display.setTextSize(1);
       display.setTextColor(WHITE);
       display.println("      Temperature = ");
       display.setTextSize(2);
       display.setTextColor(WHITE);
       display.println(D_T);
     
       etatb1 = digitalRead(bouton1);
       etatb2 = digitalRead(bouton2);
       
       if (etatb1 == LOW and etatb2 == HIGH){
            D_T = D_T + 1;
       }
       
       if (etatb1 == HIGH and etatb2 == LOW){
         D_T = D_T - 1;
       }
       
        etattemp = digitalRead(boutontemp);
       if (etattemp == LOW){
       btemp = 1 ;
     }
      
       delay(100);
       display.clearDisplay();
     
     etattemp = digitalRead(boutontemp);
       if (etattemp == LOW){
       btemp = 1 ;
     }

      etatb1 = digitalRead(bouton1);
      etatb2 = digitalRead(bouton2);
   
     if (etatb1 == LOW and etatb2 == HIGH){
        D_T = D_T + 1;
       }
     if (etatb1 == HIGH and etatb2 == LOW){
        D_T = D_T - 1;
     }
 }
 break;
 return;
 }


Serial.println();
Serial.print("bheure=");
Serial.print(bheure);
Serial.println();
Serial.print("btemp = ");
Serial.print(btemp);
Serial.println();



 delay(250);
}