Comment incrémenter ceci 0x0100

Bonjour,

J’ai ce nombre 0x0100 qui affiche 256, dans mon terminal.

J’aimerais l’incrémenter de 100. Soit avoir
0x0100
0x0200
0x0300
0x0400
etc

Donc dans mon code, j’ai ceci
Es-ce que l’on augmente un hexa, comme ceci

byte hexa = 0x0100;
for(byte y=0;y<=10;y++){
  Serial.println(hexa);
  hexa = hexa + 0x0100;

}

J’aimerais pouvoir enregistré des données tous les 100 positions

pierrot10:
J’aimerais l’incrémenter de 100. Soit avoir
0x0100
0x0200
0x0300
0x0400
etc

Donc dans mon code, j’ai ceci
Es-ce que l’on augmente un hexa, comme ceci

byte hexa = 0x0100;

for(byte y=0;y<=10;y++){
  Serial.println(hexa);
  hexa = hexa + 0x0100;

}

Oui tu incrémenteras de 0x100

pierrot10:
J’aimerais pouvoir enregistré des données tous les 100 positions

Là en fait tu enregistrera toutes les 256 positions 0x100 = 256 décimal

Je m'excuse mais je travaille pour la premiere fois avec un EEPROM

Mais ceci fais donc la meme chose

EEPROM.write(0x0100, data_len); EEPROM.write(256, data_len);

pierrot10: Je m'excuse mais je travaille pour la premiere fois avec un EEPROM

Mais ceci fais donc la meme chose

EEPROM.write(0x0100, data_len); EEPROM.write(256, data_len);

Oui c'est la même chose

Ce n'est en aucun cas lié à l'utilisation de l'EEPROM. C'est la syntaxe de base du C voir là : http://arduino.cc/en/Reference/IntegerConstants

C'est pas spécifique au C, c'est mathématique

100 en hexa, 256 en décimal, voie 1 0000 0000 en binaire sont juste des façons différentes d'afficher le même nombre.

Bon, en base 10 c'est plus facile pour nous, on a plus l'habitude.

Tu devrais dire plus facile pour vous, on prend facilement le reflex de compté en héxa ou en binaire quand on devient des gens comme nous xD

Donc je peux aussi remplacer ceci

#define EPROM_POS 0x0001
#define EPROM_LON 0x0008
#define EPROM_LAT 0x0024
#define EPROM_ALT 0x0040
#define EPROM_TIM 0x0056
#define EPROM_VEL 0x0072
#define EPROM_STA 0x0088

par un truc du genre

#define EPROM_POS 100
#define EPROM_LON 106
#define EPROM_LAT 132
#define EPROM_ALT 148
#define EPROM_TIM 164
#define EPROM_VEL 180
#define EPROM_STA 196

Ca serait en effet, plus simple pour moi

pierrot10: Donc je peux aussi remplacer ceci

#define EPROM_POS 0x0001
#define EPROM_LON 0x0008
#define EPROM_LAT 0x0024
#define EPROM_ALT 0x0040
#define EPROM_TIM 0x0056
#define EPROM_VEL 0x0072
#define EPROM_STA 0x0088

par un truc du genre

#define EPROM_POS 100
#define EPROM_LON 106
#define EPROM_LAT 132
#define EPROM_ALT 148
#define EPROM_TIM 164
#define EPROM_VEL 180
#define EPROM_STA 196

Ca serait en effet, plus simple pour moi

je ne comprends pas très bien comment tu passes de l'un à l'autre

Pour moi

define EPROM_POS 0x0001 = 1

define EPROM_LON 0x0008 = 8

define EPROM_LAT 0x0024 = 36

define EPROM_ALT 0x0040 = 64

define EPROM_TIM 0x0056 = 86

define EPROM_VEL 0x0072 = 114

define EPROM_STA 0x0088 = 136

Bonjour,

Je vais passer pour un vieux reloue mais dans ce genre de cas rien ne vaut un bon lien wikipedia pour (re)partir sur de bonne base (16) ;) http://fr.wikipedia.org/wiki/Système_hexadécimal

Manifestement tes notions de calculs en hexadécimal et en décimal sont encore assez flou.

