Bonjour,
j'ai reçu il y a quelques jours une arduino uno et comme beaucoup (je pense) j'ai expérimenté avec succès quelques tuto sur Youtube et ailleurs. Aujourd'hui je souhaite expérimenter deux idées simples que j'ai dans la tête mais j'ai quelques difficultés à les mettre en oeuvre car l'expérience me manque.
Je ne sais pas si c'est le bonne endroit et/ou la bonne méthode mais voici mes deux problèmes:
je souhaite réaliser un système télérupteur: un bouton poussoir allume ou éteint une del. Arriver à faire clignoter une ou des led, faire une minuterie c'est simple mais je bloque sur le télérupteur... (je ne trouve pas de ressource à ce sujet, du moins je ne sais pas où m'adresser).
je souhaite enregistrer 25 petits messages et chaque fois que j'appuie sur un bouton poussoir, de façon aléatoire, j'affiche un message. Le message s'affiche le temps de le lire puis disparaît (10s). A ce moment un message unique "veuillez appuyer sur ... si vous..." apparaît et reste affiché jusqu'à le prochaine impulsion sur le bouton poussoir et affiche durant 10 secondes d'un nouveau message aléatoire.
Merci d'avance pour votre aide.
Bien cordialement
PVKP
salut tu peux stocker les messages dans un tableau puis les afficher aléatoirement
si non plus simple tu peux faire ça, il y à plein de solutions différentes pour arriver à tes fin.
int bp = 2; // numéro du bouton poussoir
void setup() {
Serial.begin(9600);
pinMode(bp, INPUT);
}
void loop() {
int message = 0; //init la variable message en locale à 0
if (digitalRead(bp)) message=random(9)+1; // choix d'un message différent de 0 aléatoirement si appuis sur bp
switch (message) { // sellecteur suivant la valeur de message
case 0: { Serial.println("appuyez sur le bouton..."); delay(1); break; } // si pas de bouton appuyé
case 1: { Serial.println("message 1"); delay(10000); break; } // si message =1
case 2: { Serial.println("message 2"); delay(10000); break; } // etc ...
case 3: { Serial.println("message 3"); delay(10000); break; }
case 4: { Serial.println("message 4"); delay(10000); break; }
case 5: { Serial.println("message 5"); delay(10000); break; }
case 6: { Serial.println("message 6"); delay(10000); break; }
case 7: { Serial.println("message 7"); delay(10000); break; }
case 8: { Serial.println("message 8"); delay(10000); break; }
case 9: { Serial.println("message 9"); delay(10000); break; }
case 10: { Serial.println("message 10"); delay(10000); break; }
} // fin du switch
}
je souhaite réaliser un système télérupteur: un bouton poussoir allume ou éteint une del. Arriver à faire clignoter une ou des led, faire une minuterie c'est simple mais je bloque sur le télérupteur... (je ne trouve pas de ressource à ce sujet, du moins je ne sais pas où m'adresser).
Si j'ai bien compris ce que tu veux faire il suffit d'écrire l'inverse de l'état de la LED. Ci dessous un petit but de code qui devrait te donner un début de piste. Sans garantie car je ne l'ai pas testé, tiens moi au courant si ça fonctionnes.
// Exemple
int myBP = 2;
int myLED = 5;
void setup()
{
pinMode(myBP, INPUT); // On définit la pin du BP en entrée
pinMode(myLED, OUTPUT); // On définit la pin de la LED en sortie
}
void loop()
{
if (digitalRead (myBP)) // on lit le BP
{
digitalWrite (myLED, ! digitalRead(myLED)); // On écrit ici l'état inverse de la LED
delay (200); // Anti rebond logiciel
}
}
Merci à vous deux pour votre aide
L'affichage des messages fonctionne parfaitement merci fifi82
Je vais maintenant m'attaquer au télérupteur avec le code de landid (merci)
C'est hyper sympa à vous
Bonjour,
malgré le code de landid et aprés avoir fouillé sur internet je galère, je galère, je galère....
Mon télérupteur ne fonctionne pas. Pour l'instant j'en suis là:
void setup() {
pinMode(2,INPUT); // bouton poussoir en 2
pinMode(13,OUTPUT); // led en 13
}
void loop() {
int BP1=digitalRead(2); // lecture de l'état bouton poussoir
int LED=digitalRead(13); // lecture de l'état de la led
if ((BP1=HIGH) && (LED=HIGH)) // si BP à 1 et sortie 13 à 1
{digitalWrite(13,LOW); delay(2000);} // mettre sortie 13 à 0
if ((BP1=HIGH) && (LED=LOW)) // si BP à 1 et sortie 13 à 0
{digitalWrite(13,HIGH); delay(2000);} // mettre sortie 13 à 1
}
Ça ne fonctionne pas... Il y a certainement quelque chose qui bloque mais ma méconnaissance du langage (que je découvre petit à petit) me fait défaut....
Si quelqu'un a une petite idée à me soumettre...
Merci d'avance,
Bien cordialement
boolean ar=false; // servira pour d'anti-rebond pour exécuter digitalWrite(13,!LED) une seule fois
void setup() {
pinMode(2,INPUT); // bouton poussoir en 2
pinMode(13,OUTPUT); // led en 13
}
void loop() {
int BP1=digitalRead(2); // lecture de l'état bouton poussoir
int LED=digitalRead(13); // lecture de l'état de la led
if (BP1) { // si BP à 1
if (!ar) {digitalWrite(13,!LED); ar=true; delay(200);} // inverse la led et active "ar" si BP1=1 et si ar=0
} else ar=false; // si BP1=0 désactive "ar"
}
Oui ça pourrait marcher, c'est juste une différence de pédagogie d'apprentissage :
soit tu passes par une étape préliminaire un poil rébarbative d'acquisition de connaissances techniques
soit tu masques dans un premier temps la complexité technique, pour aller plus vite vers de petites réalisations ludiques
Il n'y a pas de pédagogie meilleure qu'une autre. Cela dépend surtout de l'apprenti lui-même.
J'ai construit mes petites libs pour mon fils de 12 ans, d'où le fait de privilégier la voie ludique.
Ceci étant dit, la solution que tu proposes me semble incomplète.
A moins que je compile mal (mentalement) ton code :
Le rebond au relachement n'est pas géré, si l'appui dure plus longtemps que ton delay.
L'anti rebond à l'enfoncement utilise ceinture et bretelle (un booléen + un delay) : l'un des deux est en trop.
Mais je me trompe peut-être
il y à toujours pleins de solution pour arriver au même résultat, c'est lui qui choisira en fonction de son niveau de programmation
le rebond au relâchement ne sert à rien vu que l'on ne fait rien au relâchement.
le delay(200) sert uniquement si il y à des mauvais contacts ce qui arrive avec certain inter bas de gamme
Bonsoir,
merci à tous pour vos réponses
Imaginons que j'ai 12 ans (élève de 5ème), que mon prof me demande de mettre en oeuvre un va et vient par le biais d'une carte Arduino, quel serait selon vous la façon plus simple de comprendre le code proposé par le prof?
Merci à vous,
Bien cordialement
Bonjour,
d'abord excusez moi d'être insistant je n'arrive absolument pas à programmer ce tout petit projet. Je suis reparti de l'idée bricoleau qui me semble être l'idée la plus simple à mettre en oeuvre et à comprendre (utiliser un booléen est encore une autre dimension à acquérir
Voici mon code, il ne fonctionne toujours pas et je n'arrive absolument pas à piger d'ou vient l'erreur. Je pense avoir suivi tous les conseils que vous m'avez donné....
Je vous remercie d'avance concernant le coup de main que vous pourriez me donner afin de me débloquer.
PKP
// déclaration des constantes
const int BP = 2; // bouton poussoir en sortie 2
const int LED = 13; // LED en sortie 13
// déclaration des variables
int etatbouton = 0; // variable pour lire le status du BP
int etatled = 0;
void setup() {
// on initialise la LED comme une sortie:
pinMode(LED, OUTPUT);
// on initialise le bouton poussoir comme une entrée:
pinMode(BP, INPUT);
}
void loop() {
// on lit la valeur du status du Bouton poussoir BP:
etatbouton = digitalRead(BP);
// on lit la valeur du status de la LED:
etatled = digitalRead(LED);
// vérifier si l'etat du bouton et de la LED.
if ((etatbouton == HIGH) && (etatled == LOW)) {digitalWrite(LED, HIGH); delay(200); } // on allume la LED:
if ((etatbouton == HIGH) && (etatled == HIGH)) {digitalWrite(LED, LOW); delay(200); } // on éteint la LED:
}
Il faut arrêter de bricoler en testant l'état du bouton.
Soit on utilise la librairie de bricoleau soit on se le fait 'à la mano' en testant le changement d'état du bouton (ce qui suppose de mémoriser l'état précédent).
// déclaration des constantes
const int BP = 2; // bouton poussoir en sortie 2
const int LED = 13; // LED en sortie 13
// déclaration des variables
void setup() {
// on initialise la LED comme une sortie:
pinMode(LED, OUTPUT);
// on initialise le bouton poussoir comme une entrée:
pinMode(BP, INPUT);
}
void loop() {
static bool etatprecedent=false;
// on lit la valeur du status du Bouton poussoir BP:
bool etatbouton = digitalRead(BP)==HIGH; // si bouton au 0V etatbouton = digitalRead(BP)==LOW
if (etatbouton && !etatprecedent)
{
// on vient d'appuyer on inverse l'état de la led
digitalWrite(LED, !digitalRead(LED));
}
etatprecedent=etatbouton;
delay(10); // anti rebond
}
Comme toujours, en programmation, quand on ne comprend pas ce qui se passe, il faut se donner les moyens de diagnostic = réduire le code au strict minimum pour isoler le problème (là c'est difficile) + ajouter des mouchards pour que le programme te cause au fur et à mesure qu'il avance.
==> Ajoute un Serial.print à l'intérieur de tes if
Salut,
pour développer un peu plus la pensée de bricoleau :
Ton code semble correct, il est donc important à ce stade de l’enquête de savoir comment est câblé le BP. C'est un problème qu'il est assez compliqué a comprendre en tant que débutant, je te conseille la lecture de cet excellent article.
(je ne trouve pas de ressource à ce sujet, du moins je ne sais pas où m'adresser).
(je ne trouve pas de ressource à ce sujet, du moins je ne sais pas où m'adresser).