Ecriture memoire Eeprom I2C type 24LC..

Un log shield sur carte SD avec horloge RTC et zone de prototypage à pastilles carrées

Ecriture memoire Eeprom I2C type 24LC..

Message non lude Valery01 » Sam 24 Nov 2012 19:38

Bonjour,

Je vous joint juste la partie qui sert à sauvegarder des valeurs en mémoire eeprom I2C du code que je suis en train de développer.
C'est fonctionnel mais dans le principe : écrire 32 fois une valeur différente ça me gêne, je préférerai faire une "chaine" ou un buffer de 128 Bytes contenant les 32 valeurs et l'écrire en une seule fois sur l'eeprom.
Je bute sur ce point, je pense qu'il faut utiliser les pointeurs mais je débute en C et ces notions me sont pas familières.

Auriez vous une idée sur la façon de faire ?


#include <I2C.h>

const int WP=24; //broche 24 pour protection ecriture mémoire Eeprom
const int adr0=30; // broche 30 pour pin A0 adresse Eeprom
const int adr1=28; // broche 28 pour pin A1 adresse Eeprom
const int adr2=26; // broche 26 pour pin A2 adresse Eeprom
const int MI2C=32; // broche 32 pour pin maitre bus I2C
volatile int adr_lect;
volatile int adr_ecrt;
volatile boolean prot_mem=true;
volatile float zero[16] = {0};
volatile float echel[16] = {0};
volatile boolean adr_high=false;

void setup()
{
  // configure la broche numérique en SORTIE
  pinMode(WP,OUTPUT);
  pinMode(adr0,OUTPUT);
  pinMode(adr1,OUTPUT);
  pinMode(adr2,OUTPUT);
  pinMode(MI2C,OUTPUT);
  digitalWrite(adr0,0);
  digitalWrite(adr1,0);
  digitalWrite(adr2,adr_high);
  Serial.begin(19200);
  ecrtEchel(); 
}


  
void ecrtEchel()
{
  I2c.begin(); // initialise le bus I2C
  I2c.setSpeed(1);
  prot_mem=false; // désactive la broche protection mémoire
  digitalWrite(WP,prot_mem);
  for(int u=0; u<16 ;u++)
  {
    adr_ecrt=128 + u*4;
    I2c.write(0x50,adr_ecrt,zero[u]);
    delay(5);
    adr_ecrt=128 + 64+ u*4;
    I2c.write(0x50,adr_ecrt,zero[u]);
    delay(5);
  }
  prot_mem=true;
  digitalWrite(WP,prot_mem);
  }
  
  
void loop()
{
}
          
  

Valery01
 
Messages: 14
Inscription: Sam 17 Nov 2012 17:15

Re: Ecriture memoire Eeprom I2C type 24LC..

Message non lude Valery01 » Sam 24 Nov 2012 22:54

J'ai "parlé" trop vite le compilateur ne donne pas d'erreur mais ça ne fonctionne pas, l'Arduino plante.

Comment sauvegarder des nombres flottant dans une eeprom?
Valery01
 
Messages: 14
Inscription: Sam 17 Nov 2012 17:15

Re: Ecriture memoire Eeprom I2C type 24LC..

Message non lude SesechXP » Dim 25 Nov 2012 09:23

Salut,

Tu as vu juste, il faut utiliser les pointeurs ;) Voici un exemple pour illustrer :

Code: Tout sélectionner
#include <stdint.h>
#include <string.h>

static void write_bytes(uint8_t* p_data, uint8_t length);

int main(void)
{
    float value = 123.456;

    // On obtient un pointeur sur le réel value.
    float* p_value = &value;

    // On appelle la fonction d'écriture en eeprom. Il est nécessaire de caster le pointeur.
    write_bytes((uint8_t*)p_value, sizeof(value));
}

static void write_bytes(uint8_t* p_data, uint8_t length)
{
    for (uint8_t i = 0; i < length; i++)
    {
        // Ecriture de l'octet p_data[i]
    }
}


