Questions sur la portées des variables

International Français
1

Bonjour,

le titre est peut être mal choisi, mais je voudrais savoir si il existe un autre moyen que de déclarer des variables en "extern" dans un fichier .ino afin de les initialisées "toutes" et "d'un seul coup" par lecture eeprom, et bien évidement, les enregistrées ensuite.

Je m'explique, je commence a programmer, et comme tous bon débutant, j'ai commencé par faire "un" fichier..avec plein de variables globales..(ouiiiiii....PAS BIEN!! (((mais tellement pratique quand on débute!!:wink: )))

Comme les choses deviennent vite "encombrante" dans un seul programme! et que quand on commence a comprendre, on ce dis: a ben tiens, je peut faire ça, puis ça, puis ça aussi....!! Je me suis mis a le découper en bloc distinct en faisant des .cpp et des .h..

Premier aperçue, suite a ça, mes premiers poste ici, ba oui ça entraîne, mais ça demande aussi une autre logique, plus "cartesienne", et du coup, certaine choses ne fonctionnées pas pareil qu'avant!!

Oui mais c'est cool.. on peut traiter chaque bloque séparément!! ça aide!!

Ouai, sauf que du coup!! ba j'ai transformé mes variables globales en variables locales a mes .cpp

je me dis..cool! securitée!!et PAF!!

Croyant que je serais a l'abris, je me rend compte que:

Sois, je suis obligé de rendre mes variables en globales via extern pour les regrouper dans une structure et tous faire d'un coup pour la mise en eeprom dans le .ino

Sois je dois dans chaque fichier .cpp, créer, de quoi localement les initialisées et les enregistrées.

Dans les deux cas, je me sens eu!! car:

Pour la première option, ba je pense prendre le risque en rajoutant dans le futur une variable qui pourrait avoir le même nom, et du coup, faire face a des erreurs que je pourrais avoir beaucoup de mal a cernés!!

Deuxième option, tout taper a la main dans chaque .cpp et prendre le risque de me tromper dans les adresses et écrasées des données. Ce qui, vous l'admettrez, est plutot balo!!

Alors, bien sur dans ce cas, quand on debute, on ce dis...a mais j'ai peut etre la solution pointeur!!
et là, plein d'espoir on créer le fameux pointeur!! et quand on compile, ba...On rage en lisant:

was not declared in this scope... et ouai, un pointeur sur une variable locale...biiiiip.
(fais suer..les variables sont dans les .cpp, qui renvoient au .h....pourrais aider un peu le compilo..)

Bref, vous l'aurez compris. On fais comment dans ce cas?

deuxième petite question. comment ce fusse-t-il, que 5 fichiers ino type "example" avec leur .cpp et leur .h chacun, compile environ dans les 10 à 15% memoire et espace de stockage?

Et que une fois mis ensemble, le .ino composer des 5 cpp + h fais que 19%??

(certe on met moins de serial, mais quand même, je pensais pas tant économiser :wink: )

Je vous remercie d'avance de l'attention que vous porterez a ce "bloc".

Oui j'avoue..j'aurais put faire plus court!!mais ça m'as fait du bien ;)!

2

Re, personne n'a de solution? ou une idée a proposée?

Je me suis mal exprimé? J'ai dis des bêtises?

Allez..comment vous faite dans ce cas? svp!

3

Je me suis mal exprimé? J'ai dis des bêtises?

Probablement. Question de terminologie sans doute.

Une variable comme tu dis "locales a mes .cpp" reste une variable globale.
Une vraie variable locale est déclarée dans le corps d'une fonction, donc sur la pile.

Si tu désires enregistrer des paramètres en EEPROM et les relire il est bien entendu conseillé de les regrouper dans une structure.
Les données peuvent comporter un numéro magique situé en fin de structure, ainsi si tu ajoutes un membre le N° magique sera déplacé. Si tu relis ta config en EEPROM tu sais immédiatement que le N° magique ne correspond pas, et tu peux prendre une décision, repartir sur une config par défaut par exemple.

Pour les autres questions, sans le code, pas de réponse possible.

4

Bonjour Hbachetti,

merci pour ton retour.

pour être franc, je suis aller voir sur ton forum aussi...pour la partie shuntdown => enregistre!
(d'ailleur, est on obliger de passer par un attachinterrupt pour le déclenchement?subcidiaire..c'est pas le sujet)

Concernant ma demande, en gros, je voulais savoir si il exister une méthode, pour passer des valeurs a l'initialisation des variables depuis le .ino vers les .cpp!! (pareil pour l'enregistrement...)

J'ai aussi continuer a regarder de mon coter, et même si je fais une structure cote .ino, cela va me demander de modifier toute mes variables dans les .cpp non?

