Show Posts
Pages: 1 [2] 3 4 ... 25
16  International / Français / Re: Comment incrémenter ceci 0x0100 on: September 30, 2013, 12:44:58 pm
Alors, oui j'ai essayé d'utiliser de int au lieu des long int.
et avec des int ca fonctionne.

Le truc c'est que je suis limitl à 32763  aors que le long int va au moins jusqu'a la valeur max de l'EEPROM soit de 262144.
Je suis conscient qu'il sera extrement rare d'aller jusquà ce grand nombre


Mais bon c'est vrai que j exagere puisque 32763min fait 546 heure.  smiley
17  International / Français / Re: Comment incrémenter ceci 0x0100 on: September 30, 2013, 10:02:50 am
Hello!

Oui j'avais essayéc eci sans succès
Code:
index_EPROM+=1L;

J'ai reproduit cette exrcice afin d'exclure une partie de mon code.
Ceci me permets de tester aJSON (qui ne marche pas, ca n'affiche le format JSON, mais doit encore chercher  smiley https://github.com/interactive-matter/aJson/blob/master/README.md ),

Mais avant, je souhaiterai comprendre et résoudre l'incrémentation qui ne dépasse pas 10L. J'ai mis les commentaire, dans le code.
Ha, ne le lisez pas le tout. Le probleme se situe dans setup() et dans loop(). Mais si c'est reglé dans setup(), ben ca regler dans loop()  smiley

Par contre je dois mettre le code me dehor du post, a cause de la limitation du nombre de caratctere:
http://www.hello-web.net/temp/forum2.html
18  International / Français / Re: Comment incrémenter ceci 0x0100 on: September 29, 2013, 04:30:55 pm
Hello,

Je constate qu'il y a un probleme au niveau de l'incrémentation (index)

Ceci est mon index
Code:
unsigned long int index_EPROM = 0L;

Je l'incrlmente simplement comme ceci

Code:
index_EPROM++;

Le truc c'es qu'il ne depasse pas 10. Ensuite il recommence à 0.
C'est pas bisard alors qu'on est en long int?
19  International / Français / Re: Comment remplacer une valeur d'une varaiable on: September 28, 2013, 03:23:16 pm
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
Quote
É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?
20  International / Français / Re: Comment remplacer une valeur d'une varaiable on: September 28, 2013, 02:30:21 pm
J'ai rwgardé un peu la doc arduino

Es-tu sure de ca ?
Code:
const unsigned long int eprom_size = 262144L ; //32768  // taille de l'EPROM en octets
ne serait-ce pas
Code:
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
Code:
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?
21  International / Français / Re: Comment remplacer une valeur d'une varaiable on: September 28, 2013, 12:31:41 pm
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  smiley
22  International / Français / Re: Comment remplacer une valeur d'une varaiable on: September 27, 2013, 05:09:08 pm
ok
Quote
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
Quote
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
Code:
const unsigned int eprom_size = 262144; //32768  // taille de l'EPROM en octets

Quote
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  smiley
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é:
Code:
writeEEPROM(rom,(eprom_inc*index_EPROM)+eprom_lon,lon);

Encore merci.

Prochain gors chapitre : XML; mettre ce qui est collecter par la boucle
Code:
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.
23  International / Français / Comment remplacer une valeur d'une varaiable on: September 27, 2013, 03:58:32 pm
Bonjour à tous,

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


Sachant que
Code:
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
Code:
index_EPROM += ((eprom_size/eprom_inc)-1);
était la meme chose que
Code:
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
Code:
index_EPROM += ((eprom_size/eprom_inc)-1);
Car il incrémente alors que je veux remplacer, et devrait être
Code:
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  smiley-cry
24  International / Français / Re: Comment incrémenter ceci 0x0100 on: September 27, 2013, 05:54:56 am
Super. Milles mercis pour tout ces explications. C'est super cool.

Quote
Pour la bière, t'inquiète, je n'oublie pas, méfiance si un jour tu viens en vacances dans le coin!
J'y étais, y a ....deux ans. Et comme ca été vraiment bien, ca sera en grand plaisir de revenir.

 smiley-cool
25  International / Français / Re: Comment incrémenter ceci 0x0100 on: September 27, 2013, 04:52:27 am
oK alors je vais rester sur
Quote
const unsigned int eprom_cou = 0x0000;
meme s'il y aun peu plus d'écriture, si c'est la même chose?

Par contre derniere question, on est d'acord que de faire
Code:
const unsigned int EPROM_COU = 0x0000;
ou
Code:
const unsigned int EPROM_COU = 0;

c'est exactement la même chose pour le microtrolleur? (juste pour avoir une confirmation.

En tout cas, milles mercis (et a fdufnews aussi) pour toutes ces explications et le temps passé.

Je passerai bien en bretagne te payer une biere, mais c'est fait un peu loin, suis de l'autre côté  smiley
26  International / Français / Re: Comment incrémenter ceci 0x0100 on: September 27, 2013, 01:44:27 am
Bon , hier soir, avec une petite bière dans la main  smiley, j'ai pensé à un truc.

1) Es-ce que je dois absolument utiliser des hexa comme
Code:
#define EPROM_COU 0x0000;