Je te laisse adapter ce principe à l'écriture en EEPROM. Par contre n'oublie pas que les EEPROM 24Cxxxx supportent l'écriture séquentielle. C'est à dire que tu indiques ton adresse de départ puis tu envoies les octets les uns après les autres.
SesechXP
 
Messages: 228
Inscription: Sam 28 Mai 2011 09:09
Localisation: 35

Re: Ecriture memoire Eeprom I2C type 24LC..

Message non lude Valery01 » Mar 27 Nov 2012 18:23

Merci de ta réponse.
Je crois avoir compris, en tout cas j'ai réussi à coder quelque chose qui fonctionne mais en écrivant à ma façon. Probablement que je n'écris pas les règles de l'art mais difficile de remettre en cause des années voir plus de mauvaises habitude...
voici le code que j'ai écrit :
Code: Tout sélectionner
/* Ce programme affecte deux séries de valeurs décimales,
   il les écrit sur une mémoire Eeprom 24LCxxx,
   remet à 0 les deux séries de valeurs (pour être sur de la lecture écriture en Eeprom),
   les lit sur la mémoire Eeprom 24LCxxx et les réaffecte au tableau de variables.
   */
   



#include <I2C.h>

const int WP=24;   //broche 24 pour protection écriture mémoire Eeprom
const int adr0=30;   // broche 30 pour pin A0 adresse Eeprom
const int adr1=28;   // broche 28 pour pin A1 adresse Eeprom
const int adr2=26;   // broche 26 pour pin A2 adresse Eeprom
const int MI2C=32;   // broche 32 pour pin maitre bus I2C
volatile int adr_lect;
volatile int adr_ecrt;
volatile boolean prot_mem=true;
// deux séries de nombres flottants :
volatile float zero[16] = {-13.05092,-1.75509,13.67356,3.67388,21.25615,33.23898,8.88643,33.09784,16.02524,34.68024,27.42563,33.74234,-16.96832,11.55365,6.32246,-14.86726};
volatile float echel[16] = {0.16508,0.20472,0.05113,0.15886,0.01530,0.06699,0.06877,0.20602,0.18926,0.12351,0.14047,0.09621,0.15438,0.02286,0.08625,0.01286};
float value;
volatile boolean adr_high=false;

// On obtient un pointeur sur le réel value.
float* p_value = &value;

void setup()
{
  // configure la broche numérique en SORTIE
  pinMode(WP,OUTPUT);
  pinMode(adr0,OUTPUT);
  pinMode(adr1,OUTPUT);
  pinMode(adr2,OUTPUT);
  pinMode(MI2C,OUTPUT);
  digitalWrite(adr0,0);
  digitalWrite(adr1,0);
  digitalWrite(adr2,adr_high);
  Serial.begin(19200);
  affiche_val();
  ecrtEchel();
  efface_val();
  affiche_val();
  lectEchel();
  affiche_val();
}

/* ******************* operation ecriture byte I2C **************************
I2c.write(address, registerAddress, *data, numberBytes);
Effectue une opération d'écriture I2C de tableau d'octets. Généralement utilisé pour envoyer un tableau d'octets commençant à l'emplacement registerAddress.
 Noter que  il n'y a aucune restriction sur le nombre d'octets peuvent être envoyés à la différence de la bibliothèque wire qui a une restriction de 32 octets
Paramètres: (uint8_t) Adresse: 7 bits adresse de l'esclave I2C
            (Uint8_t) registerAddress: Adresse du registre conformément à la fiche technique
            (Uint8_t) * Données: tableau d'octets
            (Uint8_t) numberBytes: Le nombre d'octets dans le tableau à être envoyés
Retour: 0 - écriture réussie
********************** operation ecriture byte I2C ************************/

static void write_bytes(uint8_t* p_data, uint8_t length)
{
    // Ecriture de l'octet p_data[i]
    I2c.write(0x50,adr_ecrt,p_data,length);
}

