Salut,

j'aimerais réaliser un système avec 12 boutons et un compteur. A chaque fois que j'appuie sur un bouton ca compte le nombre de fois que j'ai appuyé sur celui ci et ca le retranscrit dans un tableau.

Et ce tableau j'aimerais l'inscrire dans l'eeprom

Je sais déclarer un tableau mais comment relier bouton à compteur à la bonne case du tableau et en plus l'inscrire dans l'eeprom.

parce que eprom.write ce n'est que pour des octets non? peut-on inscrire un tableau dans l'eeprom ou faut-il que je m'oriente sur un shield SD?

Merci d'avance

Salut,

Tu peux écrire plusieurs valeurs dans l'eeprom, ou découper tes compteurs 16 ou 32 bits pour les écrire dans 2 ou 4 cases de 8 bits de l'eeprom. Il faut éviter de réécrire le tableau lui-même en entier dans l'eeprom à chaque changement d'une seule case, car le nombre de cycles d'écriture est limité (100000).

Par exemple, pour lire ou écrire des valeurs 32 bits: https://playground.arduino.cc/Code/EEPROMReadWriteLong

Mais si tu sais combien de temps ton système doit fonctionner en terme de nombre d'appuis sur les boutons, et que ça dépasse le nombre de cycles maximum, tu devrais t'orienter vers une autre solution comme la SD qui fait du wear leveling pour limiter l'usure des cellules individuelles ou un breakout FRAM qui a un nombre de cycles virtuellement illimité.

Avant toute chose, il faudrait savoir jusqu'à où tu vas compter car la mémoire n'est pas illimitée.

• Un uint8_t (1 octet, non signé) permet de compter de 0 à 255

• Un uint16_t (2 octets, non signé) permet de compter de 0 à 65.535

• Un uint32_t (4 octets, non signé) permet de compter de 0 à 4.294.967.295

• Un uint64_t (8 octets, non signé) permet de compter de 0 à 18.446.744.073.709.551.615

Faire un compteur sur des uint32_t me parait bien mais tu peux aussi utiliser des uint64_t sachant que cela tiendra largement dans la mémoire d'un arduino étant donné que tu n'en as que 12.

Comme tu l'as dis toi même l'EEPROM de l'arduino est accessible avec eprom.write et eprom.read qui permettent de lire 1 seul octet.

Mais rien ne t'empèche de faire plusieurs appels à l'EEPROM pour lire/écrire plusieurs octets constituant ton nombre.

Si tu pars sur un tableau de uint32_t, il y aura donc 48 octets (sur les 1024 d'un arduino UNO) qui serviront pour stocker ton tableau.

A chaque fois qu'un bouton est pressé, il te faudra lire les 4 octets de l'EEPROM, reconstituer le nombre, l'incrémenter, puis le ré-écrire en EEPROM.

Par contre, j'attire ton attention sur un petit détails qui a son importance : que ce passe t-il si ton arduino est débranché au moment où il écrit sur l'EEPROM ?

Réponse: il se pourrait bien qu'il n'ai eu le temps d'écrire que 2 des 4 octets et donc que le nombre en EEPROM soit complètement aléatoire car il contiendra 2 octets de l'ancien nombre et 2 octets du nouveau nombre.

Pour éviter ce problème, on ajoute généralement un autre octet déduit par un calcul mathématique (CRC) qui permet de valider ou non le nombre.

Si le CRC du nombre en EEPROM est différent du CRC de l'EEPROM, c'est que le nombre est invalide.

Cependant, c'est bien beau de savoir que le nombre est invalide mais ça ne te donnera pas sa valeur...

Pour éviter ce nouveau problème, on utilise généralement un double tableau en alternant l'écriture dans chaque tableau.

Ainsi, si le nombre d'un tableau est invalide, le nombre de l'autre tableau sera forcément valide, ce qui permet de s'affranchir des coupures de courant (au pire des cas, on ratera le comptage d'un appuis).

Par contre, cela va occuper plus de place en EEPROM :

• 48 octets pour les nombres du tableau 1
• 12 octets pour les CRC du tableau 1
• 48 octets pour les nombres du tableau 2
• 12 octets pour les CRC du tableau 2

• TOTAL: 120 octets.

Déjà merci de vos réponses,