D'après cr que j'ai pu lire, dans mes précédents post, je pourrai faire ceci
Code:
#define EPROM_COU 0;

Aussi, j'ai remplacer mes #define par des const, mais uniquement pour la difition des positions dans l'eeprom:

Code:
// 24LC236
const unsigned int EPROM_COU = 0x0000;
const unsigned int EPROM_LON = EPROM_COU+SIZE_COU; //7
const unsigned int EPROM_LAT = EPROM_LON+SIZE_LON; //22
const unsigned int EPROM_ALT = EPROM_LAT+SIZE_LAT; //37
const unsigned int EPROM_TIM = EPROM_ALT+SIZE_ALT; //52
const unsigned int EPROM_VEL = EPROM_TIM+SIZE_TIM; //67
const unsigned int EPROM_STA = EPROM_VEL+SIZE_VEL; //82
const unsigned int EPROM_INC = EPROM_STA+SIZE_STA; //84 // Incrementation de façon à ce que le prochain enregistrement se fasse directement à la suite
et là! ceci
Code:
Serial.print(F("EPROM_INC*INDEX : ")); Serial.println(index_EPROM*EPROM_INC); // Affiche 0 et plus 84 :o)
m'affiche bien 0 quand EPROM_INC est egal à 84 et index_EPROM est egal à 0. Aussi, que j'utilise 0x0000 ou 0, ca ne change rien, mais bon ca ne m'étonne pas.

S'il y a une remarque concernant ce changement, je vais laisser ceci, mais je me pose la question, pourquoi le #define cause se problème. Mais d'un cote, je prefere garder ceci, comme ceci, car ce me semble plus claire quand on defini distinctement, le type de EPROM_INC ou EPROM_XXX.

N'es-ce pas?

J'ai aussi unsigned, vu que me s nombres ne seront pas en dessous de zero, et en 8bit...

 smiley
27  International / Français / Re: Comment incrémenter ceci 0x0100 on: September 26, 2013, 03:45:54 pm
Quote
j'appelle ça de l'optimisation. n'oublions pas que l'arduino est une plateforme 8 bits, et que bosser avec 16 bits lui demande pas loin de 10 x plus de temps qu'avec un simple octet. alors je travaille toujours avec des variables 8bits non signées, et seulement si j'ai besoin, j'attaque les word, int, long...
Ok mais alors pourquoi utiliser un word alors qu unsigned int, serait plus optimal alors?

Mais ce qui me rpéoccupe le plus c'est le "82".
A savoir que
Code:
#define SIZE_COU 7
#define SIZE_LON 15
#define SIZE_LAT 15
#define SIZE_LON 15
#define SIZE_ALT 15
#define SIZE_TIM 15
#define SIZE_VEL 15
#define SIZE_STA 2

