172 réponses à ce sujet

[cook]

Avant de répondre , j'avais besoin de  tester mon moteur d'une façon plus simple . Genre sans fonction ! En mettant beaucoup de chose dans le loop sans faire n'importe quoi non plus . Un moteur , avec quelques boutons  !  Bon voila , rien de plus , il faut bien coder , sans quoi mon moteur c'est un violon .

   

 

Bien revenons à la question principale , j'aurai juste pensé que dans le setup , après la fonction plus_un(n); le (n) vaudrai 11 .

[Sandro]

Bien revenons à la question principale , j'aurai juste pensé que dans le setup , après la fonction plus_un(n); le (n) vaudrai 11 .

Mais tu as compris pourquoi ce n'est pas le cas? Si oui, c'est tout bon (et c'est normal que tu pensais que ça vaudrait 11 si personne ne t'as expliqué que c'est une copie de la valeur).

 

 

Avant de répondre , j'avais besoin de  tester mon moteur d'une façon plus simple . Genre sans fonction ! En mettant beaucoup de chose dans le loop sans faire n'importe quoi non plus . Un moteur , avec quelques boutons  !  Bon voila , rien de plus , il faut bien coder , sans quoi mon moteur c'est un violon .

Euh ... du coup tu as fait ce test sans fonctions? Ou tu souhaite le faire?

 

Personnellement, si tu en as la patience, je te conseillerais de continuer à avancer étape par étape avec des fonctions : certes, au début c'est un peu plus lent, mais une fois que tu as assimilé les fonctions, ça devient beaucoup plus facile (en particulier pour repérer les erreurs dans le code : une fonction se teste en général bien indépendamment).

 

Sinon, maintenant que tu as (je suppose) rajouté l'accolade manquante, le code fonctionne?


 

[Mike118]

Avant de répondre , j'avais besoin de  tester mon moteur d'une façon plus simple . Genre sans fonction ! En mettant beaucoup de chose dans le loop sans faire n'importe quoi non plus . Un moteur , avec quelques boutons  !  Bon voila , rien de plus , il faut bien coder , sans quoi mon moteur c'est un violon .

   

 

Bien revenons à la question principale , j'aurai juste pensé que dans le setup , après la fonction plus_un(n); le (n) vaudrai 11 .

 

Justement ce que souhaitais te montrer sandro, c'est que le fait de passer une variable en paramètre, comme il l'a fait en mettant "n " , ne changeait la valeur de n que localement à l'intérieur de la fonction. 

En gros on a fait une copie dans la fonction et on n'a que travailler sur la copie... 
Du coup quand tu sors de la fonction n vaut toujours la même chose qu'avant...

Bref revenons en au sujet principal. 

Reprend ton tout premier message et confirme moi qu'on a bien réalisé "l'étape 1 "  que tu voulais et que tout marche comme il faut ( y comprise le fait de mettre la distance en paramètre =) ).

Si oui passons à l'étape 2
Si non dis mois ce qui ne va pas et corrigeons le . 

Par contre je te conseil de continuer de faire des fonctions. 

Si tu y réfléchis, ça ne change presque rien pour toi car tu peux faire une fonction " test() " 
que tu vas appeler dans le loop  au lieu de mettre le code en vrac dans le loop. 
Tu commences comme ça et au fur et à mesure " transformer cette fonction de test " en une vrai fonction utile que tu vas garder pour ton projet =)
Puis au besoin tu créras une nouvelle fonction de test  

[cook]

Pour résumer , oui l'étape 1 est ok . Je glisse le code ci dessous . Pour moi tout marche comme il faut . Je comprends ce que j'ai fait . Allons y pour la suite . Pour les fonctions je vais refaire un message .

