172 réponses à ce sujet

[cook]

Bonjour à tous ,

en quelques lignes, je vais essayé de vous présenter au mieux mon projet .

Ça fait quelques semaines que je me suis plongé dans l'arduino et mon projet serait de faire fonctionner un guide linéaire motorisé avec un moteur pas à pas nema 17 .

 

"Photo jointe "

 

Ce guide ou " rail " linéaire est équipé d'un plateau coulissant qui se déplace de gauche à droite avec une butée électrique sur une de ses extrémités .

 

L'idée étant de le faire fonctionner avec du matériel connu et très utilisé sur les vidéos en ligne  . Comme un écran LCD  , quelques boutons poussoirs , une carte uno ,Un pilote TB 6600 .

Dans l'idéal et si nécessaire avec les librairie Accel stepper , one button , liquid cristal .

 

Le mode de fonctionnement , est celui ci :

 

En premier ,comme ce rail est équipé d'un contact de fin de course je souhaiterai avec un bouton poussoir, le diriger vers cette butée réglé à 30,0 cm du bord . En résumé , j’appuie , ,le plateau se déplace et il s’arrête à 30,0 cm du bord . L'écran affiche 30 cm .

 

En second , je souhaiterai afficher sur l'écran avec l'aide d'un bouton poussoir la distance de déplacement situé en 30,0 et 190 cm . Les millimètres sont important .

Pour résumer , je reste appuyé, le menu se déroule sans s’arrêter . Si je fait un appuis il incrémente le compteur au millimètre par millimètre .

 

En troisième appuyer sur un autre bouton poussoir pour effectuer le déplacement du moteur à la distance noté sur l'écran soit de 30,0 à 190,0 cm possible .

 

En quatrième , rajouter deux boutons ,soit un pour faire avancé le plateau de 5 mm par appuis et l'autre pour le faire reculer de 5 mm . La mesure sur l’écran affichera 5 mm de plus ou de moins .

Puis retour à l’étape 1 .

 

 

Voila , j'en suis là ! 

 Bien sur , depuis je lis , je visionne , je teste . Je code , j'allume des leds .

Mais ce n'ai pas suffisant . Je ne sais pas par quel bout le prendre. Par quoi  il faut démarrer pour concrétiser ce code ?

Toute aide sera appréciable .

En vous remerciant .

 

cook.

[Mike118]

Déjà premier bon point pour toi tu as su " découper ton travail en différents plans d'action ". 


La suite c'est de découper ces différents plans d'actions en " action élémentaire " ... Et au fur et à mesure découper le chose de sorte à ce que tu sois capable de la coder. 

Attaquons donc par le plan d'action 1 : 

 

 

 

 

En premier ,comme ce rail est équipé d'un contact de fin de course je souhaiterai avec un bouton poussoir, le diriger vers cette butée réglé à 30,0 cm du bord . En résumé , j’appuie , ,le plateau se déplace et il s’arrête à 30,0 cm du bord . L'écran affiche 30 cm .

 

 

 

Si on découpe cette phrase on comprend qu'on a : 

Un bouton 
Une butée 

Un écran 
Un moteur 


On va donc commencer par faire des fonctions élémentaires pour chacun de ces points ! 

 

Je pars du principe que tu sais les bases à savoir utiliser les bases dont utiliser le moniteur série pour afficher des données et sais faire des fonctions. ( Si c'est pas le cas n'hésite pas à me le dire )

 

On va commencer par faire une fonction qu'on va appeler "initMoteur " qu'on va pour le moment mettre dans le loop et qui ne fait que afficher sur le moniteur série " Le bouton est appuyé "  lorsque que tu appuis sur le bouton. 
Est ce que tu peux déjà nous faire ça ? 

[Forthman]

Moi ma partie c'est plutôt la mécanique.

quelle masse doit-être déplacée, et à quelle vitesse ?

[cook]

J'ai eu un peu beaucoup de mal avec le mot fonction . Le vocabulaire est important aussi!  . Le code marche . C'est vrai que si je suis pas obligé de tenir le bouton enfoncé se sera plus pratique .

Bonjour Forthman , pour la partie mécanique ,  j'ai tourné un bon , bon  moment à cause de la longueur . Mais ca va c'est résolu .

Ça correspondra pas tout a fait à la photo mais je la changerai  ...

const int PinBoutonInit = A0; //Bouton qui déplacera le chariot vers la buté à 30 cm  

int BoutonInit = 0;

void  initMoteur (){
Serial.println(" Le bouton est appuyé "  );}
  