static void read_bytes(uint8_t* p_data, uint8_t length)
{
    // Lecture de l'octet p_data[i]
    I2c.read(0x50,adr_lect,4,p_data);
}

 
void ecrtEchel()
{
  I2c.begin();         // initialise le bus I2C
  I2c.setSpeed(1);
  prot_mem=false;      // désactive la broche protection mémoire
  digitalWrite(WP,prot_mem);
  for(int u=0; u<16 ;u++)
  {
    adr_ecrt=128 + u*4;
    value = zero[u]; // on affecte la variable à value pour la "pointer"
    write_bytes((uint8_t*)p_value, sizeof(value));
    delay(5);
    adr_ecrt=128 + 64+ u*4;
    value = echel[u];
    write_bytes((uint8_t*)p_value, sizeof(value));
    delay(5);
  }
  prot_mem=true;
  digitalWrite(WP,prot_mem);
  }
 
void lectEchel()
{
  I2c.begin();         // initialise le bus I2C
  I2c.setSpeed(1);
  prot_mem=true;      // active la broche protection mémoire
  digitalWrite(WP,prot_mem);
  for(int u=0; u<16 ;u++)
  {
    adr_lect=128 + u*4;
    read_bytes((uint8_t*)p_value, sizeof(value));
    zero[u] = value;   
    adr_lect=128 + 64+ u*4;
    read_bytes((uint8_t*)p_value, sizeof(value));
    echel[u] = value;
  }
  prot_mem=true;
  digitalWrite(WP,prot_mem);
  } 

void affiche_val()
{
  for(int i=0; i<16; i++)
  {
    Serial.print("zero = ");
    Serial.print(zero[i],DEC);
    Serial.print("     , echelle = ");
    Serial.println(echel[i],DEC);
  }
}


void efface_val()
{
  for(int i=0; i<16; i++)
  {
    zero[i] = 0;
    echel[i] = 0;
  }
}


 
 
void loop()
{
}
         
 


Valery01
 
Messages: 14
Inscription: Sam 17 Nov 2012 17:15

Re: Ecriture memoire Eeprom I2C type 24LC..

Message non lude SesechXP » Mar 27 Nov 2012 19:09

Super si ça fonctionne ! Quand à l'écriture du code, le plus important est que tu le comprennes ;) Tant qu'il n'y a pas de bug potentiel, ce n'est pas si grave...

Par contre je vois que les fonctions read_bytes et write_bytes ne servent au final pas à grand chose. C'était pour l'exemple de manipulation des pointeurs. Tu pourrais simplifier de la manière suivante :
Code: Tout sélectionner
void lectEchel()
    {
      I2c.begin();         // initialise le bus I2C
      I2c.setSpeed(1);
      prot_mem=true;      // active la broche protection mémoire
      digitalWrite(WP,prot_mem);
      for(int u=0; u<16 ;u++)
      {
        adr_lect=128 + u*4;
        //read_bytes((uint8_t*)p_value, sizeof(value));
        I2c.read(0x50, adr_lect, sizeof(value), (uint8_t*)&value);
        zero[u] = value;   
        adr_lect=128 + 64+ u*4;
        //read_bytes((uint8_t*)p_value, sizeof(value));
        I2c.read(0x50, adr_lect, sizeof(value), (uint8_t*)&value);
        echel[u] = value;
      }
      prot_mem=true;
      digitalWrite(WP,prot_mem);
      }


J'ai juste un doute sur les arguments de la méthode I2C.read, quelle bibliothèque utilises-tu ?

++
SesechXP
 
Messages: 228
Inscription: Sam 28 Mai 2011 09:09
Localisation: 35

Re: Ecriture memoire Eeprom I2C type 24LC..

Message non lude Valery01 » Mar 27 Nov 2012 20:17

