Merci JML, ça au moins c'est simple et efficace, j'ai réparé ma bêtise, je me suis fait tatouer le schéma.
Merci Bricoleau, pour être franc je voulais le faire comme ça sur ce montage, c'est simple et je comprends, cette bibliothèque je l'ai vue passer, je n'en ai pas vu l'intérêt avant de savoir monter un bouton plus classiquement, je vais y jeter un oeil. A moi la ceinture!
Sisi lesept, il y a un lien dans la fenêtre qui s'ouvre, on télécharge un zip
En version de base arduino :
const byte pin_bouton = 7; //Cablage PIN---BP---GND
byte etat_bouton; //variable globale pour memoriser l'etat du bouton
void setup()
{
Serial.begin(9600);
pinMode(pin_bouton, INPUT_PULLUP);
etat_bouton = HIGH;
}
void loop()
{
byte etat = digitalRead(pin_bouton);
if (etat != etat_bouton) //l'etat a change
{
if (etat == LOW)
{
Serial.println("bouton enfonce");
}
etat_bouton = etat;
}
}
Lorsque l'on teste cette version de base, et selon la qualité du BP utilisé, on s'aperçoit qu'il y a des rebonds à l'enfoncement ou au relachement.
Cela provient des imperfections mécaniques des BP, qui génèrent des signaux parasites lors des ouvertures/fermetures des contacts.
Ces rebonds peuvent être éliminés de manière hardware par ajout d'une capa, ou de manière software en ajoutant une notion de temps dans le programme.
Exemple :
const byte pin_bouton = 7; //Cablage PIN---BP---GND
byte etat_bouton; //variable globale pour memoriser l'etat du bouton
unsigned long millis_bouton; //variable globale pour memoriser la valeur de millis()
void setup()
{
Serial.begin(9600);
pinMode(pin_bouton, INPUT_PULLUP);
etat_bouton = HIGH;
millis_bouton = 0;
}
void loop()
{
byte etat = digitalRead(pin_bouton);
if (etat != etat_bouton) //l'etat a change
{
if (millis() - millis_bouton > 20)//n'en tenir compte qu'au bout de 20 ms
{
if (etat == LOW)
{
Serial.println("bouton enfonce");
}
etat_bouton = etat;
millis_bouton = millis();
}
}
}
Et voici exactement la même chose avec simpleBouton :
#include "simpleBouton.h"
simpleBouton boutonTest(7); //Cablage PIN---BP---GND
void setup() {
Serial.begin(9600);
}
void loop() {
if (boutonTest) Serial.println("bouton enfonce");
}
Ta bibliothèque (d'ailleurs bravo c'est la classe) simplifie la vie et je ne conteste pas son utilité. Je voulais simplement apprendre à me servir des bp et ajuster ces histoires de rebonds etc. Au tout début, je copiais du code qui employait des bibliothèques, la syntaxe et la logique de l'IDE et des bibliothèques peuvent différer énormément, ça crée la confusion dans un petit cerveau de débutant, enfin je trouve.
C'est comme vouloir apprendre l'espagnol et le portugais en même temps: ça fait du portugnol, personne te comprend et t'as perdu ton temps.
Maintenant que j'y suis arrivé, ta bibliothèque va devenir un outil intéressant. je l'ai installée, je ferai les exercices que tu recommandes.
Mais j'avoue, j'ai un accéléromètre, deux nano, cinq capteurs pour mon line follower, deux modules bluetooth qui sont arrivés hier, j'ai cru que j'allais pas en dormir ^^ et un rfid aussi, alors aujourd'hui je vais les griller un par un et je me remettrai au boulot ensuite ^^
Merci, ta bibliothèque peut vite devenir un classique.
Elle ouvre des possibilités vraiment intéressantes avec un même bouton. génial.
La bib n'a rien de révolutionnaire.
Ta démarche est parfaitement saine.
Je t'ai mis ci-dessus les exemples de base arduino, c'est-à-dire le code standard que l'on est censé produire en utilisant les primitives fournies avec l'IDE Arduino.
Une fois qu'on a compris ces instructions de base, on peut parfaitement se passer de la bib simpleBouton.
Son principal intérêt est alors d'alléger le code du programme principal, ce qui permet de mieux se consacrer à l'essentiel. Par ce que même si c'est facile, quand il y a quatre boutons sur lesquels on veut gérer des priorités d'appui et des cadences de répétition progressives, le code devient vite volumineux.
A l'origine, j'avais écrit ces bibliothèques dans un autre but : permettre à un enfant de débuter en programmation arduino, en évitant d'avoir à passer par une étape d'apprentissage de pinMode, digitalRead/Write, millis(), etc.
Bonjour,
Pour obtenir un tableau de "taille variable" sans être limité par la taille de la
mémoire flash de l'Arduino, il est possible d'utiliser une(des) puce(s) 23LC1024
(puces de 1048576 bits/131072 octets de capacité de stockage). Bien que la
capacité de stockage soit finie, elle permet toutefois d'obtenir un tableau de
belle taille et d'étendre assez fortement l'espace mémoire pour les variables.
En fonction du mode d'accès a la puce, il est même possible d'accélérer les
transferts (écriture / lecture) en transmettant / lisant 1/2/4 bits d'un seul coup.
Je suis en train de travailler sur une application utilisant 2 de ces puces montées en
"parallèle" afin de transférer des données sur 2/4/8 bits en parallèle en utilisant un registre
(registre L continu) d'un Arduino Mega et en "programmant" un SPI maison (basé sur
l'accès direct au ports du registre G) afin d'accélérer encore la vitesse de transmission
des données (cf. schéma). Dans l'application que je vise, c'est bien plus la vitesse de
sauvegarde des valeurs que le nombre de valeurs sauvegardées qui est importante (bien
que la capacité de stockage de l'Arduino soit insuffisante dans cette application).
Je ferai un post dédié dès que j'aurai un peu plus progressé.
Cordialement.
Ahhhh super !
A suivre
