Bonsoir à tous

Je croyais mon problème complètement résolu. J'ai lancé plusieurs SOS pour des comportements curieux et inexplicables, dont des versions de mes anciens sketches devenus totalement inopérants sans que je n'arrive à trouver l'explication, et des recherches manipulations récentes me font mettre le doigt sur un comportement curieux que je ne sais expliquer.

Mon dernier appel https://www.developpez.net/forums/d2.../#post11907298, m'a permis de faire tourner simultanément deux maquettes, sur deux ordinateurs différents, dont une maquette de mon application et une autre permettant de tester le contenu de l'eeprom générée par ma maquette, et qui comporte des "parasites" lors de sa programmation.

Ma maquette est celle qui est "traitée" ici et que j'ai pu réaliser grâce à votre aide.

https://www.developpez.net/forums/d2.../#post11773277

https://www.developpez.net/forums/d2.../#post11720415

https://www.developpez.net/forums/d2.../#post11708737

https://www.developpez.net/forums/d2.../#post11700225

Suite à ces manipulations, je constate une "incompatibilité" (apparente) entre ma mémorisation en eeprom et une sorte de RTC à base de 1307, choisie car elle comporte une petite RAM non volatile que j'utilise pour conserver quelques valeurs (des durées manuelles) pour ne pas qu'elles soient perdues en cas de coupure d'alimentation. Ce serait donc bien de pouvoir les conserver, à condition d'expliquer et de supprimer mon problème, actuellement insoluble (pour moi).

Les faits:

Quand j'enregistre une piste de programmation d'une voie (sur les quatre possibles) pour une durée de X minutes sur une semaine qui en comporte 10080, j'ai remarqué que l'écriture semblait bien se faire, aux bonnes adresses, mais que d'autres écritures parasites apparaissaient dans d'autres zones des 10080 positions, et le plus souvent de manière erratique.

Le rebondissement récent est que c'est la présence sur le même bus i2c de la rtc fautive qui sème le trouble. Voilà, sur un sketch réalisé sur une maquette uno, qui comporte un afficheur (en i2C), une RTC et une eeprom. J'ai aussi une RTC 1307 aussi, d'un autre modèle qui ne pose pas le problème d'où mon trouble.

Voici le listing du sketch:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
      //  Cohabitation_1307_eeprom_01.ino copie de 1307_eeprom_01.ino nettoyé des inutilités 10 janvier 2023
 #include <Wire.h>    // Bibliothèque pour l'I2C
#include "RTClib.h"  // Bibliothèque pour le module RTC
#include <LiquidCrystal_I2C.h> // Bibliothèque pour l'écran
          //  =================  Définitions  =====
uint16_t    nbDeDump  =   1000 ;   // nombre de case de dump
 
#include "I2C_eeprom.h"
I2C_eeprom ee ( 0x50 , I2C_DEVICESIZE_24LC256 ) ;
 
       //   mes variables Clavier
int   KA  ;   // poussoir 1
int   KB  ;   // poussoir 2
int   KC ;    // poussoir 3
int   KD  ;   // poussoir 4
int   touches ;   // "clavier" combiné
uint16_t cpt1  ;   // compteur de boucle dump
int reep  ;   // read eeprom cad lecture EN eeprom
uint16_t  Erreurs ;   //  comptage des erreurs
 
