problème EEPROM.write

bonjour tout le monde,
je me confronte à un léger problème.
je veux envoyer 4 valeurs dans le nono.
tant que j'en envoie 3, c'est bon, après c'est la cata, problème de byte?
les valeurs sont des int (ex : 250-1250-75-990)

si vous avez une idée, car je dois pouvoir envoyer par la suite entre 6 et 12 valeurs

#include <EEPROM.h>
#include <SPI.h>       // needed for Arduino versions later than 0018
#include <Ethernet.h>
#include <Client.h>
#include <Udp.h>         // UDP library from: bjoern@cs.stanford.edu 12/30/2008
//#include "DHT.h"
//#define DHTPIN A0 


// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = {  
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 
  192,168,2,200 };
unsigned char gateway[] = { 
  192,168,2,2 };			
unsigned char mask[] = {
  255,255,255,0}; 

byte serverdist[] = { 192,168,2,14 };
Server server(80);
Client client(serverdist, 80);
unsigned int localPort = 80;      // local port to listen on
int ventilo = 8; // led
int resistance = 9; // led

int batMonPin = A1; 
int val = 0;   
float pinVoltage = 0; 
float batteryVoltage = 0;
float ratio = 5.5; 
int photocellPin = A5;
int photocellVal = 0; 

// the next two variables are set when a packet is received
byte remoteIp[12];        // holds received packet's originating IP
unsigned int remotePort; // holds received packet's originating port

// buffers for receiving and sending data
char  packetBuffer[UDP_TX_PACKET_MAX_SIZE]; //buffer to hold incoming packet,
char  packetBuffer1[UDP_TX_PACKET_MAX_SIZE]; //buffer to hold incoming packet,
char  packetBuffer2[UDP_TX_PACKET_MAX_SIZE]; //buffer to hold incoming packet,
char  packetBuffer22[UDP_TX_PACKET_MAX_SIZE]; //buffer to hold incoming packet,
char  ReplyBuffer[] = "acknowledged";       // a string to send back
char  ReplyBuffer1[] = "acknowledged";       // a string to send back
char  ReplyBuffer2[] = "acknowledged";       // a string to send back
char  ReplyBuffer22[] = "acknowledged";       // a string to send back

int address = 0;
byte value;

int lumiere1;
int temps1;
int lumiere2;
int temps2;

int lumiere1mem;
int temps1mem;
int lumiere2mem;
int temps2mem;


int readFloat(int address) {
  union floatStore {
    byte floatByte[4];
    int floatVal;
  } 
  floatOut;

  for (int i = 0; i < 4; i++) 
    floatOut.floatByte[i] = EEPROM.read(address + i);
  return floatOut.floatVal;
}

void writeFloat(int value, int address) {
  union floatStore {
    byte floatByte[4];
    int floatVal;
  } 
  floatIn;

  floatIn.floatVal = value;
  for (int i = 0; i < 4; i++) 
    EEPROM.write(address + i, floatIn.floatByte[i]);

}



void setup() {
  Ethernet.begin(mac, ip, gateway, mask);
  Udp.begin(localPort);
  Serial.begin(9600);
  pinMode(ventilo, OUTPUT);
  pinMode(resistance, OUTPUT); 
  server.begin();
  
  pinMode(photocellPin, INPUT);

  lumiere1mem = readFloat(address);
  Serial.print("lumiere 100% :");
  Serial.println(lumiere1mem);
  lumiere1=lumiere1mem; 
  
  temps1mem = readFloat(address+4);
  Serial.print("temps 100% :");
  Serial.println(temps1mem);
  temps1=temps1mem; 

  lumiere2mem = readFloat(address+8);
  Serial.print("lumiere 100% :");
  Serial.println(lumiere2mem);
  lumiere2=lumiere2mem; 
  
  temps2mem = readFloat(address+12);
  Serial.print("temps 100% :");
  Serial.println(temps2mem);
  temps2=temps2mem; 
  
}

