En préambule je suis un néophyte de l’Arduino de la programmation et de l’électronique...
Il y a quelque temps j'étais plus "à l'aise" avec tout ça et je m'y remet doucement... à mon rythme
Du coup comme il fait froid et que j'aime faire des activités avec mes enfants je me suis dit que cela serait opportun de réaliser un projet (que j'espère facile) en Arduino.
Mon projet est un suiveur de câble, tout simple mais que j'aime à compliquer...
Voici une schématique (en fichier attaché) qui sera plus explicite qu'un long discours...
le fonctionnement:
la manette touche le contacteur de base à droite ou à gauche cela d’éclanche un décompte sur l'afficheur 2 lignes: 3... 2... 1... 0!
à chaque décompte du compteur un bip du buzzer retenti 1/4 de sec et permanent de 1 à 0
de 3 à 0 il y à un dégradé progressif sans acoup de rouge à vert au niveau des led
à 0 les leds sont vertes le buzzer est éteint et un décompte min:sec est déclenché et s'affiche
le joueur à 2 secondes pour quitter le contacteur de base avec la manette sinon un nouveau décompte est déclenché
le joueur doit toucher le contacteur de base opposé en un minimum de temps et en moins de touche entre la manette et le fil
lorsque la manette touche le fil, le buzzer se déclanche les leds deviennent rouges (tout le temps du contact) et cela comptabilise et additionne une touche sur des afficheurs (2 digits)
si le contact est continue entre la manette et le fil pendant 0,5 sec cela compte pour 3 touches et ainsi de suites toutes les 0,5 sec
une fois arrivé, le score (temps et nombre de touche) est enregistré et supplante l’ancien si il est meilleur (nombre de touche en priorité et temps en 2nd)
le score est affiché sur l'afficheur 2 lignes
un toggle switch permet de sélectionner joueur 1 ou joueur 2
en plus du score l'afficheur indique quel joueur gagne
voila en gros mes specs qui sont certainement à préciser et à compléter.
je souhaite être progressif dans ma démarche et peut être pas mener tout de front:
par exemple:
dans un premier temps, afficher en rouge une dizaine de leds (rgb) dés que je provoque un contact (attention au rebond)
afficher le nombre de touche (penser à la remise à zero)
...
dans mon "bordel électronique" (que je n'arrive jamais à correctement ranger) j'ai retrouvé des arduino nano... Question: croyez vous que le nano soit suffisant? ou faut il que je passe sur un uno?
au niveau du code
je m’emmêle dans mes boucles et je me pause des questions:
est il mieux de détecter le contact (du fil avec la manette) dans une boucle de code(ça je sais faire) ou vaut il mieux gérer une interruption? (je ne n'arrive pas à comprendre comment ça marche)
comment arriver à déterminer si sur 0,5 sec ou sur 3 secondes on reste en contact et qu'il n'y ait pas de "sous-contact" intermédiaires?
un Nano est aussi performant que un uno donc ça devrait le faire (en fait la nano deux entrées suplémentaires purement analogiques sont disponibles (pas des sorties, et uniquement analogiques).
remettez éventuellement vos connaissances à jour avec les tutos d’eskimons
il ne faut pas de delais dans le code donc vous familiariser avec l’exemple « blink without delay »
C’est typiquement une définition de programme qui se prête bien à la programmation par machine à états - cf mon tuto éventuellement - Si vous réussissez à exprimer votre cahier des charges sous forme d’un graphe comme je l’ai fait alors vous verrrez que ce n’est pas trop difficile
un grand merci à J-M-L pour son accueil, l'affichage du schéma, et pour m'avoir permis de débuter dans de bons rails.
prochainement je vais essayer par moi même de mettre les photos venant de Google photo sur ce forum... me connaissant, ça va pas marcher... mais qu ne tante rien...
j'avoue avoir eut un peut peur de la programmation machine pour l'engagement que cela me prendrait... mes excuse à toi J-M-L car/donc je ne m'y suis pas mis.
je vous donne ici l'avancé de mon code qui est basé sur:
un arduino nano
un bouton temporaire (sur pin 2) simulant le contact entre la manette et le fil avec résistance et condo pour l'effet rebond
une led (sur pin 3) avec sa petite résistance qui va bien
// this constant won't change:
const int contactPin = 2; //pin de contact entre la manette et le fil
const int ledPin = 3; //pin de led en cas de contact entre la manette et le fil
// Variables will change:
unsigned int contactCounter = 0;//comteur de contact int > 32,767 entre la manette et le fil
unsigned long suiveurTime = 0; //temps de suivi du fil
void setup() {
pinMode(contactPin, INPUT); //initialise le pin de contact en tant que input:
pinMode(ledPin, OUTPUT); //initialise le pin de LED en tant que output:
Serial.begin(9600); //initialize serial communication:
}
void loop() {
funCompteur (-1); //initialise le compteur
suiveurTime = millis(); //début du chrono
funSuiveur();
Serial.println(millis() - suiveurTime); //affichage du compteur
}
//fonction gérant le mode suiveur
void funSuiveur() {
boolean boucle = true; //boucle tant que c'est = true
int contactState; //état du contact entre la manette et le fil
int contactLastState = LOW; //dernier état du contact entre la manette et le fil
unsigned long contactLastTime = 0; //temps depuis la dernière lecture d'état
unsigned long contactContinu = 500; //temps de contact en continu (en mili-seconde)
unsigned long rebondLastTime = 0; //temps depuis le dernier changement (en mili-seconde)
unsigned long rebondTime = 50; //temps de rebond "technique" (en mili-seconde)
do {
contactState = digitalRead(contactPin); //lecture du contact entre la manette et le fil
if (rebondLastTime == 0) { //on est PAS dans un rebond
if (contactLastState != contactState) { //s'il y a un changement d'état
rebondLastTime = millis(); //affecte la date de changement d'état
if (contactState == LOW) { //s'il N'y à PLUS de contact (cas le plus fréquent)
digitalWrite(ledPin, LOW); //led éteinte
contactLastState = LOW; //enregistre le dernier état du contact
contactLastTime = 0; //réinitialise la date du dernier contact
}
else { //s'il y à un nouveau contact
contactLastTime = millis(); //enregistre la date du contact
digitalWrite(ledPin, HIGH); //allume les led
contactLastState = HIGH; //enregistre le dernier état du contact
funCompteur (1); //incrémentation du nombre de contact
}
}
else { //s'il N'y a PAS un changement d'état
if (contactLastTime != 0) { //si un dernier contact est en cours
if ((millis() - contactLastTime) > contactContinu) { //si le contact se fait en continu
contactLastTime = millis(); //réinitialise la date du dernier contact
funCompteur (3); //ajoute 3 points au compteur
}
}
}
}
else { //on est dans la période de rebond
if ((millis() - rebondLastTime) > rebondTime) { //si la durée du rebond est dépassé
rebondLastTime = 0; //réinitialise la date de rebond
}
}
} while(boucle); // ...
}
//fonction gérant l'affichage du compteur
void funCompteur (int increment) {
if (increment < 0) { //le param est negatif
contactCounter = 0; //reset du compteur
}
else if (increment > 0) { //le param est positif
contactCounter += increment; //incrément le compteur
}
Serial.println(contactCounter); //affichage du compteur
}
n'hésitez pas à critiquer, c'est comme cela que je m’améliorerais...
je sais que pour l'instant ça boucle sans échappatoire... la sortie de la boucle se sera dans un 2nd temps... j'avance par étape...