#include <AccelStepper.h>
AccelStepper stepper (1, 9, 8);
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

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  AfficherLaDistance  (float Distance) {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print (  " Butée " );
  lcd.setCursor(7, 0); 
  lcd.print (  Distance  );
  lcd.setCursor(13, 0);
  lcd.print (  " cm "   );
}
 


  void  AfficherInitTerminée () {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print (" Initialisation  "  );
    lcd.setCursor(0, 1 );
    lcd.print (" terminée "  );
    Serial.println ("Initialisation terminée " );
  }

  void  AfficherInitEnCours (){ 
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print (" Initialisation  "  );
    lcd.setCursor(0, 1 );
    lcd.print (" en cours "  );
    Serial.println (" Initialisation en cours "  );
  
  }
  void initMoteur () {
    if (digitalRead(PinBoutonInit) == 0) {
      AfficherInitEnCours ();
      stepper.setSpeed(3900);

      while (digitalRead(PinContactButé) == 1) {
        stepper.runSpeed();
        // on attends la buté
      }
      stepper.stop(); // On remet à 0 les consignes de vitesse ...
      float Distance = 30.0;

      AfficherInitTerminée ();
      delay(3000);
      AfficherLaDistance(Distance) ;

      
    }
  }
  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
    stepper.setMaxSpeed(4000);
    lcd.begin(16, 2);
    lcd.print("START PRESS INIT");
  }

  void loop() {
    initMoteur ();
  }

[cook]

En ce qui concerne les Fonctions , j'ai compris que le n , pour reprendre l'exemple de Sandro ne se déplace pas comme ça d'une fonction à une autre sans un travail précis . Bien pratique cet exemple .

Au départ j'ai pensé que la cause venais de la fonction setup (parce qu'elle est intégré à l'arduino ) . 

 

Donc  j'ai repris l'exemple  ( ci dessous )  , je l'ai un peu modifié du mieux possible et le résultat est identique même si  la fonction n'est pas un" void setup" .

 

Donc je pense avoir compris .

Après bien sur , le  mettre en pratique , me demande une grosse gymnastique ; C'est vraiment pas évident .

void Un()
{
  int n=22;
  Serial.print("Dans la fonction Un, AVANT l'appel de la fonction moins_un, : n=");
  Serial.println(n);
  moins_un(n);
  Serial.print("Dans la fonction Un, AVANT l'appel de la fonction moins_un,: n=");
  Serial.println(n);
  
}
void moins_un(int n)
{
  Serial.print("Dans la fonction moins_un, AVANT la soustraction : n=");
  Serial.println(n);
  n=n-2;
  Serial.print("Dans la fonction moins_un, APRÈS la soustraction : n=");
  Serial.println(n);
}

void setup() {
  Serial.begin(9600);
  Un();
  }

void loop() {
  // put your main code here, to run repeatedly:
}

 

[cook]

Bon je vous lirai plus tard . C'est la reprise pour moi ,dans une nouvelle mission . Demain je me confiner , mais au travail . 

Je n'aurai plus la possibilité de coder la journée avec vous . Je le ferai des que possible . A trés bientot

Bonne soirée

[cook]

Bonjour, je vais pouvoir travailler sur mon code . Mes journées sont plus courte que prévu a cause de l'organisation que demande le Corona . 

Si il y a possibilité de passer à l'étape 2 , je suis partant . Je l'ai recopié si dessous .

 

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 .

Je vais essayé de  trouvé des infos de comme il faut faire pour déroulé une longueur en cm sur un écran LCD ; Si vous avez une idée ?

[Sandro]

Je suis pas sur de tout à fait comprendre ce que tu veux (les "détails" détermineront comment on fait exactement) :

a) on a un seul bouton : quand on appui une première fois, les cm défilent jusqu'à ce qu'on relâche. Ensuite, on peut appuyer, chaque appui augmentant de 1 le nombre de millimètres. Inconvénients : une fois qu'on a fixé le nombre de cm, on ne peu plus que augmenter de 1mm en 1mm. Question : on fait comment pour dire qu'on a fini? De nouveau un appui long?

on a un seul bouton : quand on enfonce le bouton, il ne se passe d'abord rien. Si on relâche avant un temps t1, alors la distance augment de 1mm. Sinon, à partir d'un temps t2 (par exemple égal à t1), on commence à augmenter les cm jusqu'à ce qu'on relâche le bouton. On peut ensuite recommencer avec des appuis court pour avancer de 1mm, ou long, pour continuer à faire défiler. Question : comment valider? Cette fois-ci, c'est plus compliqué sur ce point. On pourrait par exemple afficher un message au bout de x secondes sans aucun appui, qui demande si on veut valider : il faut ensuite un appui court pour oui, ou long pour non (ou l'inverse)