et c'est là que je bloque! du moins, en logique. j'entend par là que j'ai découper mes blocs de programme dans l'intention de pouvoir m'en resservir dans d'autre programmes...(éventuellement, tant qu'a faire!!!)

Deplus, je voudrais mettre en place un système "d'adresse tournante", déjà pour voir si je capte le truc. et en plus, pour permettre plus d'enregistrement.

Je dis ça histoire d'anticiper!!

l'idee c'est de remplir les cases eeprom d'une valeur particulière, avec des nombres de verif bien sur!!.. et d'enregristrer en fonction de la lecture de cette valeur...ensuite..pour relire. on tombe sur cette valeur. et l'adresse de depart serais connu en soustrayant la taille de la structure (ça c'est l'idee...).

mais là je m'ecarte..

en gros, autant passer une valeur d'un .cpp à un .ino..suffit de la coller dans une fonction..

Autant passer du .ino au .cpp...là, je sais pas!! ne serais ce que si c'est possible..

concernant la partie deuxième méthode, est ce que si je fais une fonction dans chaque .cpp pour enregistrer et lire l'eeprom sans mettre eeprom.h dans le .cpp, si je le met dans le .ino, les fonctions marcheront??

encore un pave.. je suis conscient que c'est pas forcement agréable a lire.. mais je patoge un peut là!!

5

Concernant ma demande, en gros, je voulais savoir si il exister une méthode, pour passer des valeurs a l'initialisation des variables depuis le .ino vers les .cpp!! (pareil pour l'enregistrement...)

Il suffit de déclarer la variable en extern dans le .h associé au .cpp
Elle devient donc accessible au .ino s'il inclut le .h

Tu peux aussi passer par une fonction qui initialise les valeurs, comme font en général les fonctions begin() des librairies.

Concernant ma demande, en gros, je voulais savoir si il exister une méthode, pour passer des valeurs a l'initialisation des variables depuis le .ino vers les .cpp!! (pareil pour l'enregistrement...)

Pas du tout. Tu peux parfaitement lire l'EEPROM dans une structure locale à une fonction et ensuite initialiser les variables des .cpp à l'aide des valeurs lues.

concernant la partie deuxième méthode, est ce que si je fais une fonction dans chaque .cpp pour enregistrer et lire l'eeprom sans mettre eeprom.h dans le .cpp, si je le met dans le .ino, les fonctions marcheront??

Cela va obliger à réserver une adresse EEPROM pour chaque .cpp
Pas très pratique.
Personnellement je laisserais au .ino le soin de gérer l'EEPROM.

6

Il suffit de déclarer la variable en extern dans le .h associé au .cpp
Elle devient donc accessible au .ino s'il inclut le .h

Ok merci de ce point, je déclaré dans le .cpp et mettait en extern dans le .ino..

et..d'un raccourci! un!

Tu peux aussi passer par une fonction qui initialise les valeurs, comme font en général les fonctions begin() des librairies.

C'est exactement comme ça que je fais. Pareil pour les broches a lire ou écrire dans le programme!

D'ou l'idee de faire dans chaque .cpp une fonction appelant l'eeprom et inclure ça dans la fonction d'initialisation du .cpp mise dans le .ino en incluant la biblio eeprom seulement dans le .ino (whoua, indigeste la phrase!)!!

comme tu me le fais remarquer..pas cool pour la gestion des adresses!!

Tu peux parfaitement lire l'EEPROM dans une structure locale à une fonction et ensuite initialiser les variables des .cpp à l'aide des valeurs lues.

enfin, de ce que j'en comprend:

on déclare les variables extern concernées chacune dans leur .h respectif!

on crée la structure dans le .ino avec les mêmes type des variables déclarées extern..

pour les enregistrées ça donne :

- on declare la structure { mesVariable. 1 - 2 - 3..};

-on nomme la structure Structure;

dans une fonction: on établie les correspondances

- maVariable.Structure = maVariableExtern;

-dans une condition, on lance l'enregistrement eeprom Structure;

pour la lecture:

-fonction de lecture eeprom Structure;

dans laquelle on établie les correspondances

maVariableExtern = maVariable.Structure;
....etc

placer dans le setup!

J'ai tous bien compris??:wink:

Merci je n'aurais pas penser aux passages des valeurs du faite de vouloir passer directement les variables. ça oblige a mettre en externe, mais bon!!

T'es un tueur!

7

Tout bon :slight_smile:

Un exemple ici : esp8266-tft-display

Le fichier config.cpp fait ce genre de chose.
La structure est dans config.h (avec un N° magic)

La configuration est faite par une page HTML et est enregistrée en EEPROM.

Attention il y a beaucoup de String C++ parce que c'est un ESP8266 avec beaucoup de RAM.
A éviter sur un ARDUINO.

Bonne suite.