LiquidCrystal_I2C lcd ( 0x27 , 16 , 2 ) ; //  afficheur 2 lignes 16 caractères
void setup ( void ) 
    {
    Serial.begin ( 115200 ) ;  // était 115200 bauds
            //Initialisation de l'éran
    lcd.begin ( 16 , 2 ) ;    // 16 col, 2 lignes
    lcd.init () ; // initialisation lcd
    lcd.clear () ;
    lcd.backlight () ;
    Wire.begin () ;   // Initialise la liaison I2C  
 
           // Définition ports e/s
    pinMode ( 9 , OUTPUT ) ;      // borne 9 ou PB1 ou D9 en sortie
    pinMode ( 10 , OUTPUT ) ;      // borne 10 ou PB2 ou D10 en sortie
    digitalWrite ( 9 , LOW ) ;    // 0 par défaut
    pinMode ( 2 , INPUT_PULLUP ) ;    // entrée SW avec pull up  borne D2 ou INT0 ou 32
    pinMode ( 3 , INPUT_PULLUP ) ;    // entrée SW avec pull up  borne D3 ou INT1 ou 1
    pinMode ( 4 , INPUT_PULLUP ) ;    // entrée SW avec pull up  borne D4 ou PD4 ou 2
    pinMode ( 5 , INPUT_PULLUP ) ;    // entrée 
 
    Serial.print ( "Source du fichier: " ) ;
    Serial.print ( __FILE__ ) ; Serial.println ( "\tGuy du 10 jan 2023" ) ;   // mon commentaire initial
    ee.begin () ;   // initialisation dialogue
    }
          //  ====  Entrée dans la boucle 
void loop ()
    {
    if ( touches == 1 ) dumpEeprom () ;     // lecture et affichage de eeprom toutes les minutes
 
    lectureClavier () ;   //
 
    delay ( 1000 ) ; // delais de 1 seconde
    allumeBleu () ;
    delay ( 500 ) ;
    eteintBleu () ;
    }
           /// ===== fin du loop ====
 
      ///   =============================
 
void dumpEeprom ()      // lecture et affichage de eeprom
    {
          Serial.println () ;   // saut de ligne
          Serial.print ( "\tDump de l'eeprom (" ) ;  // message
          Serial.print ( nbDeDump , DEC ) ;   // précise le nombre
          Serial.println ( " octets)" ) ;    // terminaison message
          for ( cpt1 = 0 ; cpt1 < nbDeDump ; cpt1 ++ )      // définition de la boucle 32767
              {
                reep = ee.readByte ( cpt1 ) ;   // lecture courante
                if ( cpt1 % 100 == 0 ) 
                    {
                      Serial.print ( "\t@ " ) ; Serial.print ( cpt1 , DEC ) ;   // adresse
                      Serial.println () ;    // fin de ligne
                    }
                if ( reep == 0 ) Serial.print ( "-" ) ;
                if ( cpt1 % 10 == 0 ) Serial.print ( " " ) ;    // séparateur dizaines
                if ( reep != 0 ) Serial.print ( reep , HEX ) ;
              }
         Serial.println () ;    //  saut de ligne terminal 
         Serial.println ( "Fin du dump" ) ;    //  
         Serial.println () ;    //  
        }
            //  ===========     
void  allumeBleu ()
  {
    digitalWrite ( 9 , HIGH ) ;    // allume
  }
          // ========
void  eteintBleu ()
  {
    digitalWrite ( 9 , LOW ) ;    // allume
  }
          // ========
 void lectureClavier ()     // lecture des boutons
    {
    KA = digitalRead ( 2 ) ;    // lecture poussoir 1
    KB = digitalRead ( 3 ) ;    // lecture poussoir 2
    KC = digitalRead ( 4 ) ;    // poussoir 3
    KD = digitalRead ( 5 ) ;    // poussoir 4
 
    if ( KA == 1 ) KA = 0 ; else KA = 1 ;   // inversion
    if ( KB == 1 ) KB = 0 ; else KB = 2 ;   // inversion et poids 2
    if ( KC == 1 ) KC = 0 ; else KC = 4 ;   // inversion et poids 
    if ( KD == 1 ) KD = 0 ; else KD = 8 ;   // inversion et poids 
 
    touches = KA + KB + KC + KD ;    // KC en positon2
    lcd.setCursor ( 14 , 1 ) ; 
    lcd.print (  touches , DEC  ) ;       // clavier décodé         
    }
Voici les ingrédients utilisés:
Nom : eeprom_32k.jpg Affichages : 430 Taille : 81,1 Ko
Ceci est l'eeprom.

Nom : 1307_elegoo.png Affichages : 561 Taille : 425,4 Ko
Ceci est la RTC qui ne pose pas de problème.


Nom : RTC_1307_avec_pb_r.jpg Affichages : 426 Taille : 228,6 Ko
Ceci est l'eeprom qui pose problème, pas toujours le même.