void loop() {
  int packetSize = Udp.available();
  if(packetSize)
  {
  val = analogRead(batMonPin);   
  pinVoltage = val * 0.00488;      
  batteryVoltage = pinVoltage * ratio;
  Serial.println(batteryVoltage);
     
      if (client.connect()) {
        delay(2000);
    Serial.println("connected");
    Serial.print(lumiere1);
    client.print("GET /recuplamp.php?lumere1=");
    client.print(lumiere1);
    client.print("&temps1=");
    client.print(temps1);
    client.print("&lumiere2=");
    client.print(lumiere2);
    client.print("&temps2=");
    client.print(temps2);
    client.print("\n");
    
    client.stop();
   
    }  
    packetSize = packetSize - 8;      // subtract the 16 byte header
    Serial.print("Received packet of size ");
    Serial.println(packetSize);


    memset(packetBuffer, 0, UDP_TX_PACKET_MAX_SIZE);
    memset(packetBuffer1, 0, UDP_TX_PACKET_MAX_SIZE);
   
    memset(packetBuffer2, 0, UDP_TX_PACKET_MAX_SIZE);

    memset(packetBuffer22, 0, UDP_TX_PACKET_MAX_SIZE);    

    
    Udp.readPacket(packetBuffer,UDP_TX_PACKET_MAX_SIZE, remoteIp, remotePort);
    Serial.print("Contents:");
    Serial.println(packetBuffer);
    
    Udp.readPacket(packetBuffer1,UDP_TX_PACKET_MAX_SIZE, remoteIp, remotePort);
    Serial.print("Contents1:");
    Serial.println(packetBuffer1);   

    Udp.readPacket(packetBuffer2,UDP_TX_PACKET_MAX_SIZE, remoteIp, remotePort);
    Serial.print("Contents2:");
    Serial.println(packetBuffer2);   
   
    Udp.readPacket(packetBuffer22,UDP_TX_PACKET_MAX_SIZE, remoteIp, remotePort);
    Serial.print("Contents22:");
    Serial.println(packetBuffer22);       

    lumiere1 =  atof(packetBuffer);
    temps1 =  atof(packetBuffer1);
    
    lumiere2 =  atof(packetBuffer2);
    temps2 =  atof(packetBuffer22);

    writeFloat(lumiere1,address);
    
    writeFloat(temps1,address+4); 
    
    writeFloat(lumiere2,address+8);

    writeFloat(temps2,address+12);     

    Serial.print("lumiere1 : ");
    Serial.println(lumiere1);
    Serial.print("temps1 : ");
    Serial.println(temps1);   
    Serial.print("lumiere2 : ");
    Serial.println(lumiere2);
    Serial.print("temps2 : ");
    Serial.println(temps2);      

  }

}

Il y a une embrouille avec des variables qui sont préfixées float mais qui sont définies comme des int mais quand même codées sur 4 octets dans une union.
A ta place je commencerai par faire le ménage la dedans avant d'aller plus loin.
Ce truc à l'odeur du code récupéré mais mal adapté.

fdufnews:
Il y a une embrouille avec des variables qui sont préfixées float mais qui sont définies comme des int mais quand même codées sur 4 octets dans une union.
A ta place je commencerai par faire le ménage la dedans avant d'aller plus loin.
Ce truc à l'odeur du code récupéré mais mal adapté.

c'est le code de ma couveuse que j'ai repris en rajoutant des valeurs envoyées en plus.
j'ai remplacé les float par int mais sans succès.
jusqu'à 3 valeurs envoyées, ca baigne nickel, dès que j'en envoie 4, ca merdouille.
donc cela viendrait il du fait qu'il y a plus de 8 bits d'envoyées?
si oui, comment faire?

Peut-être qu'il serait plus simple de faire un projet minimal qui lit et écrit dans l'EEPROM ? Parce que là c'est noyé parmi tout un tas de trucs qui rendent le debug plus difficile :roll_eyes:

je veux envoyer 4 valeurs dans le nono. Tant que j'en envoie 3, c'est bon, après c'est la cata, problème de byte?

En fait tu ne nous as pas dit ce qui allait de travers.

j'ai remplacé les float par int mais sans succès.

Oui mais les int sont codés sur 2 octets donc il faudrait commencer par changer la définition de ton union.

  union intStore {
    byte intByte[2];
    int intVal;
  } 
  intOut;

Je viens de jeter un petit coup d'oeil dans les librairies avr et en fait ces fonctions existent déjà.

j'ai entré un petit bout de code pour tester la compilation.

#include <avr/eeprom.h>

int toto=2654;
int tata;

void setup(void){
  eeprom_write_word ((unsigned int *)100,toto);
  tata=eeprom_read_word ((unsigned int *)100);
}

