Question de débutant, EEprom, write ou update ?

International Français
1

Bonjour et bonne année a la communauté Arduinaute

J'ai fais l’acquisition depuis peu d'une carte Arduino Mega, je me suis amusé un temps avec les exemples le l'Ide pour comprendre les subtilités du langage C ,après avoir lu et rerelu les divers sites, blogs, tutos , et autres, j'essaye de faire mon premier programme.

Ce programme consiste a incrémenté et décrémenté une variable de temps comprise entre 15ms et 70ms a l'aide de deux boutons poussoirs et de sauvegarder dans l'EEprom la dernière valeur programmé pour la retrouvé une fois la Mega remise sous tension.

Le programme fonctionne, par contre j'ai lu que d’écrire souvent dans l'EEprom réduisais sa durée de vie (1000000 d’écritures environ) et qu'il était préférable d’utilisé EEprom.update afin de ne pas réécrire des valeurs déjà enregistré.

Ma question, comment fait on pour mettre en place cette fonction, peut on la mettre avant EEprom.put ?
si je laisse EEprom.put il y aura forcement une réécriture!
Bref je ne comprend pas cette subtilité et ne sais comment la mette en place.

Je joint le code que j'ai réalisé en espèrent qu'il soit compréhensible et pas trop faux.

Merci a ceux qui m’aideront a avancé.

#include <EEPROM.h>
#include "simpleBouton.h"

simpleBouton bouton_plus(7);
simpleBouton bouton_moins(8);

int variable_temps=0;                                       // la variable_temps doit etre comprise entre 15ms et 70ms
int adresse = 0;

const uint32_t tempo = 400;                                 // variable de temps pour simpleBouton
uint32_t delai;

void increment_plus()                                       // increment en + de la variable variable_temps 
{
     variable_temps++;
     if (variable_temps >= 70)
    {
     variable_temps=70;
    }
    EEPROM.put(adresse, variable_temps);
    
    Serial.print(" Temps programmer   ");
    Serial.println(variable_temps);    
}
void increment_moins()                                      // increment  en - de la variable variable_temps
{  
    variable_temps--;
    if (variable_temps <= 15)
    {
     variable_temps=15;
    }
    EEPROM.put(adresse, variable_temps);
    
    Serial.print(" Temps programmer   ");
    Serial.println(variable_temps);  
}

void setup() 
{
Serial.begin(9600);

EEPROM.get(adresse, variable_temps);                      // lecture de l'EEprom au demmarage du programme 
Serial.print(" Temps enregistrer   ");
Serial.println(variable_temps);
}

void loop() 
{  
  bouton_plus.actualiser();
  bouton_moins.actualiser();
  
  if (bouton_plus.vientDEtreEnfonce())
   {      
    delai = 0;
   }
     if (bouton_plus.estEnfonceDepuisAuMoins(delai))
   {  
   increment_plus();
   delai = delai + tempo;
   }
  
  if (bouton_moins.vientDEtreEnfonce())
   {     
    delai = 0;
   }
   if (bouton_moins.estEnfonceDepuisAuMoins(delai))
   {
    increment_moins();
    delai = delai + tempo;
   }

}
2

La syntaxe est la même, il faut remplacer "put" par "update". MAIS, là où est toute la différence, est que l'instruction "put" s'adapte au type de variable à enregistrer et donc enregistre autant d'octets qu'en comporte la variable alors que la fonction update n'enregistre qu'un seul octet. C'est donc à vous de décomposer votre variable en autant d'octets qu'elle en contient et faire autant d'appels à l'instruction update en conséquence (en incrémentant l'adresse de base pour chaque octet).

Cordialement.

Pierre

3

Bonjour Pierre

Merci de votre réponse.
De ce que je comprend dans le cas de mon programme, est il pas plus simple de changé le type de la variable int variable_temps=0; par unsigned char variable_temps=0; de ce que j'ai lu un unsigned char a la taille de 1 octets (0a255) sachant que je n'ai besoin que d'une plage de nombre compris en 15 et 70 .
reprenez moi si mon raisonnement est faux, merci.

Cordialement
Maurice

4

Bonjour,

EEPROM.put() utilise EEPROM.Update() comme indiqué dans la doc.

Tu peux donc l'utiliser sans problème, ça ne récrit pas dans l'EEPROM si la valeur n'est pas modifiée.

Aussi comme tu l'as écrit si ta variable varie de 15 à 70 tu peux utiliser un octet (byte ou uint8_t).

5

n'est il pas plus simple de changer le type de la variable

Bonjour + tous mes vœux !

oui, tu peux utiliser le type de variable byte :
byte variable_temps = 0;

accessoirement, j'écrirais :
if (variable_temps < 70) { variable_temps++; }
on n'incrémente que si c'est nécessaire, geste écodurable

voire :
if (variable_temps < 255) { variable_temps++; }
ce qui te maintient informé qu'il s'est passé des choses bizarres

6

Bonjour kamill et trimarco232

EEPROM.put() utilise EEPROM.Update() comme indiqué dans la doc.

Je l'avais lu mais par manque de pratique et d’expérience je n’étais pas sur de bien l'interprété.

accessoirement, j'écrirais :
if (variable_temps < 70) { variable_temps++; }
on n'incrémente que si c'est nécessaire, geste écodurable

je ne vois pas bien l’intérêt de ce vous avez écrit, car de toute façon si j'appuie sur l'un des deux boutons j'incrémente ou décrémente ma variable et EEprom.update met a jour uniquement si ça n'a pas déjà été écrit sachant que dans mon programme ca ira jamais en dessous de 15 et au dessus de 70 ca ne fais que 55 écriture !? juste ou je m'égare ?

Merci a vous deux pour la confirmation du changement de variable, un petit pas pour les puristes mais un grand pour mon apprentissage.

Cordialement
Maurice

7

Bonjour,

je poussais jusqu'à l'absurde le principe suivant
tu veux te servir une bonne rasade de ce breuvage dont tu raffoles :
tu peux remplir ton verre et t'arrêter juste quand il est plein
ou bien tu peux faire déborder allègrement et éponger, mais cela risque de ne pas plaire à tout le monde ...

... l'arduino n'étant pas un dragon ménager, ce n'est absolument pas important et tu peux très bien laisser comme ça :slight_smile: