Bonjour à tous,

je viens vers vous, car je n'arrive pas à comprendre comment sont stockes les données en mémoire.

ci dessous petit sketch qui illustre mon incompréhension.
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
//**************************************************

#include <Arduino.h>
#include <EEPROM.h>

void setup(){
  Serial.begin(115200);
  EEPROM.begin(32);  //EEPROM.begin(Size)

  delay(2000);
 Serial.println("  ");

 // Carte NodeMCU 1.0(ESP-12E Module)

 // declaration d'un integer 32 bit non signé 
 // valeur decimal : 4660,  soit en Hexa 00 00 12 34 
 uint32_t dt =  4660 ; // 0x1234; // 00 00 12 34

 Serial.print("val hexa dt : "); Serial.print(dt,DEC);
 Serial.print(" val hexa dt : ");Serial.println(dt,HEX);

 //  Resultat moniteur série  val hexa dt : 4660 val hexa dt : 1234

// je récupère la valeur de chaque byte (octet) de l'integer
// formule magique !! récupérée sur le net, qui marche... mais qui n'est pas claire pour moi
 
 byte byteEeprom1 = * ((byte *) (& dt) + 0); // low byte = 0x34
 Serial.print("val hexa byteEeprom1 : "); Serial.println(byteEeprom1,HEX);
 byte byteEeprom2 = * ((byte *) (& dt) + 1); // high byte = 0x12
 Serial.print("val hexa byteEeprom2 : "); Serial.println(byteEeprom2,HEX);
  byte byteEeprom3 = * ((byte *) (& dt) + 2); // high byte = 0x00
 Serial.print("val hexa byteEeprom3 : "); Serial.println(byteEeprom3,HEX);
  byte byteEeprom4 = * ((byte *) (& dt) + 3); // high byte = 0x00
 Serial.print("val hexa byteEeprom4 : "); Serial.println(byteEeprom4,HEX);

 // // je m'attends à 00 00 12 34  et j'obtiens 34 12 00 00
 //  Resultat moniteur série  : val hexa byteEeprom1 : 34
 //  Resultat moniteur série  : val hexa byteEeprom2 : 12
 //  Resultat moniteur série  : val hexa byteEeprom3 : 0
 //  Resultat moniteur série  : val hexa byteEeprom4 : 0

 // je copie  l'espace mémoire integer32  : dt vers espace mémoire tableau de 4 bytes : numberByte
 // et j'imprime chaque élément du tableau
 byte numberByte[4];
 memcpy(&numberByte, &dt, 4);
 Serial.print("val hexa numberByte[0] : "); Serial.println(numberByte[0],HEX);
 Serial.print("val hexa numberByte[1] : "); Serial.println(numberByte[1],HEX);
 Serial.print("val hexa numberByte[2] : "); Serial.println(numberByte[2],HEX);
 Serial.print("val hexa numberByte[3] : "); Serial.println(numberByte[3],HEX);
 
 // impression tableau idem formule magique
 // je m'attends à 00 00 12 34  et j'obtiens 34 12 00 00
 //  Resultat moniteur série  : val hexa numberByte[0] : 34
 //  Resultat moniteur série  : val hexa numberByte[1] : 12
 //  Resultat moniteur série  : val hexa numberByte[2] : 0
 //  Resultat moniteur série  : val hexa numberByte[3] : 0
 
// j'ecris dans l'EEPROM dans l'ordre naturel 00 00 12 34 et je commit
 EEPROM.write(0,numberByte[3]);
 EEPROM.write(1,numberByte[2]);
 EEPROM.write(2,numberByte[1]);
 EEPROM.write(3,numberByte[0]);
 EEPROM.commit();
 
 // je lis le resultat par EEPROM.get dans un integer 32 bit 
 uint32_t intLowHigh = 0;
 EEPROM.get(0,intLowHigh);
 Serial.print("valeur intLowHigh decimal : "); Serial.print(intLowHigh);
 Serial.print("  valeur intLowHigh Hexa : "); Serial.println(intLowHigh,HEX);
 //  Resultat moniteur série  : valeur intLowHigh decimal : 873594880 valeur intLowHigh Hexa : 34120000
 
// j'ecris de nouveau mais dans l'ordre 34 12 00 00 numberByte [0,1,2,3)
 EEPROM.write(0,numberByte[0]);
 EEPROM.write(1,numberByte[1]);
 EEPROM.write(2,numberByte[2]);
 EEPROM.write(3,numberByte[3]);
 EEPROM.commit();
 
 // je lis le resultat par EEPROM.get dans un integer 32 bit 
 uint32_t intHighLow = 0;
 EEPROM.get(0,intHighLow);
 Serial.print("valeur intHighLow decimal : "); Serial.print(intHighLow);
 Serial.print("  valeur intHighLow Hexa : "); Serial.println(intHighLow,HEX);
 //le resultat correspond au nombre 4660 equivalent à 00 00 12 34
 //  Resultat moniteur série  : valeur intHighLow decimal : 4660valeur intHighLow Hexa : 1234

}

void loop(){
 
}
//**************************************************
ma question est simple , si elle a un sens..., dans quel sens sont donc stockes les bytes??

Merci pour vos lumières.