void loop(void){
}

La compilation se passe sans problème. Par contre je n'ai pas pu tester, je n'ai pas d'arduino sur moi.

Si tu veux essayer.....

Edit: les mêmes fonctions existent aussi pour des long et des transfert de blocs d'octets. Voir dans "repertoireArduino"\hardware\tools\avr\avr\include\avr\eeprom.h

voila ce que ca donne après avoir envoyé 250 10 90 10

Received packet of size 23

Contents:250À¨¡h

Contents1:

Contents2:

Contents22:

lumiere1 : 250

temps1 : 0

lumiere2 : 0

temps2 : 0

Received packet of size 33

Contents:250À¨¤²

Contents1:

Contents2:

Contents22:

lumiere1 : 250

temps1 : 0

lumiere2 : 0

temps2 : 0

si j'envoie que 3 valeurs, j'ai bien tout 250 10 95

Received packet of size 13

Contents:250

Contents1:10

Contents2:95

Contents22:

lumiere1 : 250

temps1 : 10

lumiere2 : 95
temps2 : 0

je viens de voir que si j'envoie juste après 250 10 125
tout se décale

Received packet of size 24

Contents:250

Contents1:

Contents2:10

Contents22:125

lumiere1 : 250

temps1 : 0

lumiere2 : 10

temps2 : 125

Received packet of size 3

Contents:250

Contents1:

Contents2:10

Contents22:125

lumiere1 : 250

temps1 : 0

lumiere2 : 10

temps2 : 125

En regardant de plus prêt ton code je ne comprends pas très bien ton problème.
Les captures que tu as mises dans le post précédent correspondent au contenu des paquets que tu reçois il me semble. Quel rapport avec l'eeprom?
Si tu veux tester l'écriture/lecture en eeprom tu ferais bien de faire juste un bout de code minimaliste qui teste les fonctions en question comme le suggère SesechXP.

j'ai réduis au plus minimalissime

#include <EEPROM.h>
#include <SPI.h>       
#include <Ethernet.h>
#include <Client.h>
#include <Udp.h>        

byte mac[] = {  
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 
  192,168,2,200 };
unsigned char gateway[] = { 
  192,168,2,2 };			
unsigned char mask[] = {
  255,255,255,0}; 

byte serverdist[] = { 192,168,2,14 };
Server server(80);
Client client(serverdist, 80);
unsigned int localPort = 80;      


// the next two variables are set when a packet is received
byte remoteIp[4];        // holds received packet's originating IP
unsigned int remotePort; // holds received packet's originating port

// buffers for receiving and sending data
char  packetBuffer[UDP_TX_PACKET_MAX_SIZE]; //buffer to hold incoming packet,
char  ReplyBuffer[] = "acknowledged";       // a string to send back

char  packetBuffer1[UDP_TX_PACKET_MAX_SIZE]; //buffer to hold incoming packet,
char  ReplyBuffer1[] = "acknowledged";       // a string to send back

char  packetBuffer2[UDP_TX_PACKET_MAX_SIZE]; //buffer to hold incoming packet,
char  ReplyBuffer2[] = "acknowledged";       // a string to send back

char  packetBuffer22[UDP_TX_PACKET_MAX_SIZE]; //buffer to hold incoming packet,
char  ReplyBuffer22[] = "acknowledged";       // a string to send back




int address = 0;
byte value;

 int lumiere1;
 int temps1;
 int lumiere2;
 int temps2;

 int lumiere1mem;
 int temps1mem;
 int lumiere2mem;
 int temps2mem;



// Utilities for writing and reading from the EEPROM
int readFloat(int address) {
  union floatStore {
    byte floatByte[2];
    int floatVal;
  } 
  floatOut;

  for (int i = 0; i < 4; i++) 
    floatOut.floatByte[i] = EEPROM.read(address + i);
  return floatOut.floatVal;
}

void writeFloat(int value, int address) {
  union floatStore {
    byte floatByte[2];
    int floatVal;
 
  } 
  floatIn;

   
  floatIn.floatVal = value;
  for (int i = 0; i < 4; i++) 
    EEPROM.write(address + i, floatIn.floatByte[i]);

}



