Programmateur ESP12 EEPROM

Bonjour
J'ai réalisé un programmateur d'arrosage sur ESP12 et j'aurai besoin de stoker en EEPROM les paramètres des cycles. Ces paramètres, ceux entre crochets sont saisis via un interface web:

//"var js = [A, 80, 10];"
//"var hds = [1220,300,620];"
//"var tps = [100,50,120];"
//"var sequences = [20,10,31];"
//"var mnemo = [jardin,buisson,iris];"
//"var gpio = [0,13,2];"

ne sachant pas trop par quel bout le prendre, quelle serai la meilleure façon de procéder.
merci

il n'y a pas d'EEPROM sur ces modules, c'est émulé en stockant dans la mémoire flash.

vous pouvez regarder les exemples de la bibliothèque pour vous faire une idée

Ok vu le nbre et la diversité des modules, j’y perd mon latin.

Donc j’ai concocté un petit script et j’aimerai savoir si c’est correct avant d’aller plus loin.

#include <EEPROM.h>
#include <Arduino.h>
#include <string>
//#include <fexceptions>

using namespace std;

#include "memoire.h"

struct cycles {
  string js;
  string hds;
  string tps;
  string sequences;
  string mnemo;
  string gpio;
};

cycles config;
int eeAddress = 5;   //Adresse de départ pour enregistrement sur EEPROM

//***************************************************************************
//enregistrement en eeprom des valeurs réceptionnées sans décodage
void sauveParametres() {

  EEPROM.begin(4096); 
  config.js=strToChar(js); 
  config.hds=strToChar(hds);
  config.tps=strToChar(tps);
  config.sequences=strToChar(sequences);
  config.mnemo=strToChar(mnemo);
  config.gpio=strToChar(gpio);
  //mise en mémoire pour ecriture par la methode put
  EEPROM.put(0, config);
  //copie dans le cache mémoire en eeprom et écriture
  Serial.println("commit");
  EEPROM.commit();
   //libère la memoire
  EEPROM.end();
}

//***************************************************************************
//lecture des valeurs sauvegardées
void lireParametres() {
  EEPROM.begin(4096);
  //Lire la mémoire
 //transfère les valeurs

  EEPROM.get(0, config);
  js = strToChar(config.js);
  hds = strToChar(config.hds);
  tps = strToChar(config.tps);
  sequences = strToChar(config.sequences);
  mnemo = strToChar(config.mnemo);
  gpio = strToChar(config.gpio);
  //libère la memoire
  EEPROM.end();
    
  Serial.println("Lecture memoire ok");
  Serial.print("js->");Serial.println(js.c_str());
  Serial.print("hds->");Serial.println(hds.c_str());
  Serial.print("tps->");Serial.println(tps.c_str());
  Serial.print("sequences->");Serial.println(sequences.c_str());
  Serial.print("mnemo->");Serial.println(mnemo.c_str());
  Serial.print("gpio->");Serial.println(gpio.c_str());
  Serial.println("***********************");
}

char* strToChar(string str)
 { int n = js.length(); 
   char char_array[n + 1]; 
   strcpy(char_array, str.c_str());
   return char_array;
 }

string charToString(char* char_array)
 {string str;
  int n = sizeof(char_array) / sizeof(char);
  for(int i = 0; i < n; i++)
    {str = str + char_array[i];}
    return str;
}

Merci

Après quelques petites corrections ce code est il correct ?

#include <EEPROM.h>
#include <Arduino.h>
#include <string>
//#include <fexceptions>

using namespace std;

#include "memoire.h"
int njs;

struct cycles {
  char* cjs;
  char* chds;
  char* ctps;
  char* csequences;
  char* cmnemo;
  char* cgpio;
};

cycles config;
int eeAddress = 5;   //Adresse de départ pour enregistrement sur EEPROM

//***************************************************************************
//enregistrement en eeprom des valeurs réceptionnées sans décodage
void sauveParametres() {

  EEPROM.begin(4096); 
  config.cjs=strToChar(js); 
  config.chds=strToChar(hds);
  config.ctps=strToChar(tps);
  config.csequences=strToChar(sequences);
  config.cmnemo=strToChar(mnemo);
  config.cgpio=strToChar(gpio);
  //mise en mémoire pour ecriture par la methode put
  EEPROM.put(0, config);
  //copie dans le cache mémoire en eeprom et écriture
  Serial.println("commit");
  EEPROM.commit();
   //libère la memoire
  EEPROM.end();
}