En fait je cherche a faire la chose suivante, pour etre plus clair sur ma prochaine questionnement

J'ai des variable de type char

char cou[6] qui peut contenir une valeur entre 0 et 999999

char lon[15] qui peut contenir un nombre de 14 chiffre : expl: 45.123540300000

char lat[15] qui peut contenir un nombre de 15 chiffre : expl: 235.12354030000

char alt[15] qui peut contenir un nombre de 15 chiffre : expl: 845.12000000000 ( ca eut avoir pas de sens, mais je préfère garder 15 unité, pour le moment, meme si deux apres la virgule suffit)

char tim[15] qui peut contenir un chiffre a 14 chiffre 20130936293040

char vel[15] qui peut contenir un nombre a 15 chiffre : expl : 2.9999999999999

char sta[1] doit aussi, comme pour les autre ajouté 1 pour le \0 ?(char sta[2]) qui contient un chiffre a à nombre, expl : 3

J'aimerais prévoir un espace de mon EEPROM pour stoské ces chiifre, mais je ne sais pas encore comment prévoir cette espace.

Par exemple pour pos, ce chiffre de 1 à 999999, sera enregistré à la position une

#define EPROM_COU 1

mais pour les suivante, comment je peux savoir la position qu'il faut prévoir, juste après l'enregistrement de cou, à la position1

Etant donné que 999999 à 6 "untié", je pense que la position pour lon sera 8

#define EPROM_LON 8

Et etant donné que LAT peut avoir 15 caravtere LAT sera à 24

#define EPROM_LAT 24

Mon résonnement est juste? En fait j'ai un mega doute, parce que 24 en exa c'est 18, car j'oublie de conter A,B,C,D,E,F après 9

Donc si je corrige

#define EPROM_LAT 18

Et si je continue pour alt en additonant 15, ca serait pas 40 (en fair c'est 24+15=39, mais je compte 40), ca ferait 28 en hexa.

C'est bien ca non?

Si je veux incrémenter de 100, c'est que par la suite je veux enregistrer des positions tous les minutes. Donc pour plus facilement me retrouver (mais encore a déterminer), je pensais enregistrer au centaine pour la premiere minuet, au 200 pour la deuxiem minute comme pare exemple

position 101 pour COU la premiere minute position 108 pour LON la premiere minute position 118 pour LAT la premiere minute etc..

position 201 pour COU la deuxime minute position 208 pour LON la deuxieme minute position 218 pour LAT la deuxime minute etc..

position A01 pour COU la 10eme minute position A08 pour LON la 10eme minute position A18 pour LAT la 10eme minute etc..

position C01 pour COU la 12eme minute position C08 pour LON la 12eme minute position C18 pour LAT la 12eme minute etc..

position F01 pour COU la 15eme minute position F08 pour LON la 15eme minute position F18 pour LAT la 15eme minute etc..

Voilà l'idée.

Qu'en pensez vous?

J'en pense que tu t'égares.

utiliser une chaine de caractères pour stocker une valeur numérique n'a pas de sens. une chaine de caractères, c'est en effet un nombre, mais en base 256...

Sais-tu exactement ce dont tu as besoin? Certes arduino est conçu et orienté pour les débutants, mais il y a des limite. Le prends pas mal, c'est loin d'être un reproche. Mais juste un conseil, essaie de comprendre la notion de valeur dans une variable, le net en est plein.

par ailleurs, si tu tentes un truc genre :

char cou1[6] = "100000";
char cou2[6] = "050000";

char cou3[6] = cou1 + cou2;

tu vas t'arracher des cheveux, crois-moi.

déjà, ça utilisera 21 octets de mémoire, alors que pour 12 octets, tu as :

long cou1 = 100000;
long cou2 = 50000;

long cou3 = cou1 + cou2;

et en plus, ça, ça marche...

fdufnews:

pierrot10: Je m'excuse mais je travaille pour la premiere fois avec un EEPROM

Mais ceci fais donc la meme chose

EEPROM.write(0x0100, data_len); EEPROM.write(256, data_len);

Oui c'est la même chose

Ce n'est en aucun cas lié à l'utilisation de l'EEPROM. C'est la syntaxe de base du C voir là : http://arduino.cc/en/Reference/IntegerConstants

Tu n'es pas aller voir le lien que je t'avais donné ou alors tu n'as pas compris.

Lorsque tu écris un chiffre de cette manière 101 c'est du décimal Lorsque tu écris un chiffre de cette manière 0x101 c'est de l'hexadécimal Lorsque tu écris un chiffre de cette manière B101 c'est du binaire Suivant la base utilisé la valeur ne représente évidemment pas la même chose.

Si tu n'es pas à l'aise avec l'hexadécimal, pourquoi te faire du mal. Utilise la notation décimal. De toute façon, le compilateur se fiche complètement de la base que tu utilises pour compter au final il traduit tout ça dans son mode de comptage à lui.

Le fait d'écrire dans l'EEPROM n'impose pas un mode d'écriture particulier pour les valeurs. Les données stockées dans l'EEPROM se présentent comme celles qui sont stockées dans la RAM ou dans la Flash.

Super_Cinci: une chaine de caractères, c'est en effet un nombre, mais en base 256...

Une chaîne de caractères c'est une information stockée sous forme de texte c'est tout.

D'acord, je vous remercie pour ces informations.

J'en pense que tu t'égares.

Probablement :) je nage un peu, mais je commence à m'orienter :)