c) un seul bouton, qui fait directement défiler les mm, mais dont la vitesse de défilement augmente avec le temps qu'on a passé dessus : on pourra donc augmenter de 1mm par un appui très court, de plusieurs par un appui un peu plus long, par beaucoup de cm par un appui prolongé. Quand on approche le but, on relâche et re-appui pour reprendre l'avancement plus doucement. Question : comment valider : idem cas

d) Plusieurs boutons : par exemple un par chiffre sauf pour les mètres qui vont avec les décimètres : (un bouton qui fait défiler les décimètres de 3 à 19, un qui fait défiler les cm de 0 à 9, un qui fait défiler les mm de 0 à 9). Avec un 4ième bouton pour valider.

 

Bref, tout est possible, il suffit de savoir exactement ce que tu veux comme comportement selon les appuis du bouton.

Je pense qu'un bouton dédié à la validation facilitera un peu la tâche, mais ce n'est pas indispensable

[Mike118]

En effet pas mal de choses sont possible, 

 

un conseil : Regarde quels sont les machines qui sont autour de toi et quels sont les " interfaces disponible "  : Combien y a t il de boutons, est ce que c'est pratique ? Tu peux aussi utiliser un potentiomètre si tu veux  

Décris précisément comment tu veux que ça marche  

 

Si j'avais un conseil à te donner ça serait pour commencer soit d'avoir 3 boutons : 

+  -  et go , 

soit d'avoir 

go et un potentiomètre

 

Mais c'est à toi de choisir ce que tu trouves le mieux =)

[cook]

Alors oui , cet étape consiste à écrire sur l'écran qui est déjà sur 30.0 cm  par le biais de l'initialisation .

Le but est de pouvoir afficher 30,0 et 190 .0 cm avec l'aide d'un bouton . Le chiffre après la virgule pour les millimètres est  important .

 

Vous me parlez d' un autre bouton pour mettre en marche le moteur . ( Je l'avais noté comme  étape suivante mais pourquoi pas tout faire en même temps )

 

J'aime bien l'idée du bouton pour dérouler les centimètres et un autre pour les millimètres . Cela me semble plus cohérent pour un réglage . 

​Le potentiomètre plus et moins , pas mal aussi .

.Apres si avec un potentiomètre je peux faire varier la vitesse du déroulement et à ce moment là mettre qu'un bouton . 

 

Je vous aide pas trop là !

En fait le nombre de boutons me gène pas du tout . Vraiment les fils  j 'ai l'habitude .  C'est surtout le code qui va avec qui m’empêche de réfléchir ! 

 

Sincèrement je sais pas . C'est quoi le plus fonctionnel pour s’arrêter au milimetre prés .

En tenant compte  des futures étapes que j'ai noté au tout début du sujet  .

[Sandro]

Voici une proposition, qui est je pense assez simple à implémenter, et pas trop compliquée à utiliser : on utiliserait 3 boutons au total :

- un bouton "grossier", qui ajoute 1cm toutes les t1 millisecondes (et si on dépasse 190, on retourne à 30) s'il est appuyé (ie on l'utilise par des appuis continus, plus ou moins longs)

- un bouton "fin", qui ajoute 1mm : on est obligé d'appuyer et de relâcher ensuite (on ne peut pas l'utiliser en continu pour éviter d'aller trop vite). Nb : on peut parcourir plusieurs centimètres, millimètre par millimètre, si on veut

- un bouton pour valider

 

Le principal inconvénient, est que si on dépasse, on doit recommencer.

