Projet stand de tir

Bonjour à tous,

Je ne suis que très débutant sur Arduino, étant initialement metteur au point en réfrigération, je ne suis qu'en charge de régler les soucis terrain que me crée les automatismes :stuck_out_tongue: Je me suis enfin décidé à comprendre mes collègues automaticiens.

Premier projet - Un stand de tir automatique.

Principe :
Bouton départ - Impulsion unique //Une fois appuyé, la cible part, en actionnant une sortie pendant un temps X
Une fois la cible arrêté aprés le temps X, le tireur fait son tir
Bouton retour - Impulsion unique // Une fois appuyé la cible revient au stand en actionnant une sortie pendant un temps Y

J'ai donc deux soucis, le premier étant que je ne suis pas sur de la manière d'utiliser la fonction Byte, ne devrais-je pas directement dire à ma sortie d'être en mode HIGH ou LOW ? En admettant que j'ai bien déclaré mes entrée/Sorties :stuck_out_tongue:

Le second - Je ne sais pas comment intégrer cette fonction de temps, je voudrais que l'lorsque j'appuie une fois sur le bouton départ/ou sortie, l'action se fasse automatiquement, sans arrêt, jusqu'à écoulement du temps défini.

J'espère réussir à être clair dans ma " vision" de l'analyse fonctionnelle.

Merci par avance de vos conseils, critiques & source de progrés.

/*
 * Code pour un aller/Retour sur temps d'une cible de tir
 * Fais partir la cible pendant un temps X lors d'une impulsion sur bouton 1
 * Fais revenir la cible pendant un temps X lors d'une impulsion sur bouton 2
 */

// Déclaration des broche pour contact de départ & de retour
const int BROCHE_DEPART = 12
const int BROCHE_RETOUR = 13

// Déclaration des broches de sortie pour piloter le moteur en marche avant ou arrière

const int BROCHE_MOTEUR_AV = 7
const int BROCHE_MOTEUR_AR = 8

void setup() {
  // Déclaration des différentes variable en entrée & sortie

pinMode(BROCHE_DEPART, INPUT);
pinMode(BROCHE_RETOUR, INPUT);

pinMode(BROCHE_MOTEUR_AV, OUTPUT);
pinMode(BROCHE_MOTEUR_AR, OUTPUT);

}

void loop() {

// Lit l'état du bouton de départ
  byte etat_depart = digitalRead(BROCHE_DEPART);

//Fait partir le moteur en marche avant fonction de l'état du bouton départ  
  digitalWrite (BROCHE_MOTEUR_AV, etat_depart);

// Lit l'état du bouton de retour
  byte etat_retour = digitalRead(BROCHE_RETOUR);

//Fait partir le moteur en marche arrière fonction de l'état du bouton retour    
  digitalWrite (BROCHE_MOTEUR_AR, etat_retour);

}

Moi ce qui me pose problème c'est la gestion d'un déplacement dans un sens puis dans l'autre en se référant uniquement au temps.
Il faut être conscient que le déplacement peut être plus ou moins long en fonction de tout un tas d'éléments comme la température (qui fige les lubrifiants) la poussière (qui encrasse les transmissions), les fluctuations de la tension d'alimentation.
tout ça pour dire que tu n'as peut-être pas pris la meilleure solution technique, à mon sens.

Je pense que tu veux dire byte. C'est une type de données pas une fonction.

Tu devrais te familiariser avec la plateforme Arduino en "jouant" avec les programmes installés avec l'IDE.

il n'y a pas de fonction Byte que je connaisse...

sinon pour bien débuter avec l'arduino, un bon point de départ c'est de lire les tutos d'eskimon

ça vous permettra de bien comprendre la gestion des pins

Bonjour, gardez à l'esprit ce qui a été dit par @fdufnews et @J-M-L
Si votre projet n'a rien à faire dans les temps morts, votre code pourrait être le suivant