J'ai simplifié selon ta méthode ça fonctionne.
J'utilise la bibliothèque : Arduino I2C Master Library - écrit par Wayne Truchsess http://dsscircuits.com/articles/arduino-i2c-master-library.html.
Cette bibliothèque n'est pas limité à 32 bytes, le 24LC1025 à un buffer de 128 bytes, malheureusement je ne l'exploite pas dans mon programme. Il faudrait que je fasse un buffer de 128 bytes dans lequel je puisse ranger mes valeurs ( 2 x 4 x 16) ça irait impeccable et après j'enverrais ce buffer à l'eeprom pour écriture.

Le hic c'est que je ne voir pas comment créer un "truc" qui fasse 128 bytes et surtout comment y ranger mes valeurs!!
Valery01
 
Messages: 14
Inscription: Sam 17 Nov 2012 17:15

Re: Ecriture memoire Eeprom I2C type 24LC..

Message non lude SesechXP » Mer 28 Nov 2012 08:20

Je ne connaissais pas la bibliothèque I2C, et c'est vrai que c'est mieux que la bibliothèque Wire avec son buffer de 32 octets.

Valery01 a écrit:Il faudrait que je fasse un buffer de 128 bytes dans lequel je puisse ranger mes valeurs ( 2 x 4 x 16) ça irait impeccable et après j'enverrais ce buffer à l'eeprom pour écriture.


La structure de données ne changera pas grand chose pour l'EEPROM. Par contre mieux vaut faire quelque chose de simple et logique à manipuler.

A quoi correspondent tes valeurs ? Si je comprends bien tu écris 2 x 4 x 16 pour 16 couples de réels ? Les valeurs zero[i] sont liées à echel[i] ?
SesechXP
 
Messages: 228
Inscription: Sam 28 Mai 2011 09:09
Localisation: 35

Re: Ecriture memoire Eeprom I2C type 24LC..

Message non lude Valery01 » Mer 28 Nov 2012 10:56

oui exact il s'agit de 16 couples de valeurs destinées à mettre à l'échelle ( à convertir en flottant) 16 mesures analogiques.
Par exemple la mesure analogique 1 est une température de -20.0°C à +40°C dans ce cas Zero[0] = -20.0 et echel[0] = 0.05859 (60.0 / 1024) 60.0°C amplitude de mesure de -20.0 à +40.0 1024 la valeur max du convertisseur analogique numérique.
La mise à l'echelle s'écrira quelquechose comme cela :
Code: Tout sélectionner
tempval = analogRead(i);
delay(1);
mes[i] = float(tempval) * echel[i] + zero[i];
Valery01
 
Messages: 14
Inscription: Sam 17 Nov 2012 17:15

Re: Ecriture memoire Eeprom I2C type 24LC..

Message non lude SesechXP » Jeu 29 Nov 2012 19:30

Juste une piste pour ce soir... Je verrais bien un tableau de float à deux dimensions. La première colonne contiendrait les "zero" et la seconde les "echel". Puis une ligne pour chaque couple.

Et puis deux fonctions : une pour la lecture et une autre pour l'écriture. L'idéal serait qu'elles seules connaissent la structure de données. Comme ça si tu veux la changer, c'est planqué à l'intérieur des fonctions et le reste du logiciel ne change pas.

A creuser...
SesechXP
 
Messages: 228
Inscription: Sam 28 Mai 2011 09:09
Localisation: 35

Re: Ecriture memoire Eeprom I2C type 24LC..

Message non lude Valery01 » Mar 4 Déc 2012 10:23

Merci de ton aide.
Si je comprend :
déclaration : float zer_ech[16,2];
utilisation : zer_ech[i,j];
j prend les valeurs 0 ou 1. j=0 :les zero avec i de 0 à 15 et j=1 les échelles avec i de 0 à 15. Mais un pointeur ne peut pas pointer sur un tableau seulement sur un élément du tableau.
Donc je ne vois pas trop comment créer les fonction de lecture écriture avec une structure de donnée sur 128 bytes. :?:
Je crois que je vais laisser tomber cette piste pout l'instant et me consacrer au reste du programme.
Valery01
 