Pour cette méthode, tu as le choix : soit on initialise la distance avec la distance actuelle, soit avec 30, comme tu préfère (il faut juste que tu le dises, car ça déterminera la manière d'écrire le code)

 

 

 

Une autre méthode serait d'utiliser 2 potentiomètres : un grossier et un fin, comme c'est le cas sur certains générateurs de tension par exemple. Et un bouton pour valider. L'avantage est qu'on peut revenir en arrière sans problème.

Je pense que c'est même encore plus facile que la première méthode.

 

 

 

Les méthodes avec un seul bouton pour aller à la fois vite et lentement, ou celles avec un potentiomètre + un bouton sont je pense un peu plus compliquées (mais ça reste faisable).

Personnellement, je pense qu'en tant qu'utilisateur, c'est la deuxième méthode que je préférerais.

 

 

Donc à toi de trancher, dès que tu as choisi, on peut t'aider à implémenter ton choix

[cook]

Je partirai bien sur l'idée de départ avec les boutons . Une question quand même : un bouton "grossier", qui ajoute 1cm toutes les t1 millisecondes . Es ce que la vitesse peut être changé ? Exemple 1 cm toute les seconde ?

 

Une autre question  "soit on initialise la distance avec la distance actuelle, soit avec 30, comme tu préfère ? Ca veut dire quoi ?

[Mike118]

 Une question quand même : un bouton "grossier", qui ajoute 1cm toutes les t1 millisecondes . Es ce que la vitesse peut être changé ? Exemple 1 cm toute les seconde ?

C'est toi qui règlera ça dans ton code 

 

 

Je partirai bien sur l'idée de départ avec les boutons .

 

Peux tu décrire précisément comment tu voudrais l'utiliser ? 
Pour ce genre d'exercice, tu oublis complètement le code, et tu décris précisément comment est ce que tu appuis sur les boutons pour faire ce que tu veux, un peu comme si tu expliquais à un enfant de 6 ans comment utiliser ton truc =). 

 

[Sandro]

Une autre question  "soit on initialise la distance avec la distance actuelle, soit avec 30, comme tu préfère ? Ca veut dire quoi ?

Juste après l'initialisation, le chariot sera en position 30cm. Il est donc "logique" que la première fois que tu règles la position où tu souhaites aller, ce soit pré-régler sur 30cm (ie la valeur 30 cm s'affiche, et si tu augment par exemple de 1 les mm, ça deviendra 30.1cm).

Imaginons que ta première commande soit d'aller à 40cm.

Ensuite, tu vas vouloir changer de position, et je suppose que ce sera le même menu pour faire le réglage : du coup, la question est de savoir si tu veux que ça t'affiche 30cm ou 40cm avant que tu ne commence à régler pour la position suivante. Est-ce plus clair?
 

[cook]

En fait entre deux réglage se sera forcement réinitialise .Donc si je décide de régler sur 40 la première fois , je vais travailler avec se réglage puis réinitialiser ensuite.  Je peux pas faire autrement .

 

Pour répondre à Mike j'ai besoin de faire un petit test et quelques essais .

[cook]

Pour régler centimètres par centimètres la nouvelle distance , je reste appuyé sur le bouton et les centimètre se déroule de 30.0 à 190,0 cm en boucle .Environ 1 cm  par seconde (réglable des fois que 1 cm par seconde soit trop rapide ou inversement )   . Je relâche le bouton le compteur s’arrête .

 

Pour les millimètres c'est un peut différent . Je fait un appuis , (donc j'appuis et je relâche) les millimètres s’incrémentent de 1 . 