/*
   Code pour un aller/Retour sur temps d'une cible de tir
   Fais partir la cible pendant un temps X lors d'une impulsion sur bouton 1
   Fais revenir la cible pendant un temps X lors d'une impulsion sur bouton 2
*/

  // Déclaration des broche pour contact de départ & de retour
  const int BROCHE_DEPART = 12;
  const int BROCHE_RETOUR = 13;

  // Déclaration des broches de sortie pour piloter le moteur en marche avant ou arrière
  const int BROCHE_MOTEUR_AV = 7;
  const int BROCHE_MOTEUR_AR = 8;

void setup() {
  // Déclaration des différentes variable en entrée & sortie
  //En supposant que le bouton de démarrage et le bouton de retour connectent leurs broches
  //correspondantes à GND (c'est la chose la plus confortable à faire).
  pinMode(BROCHE_DEPART, INPUT_PULLUP);
  pinMode(BROCHE_RETOUR, INPUT_PULLUP);

  pinMode(BROCHE_MOTEUR_AV, OUTPUT);
  pinMode(BROCHE_MOTEUR_AR, OUTPUT);

}

void loop() {

  // Lit l'état du bouton de départ
  if (digitalRead(BROCHE_DEPART) == LOW) {
    //Fait partir le moteur en marche avant fonction de l'état du bouton départ
   digitalWrite (BROCHE_MOTEUR_AV, HIGH);
   delay (Temps X en millisecondes);
   digitalWrite (BROCHE_MOTEUR_AV, LOW);
 }
  // Lit l'état du bouton de retour
  if (digitalRead(BROCHE_RETOUR) == LOW) {
  //Fait partir le moteur en marche arrière fonction de l'état du bouton retour
   digitalWrite (BROCHE_MOTEUR_AR, HIGH);
   delay (Temps X en millisecondes);
   digitalWrite (BROCHE_MOTEUR_AR, LOW);
 }
}

Étudiez-le et familiarisez-vous avec le langage arduino.
Les salutations.

@gonpezzi
joli coup sur les {} - Julien va devoir réfléchir pour trouver le bug :wink:

Cher @J-M-L Lorsque je le corrigeais, le système a répondu que vous l'aviez déjà corrigé, et que si j'écrasais votre correction, que dois-je faire ?
Salutations.

on va dire que vous avez fait exprès pour qu'il cherche un peu :wink:

J'ai eu 4 autres erreurs...

c'est OK :slight_smile:
vous pouvez corriger votre post si vous voulez, mais sinon c'est un bon exercice que de trouver ce qui ne va pas.

(il faudrait par exemple attendre le relâchement du bouton)

Tu t'es moqué de moi ? :thinking:Autant je regarde l'original de mon pc Tous les {} vont bien. Un seul a pu s'échapper dans le cutter.
Quelle a été votre rectification ?

C'est futile, il faut lâcher prise pour appuyer sur la gâchette et tirer. :wink:

j'aurais plutôt écrit

  if (digitalRead(BROCHE_DEPART) == LOW) {
    //Fait partir le moteur en marche avant fonction de l'état du bouton départ
    digitalWrite (BROCHE_MOTEUR_AV, HIGH);
    delay (Temps X en millisecondes);
    digitalWrite (BROCHE_MOTEUR_AV, LOW);
  }

On peut déclencher avec le pied.... :wink:

C'est vrai que j'ai eu cette erreur. Je pensais l'avoir corrigé avant l'upload, mais il semble que non.
Mais en regardant les choses maintenant, pourquoi ne pas le faire de cette façon, cela ne change pas la façon dont le système fonctionne.

Ce n'était pas une erreur en tout cas c'était dans le deuxième IF. Les délais (qui seront longs) doivent être inclus dans la comparaison si plus de délais que de comparaisons seront exécutés. Je corrige à nouveau.
Bonne nuit.

Hello,

Merci à tous pour vos réponses.
Alors pourquoi j'ai choisit le temps, c'est plutôt pour une raison d'expérience, les fins de course étant souvent source de soucis sur les stands de tir (Ils aiment prendre du plomb), donc je voulais tester avec un temps.

Mais je reste conscient effectivement qu'avec l'usure de l'élingue, la tension de celle-ci etc on aura
des soucis...

Pour le code, merci à tous pour les retours, la balise byte vient d'ici :stuck_out_tongue:

Je vais suivre vos conseils, et prendre du temps pour lire les tutos :slight_smile: puis me familiariser avec le code proposé.

Merci à tous !

Bonjour,

On peut également utiliser des capteurs de fin de courses non mécaniques qui seront moins sensible au plomb

avoir constamment 2 delay() qui s'exécutent - surtout si on parle de plusieurs secondes, ça va modifier très fortement le comportement du code qui ne répondra que très mal aux appuis sur les boutons.

donc mettre le code dans le if () c'est plus approprié.

Sinon je rajouterais après le digitalWrite LOW un while(digitalRead(BROCHE_XXX == LOW) ; pour attendre la fin du relâchement sinon le moteur va repartir pour un tour et forcer si on n'a pas relâché

Je suppose que tu penses à un fin de course infrarouge ou magnétique ?

On peut sans doute aussi détecter la variation de courant demandé par le moteur quand le chariot rencontre un obstacle

Entre autre mais la solution de @J-M-L fonctionne aussi (principe des volets roulans)

Mhm, bon j'ai un peu travaillé l'ensemble, suite a vos commentaire, merci encore.

  • Résistance pullup interne à l'arduino suffisamment fiable pour éviter des micro-bugs ? Ou devrais-je plutôt câbler ma propose résistance en externe de l'arduino ?

  • Je me rend compte que mon analyse fonctionnelle est à revoir, car dans le cas actuel sans utiliser de fin de course, je pourrais avoir le cas où mon chariot est déjà sortit, si je viens à actionner le bouton de départ une seconde fois, le moteur va forcer sur le temps initialement programmé.
    Donc deux fins de course sont donc inévitables... Et l'histoire du temps à boulier du coup :stuck_out_tongue:

  • Dernier point, je dois me prémunir d'envoyer les deux sortie en même temps, lorsque je suis en mode départ- je ne dois pas utiliser la sortie retour. J'ai donc rajouté les lignes de code tel que suit - Afin de créer un sorte d'auto-verrouillage. Est-ce juste ?

/*
 * Code pour un aller/Retour sur temps d'une cible de tir
 * Fais partir la cible pendant un temps X lors d'une impulsion sur bouton 1
 * Fais revenir la cible pendant un temps X lors d'une impulsion sur bouton 2
 */

// Déclaration des broche pour contact de départ & de retour
const int BROCHE_DEPART = 12
const int BROCHE_RETOUR = 13

// Déclaration des broches de sortie pour piloter le moteur en marche avant ou arrière

const int BROCHE_MOTEUR_AV = 7
const int BROCHE_MOTEUR_AR = 8

void setup() {
  // Déclaration des différentes variable en entrée & sortie
  //En supposant que le bouton de démarrage et le bouton de retour connectent leurs broches
  //correspondantes à GND (c'est la chose la plus confortable à faire).
  
  pinMode(BROCHE_DEPART, INPUT_PULLUP);
  pinMode(BROCHE_RETOUR, INPUT_PULLUP);

  pinMode(BROCHE_MOTEUR_AV, OUTPUT);
  pinMode(BROCHE_MOTEUR_AR, OUTPUT);

}

void loop() {

// Lit l'état du bouton de départ
  if (digitalRead(BROCHE_DEPART) == LOW) {
    //Fait partir le moteur en marche avant fonction de l'état du bouton départ
    digitalWrite (BROCHE_MOTEUR_AV, HIGH);
    digitalWrite (BROCHE_MOTEUR_AR, LOW);
    delay (Temps X en millisecondes);
    digitalWrite (BROCHE_MOTEUR_AV, LOW);
  }
  
// Lit l'état du bouton de retour
  if (digitalRead(BROCHE_RETOUR) == LOW) {
    //Fait partir le moteur en marche avant fonction de l'état du bouton départ
    digitalWrite (BROCHE_MOTEUR_AR, HIGH);
    digitalWrite (BROCHE_MOTEUR_AV, LOW);
    delay (Temps X en millisecondes);
    digitalWrite (BROCHE_MOTEUR_AV, LOW);
  }

}