Messages: 14
Inscription: Sam 17 Nov 2012 17:15

Re: Ecriture memoire Eeprom I2C type 24LC..

Message non lude SesechXP » Sam 8 Déc 2012 09:58

Salut,

C'est bien ça, tu accèdes aux éléments du tableau par zero_echel[i][j]. Soit le tableau :
Code: Tout sélectionner
float zero_echel[][2] =
{
    { -13.05092,    0.16508 },
    { -1.75509,     0.20472 },
    { 13.67356,     0.05113 },
    { 3.67388,      0.15886 },
    { 21.25615,     0.01530 },
    { 33.23898,     0.06699 },
    { 8.88643,      0.06877 },
    { 33.09784,     0.20602 },
    { 16.02524,     0.18926 },
    { 34.68024,     0.12351 },
    { 27.42563,     0.14047 },
    { 33.74234,     0.09621 },
    { -16.96832,    0.15438 },
    { 11.55365,     0.02286 },
    { 6.32246,      0.08625 },
    { -14.86726,    0.01286 }
};

A noter qu'il n'est pas obligatoire de préciser les deux dimensions.

Si tu appelles la fonction affiche_val :
Code: Tout sélectionner
void affiche_val()
{
    for(int i=0; i<16; i++)
    {
        Serial.print("zero = ");
        Serial.print(zero_echel[i][0],DEC);
        Serial.print("     , echelle = ");
        Serial.println(zero_echel[i][1],DEC);
    }
}

tu vas retrouver tes valeurs dans le terminal série.

Un tableau reste un espace mémoire quelconque. Quelque chose de ce goût là devrait fonctionner :
Code: Tout sélectionner
I2c.write(0x50,adr_ecrt,(uint8_t*)zero_echel, sizeof(zero_echel));

sizeof(zero_echel) renvoie bien la taille complète du tableau, soit 128 octets.
++
SesechXP
 
Messages: 228
Inscription: Sam 28 Mai 2011 09:09
Localisation: 35

Re: Ecriture memoire Eeprom I2C type 24LC..

Message non lude Valery01 » Dim 16 Déc 2012 21:53

Super merci ça fonctionne nickel :D
Voici le code pour Arduino Uno
Code: Tout sélectionner
/* Ce programme affecte deux series de valeurs décimales,
   Les ecrit sur une mémoire Eeprom 24LCxxx,
   remet à 0 les deux series de valeurs (pour être sur de la lecture écriture en Eeprom),
   les lit sur la mémoire Eeprom 24LCxxx et les réaffecte au tableau de variables.
   */
   

#include <I2C.h>

const int WP=11;   //broche 11 pour protection ecriture mémoire Eeprom
const int adr0=8;   // broche 8 pour pin A0 adresse Eeprom
const int adr1=9;   // broche 9 pour pin A1 adresse Eeprom
const int adr2=10;   // broche 10 pour pin A2 adresse Eeprom
                     //(pour 24LC1025 = chip select doit être à 1)
volatile int adr_Eep1;
volatile int adr_lect;
volatile int adr_ecrt;
volatile boolean prot_mem=true;
// tableau à deux dimensions représantant deux séries de nombres flottants :
float zero_echel[][2] =
{
    { -13.05092,    0.16508 },
    { -1.75509,     0.20472 },
    { 13.67356,     0.05113 },
    { 3.67388,      0.15886 },
    { 21.25615,     0.01530 },
    { 33.23898,     0.06699 },
    { 8.88643,      0.06877 },
    { 33.09784,     0.20602 },
    { 16.02524,     0.18926 },
    { 34.68024,     0.12351 },
    { 27.42563,     0.14047 },
    { 33.74234,     0.09621 },
    { -16.96832,    0.15438 },
    { 11.55365,     0.02286 },
    { 6.32246,      0.08625 },
    { -14.86726,    0.01286 }
};