Lorsque tu écris un chiffre de cette manière 101 c'est du décimal Lorsque tu écris un chiffre de cette manière 0x101 c'est de l'hexadécimal Lorsque tu écris un chiffre de cette manière B101 c'est du binaire

En effet, je n'avais pas bien compris, désolé.

utiliser une chaine de caractères pour stocker une valeur numérique n'a pas de sen

En fait, la librairie que j'utilise, retourne les positions dans une variable de type char. Mais ta remarque sur l'espace qu'utilise un char m'intrique. Mais vu mon niveau, je vais rester avec des char. Et uen fois que j'aurais la métrise, je regarderai ensuite.

Mais sur ce plan, je vais donc garder le meme résonnement que j'ai décris dans mon précédent post, mais je vais informer les positions en hexas

define EPROM_COU 0x0001

define EPROM_LON 0x0008

...

define EPROM_LAT 0x0018

position 0xC01 pour COU la 12eme minute position 0xC08 pour LON la 12eme minute position 0xC18 pour LAT la 12eme minute

char cou1[6] = "100000"; char cou2[6] = "050000";

char cou3[6] = cou1 + cou2;

Je ne ferai jamais ca. je stoke des infromations, je n'ai pas besoin de faire des calculs etc

Et donc pour incrémenté les positions en fonction des minutes, je pense que ceci est valable, selon un précédent post

#define EPROM_COU 0x0001
byte increment = 0x0100;
byte result;

result = EPROM_COU + increment;
Serial.println(result); // 0x0101;

ou encore

#define EPROM_TEST 0x0901
byte increment = 0x0100;
byte result;

result = EPROM_COU + increment;
Serial.println(result); // 0x0A01;

Merci encore pour vos lumières

Par contre, je suis surpis d'un truc

#define EPROM_INC 0x0100
byte mask = 0x1100;

mask = mask+EPROM_INC;

mask devrait être egal à

0x1200

non?

pierrot10: Par contre, je suis surpis d'un truc

#define EPROM_INC 0x0100
byte mask = 0x1100;

mask = mask+EPROM_INC;




mask devrait être egal à


> 0x1200


non?

Non, la variable mask est de type byte donc limitée à 0xFF si tu veux voir le bon résultat déclare ta variable comme int ou unsigned int.

Euh, du reste tout est déclaré en byte en fait. Forcement que ca marche pas bien :/

Le mieux pour faire joujou avec des mask c'est des unsigned int pour des paquets de 16 bits, voir des unsigned long pour des pack de 32

MiGaNuTs:
Euh, du reste tout est déclaré en byte en fait. Forcement que ca marche pas bien :confused:

Le mieux pour faire joujou avec des mask c’est des unsigned int pour des paquets de 16 bits, voir des unsigned long pour des pack de 32