char stat;
char lon[SIZE_LON];
char lat[SIZE_LAT];
char alt[SIZE_ALT];
char time[SIZE_TIM];
char vel[SIZE_VEL];
char msg1[5];
char msg2[5];
char coords[99];
byte courseid;

#define EPROM_COU 0x0000
#define EPROM_LON EPROM_COU+SIZE_COU //7
#define EPROM_LAT EPROM_LON+SIZE_LON //22
#define EPROM_ALT EPROM_LAT+SIZE_LAT //37
#define EPROM_TIM EPROM_ALT+SIZE_ALT //52
#define EPROM_VEL EPROM_TIM+SIZE_TIM //67
#define EPROM_STA EPROM_VEL+SIZE_VEL //82
#define EPROM_INC EPROM_STA+SIZE_STA //84 // Incrementation de façon à ce que le prochain enregistrement se fasse directement à la suite

word index_EPROM = 0;

Par contre j'ai essayé de remplacé ceci
Code:
        Serial.print(F("INDEX : ")); Serial.println(index_EPROM); // Affiche 0
        Serial.print(F("EPROM_INC : ")); Serial.println(EPROM_INC); // Affche 84
        Serial.print(F("EPROM_INC*INDEX : ")); Serial.println(EPROM_INC*index_EPROM); // Affiche 82

Code:
        Serial.print(F("INDEX : ")); Serial.println(index_EPROM); // Affiche 0
        Serial.print(F("EPROM_INC : ")); Serial.println(EPROM_INC); // Affche 84
        Serial.print(F("EPROM_INC*INDEX : ")); Serial.println(EPROM_INC*0); // Affiche 82

Code:
        Serial.print(F("INDEX : ")); Serial.println(index_EPROM); // Affiche 0
        Serial.print(F("EPROM_INC : ")); Serial.println(EPROM_INC); // Affche 84
        Serial.print(F("EPROM_INC*INDEX : ")); Serial.println(84*0); // Affiche 0
Code:
        Serial.print(F("INDEX : ")); Serial.println(index_EPROM); // Affiche 0
        Serial.print(F("EPROM_INC : ")); Serial.println(EPROM_INC); // Affche 84
        Serial.print(F("EPROM_INC*INDEX : ")); Serial.println(index_EPROM*EPROM_INC); // Affiche 84 mais devrait affihcer 0
28  International / Français / Re: Comment incrémenter ceci 0x0100 on: September 26, 2013, 02:34:49 pm
Bon , j'espère ne pas avoir loupé une partie de ton explication, mais il y a un peti binz.

Par exemple
Code:
// SI
#define EPROM_COU 0x0000
#define EPROM_INC 84
// D'AILLEUR, POURQUOI word ET PAS int?
word index_EPROM = 0;

Serial.println((EPROM_INC*index_EPROM)+EPROM_COU);
// CECI DEVRAIT AFFICHER ZERO, MAIS IL M'AFFICHE 82

Si EPROM_INC est egal à 84 et qu'on multiplie par 0, ca doit faire 0. Et si après on fait 0 + 0x0000. Il doit s'afficher  0 ou 0x0000.

Pourquoi ca afiiche 82, et même pas 84?
29  International / Français / Re: Comment incrémenter ceci 0x0100 on: September 25, 2013, 09:38:17 am
Je suis en train de reproduire la porposition de supercinci.
Et j'ai une question:
Dans ce code
Code:
#define EPROM_LON EPROM_LAT+SIZE_LAT // 15 octets plus loin (taille de cou[15] enregistré précédemment)
On additionne EPROM_LAT qui est en hexa avec SIZE_ALT qui ne l'est pas. Ca ne rsique pas de causer un proble dans le résultat, vu qu'on est en hexa??
30  International / Français / Re: Comment incrémenter ceci 0x0100 on: September 25, 2013, 05:54:22 am
Super merci et aussi a super_cinci.

J'ai lu rapidement vos idées. Je prendrai le temps de bien relire, ce soir et voir comment adapter mon code pour le rendre plus optimal en fonction de vos comentaire.

Je vous remercie
Pages: 1 [2] 3 4 ... 25