float value;
volatile boolean adr_high=false;
unsigned int chip_Eep1;


void setup()
{
  // configure la broche numérique en SORTIE
  pinMode(WP,OUTPUT);
  pinMode(adr0,OUTPUT);
  pinMode(adr1,OUTPUT);
  pinMode(adr2,OUTPUT);
  digitalWrite(adr0,0);
  digitalWrite(adr1,0);
  adr_high=true; // pour 24LC1025
  digitalWrite(adr2,adr_high);
  Serial.begin(19200);
  adr_Eep1 = 256;
  chip_Eep1 = 0x50;
  affiche_val();
  ecrtEchel();
  efface_val();
  affiche_val();
  lectEchel();
  affiche_val();
}

/* ******************* operation ecriture byte I2C **************************
I2c.write(address, registerAddress, *data, numberBytes);
Effectue une opération d'écriture I2C de tableau d'octets. Généralement utilisé pour envoyer un tableau d'octets commençant à l'emplacement registerAddress.
 Noter que  il n'y a aucune restriction sur le nombre d'octets peuvent être envoyés à la différence de la bibliothèque wire qui a une restriction de 32 octets
Paramètres: (uint8_t) Adresse: 7 bits adresse de l'esclave I2C
            (Uint8_t) registerAddress: Adresse du registre conformément à la fiche technique
            (Uint8_t) * Données: tableau d'octets
            (Uint8_t) numberBytes: Le nombre d'octets dans le tableau à être envoyés
Retour: 0 - écriture réussie
********************** operation ecriture byte I2C ************************/

 
void ecrtEchel()
{
  I2c.begin();         // initialise le bus I2C
  I2c.setSpeed(1);
  prot_mem=false;      // désactive la broche protection mémoire
  digitalWrite(WP,prot_mem);
  I2c.write(chip_Eep1,adr_Eep1,(uint8_t*)zero_echel, sizeof(zero_echel));
  delay(5);
  I2c.end();
  prot_mem=true;
  digitalWrite(WP,prot_mem);
}
 
void lectEchel()
{
  I2c.begin();         // initialise le bus I2C
  I2c.setSpeed(1);
  prot_mem=true;      // active la broche protection mémoire
  digitalWrite(WP,prot_mem);
  I2c.read(chip_Eep1,adr_Eep1,sizeof(zero_echel),(uint8_t*)zero_echel);
  prot_mem=true;
  digitalWrite(WP,prot_mem);
  } 

void affiche_val()
{
  Serial.println(sizeof(zero_echel)); 
  for(int i=0; i<16; i++)
    {
        Serial.print("zero = ");
        Serial.print(zero_echel[i][0],DEC);
        Serial.print("     , echelle = ");
        Serial.println(zero_echel[i][1],DEC);
    }
}

void efface_val()
{
  for(int i=0; i<16; i++)
  {
    zero_echel[i][0] = 0;
    zero_echel[i][1] = 0;
  }
}

 
void loop()
{
}
Valery01
 
Messages: 14
Inscription: Sam 17 Nov 2012 17:15

Re: Ecriture memoire Eeprom I2C type 24LC..

Message non lude SesechXP » Lun 17 Déc 2012 18:35

Super :P

Maintenant il va être nécessaire de revoir quelque peu les types de données :D

Un entier signé 16 bits (int, valeur max = 32767) est surdimensionné pour désigner les broches. Il est préférable d'utiliser des entiers non signé 8 bits (byte ou uint8_t, valeur max = 255). Tu économiseras quelques octets de mémoire...
Code: Tout sélectionner
const uint8_t WP=11;   //broche 11 pour protection ecriture mémoire Eeprom
const uint8_t adr0=8;   // broche 8 pour pin A0 adresse Eeprom
const uint8_t adr1=9;   // broche 9 pour pin A1 adresse Eeprom
const uint8_t adr2=10;   // broche 10 pour pin A2 adresse Eeprom
                     //(pour 24LC1025 = chip select doit être à 1)