void setup() {
  
  Serial.begin(9600);
  pinMode(A0, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
}

void loop() {

  BoutonInit = digitalRead(PinBoutonInit);
 

  if (BoutonInit == 0)  {
  initMoteur ();
  }
  
 
}

[Mike118]

hum : 

Ceci : 

 

void  initMoteur (){
 Serial.println(" Le bouton est appuyé "  );
}

c'est une fonction. 

 

Son nom c'est : " initMoteur ".
Son type est : Void => c'est une fonction qui ne retourne rien ! Si on voulait faire une fonction qui retourne une variable de type int8_t par exemple  on aurait fait : 

 

int8_t  initMoteur (){
 Serial.println(" Le bouton est appuyé "  );
 return 1;
}

Cette fonction n'a rien en paramètre on voit " () " . 
Par contre il serait possible de lui donner un paramètre en faisant ainsi : 

 

int8_t initMoteur (int8_t ma_data){
 Serial.println(" Le bouton est appuyé " );
 Serial.println(ma_data );
 return 1;
}

ma_data est le nom de ton paramètre et son type est spécifié => int8_t . 

Il est possible de mettre plusieurs paramètres dans une fonction en les séparant avec une virgule   

 

void initMoteur (int8_t ma_data1, int8_t ma_data2, int16_t ma_data3) {

}

Si tu as un soucis sur les types => les tailles de variables en C

 

 

Pour en revenir sur le code que tu as fournit tu aurais aussi pu faire : 

const int PinBoutonInit = A0; //Bouton qui déplacera le chariot vers la buté à 30 cm  



void  initMoteur () {
 int BoutonInit = digitalRead(PinBoutonInit);
 if (BoutonInit == 0)  {
  Serial.println(" Le bouton est appuyé "  );
 }
}
  

void setup() {
  
  Serial.begin(9600);
  pinMode(A0, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
}

void loop() {
  initMoteur (); 
}

Qui est équivalent à ce que tu as fait et qui a l'avantage de ne pas utiliser de variables globales mais uniquement une variable locale dans ta fonction. 

 

 

Maintenant que tu as testé ton bouton, tu vas tester la même chose avec ta butée. ( Si tu ne l'as pas encore tu mets un deuxième bouton ) . mais cette fois ci on va afficher " la butée est appuyée " . 

 

=> C'est bête mais ça permet de vérifier que le bouton et la butée marche. =) 

Une fois cette vérification faites tu dois modifier ta fonction initialisation de sorte à ce que : 

Elle teste  le bouton et si le bouton est appuyé alors 

  afficher Initialisation en cours " et attendre en continu que la butée soit appuyée
  Quand la butée est  enfin appuyée => Afficher "Initialisation terminée " . 

Fin si
Fin de la fonction 

 

Est ce que tu peux faire ça ?

 

[Sandro]

Petit complément par rapport au message de Mike : pour l'instant, fait uniquement ce qu'il t'a dit (gérer les boutons et la butée), ne fait pas encore bouger le moteur avant d'avoir testé la butée.

Pour tester, il suffit d'appuyer sur la butée avec le doigt.

[cook]

J'avais pas pensez que l'on pouvais tous mettre dans la fonction . C'est encore plus clair à lire comme code . Du coup ça me fait réfléchir différemment  pour la suite . Pour les fonctions et à quoi ça sert , c'est plus concret .

Je vais relire dans tous les cas . Pas sur d'avoir bien compris la nouvelle question .

Salu Sandro , je n'ai pas ce qui faut pour la mise en route . La parti électrique est en cour et la partie mécanique aussi avec plus de modif . Je pensais trouver plus facilement la solution !!!   Je profite du confinage pour avancer le code . 

 

Apparemment c'est pas fini !!  .

Bonne soirée

[Sandro]

Coté matériel, qu'est-ce que tu as déjà? (comme ça on saura quels tests on peut te faire faire ou pas, et éventuellement te guider dans le choix du matériel qui te manque).

 

Pour la fonction, je te proposerais un petit changement si ça vas à Mike :

Tant que le bouton n'est pas appuyé
   //ne rien faire (ie attendre)
Fin Tant que

afficher "Initialisation en cours "

Tant que la butée n'est pas appuyée
    //ne rien faire (ie attendre). Nb : plus tard, ici on fera bouger le moteur pour aller vers la butée
Fin Tant que

Afficher "Initialisation terminée " . 

Fin de la fonction 

Pour décrire la fonction plus en mots : on attend que le bouton soit pressé, puis on affiche "Initialisation en cours". Ensuite on fait bouger le chariot (ou pas pour l'instant) jusqu'à appuyer sur le bouton de la butée : à ce moment, on arrête le moteur (pas la peine pour l'instant car il ne démarre pas) et on affiche "Initialisation terminée " .

 

 

Est-ce que c'est plus clair comme ça?

 

 

 

NB : par rapport à la fonction de Mike, celle que je propose bloque le programme jusqu'à l'appui sur le bouton, alors que celle de Mike termine dessuite si le bouton n'est pas appuyé (du coup il faut l’appeler à nouveau pour re-tester)

[Mike118]

@Sandro 
Pour le moment le but était de lui faire tester sa fonction dans le loop ^^ On est encore au début des tests ^^ Je ne sais pas trop son niveau donc je propose étape par étape ^^ 
Déjà il est pas sûr d'avoir compris la question donc mieux vaut éviter de lui compliquer le truc  

Par contre sur le principe je ne suis pas forcément d'accord avec toi Sandro quand tu as plusieurs bouton que tu veux " monitorer " ( et sans chercher à faire plus compliquer pour le moment avec des interruptions ) il est plus intéressant d'avoir des codes "non bloquant" =) ( Même si parfois on est bien obligé de mettre des boucles " bloquantes " quand justement il est important de bloquer les actions  => Tant que la butée n'est pas activée ... )

De plus rien n'empêche  d'encapsuler une fonction non bloquante dans un bloc bloquant si on a besoin... Alors que l'inverse n'est pas possible ...

[cook]

Bonjour ,

Bon eh bien, j'ai pas vraiment compris la question , ou peut être je sais pas y répondre . Je suis mélangé !

Je sais pas alors voila j'ai fait un code qui ressemble en partant du principe de fonctionnement je fait un appuis , j'affiche " en cour initialisation" et à la buté j'affiche   " initialisation terminé" . Je me suis dit que se serait plus commode plutôt que de tenir le bouton enfoncé .

Ca m'évite de rendre une feuille blanche  

const int PinBoutonInit = A0; //Bouton qui déplacera le chariot vers la buté à 30 cm
const int PinContactButé = A1;// Contact qui stope le chariot à 30 cm

int BoutonInit = 0;
int ContactButé = 0;
int InitEnCours = 0;

void  initMoteur () {
  BoutonInit = digitalRead(PinBoutonInit);
  ContactButé = digitalRead(PinContactButé);
  
  if (BoutonInit == 0)  {
   InitEnCours = 1;
  }
  
  if (ContactButé == 0)  {
   Serial.println( "Initialisation terminée " );
    InitEnCours = 0;
  }
  
  if (InitEnCours == 1) {
   Serial.println(" Initialisation en cours "  );
  }
  else {
   
  }
}



void setup() {

  Serial.begin(9600);
  pinMode(A0, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
   pinMode(A1, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
}

void loop() {


  initMoteur ();
}

[cook]

Cotés matériel , j'ai l’écran LCD que je viens de finir de  raccorder . Il a pas marché du premier coup . J'en avais que la moitie gauche ou droite je sais plus. J'ai abandonné puis il s'est mis à marcher au bout de 2 heures tout seul . Bon passons !!

 

J'ai des  boutons , résistances , potentiomètre , une carte UNO avec des fils cassé dans les broches de raccordement .

Un moteur  avec une réduction mécanique . Plus de couple ! C'est bon j'aime .

 C'est du matériel d'occasion ou tout n'est pas en bon état  , mais je teste au fur et a mesure .

Bientôt le pilote . Je le brancherai provisoire sur le bureau .

voili voila

[Mike118]

Visiblement tu connais bien les "if " mais est ce que tu connais la boucle while  et comment l'utiliser ? 

Et est ce que tu connais les variables " static " ? 

Pas de honte à pas connaître c'est en codant qu'on apprend C'est pour savoir si je te propose un petit truc à tester dessus ou pas =)

[cook]

J'ai fais des test avec while mais c'est trop compliqué de sortir de la boucle quand on veux créer un code . Static jamais entendu parlé !

Je suis resté sur if et un peu de swich case .

[cook]

La,  j'essaye de marquer la distance en cm sur l’écran LCD !  Franchement c'est hard pour trouver un exemple sur le net .

[Mike118]

Attend, il faut y aller pas à pas et pas trop s'éparpiller ... 

Je te recommande de maîtriser un peu plus les bases avant de passer sur l'écran est ce que ça te va? 


Du coup je te propose un petit exercice avec la boucle " while " . 


Fait une fonction1 qui  : 

" Tant que la butée n'est pas appuyée "  affiche : " Appuis sur la buté "  en boucle

 

Et fait une fonction2 qui

" tant que la butée n'est pas relâchée " affiche " Relache la butée " en boucle 

Et pour la tester tu fais un loop 

loop() {

 

fonction1(); 
fonction2(); 

 

}

 

 

Poste le code que tu aura réussi à faire même si il marche pas à 100% =) on va se baser sur ce petit exercice intermédiaire pour compléter l'exercice de la fonction " initMoteur " qui n'est pas encore terminé =)

 

De mon côté je vais te préparer un petit code que tu vas pouvoir tester pour comprendre les variables statiques. 

 

[cook]

Là c'est compliqué . J'ai l’impression du déjà vu dans mes tests de codage .

Je me suis dit aussi que l’énoncé du problème était mal écrit dans la fonction2 il qu'il fallait comprendre " tant que la butée est  appuyée " affiche : Relache la butée " en boucle .

​Bref j'y suis pas arrivé . J'ai chaud ! . Il doit falloir rajouté une condition au While pour sortir de la boucle . Je le voit comme ça , Comme à chaque fois

const int PinBoutonInit = A0; //Bouton qui déplacera le chariot vers la buté à 30 cm
const int PinContactButé = A1;// Contact qui stope le chariot à 30 cm

int BoutonInit = 0;
int ContactButé = 0;
int InitEnCours = 0;

void  fonction1 () {

  ContactButé = digitalRead(PinContactButé);
  while (ContactButé == 1) {
    Serial.println( "Appuis sur la buté " );
  }

}

void  fonction2 () {
  ContactButé = digitalRead(PinContactButé);
  while (ContactButé == 0)  {
    
    Serial.println( "Relache la butée " );
  }

}

void setup() {

  Serial.begin(9600);
  pinMode(A0, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A1, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
}

void loop() {


  fonction1 ();
  fonction2 ();
}

[Mike118]

En effet il fallait comprendre relâché pour la fonction 2 ... J'ai corrigé mon message. 

 

En tout cas ta tentative est proche de la vérité ! =) 

Voici la correction de l'exercice que je te propose: 

 

const int PinBoutonInit = A0; //Bouton qui déplacera le chariot vers la buté à 30 cm
const int PinContactButé = A1;// Contact qui stope le chariot à 30 cm


void  fonction1 () {
  while (digitalRead(PinContactButé)) {  // ici pas besoin de mettre == 1 mais tu aurais pu ... 
    Serial.println( "Appuis sur la buté " );
  }
}

void  fonction2 () {
  while (digitalRead(PinContactButé) == 0)  {  
    Serial.println( "Relache la butée " );
  }

}

void setup() {

  Serial.begin(9600);
  pinMode(A0, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A1, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
}

void loop() {


  fonction1 ();
  fonction2 ();
}

Par contre si tu veux absolument utiliser des variables ( ce qui n'est pas une mauvaise idée mais qui t'a sans doute pausé problème en fait tu aurrais pu le faire de cette façon : 

 

void  fonction1 () {
  bool etat = digitalRead(PinContactButé);
  while (etat) {  // ici pas besoin de mettre == 1 mais tu aurais pu ... 
    Serial.println( "Appuis sur la buté " );
    etat = digitalRead(PinContactButé);
  }
}

le truc c'est de ne surtout pas oublier de remettre " etat " à jour dans ton while =) 

Et tu vois que ma variable " etat " est une variable locale à ma fonction et non globale comme ce que tu avais fait. 
Dès maintenant essaye d'éviter de déclarer des variables globales surtout quand tu n'en as pas besoin : Ref BoutonInit et InitEnCours

qui n'étaient même pas utilisé dans ton programme =) 

 

Je te laisse tester le code fournit. Et maintenant fort de cette exercice, essayer de proposer une fonction initMoteur qui marche comme demandé plus haut! =) 

[cook]

 oooui , c'est pas loin !  pour moi oui ! je vais relire en attendant .

 

 

J'ai besoin d'une précision

"Et maintenant fort de cette exercice, essayer de proposer une fonction initMoteur qui marche comme demandé plus haut! =) "

 

Je comprends pas ; Il marché mon iniMoteur 

Il faut le modifier dans quel sens ?

[Mike118]

Hum en effet ton " initMoteur " proposait "marchait"... Sur le principe il a même un avantage par rapport à ce que je demandais => Il n'est pas du tout bloquant. 

Par contre dans ce que je " demandais " je précisais que si le bouton était pressé alors on restait bloqué dans notre fonction jusqu'à ce qu'on appuis sur la butée ...  

Il peut être intéressant d'avoir des fonctions où on passe à la suite que si elle est terminée. C'est souvent le cas pour une initialisation : ça serait dommage de commencer à faire quelque chose d'autre alors que l'initialisation n'est pas finie. 

En aucun cas ça ne veut dire que ce que tu as fait est faux, il y a souvent plusieurs méthodes pour faire la même chose =) Voit cet exercice comme une façon un peu différente de faire la fonction " initMoteur " qui du coup devra utiliser un " while " =)  afin de valider que maintenant tu sais parfaitement utiliser la boucle while =)

Après en fonction des autres choses qui seront demandées tu pourras choisir si tu fais avec ou sans le while =)   

 

 

Pour en revenir sur la fonction initMoteur que tu as proposes : 

a) si l'initialisation n'est pas " en cours "c'est dommage d'afficher " initialisation terminé " quand on appuis sur la buté ... 

b)tu as utilisé des variables globales... 