void setup() {
  // start the Ethernet and UDP:
  Ethernet.begin(mac, ip, gateway, mask);
  Udp.begin(localPort);
  Serial.begin(9600);
  server.begin();

  lumiere1mem = readFloat(address);
  Serial.print("lumiere 100% :");
  Serial.println(lumiere1mem);
  lumiere1=lumiere1mem; 
  
  temps1mem = readFloat(address+4);
  Serial.print("temps 100% :");
  Serial.println(temps1mem);
  temps1=temps1mem; 

  lumiere2mem = readFloat(address+8);
  Serial.print("lumiere 100% :");
  Serial.println(lumiere2mem);
  lumiere2=lumiere2mem; 
  
  temps2mem = readFloat(address+12);
  Serial.print("temps 100% :");
  Serial.println(temps2mem);
  temps2=temps2mem; 
  
}

void loop() {

  // if there's data available, read a packet
  int packetSize = Udp.available(); // note that this includes the UDP header
  if(packetSize)
  {
 
    packetSize = packetSize - 8;      // subtract the 16 byte header
    Serial.print("Received packet of size ");
    Serial.println(packetSize);


    memset(packetBuffer, 0, UDP_TX_PACKET_MAX_SIZE);
    memset(packetBuffer1, 0, UDP_TX_PACKET_MAX_SIZE);
    memset(packetBuffer2, 0, UDP_TX_PACKET_MAX_SIZE);
    memset(packetBuffer22, 0, UDP_TX_PACKET_MAX_SIZE);    

    
    Udp.readPacket(packetBuffer,UDP_TX_PACKET_MAX_SIZE, remoteIp, remotePort);
    Serial.print("Contents:");
    Serial.println(packetBuffer);
    
    Udp.readPacket(packetBuffer1,UDP_TX_PACKET_MAX_SIZE, remoteIp, remotePort);
    Serial.print("Contents1:");
    Serial.println(packetBuffer1);   

    Udp.readPacket(packetBuffer2,UDP_TX_PACKET_MAX_SIZE, remoteIp, remotePort);
    Serial.print("Contents2:");
    Serial.println(packetBuffer2);   
   
    Udp.readPacket(packetBuffer22,UDP_TX_PACKET_MAX_SIZE, remoteIp, remotePort);
    Serial.print("Contents22:");
    Serial.println(packetBuffer22);       

    lumiere1 =  atof(packetBuffer);
    temps1   =  atof(packetBuffer1);
    lumiere2 =  atof(packetBuffer2);
    temps2   =  atof(packetBuffer22);

    writeFloat(lumiere1,address);
    writeFloat(temps1,address+4); 
    writeFloat(lumiere2,address+8);
    writeFloat(temps2,address+12);     

    Serial.print("lumiere1 : ");
    Serial.println(lumiere1);
    Serial.print("temps1 : ");
    Serial.println(temps1);   
    Serial.print("lumiere2 : ");
    Serial.println(lumiere2);
    Serial.print("temps2 : ");
    Serial.println(temps2);      



  }

}

mais au bout d'un moment, ca cafouille total.
2 valeurs envoyées, nickel, 3 ca tient 3 envoies et ca cafouille, 4, c'est cata.
bon j'ai la grippe, donc le neurone pas trop en place.

infobarquee:
mais au bout d'un moment, ca cafouille total.
2 valeurs envoyées, nickel, 3 ca tient 3 envoies et ca cafouille, 4, c'est cata.
bon j'ai la grippe, donc le neurone pas trop en place.

Bonjour
Tu a surement attrapé la nouvelle grippe aviaire ! (canards en bois au micro-onde) :grin:

pas bien le temps de me poser sur le code , mais pour simple test :

decale ton premier poste de tableau [0] vers ...5,6, ... pour voir si la "merdouille" est reproductible

j'ai réduis au plus minimalissime

Ben non puisqu'il y a toujours mélangé les accès Ethernet et l'écriture en eeprom. Tu ne sais pas dire si le problème vient de l'écriture en eeprom, de la liaison Ethernet ou d'une interaction des deux.

Il ne faut pas perdre de vue que l'écriture en eeprom n'est pas transparente, elle bloque l'exécution du code pendant un moment.

\note All of the read/write functions first make sure the EEPROM
is ready to be accessed. Since this may cause long delays if a
write operation is still pending, time-critical applications
should first poll the EEPROM e. g. using eeprom_is_ready() before
attempting any actual I/O. But this functions are not wait until
SELFPRGEN in SPMCSR becomes zero. Do this manually, if your
softwate contains the Flash burning.
(extrait des commentaires dans avr/eeprom.h)