Et voici un dump sur les 1000 premiers octets de l'eeprom testée. Les bits utiles à 0 du nibble bas sont remplacés par des tirets pour simplifier la lecture. Quand c'est différent de 0, c'est que une des quatre piste est programmée.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
	Dump de l'eeprom (1000 octets)
	@ 0
- --------- 1111111111- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 100
 2222222222- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 200
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 300
- ---------- --------- 3333333333- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 400
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 500
- ---------- ---------- --------- 4444444444- ---------- ---------- ---------- ---------- ---------- ---------	@ 600
- ---------- ---------- ---------- --------- 5555555555- ---------- ---------- ---------- ---------- ---------	@ 700
- ---------- ---------- ---------- ---------- --------- 6666666666- ---------- ---------- ---------- ---------	@ 800
- ---------- ---------- ---------- ---------- ---------- --------- 7777777777- ---------- ---------- ---------	@ 900
- ---------- ---------- ---------- ---------- ---------- ---------- --------- 8888888888- ---------- ---------
Fin du dump
C'est lu sans que le RTC soit enfichée. C'est lu correctement, et j'ai pu vérifier que la RTC, qui là n'est pas programmée, est bien lue quel qu'en soit le modèle si le programme du sketch l'exploite et l'affiche.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
	Dump de l'eeprom (1000 octets)
	@ 0
- --------- 1111111111- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 100
 2222222222- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 200
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 300
- ---------- --------- 3333333333- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 400
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 500
- ---------- ---------- --------- 4444444444- ---------- ---------- ---------- ---------- ---------- ---------	@ 600
- ---------- ---------- ---------- --------- 5555555555- ---------- ---------- ---------- ---------- ---------	@ 700
- ---------- ---------- ---------- ---------- --------- 6666666666- ---------- ---------- ---------- ---------	@ 800
- ---------- ---------- ---------- ---------- ---------- --------- 7777777777- ---------- ---------- ---------	@ 900
- ---------- ---------- ---------- ---------- ---------- ---------- --------- 8888888888- ---------- ---------
Fin du dump
Sauf erreur, c'est strictement identique.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
	Dump de l'eeprom (1000 octets)
	@ 0
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 100
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 200
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 300
- ---------- --------- 2222222222- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 400
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 500
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 600
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 700
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 800
- ---------- ---------- ---------- ---------- ---------- --------- 4444444444- ---------- ---------- ---------	@ 900
- ---------- ---------- ---------- ---------- ---------- ---------- --------- 8888888888- ---------- ---------
Fin du dump
Ceci est la lecture de la même eeprom par l'échantillon 1 de ma RTC à problème. Je me suis aperçu que mon autre échantillon donne une lecture différente de celle-ci:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
	Dump de l'eeprom (1000 octets)
	@ 0
- --------- 1111111111- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 100
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 200
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 300
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 400
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 500
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 600
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 700
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 800
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------	@ 900
- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------
Fin du dump
Côté hard, la maquette ne comporte que le bus i2c et les alimentations en plus des switches qui permettent de lancer le dump.

J'ose espérer que je ne fais pas d'erreur d'interprétation et que mes informations données ici vous permettront de mettre le doigt sur l'ânerie que je fais (je ne vois pas d'autre explication) qui m'empêche de dormir depuis déjà un certain temps.

J'avais contourné le problème sur mon prototype, en limitant ma zone à 1440 octet, soit une journée au lieu de la semaine. Bien que non prouvé dans les faits, j'ai cru remarquer que les parasites apparaissaient parfois avec un décalage de 4096 octets.

Pourtant, les constats que montrent mes relevés ci-dessus, montrent une altération en lecture de l'eeprom.

J'attends avec une grande impatience vos remarques, vous les spécialistes mais surtout les pratiquants car j'ai du mal admettre que ce que je demande à mes deux périphériques est normal, et si le comportement est anormal, c'est mon programme qui comporte une erreur ou des maladresses.

Merci d'avance pour les progrès que vous allez, une fois de plus, me permettre de faire.