je me suis orienté vers un shield SD finalement, car ces boutons proviennent d'un banc d'essais donc avec une shield SD ce sera plus simple de sortir mes données et mon banc pourra être totalement indépendant contrairement à l'eeprom.

Concernant ce banc j'ai plusieurs questions:

en gros j'ai décidé de remplacer les boutons par des claviers (plus visuel et ergonomique) que des BP, niveau code cela à l'air plutôt simple en plus. je demande même si je me doute de la réponse: les touche du clavier peuvent servir comme des BP non? ex: touche 1 ouvre ma première electrovanne, 2 la 2eme etc...

- Pour l'écriture du tableau dites moi si je me plante :

int TableauJM_JMP[11]

Tableau JM_JMP[0] = CompteurPushB1 

Tableau JM_JMP[1] = CompteurPushB2

etc jusqu'à 11 et avec la variable compteurPushBn déclarée avant et qui compte les appui des touches du clavier

est ce que cela marche ou je suis à côté de la plaque? je suis débutant donc n'hesitez pas sur les remarques

- Pour l'écriture sur la carte SD, est ce dans le cas du tableau je dois écrire du genre :  if (myFile) {

    Serial.print("écriture en cours");
    myFile.println(Tableau JM_JMP[11]);
    // close the file:
    myFile.close(); 

ou cela est plus compliqué que je ne le pense?

- Pour finir, question cablage:

est ce qu'en sortie d'une borne relais (donc entre la borne et mes electrovannes) 

je dois quand même positionner des resistances?

Merci encore

-
Edité par CorentinLesage3 21 juillet 2017 à 11:18:57

Tout dépend de ce que tu veux dire par clavier...

Ce serait bien de nous donner le nom ou la référence du clavier que tu souhaites utiliser.

----------

Pour ce qui est du code, je ne comprends pas trop l'utilité de ton tableau si tu as déjà créé 12 variables nommée CompteurPushB1, CompteurPushB2, CompteurPushB3...

Quand à l'écriture sur la carte SD, ton code est bon

Mais tu auras le même problème qu'avec l'EEPROM : si il y a une coupure de courant ou si la carte SD est retirée pendant une écriture, son contenu sera assez aléatoire...

----------

Et pour finir, si tu as des électrovannes 12V et une alimentation 12V, alors pas besoin de résistance après tes relais.

Le clavier sera comme celui-ci : https://www.amazon.fr/Clavier-matrice-Autocollant-Keyboard-Arduino/dp/B00BQRNQ2A/ref=sr_1_4?s=hi&ie=UTF8&qid=1500967470&sr=1-4&keywords=clavier+arduino

Ce serait juste pour ordonner mes valeurs mais si je les écrits directement sur la SD, elles vont s'actualiser à chaque écriture ou se rajouter à la suite?

s'il y a coupure de courant pendant l'écriture ce n'est pas si grave car je ne perdrai qu'une valeur et mon panel sera assez élevé pour que je puisse en enlever une

super merci encore! 

Pour l'écriture, cela dépend de comment tu procèdes :

• Soit tu écris dans le fichier directement et dans ce cas, il contiendra toutes les valeurs les unes après les autres avec un fichier dans ce style :

1
2
3
4
5
6

• Soit tu écrases le fichier avant d'écrire dessus et dans ce cas, il ne contiendra que la dernière valeur avec un fichier dans ce style :

6

 Mais attention aux coupures de courant !!!

La carte SD ne contient pas que des fichiers mais aussi une table de partition indiquant à quel endroit se trouve quel fichier ainsi que la taille du fichier en question.

Si il y a une coupure de courant pendant l'écriture sur la table de partition, tu peux potentiellement perdre une partie ou tout le fichier !

Non, je voulais faire un tableau car j'ai 12 compteurs boutons et je voulais savoir combien de fois chaque boutons a été appuyé.

Donc je demandais si ca allait s'inscrire genre: (appui sur bouton 1)

Compteur1 : 1

Puis appui sur bouton 2 :

Compteur 1 : 1

Compteur2 : 1

Puis de nouveau appui sur bouton 1:

Est ce que cela va s'inscrire genre

C1 : 1

C2 : 1

C1: 2

// OU : 

C1 : 2

C2 : 1 . 

