Bonjour,
J’ai un appareil avec un Arduino que je règle par le port série.
Quand je sauvegarde les réglages dans l’Eeprom, via le port série, j’aimerais y inscrire automatiquement la date du PC.
Comment faire pour récupérer les date du PC dans mon code Arduino?
Bout de code exemple :
// get serial date ??
#include <EEPROM.h>
//#define EepromInit //Initialisation de l'Eeprom lors du premier téléverssement
#ifdef EepromInit
//Inscrit la date de mise en service de l'appareil
#define jjMiseEnService 32 //Entré le jour de la mise en service
#define mmMiseEnService 13 //Entré le mois de la mise en service
#define aaMiseEnService 00 //Entré l'année de la mise en service (2 caractères)
#endif
const int adresseEeprom = 1001;
String msg;
void setup() {
Serial.begin(9600);
#ifdef EepromInit
EEPROM.update(adresseEeprom,jjMiseEnService);
EEPROM.update(adresseEeprom+1,mmMiseEnService);
EEPROM.update(adresseEeprom+2,aaMiseEnService);
SaveReglages();
#endif
}
void loop() {
if (Serial.available()) {
msg = Serial.readString();
msg = msg.substring(0, msg.length() - 1); // Enlève le [Enter] à la fin du message
if (msg == "Save") {
SaveReglages();
Serial.println("Les données ont été sauvegardé");
} else if (msg == "Info") {
char str[8];
Serial.print("L'appareil à été mise en service le ");
sprintf(str,"%02d.%02d.%02d",EEPROM.read(adresseEeprom),EEPROM.read(adresseEeprom+1),EEPROM.read(adresseEeprom+2));
Serial.println(str);
Serial.print("La dernière sauvegarde date du ");
sprintf(str,"%02d.%02d.%02d",EEPROM.read(adresseEeprom+3),EEPROM.read(adresseEeprom+4),EEPROM.read(adresseEeprom+5));
Serial.println(str);
} else {
Serial.print(msg); Serial.println(", n'est pas reconnu par cette appareil.");
}
msg ="";
}
}
void SaveReglages(){
uint8_t jj = 1, mm = 2, aa = 0;
//lire la date du PC est là transferé dans les variables
EEPROM.update(adresseEeprom+3,jj);
EEPROM.update(adresseEeprom+4,mm);
EEPROM.update(adresseEeprom+5,aa);
}
Le montage ne comporte pas de module RTC. C’est juste à titre informatif que je veux y mettre cette date.
A la suite de la commande Save, tu envois la date de ton PC.
au lieu de comparer msg et Save, il faut comparer les 4 premier caractères de la variable msg.
si msg commence bien par Save, tu donne à ta fonction SaveReglages la variable msg en paramétre.
Dans celle-ci tu découpe ta chaine pour affecter les variables jj, mm, aa ou la stocke en entier dans ton eeprom
Merci @lesept avec t'a fonction, je récupère la date de compilation, pas la date du dernier message envoyé. Donc pas la date de la sauvegarde. Mais c’est déjà bien d’arriver à ça.
Oui @terwal je vais faire comme tu dis si je trouve pas de façon d’automatiser ça. En automatisant, j’éviterais les problèmes. Dans deux ou trois ans, quand je vais changer un réglage il faudra que j’envoie la date avec le bon formatage…
J’ai trouver ceci, mais comme je ne parle pas anglais et que j’arrive pas à traduire cette page avec google, je comprend pas grand-chose. En tous cas j’ai pas réussit à le faire avec leur exemple.
Tu peux tout à fait "automatiser", je t'ai donné la façon de faire général.
Comme tu ne dis pas ce que tu fais exactement coté PC, ni avec quoi, ce que fais exactement ton programme, notamment dans quel cadre la fonction save est appelée.
Le post en anglais, fait je pense a peu près la même chose que toi.
Le programme Arduino s'attend à ce qu'un programme ou quelqu'un sur le PC, envois la date sur le port série.
En gros si tu veux que ton Arduino, récupère la date du PC, faut-il que celui-ci te l'envois.
Donc en gros, à quoi correspond ces fameux réglages et notamment que fais tu coté PC pour envoyer les nouveaux réglages à ton Arduino.
Mon projet en cour :
C’est un automate qui vas détecter quand le niveau d’air est trop bas dans ma cloche à eau. Quand le niveau est trop bas il vas enclencher un compresseur.
Le compresseur, c’est un motoréducteur qui entraîne un petit vérin pneumatique (comme un pompe à vélo).
Le port série me sert à régler le nombre de tours du compresseur et le temps de fonctionnement au-delà du quel il vas ce mettre en alarme. Il me reste à faire des compteurs d’enclenchements et d’alarmes pour avoir une statistique «du nombre de pompage d’eau diviser par le nombre de pompage d’air» pour savoir si je dois mettre plus ou moins de tours par cycle du compresseur. Quand je modifie les réglages, je les enregistre dans l’Eeprom. En enregistrant, les compteurs actif ce vide dans les compteurs totalisateurs et comme ça j’ai une statistique depuis la mise en service et une autre depuis le dernier réglage. Je veux avoir la date de mise en service et celle du dernier réglage pour compléter mes statistique.
Le code actuel de mon projet (encore à l’état ...chantier…)
PS: Dans ce code c'est la fonction "S_Eeprom" qui déclanche la sauvegarde.
// Compresseur d'air pour cloche à eau
#define VERSION V01.01 //1ère version Menu sur port série
/**/
/*Définition du projet */
/*Utilisation des inverseurs [invert...] */
// Inverse le type de contacteur: un NC devient NO; un NO devient un NC
// ATTENTION à la compatibilitée avec des montages sans tous les capteurs ...
/**/
/*Type de montage: */
/*- Sans pressiostat: */
// Brancher le contacteur de niveau aux pin "2: NiveauPort" et "4: PressioPort".
// Le compresseur s'enclanchera après détection de niveau bas, à la reouverture du capteur de niveau. Il devra juste vaincre une pression plus haute qu'avec un pressiostat.
// ... Le comptage d'enclenchement de la pompe sera pas juste. ...
/*- Sans capteur de niveau:*/
// Brancher le Pressiostat aux pin "2: NiveauPort" et "4: PressioPort".
// Le compresseur s'enclanchera à chaque fois que le pressiostat passera au niveau basse pression. Le compresseur tournera à chaque cycle d'enclanchement de la pompe à eau.
// Attention à bien regler le nombre de tours par cycle pour envoyer assé mais pas trop d'air.
/*- Sans pressiostat ni capteur de niveau: */
//- Brancher un contacteur piloté par l'enclanchement de la pompe à eau aux pin "2: NiveauPort" et "4: PressioPort". 5v = pompe à l'arrêt; 0v (GND) la pompe fonctionne.
// ATTENTION: Uniquement de 5 volts: Utiliser par exemple un opthocoupleur. pour séparrer la haute tention du 5v.
// Le compresseur s'enclanchera à chaque fois que la pompe s'enclenchera. Le compresseur tournera à chaque cycle d'enclanchement de la pompe à eau.
// Attention à bien regler le nombre de tours par cycle pour envoyer assé mais pas trop d'air.
/**/
/* Niveau d'alarmes: // pas instalées pour l'instant. */
// Temps Maximum atteint:
// Capteur de Point mort haut ou moteur défectueux ou tous autre avarie empéchant le compresseur de faire un tour dans le temp imparti:
/* {Niveau d'alarme [2]} */
// - Le compresseur vas tourner le temps maximum programmé. Une allarme sera envoyé au port série à chaque cycle.
// Moteur trop lent ou délais imparti au cyle trop court:
/* {Niveau d'alarme [1]} */
// - Le compresseur vas tourner le temps maximum programmé. Le témoin Pmh risque de rester allumé (suivant la position d'arrêt.)
/*Capteur de consomation pas instalé pour l'instant.
// Consomation du moteur trop basse:
// {Niveau d'alarme [3]} //
// un tuyau d'air est peut-être cassé, risque d'innondation.
// Consomation du moteur trop haute
// {Niveau d'alarme [3]} //
// Le sistème force trop, risque de brûler le moteur
*/
/**/
/*Branchements - - > > !!!! à mettre à jour!!!! - */
// Pin 2: Contacteur de niveau -GND quand le niveau d'eau et trop haut (PUUL UP).
// Pin 3: Contacteur de Point mort haut -GND quand le piston est au Pmh (PUUL UP).
// Pin 4: Pressiostat - GND quand la pression est trop haute pour l'enclanchement du compresseur (PUUL UP).
// Pin 5: Switch mode manuel -GND quand le mode manuel est demandé (PUUL UP).
// Pin 9: LED Niveau d'air bas détecté
// Pin 10: LED position du piston hors du point mort haut
// Pin 11: LED Mode manuel activé
// Pin 12: Relais d'allimentation du moteur
// Pin 13: LED Moteur on (plus led bulting de la carte Nano)
// Option possibles: //Pas paramètrées
// Pin 6: LED Alarme niveau 1
// Pin 7: LED Alarme niveau 2
// Pin 8: LED Alarme niveau 3
// Pin 1: BUZZER Alarme niveau 3
/**/
/*#include -> librairies */
#include <EEPROM.h>
/**/
/*#define -> Macro */
//#define EepromInit // Commanter sur le téléversement définitif; Décommanter sur le premier téléversement
//Enregistre les valeurs par défaut dans la mémoire eeprom (Valeurs par défaut = aux valeurs dans la déclaration des variables).
#ifdef EepromInit
#define MiseEnService
#endif
#ifdef MiseEnService
//Inscrit la date de mise en service de l'appareil
#define jjMiseEnService 00 //Entré le jour de la mise en service
#define mmMiseEnService 00 //Entré le mois de la mise en service
#define aaMiseEnService 00 //Entré l'année de la mise en service (2 caractères)
//Initialisation du nombre total d'activations AVANT la dernière sauvegarde)
#define cptOldPompeInit 0 //Entré la valeur du compteur d'enclanchement de la pompe
#define cptOldComprInit 0 //Entré la valeur du compteur d'enclanchement du compresseur
#define cptOldComprNoTimeInit 0 //Entré la valeur du compteur de défaut de cycle compresseur
#define cptOldComprManuelInit 0 //Entré la valeur du compteur d'enclanchement manuel du compreseur
//Initialisation des compteurs actif (nombre d'activations DEPUIS la dernière sauvegarde)
#define cptNewPompeInit //Décocher pour initialiser le compteur d'enclanchement de la pompe (valeur initialisée à zéro)
#define cptNewComprInit //Décocher pour initialiser le compteur d'enclanchement du compresseur (valeur initialisée à zéro)
#define cptNewComprNoTimeInit //Décocher pour initialiser le compteur de défaut cycle compresseur (valeur initialisée à zéro)
#define cptNewComprManuelInit //Décocher pour initialiser le compteur d'enclanchement manuel (valeur initialisée à zéro)
#endif
//#define MyDebug
/**/
/*PINs -> valeurs */ //Arduino Nano >> SD-Card = SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK) || I2C: A4 (SDA), A5 (SCL) "A4=D18, A5=D19" || interrupt 2, 3 ||
const int NiveauPort = 5; // Capteur de niveau: Si l'eau pousse le floteur jusqu'au niveau, le contact ce ferme.
const int TourPort = 6; // Le contact ce ferme quand le piston est complettement sortie
const int PresioPort = 7; // Pressiostat: le contact souvre en dessous de la pression réglée. (Par ex: en dessous de 2.5bar ouvert, en dessus fermé
/**/ //( Sers à déclancher le compresseur à la pression basse de la cloche et à compter le nombre d'enclanchement de la pompe à eau.)
const int StartManuelPort = 8; // Interupteur de démarage manuel du compresseur.
const int MotorPort = 9; // Pin du relais moteur
const int ledNiveauOn = 14; // Témoin de détection du niveau d'air insufisant dans la cloche. Ce désactive après le cycle du compresseur.
//const int ledPmhOff = 15; // Témoin du PMH. S'allume Quand le piston du compresseur n'est pas au point mort haut. (voir [TourPort] ligne ~9)
//const int ledPressioOn = 16; // Témoin pressiostat: S'allume quand la pression dans la cloche est basse.
//const int ledMotorOn = 17; // Témoin Moteur: S'allume quand le moteur du compresseur tourne.
const int ledManuelOn = 20; // Témoin mode manuel: S'allume quand un cycle manuel est demandé.
const uint8_t ledAlarme = 15;
const uint8_t buzAlarme = 16;
/**/
/*Variables -> déclaration */
byte Alarmes = 0;
int NbrTour = 5; // Nombre de tours que le compresseur doit faire dans un cycle de pompage
int PmhNbr = 0; // Emplacement pour comptabiliser le nombre de tours du compresseur dans un cycle de pompage
int TAntiReboud = 10; // Pause en millième de seconde pour éviter le reboud des contactes (Arc à la fermeture/ouverture)
long TimerMotor = 0; // millis() lors de l'enclanchement du moteur. Si "= 0" moteur à l'arrêt
long MaxMotorOn = 36000; // Temp maximum de rotation du moteur (par ex. en cas de problème avec un capteur)
// // Valeur recommandée : [NbrTour] / ([tr/min]vitesse du moteur) x ([1.2] ajouter 20% de marge) x ([60 000] millis/minutes)
//Compteurs
// nom des compteurs actifs. Valeur de comptage DEPUIS la dernière sauvegarde des réglages, c'est des compteurs sur 15 bytes afin de ménager l'Eeprom.
#define cptPompe 0
#define cptCompr 1
#define cptComprNoTime 2
#define cptComprManuel 3
// compteurs old == valeur total de comptage AVANT la dernière sauvegarde des réglages
uint32_t cptOldPompe =0;
uint32_t cptOldCompr =0;
uint32_t cptOldManuel =0;
uint32_t cptOldComprNoTime =0;
// pour un stockage temporère lors de la lecture/l'écriture du compteur 15 bytes dans l'Eeprom
uint32_t cptTempEeprom =0;
int comptDefTimerMoteur = 0;
long NbrPompeOn = 0; //Compteur du nombre d'enclanchement de la pompe à eau.
long NbrCompresseurOn = 0; //Compteur du nombre d'enclanchement du compresseur.
long NbrCompresseurTimeOut = 0; //Compteur du nombre de cycle incomplet du compresseur.
//Compteur 15 bytes Eeprom
struct cpt15byte { // 100'000 [écritures] / 256 [écritures/boucle] = 390.625 [boucles] "pour 100'000 écritures sur l'Eeprom"
uint16_t boucle; //octet 1 à 2 <== max garanti = 390 -> 390*(13*255)= 1'292'650 (sans utiliser les remise à 0 des octets, ça simplifie)
char octetNr[12];
// uint8_t nbrA; //octet 3
// uint8_t nbrB; //octet 4
// uint8_t nbrC; //octet 5
// uint8_t nbrD; //octet 6
// uint8_t nbrE; //octet 7
// uint8_t nbrF; //octet 8
// uint8_t nbrG; //octet 9
// uint8_t nbrH; //octet 10
// uint8_t nbrI; //octet 11
// uint8_t nbrJ; //octet 12
// uint8_t nbrK; //octet 13
// uint8_t nbrL; //octet 14
// uint8_t nbrM; //octet 15
};
cpt15byte cptEeprom[3]; //0 == pompe; 1 == compresseur; 2 == comprNoTime; 3 == comprManuelStart
//Inversseurs
bool invertNiveau = 0; // inverseurs de contacteur (NC devient NO; NO >> NC).
bool invertPmh = 0;
bool invertPressio = 0;
bool invertMotor = 0; //!!! Je vous déconseille d'utiliser un relais excité à l'arrêt du moteur, les temp de pause entre deux pompage peut-être très long.
bool invertManuel = 0;
bool NiveauOn = false;
bool PmhOn = false;
bool PmhChange = false; // Vrai si un changement d'état du capteur Pmh est à traiter
bool PressioOn = false;
bool PressioSatus = false; // Ser à définir le changement d'état du pressiostat
bool MotorOn = false;
bool ManuelOn = false;
String msg; // Emplacement pour le message reçu sur le port série.
String msgAl; // message reçu concernant les alarmes
uint8_t msgCode = 0; // Code servant à la réécriture du dernier msg_série avec la touche ENTER (mise à jour des valeurs)
bool EepromSave = true; // les réglages actuels sont sauvegardé dans l'Eeprom "~~ éventuellement déplacer dans le byte Alarme ~~".
const int AddEeprom = 370; // Empliacement de départ pour l'enregistrement dans l' Eeprom des valeur de réglage
/**/
void setup() {
Serial.begin(9600);
delay(100);
#ifdef MyDebug
Serial.println();
Serial.println(" ||| Start Compresseur (Setup)|||");
Serial.println(F("Envoyez "Aide" depuis le port série pour plus d'informations"));
Serial.println();
#else
Serial.println(F(" ||| Start Logitiel|||"));
Serial.println(F("Envoyez "Aide" depuis le port série pour plus d'informations"));
#endif
#ifdef EepromInit /* :Ecrit les valeurs par défaut dans l'Eeprom*/
EepromWrite();
#else /*EepromInit : Utilise les valeurs inscrites dans l'Eeprom */
EepromRead();
#endif /*EepromInit*/
pinMode(NiveauPort, INPUT_PULLUP);
pinMode(TourPort, INPUT_PULLUP);
pinMode(PresioPort, INPUT_PULLUP);
pinMode(StartManuelPort, INPUT_PULLUP);
pinMode(MotorPort, OUTPUT);
digitalWrite(MotorPort, LOW - invertMotor);
pinMode(ledNiveauOn, OUTPUT);
//pinMode(ledPmhOff, OUTPUT);
//pinMode(ledPressioOn, OUTPUT);
pinMode(ledManuelOn, OUTPUT);
//pinMode(ledMotorOn, OUTPUT);
pinMode(ledAlarme, OUTPUT);
pinMode(buzAlarme, OUTPUT);
#ifdef MyDebug
Serial.println(" - - - Fin du Setup() - - -");
#endif
}
void loop() {
// --> Lecture des capteurs
if (digitalRead(NiveauPort) - invertNiveau == LOW) {
#ifdef MyDebug
if (NiveauOn == LOW) {
Serial.println(" Niveau d'air trop bas détecté");
}
#endif
NiveauOn = HIGH;
}
PressioOn = digitalRead(PresioPort) - invertPressio;
if (digitalRead(StartManuelPort) - invertManuel == LOW) {
ManuelOn = HIGH;
}
if (digitalRead(TourPort) - invertPmh != PmhOn) {
PmhOn = !PmhOn;
PmhChange = true;
}
delay(TAntiReboud);
// --> Gestion des LEDs
digitalWrite(ledNiveauOn, NiveauOn);
digitalWrite(ledManuelOn, ManuelOn);
// Pour les leds d'alarmes voir dans gestion des alarmes (~vers la ligne 280)
/*Leds à supprimer
digitalWrite(ledPmhOff, !PmhOn);
digitalWrite(ledPressioOn, PressioOn);
if (TimerMotor == 0) {
digitalWrite(ledMotorOn, LOW);
} else {
digitalWrite(ledMotorOn, HIGH);
}
*/
// --> Gestion des alarmes
byte tempAlarmes = Alarmes;
// Analyse des données sujetes à alarme
if (comptDefTimerMoteur > 41 && bitRead(Alarmes, 1)==1) {
bitWrite(tempAlarmes, 2, 1);
}
if (comptDefTimerMoteur >41) {
bitWrite(tempAlarmes, 1, 1);
comptDefTimerMoteur = 0;
}
if (comptDefTimerMoteur >10) {
bitWrite(tempAlarmes, 0, 1);
}
if (comptDefTimerMoteur == 100){
if (bitRead(Alarmes, 1)==1){
bitWrite(tempAlarmes, 1, 0);
comptDefTimerMoteur = 0;
} else {bitWrite(tempAlarmes, 0, 0);}
}
if (tempAlarmes != Alarmes){
EEPROM.update(AddEeprom, tempAlarmes);
Alarmes = tempAlarmes;
}
// Voyants alarmes
if (tempAlarmes != 0){
bool alarmeNiveau1 = bitRead(tempAlarmes, 0);
alarmeNiveau1 = alarmeNiveau1 + bitRead(tempAlarmes, 4);
alarmeNiveau1 = alarmeNiveau1 + bitRead(tempAlarmes, 5);
bool alarmeNiveau2 = bitRead(Alarmes, 1);
alarmeNiveau2 = alarmeNiveau2 + bitRead(tempAlarmes, 3);
bool alarmeNiveau3 = bitRead(Alarmes, 2);
alarmeNiveau3 = alarmeNiveau3 + bitRead(tempAlarmes, 6);
alarmeNiveau3 = alarmeNiveau3 + bitRead(tempAlarmes, 7);
if (EepromSave == false){alarmeNiveau1 == true;}
if (alarmeNiveau3 == true){
digitalWrite(ledAlarme, HIGH);//LED alarme Flash
} else if (alarmeNiveau2 == true){
digitalWrite(ledAlarme, HIGH);//LED alarme blink
} else if (alarmeNiveau1 == true){
digitalWrite(ledAlarme, HIGH);
}
} else {
digitalWrite(ledAlarme, LOW);
digitalWrite(buzAlarme, LOW);
}
// Message alarmes
if (msgAl != "Rien"){
if (msgAl.length()>3){
//Extraction des valeurs depuis le message
bool OuiNon;
bool Erreure = false;
int codeAlarme = String(msgAl.substring(0,msgAl.length()-2)).toInt();
char Almsg1[] = "Voulez-vous réelement effacer l'alarme ";
char Almsg2[] = " - Presez [ENTER] pour afficher les alarmes active";
if (msgAl.substring(msgAl.length()-2, msgAl.length()) == ",N"){OuiNon = false;}
else if (msgAl.substring(msgAl.length()-2, msgAl.length()) == ",n"){OuiNon = false;}
else if (msgAl.substring(msgAl.length()-2, msgAl.length()) == ",O"){OuiNon = true;}
else if (msgAl.substring(msgAl.length()-2, msgAl.length()) == ",o"){OuiNon = true;}
else {Erreure = true;}
//Traitement du message
switch (codeAlarme){
case 11: //Effacer défaut du timer moteur niveau 1
if (OuiNon == true){
Serial.print(Almsg1); Serial.println(F("[1] défaut du timer moteur niveau 1 ?"));
if (ReponceON()==true){
bitWrite(Alarmes, 0, 0);
EepromSave = false;
}
}
break;
case 12: //Effacer défaut du timer moteur niveau 2
if (OuiNon == true){
Serial.print(Almsg1); Serial.println(F("[2] défaut du timer moteur niveau 2 ?"));
if (ReponceON()==true){
bitWrite(Alarmes, 1, 0);
EepromSave = false;
}
}
break;
case 13: //Effacer défaut du timer moteur niveau 3
if (OuiNon == true){
Serial.print(Almsg1); Serial.println(F("[3] défaut du timer moteur niveau 3 ?"));
if (ReponceON()==true){
bitWrite(Alarmes, 2, 0);
EepromSave = false;
}
}
break;
case 14: //Effacer défaut ...
if (OuiNon == true){
Serial.print(Almsg1); Serial.println(F("[4] ... ?"));
if (ReponceON()==true){EepromSave = false;}
}
break;
default:
PrintAlarmes();
//Serial.println(msgAl);
//Serial.println(codeAlarme);
}
Serial.println (Almsg2);
msgCode = 7;
}
msgAl = "Rien";
}
// --> Gestion des compteurs
if (NbrPompeOn != EepromReadCompteur(1)){
EepromWriteCompteur(1,NbrPompeOn);
}
if (NbrCompresseurOn != EepromReadCompteur(2)){
EepromWriteCompteur(2,NbrCompresseurOn);
}
if (NbrCompresseurTimeOut != EepromReadCompteur(3)){
EepromWriteCompteur(3,NbrCompresseurTimeOut);
}
// --> Traitement données compresseur
if (ManuelOn == HIGH) {
if (TimerMotor == 0) {
TimerMotor = millis();
#ifdef MyDebug
Serial.println(" Démarrage manuel du compresseur");
#endif
}
NiveauOn = LOW;
}
if (PressioOn != PressioSatus) {
PressioSatus = PressioOn;
if (PressioOn == LOW) {
NbrPompeOn++;
#ifdef MyDebug
Serial.print(" Compteur pompe = "); Serial.println(NbrPompeOn);
#endif
}
}
if (NiveauOn == HIGH) {
if (PressioOn == HIGH) {
if (TimerMotor == 0) {
TimerMotor = millis();
#ifdef MyDebug
Serial.println(" Démarrage du moteur demandé");
#endif
NiveauOn = LOW;
}
}
}
if (TimerMotor > 0) {
if (MotorOn == false) {
StartMoteur();
} else {
ControlMoteur();
}
}
// --> Lecture port série
if (Serial.available()) {
msg = Serial.readString();
msg = msg.substring(0, msg.length() - 1); // Enlève le [Enter] à la fin du message
char msgSplit1[4] ; msg.toCharArray(msgSplit1, 5);
char msgSplit2[10] ; msg.substring(5,13).toCharArray(msgSplit2, 10);
int newVal = String(msgSplit2).toInt();
if (msg == "INFO") {
msgCode = 2;
}
else if (msg == "S_Eeprom"){
msgCode = 3;
}
else if (msg == "R_Eeprom"){
msgCode = 4;
}
else if (msg == "ALARME"){
msgCode = 7;
}
else if (msg == "SAVE"){
msgCode = 8;
}
else if (msg == ""){
//msgCode = msgCode; >> Rien ne change
}
else if (strcmp(msgSplit1,"Tour")==0){
msgCode=5;
}
else if (strcmp(msgSplit1,"Smax")==0){
msgCode=6;
}
else if (strcmp(msgSplit1,"mSSw")==0){
msgCode=9;
}
else if(msg.substring(0, 2) == "Al"){
msgAl = msg.substring(3, msg.length());
msgCode=99;
}
else {
msgCode = 0;
}
switch (msgCode) {
case 2: //[INFO]
PrintInfo();
//msgCode reste à 2
break;
case 3: //[R_Eeprom]
PrintSave();
Serial.println(F(" --> Remplacer les valeurs sauvgardées par les valeurs actuellement utilisées ?"));
if (ReponceON()==true){
EepromWrite();
PrintSave();
}
msgCode = 0;
break;
case 4: //[S_Eeprom]
PrintSave();
Serial.println(F(" --> Remplacer les valeurs actuellement utilisées par les valeurs sauvgardées ?"));
if (ReponceON()==true){
EepromRead();
PrintSave();
}
msgCode = 0;
break;
case 5: //[Tour:]
if (NbrTour != newVal && newVal > 0){
Serial.print(F("> Tours par cycle, nouvelle valeur : ")); Serial.print(newVal);
Serial.print(F(" ; valeur actuel : ")); Serial.println(NbrTour);
Serial.println(F("Utiliser la nouvelle valeur ? (!voir info sauvegarde sur la page aide !)"));
if (ReponceON()==true){
NbrTour = newVal;
EepromSave = false;
Serial.println(F("La valeur utiliées et maintenant de ")); Serial.print(NbrTour);
}
}
else if (newVal <= 0){
Serial.print(F("La valeur [n] doit être supérieur à 0"));
}
Serial.println(F(" - Presez [ENTER] pour afficher la page INFO"));
msgCode = 2;
break;
case 6: //[Smax:]
if (MaxMotorOn != long(newVal)*1000 && newVal > 1){
Serial.print(F("> Secondes max pour un cycle; nouvelle valeur : ")); Serial.print(newVal);
Serial.print(F(" ; valeur actuel : ")); Serial.println(MaxMotorOn / 1000);
Serial.println(F("Utiliser la nouvelle valeur ? (!voir info sauvegarde sur la page aide !)"));
if (ReponceON()==true){
MaxMotorOn = long(newVal)*1000;
EepromSave = false;
Serial.print(F("La valeur utiliées et maintenant de ")); Serial.print(MaxMotorOn / 1000);
}
}
else if (newVal <= 1){
Serial.print(F("La valeur [n] doit être supérieur à 1"));
}
Serial.println(F(" - Presez [ENTER] pour afficher la page INFO"));
msgCode = 2;
break;
case 7: //[ALARME]
PrintAlarmes();
msgCode = 0;
break;
case 8: //[SAVE]
PrintSave();
msgCode = 0;
break;
case 9: //[mSSw]
if (TAntiReboud != newVal && newVal > 1){
Serial.print(F("> Milli-secondes d'anti-reboud; nouvelle valeur : ")); Serial.print(newVal);
Serial.print(F(" ; valeur actuel : ")); Serial.println(TAntiReboud);
Serial.println(F("Utiliser la nouvelle valeur ? (!voir info sauvegarde sur la page aide !)"));
if (ReponceON()==true){
TAntiReboud = newVal;
EepromSave = false;
Serial.print(F("La valeur utiliées et maintenant de ")); Serial.print(TAntiReboud);
}
}
else if (newVal <= 1){
Serial.print(F("La valeur [n] doit être supérieur à 1"));
}
Serial.println(F(" - Presez [ENTER] pour afficher la page INFO"));
msgCode = 2;
break;
case 10: //[] pas atribuée
Serial.println(F(" --> 10"));
msgCode = 0;
break;
case 99: //[Al:]
msgCode = 7;
break;
default: //[Autre valeur]= fichier d'aide
PrintAide();
msgCode = 0;
}
msg = "";
} /* if (Serial.available())*/
// <-- FIN de la LOOP <--
}
void StartMoteur() {
// --> Démarrage le moteur du compresseur
PmhNbr = NbrTour * 2;
if (PmhOn == LOW) {
PmhNbr = PmhNbr + 1;
}
PmhChange = false;
digitalWrite(MotorPort, HIGH - invertMotor);
MotorOn = true;
NbrCompresseurOn++;
#ifdef MyDebug
Serial.println(" >> Démarrage du compresseur");
Serial.print(" Compteur compresseur = "); Serial.println(NbrCompresseurOn);
#endif
}
void ControlMoteur() { // Le moteur tourne déjà
// --> Contrôle le nombre de tours et le temp de fonctionnement du compresseur
// --> Contrôle le temp de fonctionnement du compresseur
if (abs(millis() - TimerMotor) > MaxMotorOn) { // Si le morteur tourne depuis plus de 20 seconde (~3tour à 10tr/min), arréter le moteur et reprendre au contrôle du niveau.
NbrCompresseurTimeOut ++;
StopMoteur();
}
// --> Contrôle le nombre de tours du compresseur
if (PmhChange == true) {
PmhNbr--;
PmhChange = false;
if (PmhOn == HIGH) {
#ifdef MyDebug
Serial.print(" - - > Tour compresseur restant: "); Serial.println(PmhNbr / 2);
#endif
}
if (PmhNbr < 1) {
StopMoteur();
}
}
}
void StopMoteur() {
// --> Arrête le compresseur et envoye un rapport au port série.
long MotorOnTime = abs(millis() - TimerMotor);
digitalWrite(MotorPort, LOW - invertMotor);
MotorOn = false;
TimerMotor = 0;
ManuelOn = LOW;
if (PmhNbr == 0) { // Les tours demandés ont été fait
comptDefTimerMoteur--;
if (comptDefTimerMoteur <100) {comptDefTimerMoteur = 90;}
} else {
if (comptDefTimerMoteur <10) {comptDefTimerMoteur = 10;}
if (comptDefTimerMoteur >40) {comptDefTimerMoteur = 40;}
if (PmhNbr >= NbrTour * 2) { // Le capteur Pmh n'a pas détecté de tour complet
comptDefTimerMoteur = comptDefTimerMoteur + 10;
} else { // Les tours n'ont pas pu être exécutés dans le temp donné
comptDefTimerMoteur = comptDefTimerMoteur + 10;
}
}
#ifdef MyDebug
Serial.println(" Arrêt du compresseur");
if (PmhNbr == 0) { // Les tours demandés ont été fait
Serial.print(" - le compresseur à effectué les ");
Serial.print(NbrTour);
Serial.print(" tours demandés en ");
Serial.print(MotorOnTime / 1000);
Serial.println(" secondes");
} else {
Serial.print(F(" ! le compresseur à été arrêté après sont temp de travail maximum de "));
Serial.print(MaxMotorOn / 1000);
Serial.println(F(" second. "));
if (PmhNbr >= NbrTour * 2) { // Le capteur Pmh n'a pas détecté de tour complet
Serial.println(F("!!! Contrôler fonctionnement du capteur, aucun tour n'a été comptabilisé !!!"));
} else { // Les tours n'ont pas pu être exécutés dans le temp donné
Serial.println(F("Le nombre de tours désiré n'a pas pu être atteint"));
}
}
#else
if (PmhNbr != 0) {
if (PmhNbr >= NbrTour * 2) {
Serial.println(F(" !!! Contrôler fonctionnement du capteur, aucun tour n'a été comptabilisé !!!"));
} else {
Serial.println(F(" ! Le nombre de tours désiré n'a pas pu être atteint dans le temp imparti"));
}
}
#endif
}
void EepromWrite() { // Ecrire Eeprom
//1024 octets d’EEPROM = 1024 valeurs de 1 octet (de type byte / char / uint8_t / int8_t / boolean, par exemple)
//1024 octets d’EEPROM = 512 valeurs de 2 octets (de type int / word / short / uint16_t / int16_t, par exemple)
//1024 octets d’EEPROM = 256 valeurs de 4 octets (de type long / float / uint32_t / int32_t, par exemple)
//EEPROM.update(address, value) Analogue à write(), mais les nouvelles données sont écrites dans la cellule uniquement lorsqu’elles diffèrent de ce qui a déjà été écrit.
//EEPROM.put(address, data) Ecrit tout type de données dans l’EEPROM à l’adresse address. La fonction n’écrit que des données différentes dans la cellule.
EEPROM.update(AddEeprom, Alarmes); // add ++ 1
EEPROM.put(AddEeprom + 1, NbrTour); // add ++ 2
EEPROM.put(AddEeprom + 3, MaxMotorOn); // add ++ 4
EEPROM.put(AddEeprom + 7, TAntiReboud); // add ++ 2
byte inversseur; // bit_à_bit >>Info:https://www.locoduino.org/spip.php?article70
bitWrite(inversseur, 0, invertNiveau); //bit0 invertNiveau
bitWrite(inversseur, 1, invertPmh); //bit1 invertPmh
bitWrite(inversseur, 2, invertPressio); //bit2 invertPressio
bitWrite(inversseur, 3, invertMotor); //bit3 invertMotor
bitWrite(inversseur, 4, invertManuel); //bit4 invertManuel
EEPROM.update(AddEeprom + 9, inversseur); // add ++ 1
EepromSave = true;
}
void EepromWriteCompteur(int _nrCpt, long _valCpt){
//
}
void EepromCptPlus(uint8_t _nrCpt){
//Incrémante de un le compteur _nrCpt
int _adTemp = AddEeprom +15;
switch (_nrCpt){
case 0: //(cptPompe)
break;
case 1: //(cptCompr)
_adTemp += 15;
break;
case 2: //(cptComprNoTime)
_adTemp += 30;
break;
case 3: //(cptComprManuel)
_adTemp += 45;
break;
}
// à construire
}
void EepromCptZero(uint8_t _nrCpt){
// met à zéro le compteur _nrCpt
}
void EepromRead() { // Lire Eeprom
//EEPROM.read(address);
//EEPROM.get(address, data) Lit tout type de données de l’EEPROM de l’Arduino à l’adresse address. Les données (data) peuvent être de n’importe quel type, par exemple int ou float
Alarmes = EEPROM.read(AddEeprom); //byte >> 1 octet -> add = +0
EEPROM.get(AddEeprom + 1, NbrTour); //int >> 2 octets -> add = +1
EEPROM.get(AddEeprom + 3, MaxMotorOn); //long >> 4 octets -> add = +3
EEPROM.get(AddEeprom + 7, TAntiReboud); //int >> 2 octet -> add = +7
byte inversseur = EEPROM.read(AddEeprom + 9); //byte>> 1 octet -> add = +9
invertNiveau = bitRead(inversseur, 0); //bit0 invertNiveau = bitRead(EEPROM.read(AddEeprom + 9), 0);
invertPmh = bitRead(inversseur, 1); //bit1 invertPmh = bitRead(EEPROM.read(AddEeprom + 9), 1);
invertPressio = bitRead(inversseur, 2); //bit2 invertPressio = bitRead(EEPROM.read(AddEeprom + 9), 2)
invertMotor = bitRead(inversseur, 3); //bit3 invertMotor = bitRead(EEPROM.read(AddEeprom + 9), 3)
invertManuel = bitRead(inversseur, 4); //bit4 invertManuel = bitRead(EEPROM.read(AddEeprom + 9), 4)
EepromSave = true;
}
long EepromReadCompteur(int _nrCpt){
// #define cptPompe 0 #define cptCompr 1 #define cptComprNoTime 2 #define cptComprManuel 3
int _adTemp = AddEeprom +15;
long _Valeur = 0;
uint16_t _nbrBoucle = 0;
switch (_nrCpt){
case 0: //(cptPompe)
break;
case 1: //(cptCompr)
_adTemp += 15;
break;
case 2: //(cptComprNoTime)
_adTemp += 30;
break;
case 3: //(cptComprManuel)
_adTemp += 45;
break;
}
EEPROM.get(_adTemp, _nbrBoucle);
_Valeur = EEPROM.read(_adTemp+2);
uint8_t i;
for (i=3;i<=16;i++){
if (i == 16){
_Valeur = (_Valeur-1)*13 + i-3;
break;
}
if (EEPROM.read(_adTemp + i) != _Valeur){
_Valeur = (_Valeur-1)*13 + i-3;
break;
}
}
_Valeur = _Valeur + _nbrBoucle*3315;
return _Valeur;
}
void PrintInfo() {
// --> Envoye les informations au port série
Serial.println();
Serial.println(F(" ===>> Début de printInfo ===>>"));
Serial.print(F(" Nombre de cycle (démarrages) de la pompe : "));
Serial.print(NbrPompeOn);
Serial.print(F(" || du compresseur : "));
Serial.println(NbrCompresseurOn);
Serial.print(F("- Nombre de tour du compresseur par cycle : "));
Serial.println(NbrTour);
Serial.print(F("- Secondes par cycle du compresseur maximum: "));
Serial.print(MaxMotorOn / 1000);
Serial.println(F(" || minimum: (pas défini)"));
Serial.print(F(" Etat des fonctions: -"));
Serial.print(" NiveauOn ");
Serial.print(NiveauOn);
Serial.print(" || PmhOn ");
Serial.print(PmhOn);
Serial.print(" || PressioOn ");
Serial.print(PressioOn);
Serial.print(" || MotorOn ");
Serial.print(MotorOn);
Serial.print(" || ManuelOn ");
Serial.println(ManuelOn); //
if (Alarmes + !EepromSave > 0){PrintAlarmes();}
Serial.println(F(" <<=== Fin de printInfo <<=== presse [ENTER] pour mettre à jour <<==="));
}
void PrintAide() {
// --> Envoye les codes utilisable au port série "" ALARME SAVE
Serial.println();
Serial.println(F(" ===>> Début de l'aide ===>>"));
Serial.println(F("Envoyer ALARME pour afficher la page des alarmes"));
Serial.println(F("Envoyer INFO pour afficher les information de la carte"));
Serial.println(F("Envoyer SAVE pour afficher les valeurs memorisees"));
Serial.println(F("Envoyer S_Eeprom pour enregistrer les réglages actuel"));
Serial.println(F("Envoyer R_Eeprom pour rétablir les réglages enregistrés"));
Serial.println(F("Envoyer Tour:n pour régler les tours par cycle (n = nombres de tours)"));
Serial.println(F("Envoyer Smax:n pour régler le temp maximum par cycle (n = nombres de secondes)"));
Serial.println(F("Envoyer mSSw:n pour régler l'anti-reboud des contacteurs (n = en milli-secondes)"));
//Serial.println(F("Envoyer HR+09:30 pour regler l'heure à 9:30"));
//Serial.println(F("Envoyer DT+01,03,23 pour regler la date au 1 mars 2023"));
if (Alarmes + !EepromSave > 0){
Serial.println(F("!! ATTENTION des alarmes sont activées. Envoyer [ALARME] pour voir les réparations à faire !!"));
}
Serial.println(F(" <<=== Fin de l'aide <<==="));
}
void PrintAlarmes() {
// --> Envoye les codes utilisable au port série "" ALARME SAVE
char msgInfoAide[] = " (pour plus d'infos voir dans l'aide)";
Serial.println();
Serial.println(F(" ===>> ALARMES actives: ===>>"));
Serial.println(F(" ---> Liste des alarmes Niveau [3] (haut niveau) qui sont activées"));
if (bitRead(Alarmes,2)){
Serial.println(F("Al_n°3-> Le moteur du compresseur n'a pas souvent réussit à terminer ces tours dans le temps qu'il lui est imparti."));
Serial.println(F("Al_n°3--> Verifier que le moteur fonctionne correctement et que ça bielle y est bien fixée"));
Serial.println(F("Al_n°3--> Verifier que le verin coulisse par trop difficilement et que les anti-retours fonctionnent"));
Serial.println(F("Al_n°3--> Verifier que les tuyaux ne soitent pas bouchés ou écrasés"));
Serial.println(F("Al_n°3--> Verifier le capteur de pmh sur la bielle du moteur"));
Serial.print(F("Al_n°3---> Si tous et ok, contrôler et ajuster les réglages [S_max:] et [Tour:]")); Serial.println(msgInfoAide);
Serial.println(F("Al_n°3---> ---> Pour effacer cette alarme envoyer [Al:13,O]"));
}
Serial.println(F(" ---> Liste des alarmes Niveau [2] (niveau moyen) qui sont activées"));
if (bitRead(Alarmes,1)){
Serial.println(F("Al_n°2-> Le moteur du compresseur a des difficultées à terminer ces tours dans le temps qu'il lui est imparti."));
Serial.println(F("Al_n°2--> Verifier les composants mécanique du compresseur"));
Serial.print(F("Al_n°2---> Si tous et ok, contrôler et ajuster les réglages [S_max:] et [Tour:]")); Serial.println(msgInfoAide);
Serial.println(F("Al_n°2---> ---> Pour effacer cette alarme envoyer [Al:12,O]"));
}
Serial.println(F(" ---> Liste des alarmes Niveau [1] (bas niveau) qui sont activées"));
if (bitRead(Alarmes,0)){
Serial.println(F("Al_n°1-> Le moteur du compresseur termine ces tours la limite du temps qu'il lui est imparti."));
Serial.println(F("Al_n°1--> Verifier les composants mécanique du compresseur"));
Serial.print(F("Al_n°1---> Si tous et ok, contrôler et ajuster le temps de fonctionnement par cycle [Smax:]")); Serial.println(msgInfoAide);
Serial.println(F("Al_n°1---> ---> Pour effacer cette alarme envoyer [Al:11,O]"));
}
// Eeprom SAVE
if (EepromSave == false) {
Serial.println();
Serial.println(F("!!!!!!!!!!!! Les réglages actuels ne sont pas sauvgardés !!!!!!!!!!!!!!!")); //
Serial.println(F("!!!!! S_Eeprom pour les enregistrer ou R_Eeprom pour les rétablir !!!!!!"));
}
Serial.println(F(" <<=== Fin des ALARMES <<==="));
}
void PrintSave() {
// --> Envoye les codes utilisable au port série "" ALARME SAVE
Serial.println();
// alarmes (Alarmes = EEPROM.read(AddEeprom); //byte>> 1 octet >>)
Serial.println(F(" ===>> Comparatif des valeurs actuellement utilisées et de celles en mémoires ===>>"));
Serial.println(F(" (> 0 = Non <> 1 = Oui <)"));
Serial.print(F(" ALARMES || "));Serial.print("utilisée");Serial.print(" || ");Serial.println("Eeprom");
Serial.print(F("timeMoteur 1 || "));Serial.print(bitRead(Alarmes,0));Serial.print(" || ");Serial.println(bitRead(EEPROM.read(AddEeprom), 0)); ////bit0
Serial.print(F("timeMoteur 2 || "));Serial.print(bitRead(Alarmes,1));Serial.print(" || ");Serial.println(bitRead(EEPROM.read(AddEeprom), 1)); ////bit1
Serial.print(F("timeMoteur 3 || "));Serial.print(bitRead(Alarmes,2));Serial.print(" || ");Serial.println(bitRead(EEPROM.read(AddEeprom), 2)); ////bit2
//Serial.print(F("Al_n°4 || "));Serial.print("libre");Serial.print(" || ");Serial.println(bitRead(EEPROM.read(AddEeprom), 3)); ////bit3
//Serial.print(F("Al_n°5 || "));Serial.print(bitRead(Alarmes,4));Serial.print(" || ");Serial.println(bitRead(EEPROM.read(AddEeprom), 4)); ////bit4
//Serial.print(F("Al_n°6 || "));Serial.print( );Serial.print(" || ");Serial.println(bitRead(EEPROM.read(AddEeprom), 5)); ////bit5
//Serial.print(F("Al_n°7 || "));Serial.print( );Serial.print(" || ");Serial.println(bitRead(EEPROM.read(AddEeprom), 6)); ////bit6
//Serial.print(F("Al_n°8 || "));Serial.print( );Serial.print(" || ");Serial.println(bitRead(EEPROM.read(AddEeprom), 7)); ////bit7
Serial.println( );
Serial.print(F(" INVERSSEURS || "));Serial.print("utilisée");Serial.print(" || ");Serial.println("Eeprom");
Serial.print(F("Sonde niveau || "));Serial.print(invertNiveau);Serial.print(" || ");Serial.println(bitRead(EEPROM.read(AddEeprom + 9), 0)); ////bit0 invertNiveau = bitRead(EEPROM.read(AddEeprom + 9), 0)
Serial.print(F("sonde pmh || "));Serial.print(invertPmh);Serial.print(" || ");Serial.println(bitRead(EEPROM.read(AddEeprom + 9), 1)); //bit1 invertPmh = bitRead(EEPROM.read(AddEeprom + 9), 1);
Serial.print(F("presiostat || "));Serial.print(invertPressio);Serial.print(" || ");Serial.println(bitRead(EEPROM.read(AddEeprom + 9), 2)); //bit2 invertPressio = bitRead(EEPROM.read(AddEeprom + 9), 2)
Serial.print(F("relais moteur || "));Serial.print(invertMotor);Serial.print(" || ");Serial.println(bitRead(EEPROM.read(AddEeprom + 9), 3)); //bit3 invertMotor = bitRead(EEPROM.read(AddEeprom + 9), 3)
Serial.print(F("start manuel || "));Serial.print(invertManuel);Serial.print(" || ");Serial.println(bitRead(EEPROM.read(AddEeprom + 9), 4)); //bit4 invertManuel = bitRead(EEPROM.read(AddEeprom + 9), 4)
//Serial.print(F("Inv_n°6 || "));Serial.print("libre");Serial.print(" || ");Serial.println(bitRead(EEPROM.read(AddEeprom + 9), 5));
//Serial.print(F("Inv_n°7 || "));Serial.print("libre");Serial.print(" || ");Serial.println(bitRead(EEPROM.read(AddEeprom + 9), 6));
//Serial.print(F("Inv_n°8 || "));Serial.print("libre");Serial.print(" || ");Serial.println(bitRead(EEPROM.read(AddEeprom + 9), 7));
Serial.println();
Serial.print(F(" REGLAGES || "));Serial.print("utilisée");Serial.print(" || ");Serial.println("Eeprom");
int _int;
EEPROM.get(AddEeprom + 1, _int);
Serial.print(F("Tours/cycle || "));Serial.print(NbrTour);Serial.print(" || ");Serial.println(_int); //EEPROM.get(AddEeprom + 1, NbrTour)
long _long;
EEPROM.get(AddEeprom + 3, _long);
Serial.print(F("msec./cycle || "));Serial.print(MaxMotorOn);Serial.print(" || ");Serial.println(_long); //EEPROM.get(AddEeprom + 3, MaxMotorOn)
EEPROM.get(AddEeprom + 7, _int);
Serial.print(F("msec.anti-reboud|| "));Serial.print(TAntiReboud);Serial.print(" || ");Serial.println(_int); //EEPROM.get(AddEeprom + 7, TAntiReboud)
Serial.println();
Serial.println(F("!!! ATTENTION, à chaque redémarrage les valeurs non sauvegardées voitent êter perdues !!!"));
Serial.println();
Serial.println(F(" <<=== Fin des valeurs en mémoires <<==="));
}
bool ReponceON(){
// attend une réponce oui ou non avant de poursuivre
// ATTENTION la fonction bloque le déroulement du programme !
bool newReponce = false;
bool reponce = false;
String txtrecu ="";
int i = 0;
long timer = millis() + 15000; //Temps d'attente sur la reponce. Après ce delais envoye NON;
Serial.print(F(" --> envoyer: O pour oui; N pour non --> Reponce : "));
while (newReponce == false){
if (Serial.available()) {
txtrecu = Serial.readString();
if (txtrecu.substring(0,1) == "N" || txtrecu == "n\n"){
reponce = false;
newReponce = true;
} else if (txtrecu.substring(0,1) == "O" || txtrecu == "o\n"){
reponce = true;
newReponce = true;
}
}
if (timer < millis()){
reponce = false;
newReponce = true;
}
}
if (reponce == true){Serial.println("OUI");} else {Serial.println("NON");}
return reponce;
}
/**/
J’aurais aimé ne pas avoir à renseigner la date quand je sauvegarde, mais que l’Arduino la pompe directement sur le port série.
Il me semblai que les modules RTC ce synchronisaient avec le port série à chaque connexion, mais après quelques recherche, je crois plutôt que c’est uniquement lors du téléversement avec la même fonction que celle donnée par @lesept
Après si ce n’ai pas possible, je vais devoir la renseigner, c’est pas la fin du monde.
édit: J'ai corriger le code pour qu'il puisse compiler: excuser moi, j'avais copier le code sans regarder
En gros: dès que j'envois Aide (ou une commande fausse le fichier aide m'imprime la liste des commandes:
===>> Début de l'aide ===>>
Envoyer ALARME pour afficher la page des alarmes
Envoyer INFO pour afficher les information de la carte
Envoyer SAVE pour afficher les valeurs memorisées
Envoyer S_Eeprom pour enregistrer les réglages actuel
Envoyer R_Eeprom pour rétablir les réglages enregistrés
Envoyer Tour:n pour régler les tours par cycle (n = nombres de tours)
Envoyer Smax:n pour régler le temp maximum par cycle (n = nombres de secondes)
Envoyer mSSw:n pour régler l'anti-reboud des contacteurs (n = en milli-secondes)
<<=== Fin de l'aide <<===
Pour qu'il la pompe sur le port série, il faut que quelque chose la lui envoie.
Je n'ai pas bien compris : qu'est-ce qui se trouve à l'autre bout de la liaison série ? Un code Python ? Si oui, il suffit à l'Arduino de demander la date au code Python
Sinon, pourquoi ne pas mettre une RTC ? Ca coute 2€...
Enfin, tu peux tenir la date à jour dans l'Arduino lui-même. Si tu as juste besoin de la date (donc pas besoin de précision sur l'heure), il suffit de la calculer avec l'Arduino. Si tu utilises le système durant des mois, il est possible que tu perdes un jour au bout d'un long moment. Reste à savoir si c'est important...
Pour conserver le max de précision, tu peux utiliser micros() pour suivre le temps. micros() permet de durer près de 70 minutes sans 'reboucler' : donc dès que micros() dépasse une heure (soit 60 000 000 microsecondes), tu incrémentes un compteur de un. Lorsque le compteur passe à 24, c'est que une journée est passée.
Non, le Python cest au dessus de mes compétance! c'est un simple moniteur série (celui de lArduino IDE). Je regarde pour évantuelement utiliser un smartphone pour le moniteur série en USB, mais je n'ai tous compris avec le "câble OTG"
Je voulais savoir si il y avais une formule magique pour la demander au moniteur série, via un fonction ou une bibliothèque.
C'est pas le bout du monde si il n'y arrive pas, comme tu dit on peut soit l'accérire autrement, soit comme le dit @terwal demander à la renseigner dans le port série avant défectuer la sauvegarde.
Merci à tous les deux pour vos précieux renseignements.
La liaison série est vraiment un simple lien, comme une ligne téléphonique, pour connaitre l'heure tu appel l'horloge parlante, c'est pas la ligne téléphonique qui te l'a fournis.
Après cela dépend du programme que tu utilise pour communiquer sur le port série(de l'autre coté de l'arduino), il est peut être possible d'avoir une commande dans ce logiciel qui imprime automatiquement l'heure.
L'idéal serait d'avoir un petit programme Python qui demande de taper des commandes et se charge de les envoyer sur la liaison série, comme ça il pourrait envoyer la date sur certaine commande clé.
Un câble OTG, en gros est un câble qui est capable de dire au Téléphone qu'il doit alimenter l'autre appareille et ne pas être alimenter par l'autre appareille, comme quand il est connecté à un ordinateur.
Mais je crois qu'il est possible de dire à ton téléphone de forcer à être celui qui alimente ou est le maitre.
La solution, si le moniteur série est choisi pour envoyer les commandes, est celle de terwal
Au lieu d'envoyer SAVE, tu envoies SAVE JJ/MM/AAAA
Tu utilises tellement de String et subString que tu dois pouvoir décomposer JJ/MM/AAAA en jour mois et année, non ?
Ensuite, dans le code de décomposition il serait préférable de vérifier le format, en renvoyer un message si celui-ci n'est pas correct.
Par exemple, si tu envoies SAVE sans argument, renvoie "Usage : SAVE JJ/MM/AAAA"
Avec le moniteur série, il n'y a pas d'automatisation possible.
Le seul moyen d'automatiser serait d'écrire un logiciel sur le PC, en PYTHON par exemple.
Cette fois j'ai compris que c'est pas possible de faire comme je le pensais.
Bien-sur, mais comme je l'ai dit j'ai pas le niveau pour ça. Et en plus le jour ou j'en aurais besoin, je suis tellement bordélique que je saurais pas ou le retrouver.
Ca sera un Nano, mais j’ai vue, c’est pour ça que je met un warning qui invite à sauvegarder les réglages sur l’eeprom.
Un grand merci à vous quatre pour avoir u la patience de m’expliquer.
Et plus généralement, un grand merci à toutes ses personnes qui prennent le temps de partager leurs connaissances sur ce forum. Même si cette fois il n’y avait pas de formule magiques, pour moi vous restez des magiciens du codage qui sortent des trucs incroyables de leurs chapeaux.
Ha d’accords, c’est pas un simple câble. Quand tu dit «qu'il doit alimenter l'autre appareille» tu parles de data ou du 5volts ?
Je pensais mettre un câble comme celui-ci tous le temps connecté à l’arduino et le côté USB-A collé au boîtier comme passe cloison.
Mais il sera utilisé dans le sens inverce de ce pourquoi il a été construit ! Est-ce-un problème ?
Et si je veux mettre à jour le logitiel avec le PC et un câble USB-A mâle-mâle ça marche ?
Après c'est toi qui vois en fonction de tes besoins, le plus simple étant de concaténer savez et la date au format jj/mm/AA ou de faire des retours à ligne après save et chaque nombre de ta date si tu ne veux pas faire des extractions de sous chaîne.
Pour l'otg, je parle de l'alimentation, lorsque tu connecte ton Arduino, une clé usb ou ton mobile à ton pc, ils sont alimentés par ton pc.
Lorsque tu veux brancher une clé USB à ton mobile, c'est ton mobile qui doit alors alimenter ta clé USB, pour cela il faut utiliser un câble otg, pour que ton mobile, doit alimenter ta clé, sinon croira qu'il est connecté comme avec un pc.
Je ne suis pas sûre, mais je pense que tu pourras utiliser ce câble, si l'autre câble qui relira celui-ci à ton mobile est aussi compatible otg