//***************************************************************************
//lecture des valeurs sauvegardées
void lireParametres() {
  EEPROM.begin(4096);
  //Lire la mémoire
 //transfère les valeurs

  EEPROM.get(0, config);


  js = charToString(config.cjs);
  hds = charToString(config.chds);
  tps = charToString(config.ctps);
  sequences = charToString(config.csequences);
  mnemo = charToString(config.cmnemo);
  gpio = charToString(config.cgpio);
  //libère la memoire
  EEPROM.end();
    
  Serial.println("Lecture memoire ok");
  Serial.print("js->");Serial.println(js.c_str());
  Serial.print("hds->");Serial.println(hds.c_str());
  Serial.print("tps->");Serial.println(tps.c_str());
  Serial.print("sequences->");Serial.println(sequences.c_str());
  Serial.print("mnemo->");Serial.println(mnemo.c_str());
  Serial.print("gpio->");Serial.println(gpio.c_str());
  Serial.println("***********************");
}

char* strToChar(string str)
 { int n = js.length(); 
   char char_array[n + 1]; 
   strcpy(char_array, str.c_str());
   return char_array;
 }

string charToString(char* char_array)
 {string str;
  int n = sizeof(char_array) / sizeof(char);
  for(int i = 0; i < n; i++)
    {str = str + char_array[i];}
    return str;
}

merci

Bonjour
Donc finalement ça peut servir j’ai stocké mes valeurs comme ceci:

#include <EEPROM.h>
#include <Arduino.h>
#include <string>
//#include <fexceptions>

using namespace std;

#include "memoire.h"

struct cycles {
  int init;
  int a1;
  int a2;
  int a3;
  int a4;
  int a5;
  int a6;
  char donnees[200];
};

cycles config;
int a0 = 0;

//***************************************************************************
//enregistrement en eeprom des valeurs réceptionnées sans décodage
void sauveParametres() {
  //nbre de caractères de chaque donnée
  int a1 = js.length();
  int a2 = hds.length();
  int a3 = tps.length();
  int a4 = sequences.length();
  int a5 = mnemo.length();
  int a6 = gpio.length();
  string str = js+hds+tps+sequences+mnemo+gpio;
  
  //mise en mémoire
  EEPROM.begin(4096);
  config.init=23456;
  config.a1 = a1;
  config.a2 = a2;
  config.a3 = a3;
  config.a4 = a4;
  config.a5 = a5;
  config.a6 = a6;
  strcpy(config.donnees, str.c_str());
 //mise en mémoire pour ecriture par la methode put
  EEPROM.put(0, config);
  //copie dans le cache mémoire en eeprom et écriture
  Serial.println("init fin commit");
  EEPROM.commit();
   //libère la memoire
  EEPROM.end();
}

//***************************************************************************
//lecture des valeurs sauvegardées
void lireParametres() {
  string str;
  
  EEPROM.begin(4096);
  //Lire la mémoire
  EEPROM.get(0, config);
  byte erreur = config.init != 23456;
if(erreur)
  {config.init = 23456;
   EEPROM.put(0, config);}
else
 {//décodage
  str = config.donnees;
  js = str.substr(a0,config.a1);
  a0 = a0 + config.a1;
  hds = str.substr(a0,config.a2);
  a0 = a0 + config.a2;
  tps =  str.substr(a0,config.a3);
  a0 = a0 + config.a3;
  sequences =  str.substr(a0,config.a4);
  a0 = a0 + config.a4;
  mnemo =  str.substr(a0,config.a5);
  a0 = a0 + config.a5;
  gpio =  str.substr(a0,config.a6);
  }
  //libère la memoire
  EEPROM.end();

  Serial.println("Lecture memoire ok");
  Serial.print("str->");Serial.println(str.c_str());
  Serial.print("js->");Serial.println(js.c_str());
  Serial.print("hds->");Serial.println(hds.c_str());
  Serial.print("tps->");Serial.println(tps.c_str());
  Serial.print("sequences->");Serial.println(sequences.c_str());
  Serial.print("mnemo->");Serial.println(mnemo.c_str());
  Serial.print("gpio->");Serial.println(gpio.c_str());
  Serial.println("***********************");
}

Salut

Le passage par la classe String n’est pas necessaire, vu la place en flash vous pourriez stocker directement de buffer d’une longueur raisonnable pour chaque chaîne.

Mais bon ça marche aussi comme cela