Comment remplacer une valeur d'une varaiable

Bonjour à tous,

je mexcuse pour cette question si bête, mais ca me plane dans un doute.

Sachant que

unsigned int index_EPROM = 0;
const unsigned int eprom_size = 256000; // Micro proc : 24LC256
const unsigned int eprom_inc = 84;

// Si index2_EPROM est plus grand que 0, alors loop toute l'eeprom. index2_EPROM est > 0, car l'eeprom a été remplie et est donc pleine. 
// (les enregistrement suivants, aurons repris à 0x0000).
if(index2_EPROM>0){
    // Si oui index_EPROM prend la valeur maximal que peut avoir index_eprom, sachant que l'eprom 24LC256 à 250k
    index_EPROM += ((eprom_size/eprom_inc)-1);
    index2_EPROM = 0;
    
  }
  // Loop the eeprom
  for(int c=0; c <= index_EPROM; c++){
    readEEPROM(rom,(eprom_inc*c)+eprom_cou, course_id);
    readEEPROM(rom,(eprom_inc*c)+eprom_lon, lon);
    readEEPROM(rom,(eprom_inc*c)+eprom_lat, lat);
    readEEPROM(rom,(eprom_inc*c)+eprom_alt, alt);
    readEEPROM(rom,(eprom_inc*c)+eprom_tim, time);
    readEEPROM(rom,(eprom_inc*c)+eprom_vel, vel);
    readEEPROM(rom,(eprom_inc*c)+eprom_sta, _stat);
    
    // Convert into XML format (has to be done very soon)

   // Merge in coords
    sprintf(coords, "g=%s,%s,%s,%s,%s,%s,%s,%s",course_id,lon,lat,alt,time,vel,_stat,c);
   #ifdef DEBUG 
      // Display the red values, but will be soon built in XML format
      Serial.println(coords);
  #endif
   }
  
  index_EPROM = 0;

Dans un préceédent post, on m’avait expliquer que

index_EPROM += ((eprom_size/eprom_inc)-1);

était la meme chose que

index_EPROM = index_EPROM + ((eprom_size/eprom_inc)-1);

Donc le premier est plus simple en écriture
Dans ce cas on parle “d’incrémentation” ou d’addition.

Donc dans mon code, si-dessus, ceci est faux

index_EPROM += ((eprom_size/eprom_inc)-1);

Car il incrémente alors que je veux remplacer, et devrait être

index_EPROM = ((eprom_size/eprom_inc)-1);

pour prendre sa valeur.

Donc on est bien d’accord ensemble?

J’ai un peu honte de poser cette question, car je donne probablement la réponse et peut etre que je suis encore confu avec les chars.