Hors si une variable n'est pas utilisée dans plusieurs fonctions différentes, il faut prendre l'habitude de garder les variables déclarée localement. 

Sauf que parfois on veut garder en mémoire la valeur d'une variable même quand on sort de la fonction histoire de pouvoir la tester ou la lire la prochaine fois où on entre dans cette fonction ... Et donc souvent les gens à tord  ( cf phrase précédente ) choisissent dans faire une variable globale ... ( Ce que tu as fais ^^ ) . Alors qu'il y a une façon " propre de la faire" avec les variables " static "  .

 

 

Donc voilà ton " corrigé " en utilisant " static " ,  avec la petite modification avec des if ... tout en gardant le caractère non bloquant de ta fonction originale =)

 

void  initMoteur () {

  static bool InitEnCours = 0;  
  //la variable sera initialisé qu'une seule fois la première fois où on rentre dans la fonction
  
  if (digitalRead(PinBoutonInit) == 0) {
   InitEnCours = 1;
  }
  if (InitEnCours == 1) {
   Serial.println(" Initialisation en cours "  );
   if (digitalRead(PinContactButé) == 0)  {
    Serial.println( "Initialisation terminée " );
    InitEnCours = 0;
   }
  }

}

Est si tu enlèves " static " la fonction ne marchera plus comme tu le souhaites ... 
Tu peux tester  