argggggg vais y perdre mon latin, m'en fiche j'ai encore des canards en plus depuis cet aprem. :slight_smile:

j'ai mis en long qui est sur 4 bytes comme le float au lieu de int, 2 valeurs ok et toujours la ###???? ]:smiley: après

fdufnews:

j'ai réduis au plus minimalissime

Ben non puisqu'il y a toujours mélangé les accès Ethernet et l'écriture en eeprom. Tu ne sais pas dire si le problème vient de l'écriture en eeprom, de la liaison Ethernet ou d'une interaction des deux.

Je plussoie
Appliquer le rasoir d'Ockam : simplifie, simplifie, élimine les hypothèses jusqu'à ce que soit tu tombes sur quelque chose d'évident soit ca marche.
Et tu pourra repartir de là.

alors j'ai résolu le problème par une ruse de sioux breton pur sel de guérande :slight_smile:

au lieu d'envoyer plusieurs packets donc valeurs, j'ai tout mis dans un seul en mettant des pointeurs afin de parser le buffer.
par contre j'ai quelques doutes sur l'état de l'eeprom ou l'encodage du packet.
je peux me retrouver avec les bonnes valeurs dans la console comme :
les - et ? sont mes marquers de séparation de valeurs et fin de ligne

1250-90-9500-56?

comme ca peut afficher en envoyant la même chose

125!-90-95 0-56?

il me reste a parser (ma hantise en C# mais pas en php) afin de récupérer mes valeurs pour la suite.
tout est en char maintenant.

bonjour,
ayant un peu de temps cet après midi, je me suis repenché sur ce problème de plusieurs variables envoyées.
autant ca peut très bien fonctionner 3-4-5 fois de suite, autant ca peut partir en pinuts pour une raison x.
pour tester, j'envoie les même valeurs à chaque fois et voila le résultat

lumiere 100% :1250

temps 100% :50

lumiere 50% :900

temps 50% :150

Received packet of size 14

Contents:1250À¨?Ò

Contents1:

Contents1:

Contents1:

lumiere1 : 1250

temps1 : 0

lumiere2 : 0

temps2 : 0

connected

Received packet of size 36

Contents:1250

Contents1:50

Contents1:900

Contents1:150

lumiere1 : 1250

temps1 : 50

lumiere2 : 900

temps2 : 150

connected

Received packet of size 36

Contents:1250

Contents1:50

Contents1:900

Contents1:150

lumiere1 : 1250

temps1 : 50

lumiere2 : 900

temps2 : 150

connected

Received packet of size 36

Contents:1250

Contents1:50

Contents1:900

Contents1:150

lumiere1 : 1250

temps1 : 50

lumiere2 : 900

temps2 : 150

connected

j'ai résolu en partie le problème via un subterfuge trouvé dans la partie english du forum en remplacant

    Udp.readPacket(packetBuffer,UDP_TX_PACKET_MAX_SIZE, remoteIp, remotePort);

par

     Udp.readPacket(packetBuffer,packetSize, remoteIp, remotePort);

mais bon, tant que c'est pas à 100% à chaque fois, je continu de chercher une solution fiable.

alors des petites news, apparemment je suis pas le seul a avoir eu ce genre de problème.
je suis en train de tester cette solution et pour le moment, je dirais que ca fonctionne plutot mieux.
voici le lien et les modifs faites par certains pour la 022 et 1.0
http://code.google.com/p/arduino/issues/detail?id=669

De toute façon n'oublions pas qu'il n'y a pas de garantie d'acheminement sur UDP et que n'importe quel équipement réseau à le droit de mettre les datagrammes à la poubelle s'il en a ras la g...e.
TCP résoud ce problème par des handshake et des retransmissions si nécessaire.
Mais bon, normalement on ne s'attend pas à perdre des packets sur un réseau local normalement chargé.

Est ce- qu'il faut récupérer les fichiers les uns après les autres dans la discussion ou bien les modifs ont été fondues dans le tronc ?

tu peux trouver toutes les modifs fixed ici

Ok. Dont le github est mis à jour au jour-le-jour.
Et contient donc tous les fixes qui peuvent être fait entre les release stables officielles.
Merci, je ne le savais pas.