Parce que si cela s'inscrit comme la première version si j'ai un grand nombre d'échantillons ca va être plutôt chiant à analyser d'où ma volonté de faire un tableau, sauf si ca s'inscrit directement comme la deuxième version.

Ok pour la coupure de courant je vais bosser dessus dans ce cas!

Tu fais ce que tu veux avec ton fichier, tout dépendra du code que tu ferras.

Tu peux très bien faire un seule fichier contient la dernière valeur de tous les capteurs.

Ou bien un fichier qui contient une valeur par ligne.

Ou bien un fichier par capteur.

Ou encore autre chose...

Bref, c'est comme tu veux.

Si je veux un fichier qui contient que la dernière valeur; et que j'écris if (myFile)

 if (myFile) {

    Serial.print("écriture en cours");
    myFile.println(Tableau JM_JMP[11]);
    // close the file:
    myFile.close(); 

 Alors j'aurai à chaque ligne la nouvelle valeur de mes compteurs dès que j'appui sur un bouton c'est bien ça?

Ta variable JM_JMP[11] contient la valeur à l'index N°11 du tableau.

Donc ton fichier contiendra la valeur du 12ème bouton uniquement.

-
Edité par lorrio 25 juillet 2017 à 15:28:22

J'ai une autre question; pour te redonner le contexte : j'ai un banc d'essais avec 6 douches. Le premier clavier ouvre les 6 electrovannes. Mon deuxième clavier j'aimerais qu'il fasse: 

En gros : tu vote pour la première douche : le mec tape un chiffre sur le clavier

ensuite vote pour la deuxième douche : il vote etc... et arrivé à la 6e ca repart à la première. Donc il me faudrait 6 variables et compter le nombre de notes (mais du coup qui peuvent être différentes) donc finalement pas compter le nombre de notes mais enregistrer les notes obtenues.

Ou alors, peut être plus simple, additionner toutes les notes par douche et enregistrer le nombre d'appuis, je pourrais sortir plus facilement la moyenne obtenue non?

Vers où je dois me diriger et si tu as des tutos ou des bouts de codes pour m'orienter je suis preneur

Merci!

-
Edité par CorentinLesage3 25 juillet 2017 à 16:21:03

Si ton but est de pouvoir ressortir la moyenne de chaque douche, tu as tout intérêt de stocker la somme ainsi que le nombre d'appuis afin de limiter l'espace mémoire occupée.

Avec ce système, tu te limites à un tableau à une dimensions de 6 cellules (une cellule par douche) ainsi qu'une variable contenant le nombre d'appuis.

Mais si tu veux pouvoir ressortir à tout moment la liste de chaque note pour chaque douche, alors tu es obligé de retenir chacune des notes.

Dans ce cas là, il te faudra forcément un tableau à 2 dimensions qui prendra beaucoup plus de place en mémoire (tout dépendra du nombre de notes maxi que tu veux retenir).

Oui je pense faire somme et nombre d'appuis, ce sera beaucoup plus simple et je n'ai pas besoin de toutes les notes.

Par contre comment faire pour noter les 6 avec un clavier du genre : 

LCD demande : note D1 ; le client note ; LCD demande : note D2 ; le client note ... etc

et arrivé à D6 il reprend à D1.

Je pensais faire un menu sur mon LCD mais ce sera lourd je pense, je pensais aussi à "je passe à la variable si D1 précédent différent de D1" mais si la personne donne la note de 0 ca marche pas. Est ce que je dois juste mettre dans la loop à la suite : 

int a = clavier.getKey(); 

int b = 0

void loop {

            if (touche != NO_KEY){ // 

D1( a;b)

}

int D1 ( int Da ; int Db )

{ int somme = 0

somme = Da + Db 

b = somme

}

et ensuite faire de même avec D2 (juste en dessous de D1 et D3 idem en dessous de D2); si je fais ça, est ce que l'arduino va d'abord traiter 1 et après 2 ou je dois appliquer une autre manip que simplement mettre à la suite?

Merci

-
Edité par CorentinLesage3 26 juillet 2017 à 10:01:31

Où est le problème ?

Il te suffit d'avoir une variable qui retient l'indexe de la douche en cours.

Puis de scanner les touches en permanence.

Si une touche est enfoncée, alors tu sauvegardes la valeur, tu incréments l'indexe et tu affiche le message suivant.