Maintenant tu devrais aussi savoir utiliser les variables de type static ! =) 
Bon biensure on ne fera des variables static que quand on en a besoin à savoir : "Quand on veut garder en mémoire la valeur d'une variable même quand on sort de la fonction histoire de pouvoir la tester ou la lire la prochaine fois où on entre dans cette fonction"


Bref j'attend la version du code en mode " bloquant avec un while " pour vérifier que c'est bon tu maîtrise le while avant de passer à la suite 

 

 

[cook]

Pratique la variable static . Ça ressemble à un auto maintient en fait .Faudra que j'y pense plus souvent . Là j'ai un peu galéré .

Il faut vraiment que je trouve une solution au bouton avec pull up .

Tout est inversé . Selon ce que l'on code c'est rajouter une complication . Enfin c'est mon avis .

Le code fonctionne avec le while et dix cafés , du coup je comprends mieux ce que veux dire bloquant !

 

 

PS:

Aujourd'hui J'ai reçu le pilote de quoi faire fonctionner le moteur .Tout a été bien protégé  . Avec une vrai Breadboard . Nickel

const int PinBoutonInit = A0; //Bouton qui déplacera le chariot vers la buté à 30 cm
const int PinContactButé = A1;// Contact qui stope le chariot à 30 cm

int BoutonInit = 0;
int ContactButé = 0;


void  initMoteur () {

  BoutonInit = digitalRead(PinBoutonInit);

  if (BoutonInit == 0)  {
    Serial.println (ContactButé );
    while (digitalRead(PinContactButé) == 1) {
      Serial.println (" Initialisation en cours "  );
    }

  }
  while (digitalRead(PinContactButé) == 0) {
    Serial.println ("Initialisation terminée " );

  }
}

void setup() {

  Serial.begin(9600);
  pinMode(A0, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
  pinMode(A1, INPUT_PULLUP); //  pour le mettre en INPUT_PULLUP
}

void loop() {


  initMoteur ();

}