Pour exemple le compteur est sur 30.0 après la réinitialisation . Je fait un simple appuis  (donc j'appuis et je relâche) le compteur passe à 30.1 cm .

Autre cas de figure , le compteur est réglé sur 30.9 et je fait un appuis , (donc j'appuis et je relâche) . Le compteur passe à 30.0 .

Vous me dirai si la solution est bonne ou si il faut changer .

[Sandro]

Bonjour,

Si c'est ça que tu veux comme interface, ça me va. Il n'y a pas de "mauvaise" solution (juste certaines plus faciles à utiliser et/ou à programmer).

Tu utilisera un bouton séparé pour valider, c'est bien ça?

 

Du coup, voici ce que je peux te proposer:

comme fonctionnement détaillé :

- si tu appuis sur le bouton pendant une durée comprise entre t1=10ms et t2=500 ms, alors tu fais défiler les mm (avec 0 qui suit 9)

- si tu appuis sur le bouton pendant une durée >= t3=2s, tu commences à incrémenter de 1cm tous les dt4=1s. Du coup, si initialement tu es à 30.0 cm à t=0, à t=2s (=t3) tu sera à 31.0 cm, puis à t=3s(=t3+1*dt4) tu sera à 32.0 cm, puis à t=4s(=t3+2*dt4) tu sera à 33.0 cm

- si le bouton de défilement n'est pas enfoncé, alors (et alors seulement), si tu appuis sur le bouton valider tu valides. Le fait d'exiger que le bouton de défilement est relâché facilitera un peu le code et je trouve ça plus logique (on ne valide pas pendant qu'on est en train de faire défile). Si ce point te dérange, on pourra le modifier

 

Nb : pour toutes les durées (t1, t2, t3 et dt4, tu peux bien sur choisir n'importe quelle valeur, la seule contrainte est que t1 < t2 <= t3, pas de contrainte sur dt4)

 

 

Je te propose qu'on utilise des distances en mm (ça évite les nombres à virgules), et des durées en millisecondes.

Est-ce que pour les affichages tu tiens à ce que ce soit en cm, ou un affichage en mm te convient aussi bien? (ça marche aussi, ce sera juste un poil moins propre)

 

Une fois que tu as choisis pour millimètres entiers vs centimètres décimaux, tu pourra faire les étapes suivantes :

1) si tu as choisis de tout faire en mm, commence par adapter le code existant (remplace les float par des int, change la valeur initiale de la distance de 30 à 300, et change l'unité "cm" en "mm")

 

2) Écris une fonction

void afficherDistanceChoisie(TYPE distance)
{

}

où TYPE est "int" ou "float" selon si tu travailles en mm ou en cm.

Cette fonction sert à afficher la distance sélectionnée actuellement : en gros, c'est la même que afficherDistance sauf que le message change (je pense pas que tu veuilles écrire "Butée" quand tu sélectionne la valeur où aller)

 

3) Écris une fonction

TYPE selectionnerDistance()
{
    int distance=300;  //ou float=30.0 si tu restes en cm

    //à compléter

    return distance;
}

Cette fonction permettra au final de faire toute la sélection de la distance, et d'attendre le bouton de validation.
 

Pour cette étape, je voudrais que la seule chose que tu fasses dedans, c'est de modifier la distance en 400mm (ou 40.0cm) puis afficher la distance (avec la fonction afficherDistanceChoisie) juste avant de renvoyer la distance (le renvoi est déjà fait avec le return).
Pour tester, je te suggère de transformer ton loop en :

void loop()
{
    InitMoteur();
    TYPE distance=selectionnerDistance();
    afficherDistanceChoisie(distance);
}

Si tout vas bien, tu devrais afficher 2 fois d'affilé la valeur 400mm / 40.0cm

 

4) Tu modifie la fonction selectionnerDistance pour qu'elle attende que tu ais appuyé sur le bouton de validation pour terminer (il faut utiliser une boucle while qui continue tant que le bouton de validation n'est pas enfoncé).

 

 

Je te propose que tu commences par ces 4 étapes, je te détaillerais la suite ensuite. Si tu bloques (ou si c'est pas clair), n'hésite pas à demander. Poste ton code final (et ton code intermédiaire si tu bloques ou que ça ne marches pas comme prévu)
 

[cook]

Bonjour Sandro , je pensais mettre un bouton pour les millimètres et un bouton pour les centimètres .

Ça va on peut  ?

 

Pour la validation si cela correspond à mettre en route le moteur pour aller à la distance choisie , oui il y aura un bouton validation.

 

Pas de problème pour tout mettre en millimètre . 

 

J’espère que ton travail sur le dernier message n'est pas totalement perdu . 

[Sandro]

Pour la validation si cela correspond à mettre en route le moteur pour aller à la distance choisie , oui il y aura un bouton validation.

C'est exactement ça. C'est ce bouton que tu dois implémenter dans l'étape 4 (nb : il faut juste détecter qu'il est appuyé pour sortir du while, on ne fait pas bouger le moteur pour l'instant)
 

 

Pas de problème pour tout mettre en millimètre .

Super, du coup, partout où j'avais écrit "TYPE", il faudra mettre "int".

L'avantage d'utiliser des "int" plutôt que des floats est multiple : ça évite les erreurs d'arrondi, c'est plus rapide, ça prend moins de place en mémoire, ... Donc souvent d'utiliser une autre unité qui évite d'avoir des virgules est une bonne solution (si tu le désire, à la fin on pourra modifier les fonctions d'affichage pour afficher en cm même si les variables sont en mm, mais on fera ça tout à la fin si tu le souhaites)

 

Du coup, à toi de travailler, tu as 4 étapes à faire
 

[cook]

Je  comprends pas les boutons   . je  m'explique de ce que je comprends . 

 

1 bouton pour régler les centimètres 

1 bouton pour régler les millimètres

1 bouton pour valider la distance choisie

1 bouton pour faire avancé le moteur

 

Si on est d'accord et que ton message 79 résume les 4 boutons que je viens d'écrire  . Eh bien c'est parti . 

On est d'accord ?