Faut pas se fier au nom, de ce que j’ai compris c’est plutôt l’adresse de base dans la mémoire

Bonjour,¨

Je suis toujours bloqué avec ceci. Du moins j'ai une solution, mais j'en suis pas convaicnu. Si vous pour m'en convaincre ou me dire comment vous le feriez mieux.

En résumé et pour rappel Je defini la position des enregustrement longitude, latitude, altitude etc

// 24LC236
#define EPROM_COU 0x0001
#define EPROM_LON 0x0008 // 8 en dec
#define EPROM_LAT 0x0018 // 24 en dec
#define EPROM_ALT 0x0028 // 40 en dec
#define EPROM_TIM 0x0038 // 56 en dec
#define EPROM_VEL 0x0048 // 72 en dec
#define EPROM_STA 0x0058  // 88 en dec
#define EPROM_INC 0x0100  // Incrementation
unsigned int mask=0x0000;
const byte rom = 0x50;    // Address of 24LC256 eeprom chip
char data[15];

Puis en suite , je dois trouver un truc pour que lorsque la fonction GetGPS() est appelée la deuxieme fois, il enregistre ces positions aux positions incrémentée de 0x0100, par exemple

course à l'adresse 0x0101 lontitude à la position 0x0108 latitude à la position 0x0118 altitude à la position 0x0128 etc

Puis quand elle sera appelée la troisème fois, ca serait ca

course à l'adresse 0x0201 lontitude à la position 0x0208 latitude à la position 0x0218 altitude à la position 0x0228 etc

et aindi de suite

J'ai donc trouvé cette solution. Comme pourriez-vous faire mieux, comment feriez-vous

char cou[15];
char lon[15];
char lat[15];
char alt[15];
char time[14];
char vel[6];
char sta[2];

// 24LC236
#define EPROM_COU 0x0001
#define EPROM_LON 0x0008 // 8 en dec
#define EPROM_LAT 0x0018 // 24 en dec
#define EPROM_ALT 0x0028 // 40 en dec
#define EPROM_TIM 0x0038 // 56 en dec
#define EPROM_VEL 0x0048 // 72 en dec
#define EPROM_STA 0x0058  // 88 en dec

#define EPROM_INC 0x0100  // Incrementation
unsigned int mask=0x0000;
const byte rom = 0x50;    // Address of 24LC256 eeprom chip

setup(){
 Serial.begin(9600);
  Wire.begin ();
}

loop(){
GetGPS();
delay(60000);
}

GetGPS(){
          
          gps.getPar(lon,lat,alt,time,vel);

        // first time mask is egual to 0x0000 then it will be recorded at position 0x0001
        // next time , mask is equla to 0x0100, then it will be recorded at position 0x0101
        // next time, mask is equal t0 0x0200, then it will be recorded at position 0x0201
        writeEEPROM(rom,mask+EPROM_COU,cou); // No worries about the value of cou, it's work
       // EPROM_LON will inrement as for EPROM_COU, etc
        writeEEPROM(rom,mask+EPROM_LON,lon);
        writeEEPROM(rom,mask+EPROM_LAT,lat);
        writeEEPROM(rom,mask+EPROM_ALT,alt);
        writeEEPROM(rom,mask+EPROM_TIM,tim);
        writeEEPROM(rom,mask+EPROM_VEL,vel);
        writeEEPROM(rom,mask+EPROM_STA,sta); // No worries about the value of sta, it's work, it not my worries

       mask = mask+EPROM_INC;
       // Incrment mask as the folowing 0x0100, 0x0200, 0x0300, 0x0400 .... 0x1100, 0x1200.. etc

}

How would you to bette, to increment the 2 digit of the hexa.

Was I clear to undertand, my wories?

Le principe de l'incrément fonctionne mais la mémoire est très mal utilisée. Tu écris dans les 90 octets et tu utilises un pas de 256 donc environ 1/3 de la mémoire ne sera pas utilisé. En plus ta mémoire fait 32k octets avec un pas de 256 pour chaque enregistrement tu ne pourras pas stocker plus de 32768/256 = 128. Avec un enregistrement toutes les minute comme tu l'as programmé cela de donne 2h d'enregistrement.