À l'inverse, le type int est insuffisant pour les adresses mémoire. Sachant que la 24LC1024 a une capacité de 128 ko, l'adresse peut aller jusqu'à 131072. Adresse inatteignable avec un int, il y a donc un bogue... Il est impératif d'utiliser un entier non signé 32 bits (unsigned long int ou uint32_t) :
Code: Tout sélectionner
volatile uint32_t adr_Eep1;
volatile uint32_t adr_lect;
volatile uint32_t adr_ecrt;

Sinon dans les boucles for, le compteur i peut également être de type uint8_t. Là aussi tu gagneras un peu de mémoire.
SesechXP
 
Messages: 228
Inscription: Sam 28 Mai 2011 09:09
Localisation: 35

Re: Ecriture memoire Eeprom I2C type 24LC..

Message non lude phil » Mar 18 Déc 2012 14:49

une petite question c'est pas mieux de faire en global
Code: Tout sélectionner
#define WP 11
#define adr0 8
#define adr1 9
#define adr2 10
au lieu de
Code: Tout sélectionner
const uint8_t WP=11;   //broche 11 pour protection ecriture mémoire Eeprom
const uint8_t adr0=8;   // broche 8 pour pin A0 adresse Eeprom
const uint8_t adr1=9;   // broche 9 pour pin A1 adresse Eeprom
const uint8_t adr2=10;   // broche 10 pour pin A2 adresse Eeprom
?

Il me semble qu'avec cette méthode, on utilise pas du tout de mémoire pour la définition des pins. Est ce que je me trompe ?
all your shields are belong to us...
Avatar de l’utilisateur
phil
 
Messages: 192
Inscription: Mer 7 Sep 2011 11:19

Re: Ecriture memoire Eeprom I2C type 24LC..

Message non lude SesechXP » Mar 18 Déc 2012 18:54

En effet, on peut utiliser des macros qui seront interprétées lors de la compilation, et on économise une variable par pinouille. Après, est-ce qu'on doit ? J'ai envie de dire que c'est un peu au goût de chacun.

Arduino estime que les macros peuvent avoir des effets de bord indésirables (écrasement d'une autre définition sans préavis ou presque) et recommande des variables constantes.

En utilisant des variables constantes, on reste cohérent avec la bibliothèque Arduino qui définit notamment ces constantes dans le fichier pins_arduino.h :
Code: Tout sélectionner
static const uint8_t SS   = 10;
static const uint8_t MOSI = 11;
static const uint8_t MISO = 12;
static const uint8_t SCK  = 13;

static const uint8_t SDA = 18;
static const uint8_t SCL = 19;
static const uint8_t LED_BUILTIN = 13;

static const uint8_t A0 = 14;
static const uint8_t A1 = 15;
static const uint8_t A2 = 16;
static const uint8_t A3 = 17;
static const uint8_t A4 = 18;
static const uint8_t A5 = 19;
static const uint8_t A6 = 20;
static const uint8_t A7 = 21;


Réponse de Normand en fait :mrgreen: Si les exemples Arduino utilisaient les types de données les plus adaptés ce serait déjà pas mal :roll:
SesechXP
 
Messages: 228
Inscription: Sam 28 Mai 2011 09:09
Localisation: 35

Re: Ecriture memoire Eeprom I2C type 24LC..

Message non lude phil » Mar 18 Déc 2012 23:44

Arduino estime que les macros peuvent avoir des effets de bord indésirables (écrasement d'une autre définition sans préavis ou presque) et recommande des variables constantes.

Objectivement je fait comme ça 98 % du temps et j'ai pas de problème. Pour les 2% qui restent je vais peut être reprendre deux trois bout de code qui me posaient problème au cas ou... histoire de voir.
Merci pour cette réponse précise
all your shields are belong to us...
Avatar de l’utilisateur
phil
 
Messages: 192
Inscription: Mer 7 Sep 2011 11:19


Retourner vers Mémoire

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 2 invités