Vlaaaa, au pire des cas j’ai un blâme =(

le blâme, non, mais ...

premièrement, tu fais :

const unsigned int eprom_size = 256000; // Micro proc : 24LC256

si tu veux parler de la taille de l'eprom, qui doit être de 256Ko, saches que contre toute attente, en programmation, 1Ko n'est pas 1000 octets, mais 1024 octets (une histoire de puissances de 2, on y revient toujours, aux bases binaires...). du coup, 256Ko = 256 x 1024 octets = 262144 octets. ça, c'est dit.

oui, A += B équivaut à A = A + B (A incrémenté de B).

index_EPROM = ((eprom_size/eprom_inc)-1); te donne en effet l'index max d'enregistrements possibles dans ton eprom. (index max = nombre max - 1)

index_EPROM += ((eprom_size/eprom_inc)-1); te donnera l'ancienne valeur de index_EPROM ajoutée à l'index max d'enregistrement, soit un dépassement de capacité de l'eprom potentiel.

un conseil : définis in truc genre index_eprom_max dès le début, ça te fera gagner du temps et de la "stabilité" dans ton code.

pour répondre à la question "Comment remplacer une valeur d'une variable", je dirais que :

l'opérateur "+=" incrémente,
l'opérateur "=" affecte.

ok

du coup, 256Ko = 256 x 1024 octets = 262144 octets

En effet, j’ai voulu arondir à 256000. De toute maniere je crois que j’ai beaucoup de marge. Ceci etant dit, j’ai comme meme modifier à 262144

un conseil : définis in truc genre index_eprom_max dès le début

Oui c’est bien ce que j’ai fait. Il est en tete de mon script

const unsigned int eprom_size = 262144; //32768  // taille de l'EPROM en octets

l’opérateur “+=” incrémente,
l’opérateur “=” affecte.

Super, c’est maintenant très très claire.

je suis super content. Car ca semble vraiment bien fonctionner. Je dois encore tester et vérifier pour continuer serainement :slight_smile:
J’étais vraiment bloqué mais là, j’ai déjà pu deja attaqué la lecture de l’eeprom pour l’envoi, grâce a tes exemples. Ca ma vraiment débloqué:

writeEEPROM(rom,(eprom_inc*index_EPROM)+eprom_lon,lon);

Encore merci.

Prochain gors chapitre : XML; mettre ce qui est collecter par la boucle

for(int c=0; c <= index_EPROM; c++){}

au fomat XML pour envoyer une fois, le tout, après la boucle, sur le serveur! Mais j’ai déjé une piste.

bonnes continuations alors :wink: !

je suis super content. Car ca semble vraiment bien fonctionner. Je dois encore tester et vérifier pour continuer sereinement

Je me permets de douter que cela fonctionne bien.
262144 est très supérieur à 65536. Donc 262144 ne rentre pas dans un int. Il faut travailler avec des long. En plus une constante longue doit être suffixé avec un L pour indiquer son type.

const unsigned long int eprom_size = 262144L ; //32768  // taille de l'EPROM en octets

Évidemment la remarque sur le type long s'applique aussi aux variables qui vont utiliser cette constante.

Salut,
Merci pour cette Remarque qui a sont importance. J ai compile sans avoir de message d erreur, Mais je n ai pas encore tester le cas ou.

Je vais Donc me pancher la dressus. Merci pour ce detail :slight_smile:

J’ai rwgardé un peu la doc arduino

Es-tu sure de ca ?

const unsigned long int eprom_size = 262144L ; //32768  // taille de l'EPROM en octets

ne serait-ce pas

const unsigned long eprom_size = 262144L ; //32768  // taille de l'EPROM en octets

sans le int? Qu’es-ce qui diffère réellement?

Mais au final, il faudrait que je moifie pas mal de petite chose

unsigned int index2_EPROM =0;
unsigned long int index_EPROM = 0L; // PARCE QU?IL PEUT MONTER JUSQU A 262144
const unsigned long int eprom_size = 262144L; // Micro proc : 24LC256
const unsigned long int eprom_inc = 84L; // PARCE QU IL EST DIVISER AVEC eprom_size (J aurai peut etre un probleme avec celui-la...

// Si index2_EPROM est plus grand que 0, alors loop toute l'eeprom. index2_EPROM est > 0, car l'eeprom a été remplie et est donc pleine. 
// (les enregistrement suivants, aurons repris à 0x0000).
if(index2_EPROM>0){
    // Si oui index_EPROM prend la valeur maximal que peut avoir index_eprom, sachant que l'eprom 24LC256 à 250k
    index_EPROM += ((eprom_size/eprom_inc)-1);
    index2_EPROM = 0;
    
  }
  // Loop the eeprom
  for(long int c=0; c <= index_EPROM; c++){ // PARCE QU'IL EST COMPARER AVEC index_EPROM QUI PEUT MONTER JUSQU A 262144L
    readEEPROM(rom,(eprom_inc*c)+eprom_cou, course_id);
    readEEPROM(rom,(eprom_inc*c)+eprom_lon, lon);
    readEEPROM(rom,(eprom_inc*c)+eprom_lat, lat);
    readEEPROM(rom,(eprom_inc*c)+eprom_alt, alt);
    readEEPROM(rom,(eprom_inc*c)+eprom_tim, time);
    readEEPROM(rom,(eprom_inc*c)+eprom_vel, vel);
    readEEPROM(rom,(eprom_inc*c)+eprom_sta, _stat);
    
    // Convert into XML format (has to be done very soon)

   // Merge in coords
    sprintf(coords, "g=%s,%s,%s,%s,%s,%s,%s,%s",course_id,lon,lat,alt,time,vel,_stat,c);
   #ifdef DEBUG 
      // Display the red values, but will be soon built in XML format
      Serial.println(coords);
  #endif
   }
  
  index_EPROM = 0L; // L PAREC QUE C EST UN LONG

En gros, c’est ca si j ai bien compris fdufnews. N’es-ce pas?

pierrot10:
J'ai rwgardé un peu la doc arduino

Es-tu sure de ca ?

Pour faire une petite mise au point, la doc arduino ce n'est pas la bible. Le langage utilisé pour développer avec l'IDE arduino c'est un sous-ensemble du C.
Il y a de la littérature autrement meilleur que la doc arduino.

pierrot10:

const unsigned long int eprom_size = 262144L ; //32768  // taille de l'EPROM en octets

ne serait-ce pas

const unsigned long eprom_size = 262144L ; //32768  // taille de l'EPROM en octets

sans le int? Qu'es-ce qui diffère réellement?

int c'est un type (comme char, float et double)
long c'est un qualifieur (comme short) que l'on ajoute au type int pour indiquer une modification de sa longueur
il peut être omis. Cela ne génère donc pas d'erreur. Mais en même temps en le laissant on ne risque pas d'oublier le type que l'on utilise.

Ok, merci fdufnews,

Juste encore un petit détail.

On es d’accord, si je t’ai bien compris, que ci je compatre

int c = 0;
et unsigned long int d = 22222222222;

c doit être alors un long int alors?
J’aurai tendance à dire, non, qu’il n’y a pas besoin.

Mais tu as écris

Évidemment la remarque sur le type long s’applique aussi aux variables qui vont utiliser cette constante.

Qui me met donc dans le doute.
Dans un sens ca me semble logique que la variable c doit est un long int, si du coup elle prend une valeur supérieur à 65536.
Mais si elle ne devait pas être supérieur à 65536 (ce qui ne sera pas mon cas), elle peut rester en int.

non?

pierrot10:
On es d'accord, si je t'ai bien compris, que ci je compatre

int c = 0;
et unsigned long int d = 22222222222;

c doit être alors un long int alors?
J'aurai tendance à dire, non, qu'il n'y a pas besoin.

Si tu compares la variable avec un long c'est bien qu'à un moment ou un autre elle risque de prendre une telle valeur. Sinon à quoi servirait de faire cette comparaison?