Automatiser un tiroir.

Guillaume_17 · December 16, 2018, 5:44pm

Salut à tous,

Cela fait quelques temps que j'y pense, mais je ne me suis jamais réellement lancé : automatiser un tiroir dans ma cuisine.

L'idée est très simple :

j'appuie sur un bouton, le tiroir sort.
Je réappuie sur le même bouton, le tiroir rentre.

Si cette idée est simple, sa mise en pratique semble beaucoup plus difficile !
Il n'existe que très peu de kits dans le commerce, et ils coûtent une blinde.
Et après avoir passé de nombreuses heures de recherche sur le net, je n'ai rien trouvé de bien concret
J'ai des petites connaissances en automatisme, très basiques, étudié ça au lycée il y a plus de 15 ans, et je n'y connais rien aux Arduino ; je ne suis même pas sûr que ce soit la solution la plus adaptée à mes besoins. Le but est que ça fasse l'affaire pour pas cher.

En revanche j'estime être un très bon mécanicien et la conception de pièces différentes pour créer un mécanisme ne me posera pas de problème.
Pour l'entraînement du tiroir, j'ai l'intention d'utiliser notamment un moteur pas à pas avec courroie crantée et poulie adéquate, comme on en trouve sur les imprimantes 3D.
Le guidage du tiroir est évidemment déjà assuré par son propre système de coulisses à billes.

C'est donc avec ce post que j'ouvre ce topic, pour l'instant c'est un peu le fouillis dans ma tête, on verra bien où ça va mener !

A suivre

lesept · December 16, 2018, 5:58pm

Côté arduino, ce ne devrait pas être très difficile. Tu peux même remplacer le bouton par un capteur de proximité qui permettrait d'ouvrir le tiroir sans action directe de ta part... MAGIE...

Tu peux commencer par chercher des tutos sur internet pour savoir comment commander un moteur. Cherche eskimon et openclassrooms.

Il te faudrait peut être des capteurs de fin de course pour arrêter le moteur à la fin de son déplacement.

Guillaume_17 · December 16, 2018, 6:59pm

Salut Lesept,

Bonne idée le capteur de proximité : en effet j'avais pensé à en placer un sous le meuble, juste à l'avant, pour pouvoir ouvrir le tiroir en passant le pied un peu sous le meuble, un peu comme le coffre de certaines voitures, pour faire une ouverture sans les mains puisque ce tiroir sera un "gros" tiroir contenant la poubelle de la cuisine.

Pour le moteur, j'avais pensé à un moteur pas à pas pour plusieurs raisons : la distance d'ouverture du tiroir pourra être réglée assez finement, sa vitesse d'ouverture/fermeture devrait également être réglable (si ça se trouve elle pourrait même être progressive ?), et avec un tel moteur il devrait être possible de se dispenser de capteurs fin de course (mais j'ai quand même prévu d'en installer un à chaque bout : ça coûte rien, c'est plus sécuritaire et c'est facilement gérable).

Super info que d'aller jeter un œil sur le blog d'Eskimon, c'est une mine d'infos intéressante merci !
En prime, rien qu'avec la partie dédiée aux moteurs pas-à-pas, j'ai presque déjà 25% de mon code de fait

hazerty565 · December 16, 2018, 7:48pm

en faite, il faut que tu trouve une glissiere motorisé, cela peut etre assez compliqué et peut etre chers...

par la suite rien de sorcier, avec un bouton, ou capteur de proximité comme dit plus haut...

A moins de trouver un Lecteur CD, tout le mecanisme est dedans , 2 butée, une pour la fin et l'autre debut.

le probleme du capteur de proximité, il faut regler la sensibilité, par exemple tu passe devant et que tu veux pas l'ouvrir, cela peut etre dangereux avec les enfants, surtout un tiroir a hauteur de tete....

lesept · December 16, 2018, 8:52pm

On peut imaginer un capteur ultrasons HC-SR04 :

ou utiliser la bibliothèque Capacitive Sensor qui permet d'utiliser une petite plaque métallique comme capteur tactile ou de proximité.

Le premier permet de détecter une présence plus loin et on peut choisir la distance de détection en mesurant le délai de trajet aller - retour entre le capteur et l'obstacle. Par contre, le capteur est un peu gros et pas très esthétique.

Le second est vraiment dédié à une détection de proximité : une sorte de bouton tactile ou une détection à quelques centimètres. Le capteur est plus discret : une petite plaque métallique, j'en ai même fait un avec une pièce de 10 cents (voir ici, réponse #11)...

Guillaume_17 · December 17, 2018, 6:30am

hazerty565:
une glissiere motorisé

En effet ça existe, mais j'ai eu du mal à en trouver et ça coûte cher.

A moins de trouver un Lecteur CD, tout le mecanisme est dedans , 2 butée, une pour la fin et l'autre debut.

La solution est bonne, mais pour un petit tiroir assez léger : à la base c'est prévu pour charger un DVD d'environ 250 grammes, mon tiroir peut peser dans les 7 à 8 kilos ! Il me faut du costaud.
J'ai pensé aux moteurs linéaires, mais ils ne correspondent pas à mon besoin : trop lents, j'ai une ouverture d'environ 45cm et il me faut une vitesse d'ouverture d'environ 90 à 110mm/s pour que ça doit raisonnable
Un moteur linéaire est dans les 6mm/s

cela peut etre dangereux avec les enfants, surtout un tiroir a hauteur de tete....

Dangereux ou marrant...

Lesept, j'adore cette idée de capteur avec une lame de métal ! Collée sous le rebord du plan de travail ça sera super, et ça a un côté "bouton tactile" c'est génial !

lesept · December 17, 2018, 8:14am

Guillaume_17:
Lesept, j'adore cette idée de capteur avec une lame de métal ! Collée sous le rebord du plan de travail ça sera super, et ça a un côté "bouton tactile" c'est génial !

Il faut la tester "en vraie grandeur", car elle est basée sur la mesure d'une capacité. Je l'ai fait avec un câble électrique d'une dizaine de centimètres, mais si on imagine que le moteur et l'Arduino sont au fond du tiroir et le capteur devant, il y aura un câble d'une cinquantaine de centimètres (1 mètre aller / retour) qui ajoutera une capacité supplémentaire qui risque de modifier le fonctionnement.

Guillaume_17 · December 22, 2018, 1:53pm

Je ne pense pas qu'un fil électrique comme celui-ci puisse réellement avoir un effet capacitif suffisant pour perturber le montage.
Mais, si ça devait arriver, j'ai trouvé la réponse : en fait, peu importe la valeur de la capacité de base, on va faire en sorte que l'Arduino capte une différence de valeur, et définir un certain seuil à partir du quel il va réagir.
J'ai trouvé une très bonne vidéo ici : vidéo YouTube "Arduino, bouton sans bouton"
Pour ceux qui sont pressés, informations utiles à 6'15" : lorsqu'on touche le fil (il y a une résistance en série), la valeur lue par l'Arduino change. Le seuil pour allumer ou non la led est fixé à 50 par le youtubeur.

Donc, peu importe la longueur du fil utilisé, même si celui-ci génère une certaine capacité à lui tout seul on peut s'en sortir

lesept · December 22, 2018, 2:47pm

Tu as avancé dans ton projet ?

Guillaume_17 · December 23, 2018, 12:52pm

"Avancé", un petit peu oui, j'y travaille à temps perdu.

Pour l'instant j'ai commandé un Arduino, reçu il y a deux jours (un Nano non-officiel premier prix). C'est mon premier, et comme je n'y connais que dalle, j'ai passé beaucoup de temps à me documenter dessus et à comprendre comment ça fonctionne.
J'ai réussi mon premier téléversement (et j'en suis content), juste pour voir si je pouvais le faire fonctionner : simple, j'ai modifié la vitesse de clignotement de la LED embarquée dessus, à côté de la LED 'power'.

**->**Donc j'ai un Arduino, il fonctionne et j'arrive à téléverser des programmes dessus, et ça : c'est un bon début !

J'ai réfléchi à une chose aussi : le tiroir sera équipé de glissières avec amorti en fin de course, donc il faudra désactiver le stepper et laisser le tiroir en roue libre à la fin de course, aussi bien à l'ouverture qu'en fermeture. En fait le moteur entrainera le tiroir pour le mettre en mouvement (par exemple sur les 25 premiers centimètres de course) et le laissera terminer sa course tout seul une fois lancé. Le petit plus, c'est que ça évite aussi de se faire coincer trop fort les doigts ou la main dans le tiroir.

Pour l'entrainement du tiroir, ça sera un moteur pas à pas du type NEMA17 (classique…) avec courroie crantée avec un pololu, ça doit pas être bien compliqué à installer.

J'ai aussi commandé deux ou trois babioles en attendant : une plaque d'essai, quelques fils dupont, un pololu A4988, et un capteur de courant.

Le plus gros du boulot sera, à mon avis, de créer les pièces nécessaire à la fixation du moteur et du système d'entrainement du tiroir. Conception/impression 3D… ça va me prendre du temps.

lesept · December 23, 2018, 2:29pm

Bonne continuation !

Guillaume_17 · January 16, 2019, 11:06am

Salut,
je poste pour vous faire part de l'avancement de mes travaux, pour ceux qui sont intéressés et qui suivent ce petit projet.

J'ai énormément appris puisqu'effectivement je partais de rien en terme de connaissance en programmation. J'ai commencé à écrire le code pour l'Arduino. Quelle galère, j'ai trouvé quelques bouts de codes par-ci par-là, je les ai copié/collé, j'ai cherché à comprendre ce que chaque ligne de code voulait dire… et je suis arrivé à un truc qui prend vraiment tournure.

Je me suis notamment appuyé sur ces pages pour les codes, j'en profite pour remercier leurs auteurs :

Le code de Paul Badger qu'on peut retrouver ici : Arduino Playground - CapacitiveSensor
Et cette vidéo où le présentateur explique tout en détail : [Arduino] Bouton sans bouton ( capteur capacitif ) tuto - YouTube

J'ai fait une sorte de copier/coller du code pour le bouton tactile et un autre pour la mise en route du moteur pas à pas. Normalement, mon code devrait fonctionner.

J'ai également dû faire face à un autre problème : un NEMA17 sera insuffisamment puissant pour faire translater une charge de plusieurs kilos (j'avais estimé jusqu'à 10Kg en incluant 20% de marge).
J'ai fait de rapides calculs, et à la louche, il me faut 1Nm de couple.
Avec un NEMA17 on en est très loin, son couple moteur est très faible.
Impossible d'utiliser un réducteur, car je perdrai l'effet "roue libre" du moteur pas à pas, pour bénéficier de l'amorti de la glissière du tiroir : le mécanisme débraye et c'est un ressort de rappel qui termine de rentrer le tiroir dans son logement.
Je compte utiliser un moteur plus puissant, par exemple dans la famille des NEMA23 je devrais trouver mon bonheur (souvent plus de couple moteur).
Du coup j'abandonnerai par la même occasion le A4988 pour un TBS109 qui, lui, supportera le courant demandé.

Et comme je veux aller jusqu'au bout : je suis en train de me casser la tête pour faire varier la vitesse de mon moteur pas à pas pour une ouverture douce et une accélération linéaire.
J'ai trouvé ceci : http://fdec.fr/motpap/ , mais vu l'usine à gaz que c'est je crois que je vais copier/coller pas mal de lignes de code en faisant augmenter la vitesse de rotation du moteur à chaque fois jusqu'à obtenir la vitesse voulue, j'irai plus vite .

Voilà, à suivre ....

lesept · January 16, 2019, 12:09pm

Bon courage, on pourra t'aider à débuguer ou optimiser le code !

Guillaume_17 · January 28, 2019, 5:34pm

Bon, j'ai pas mal avancé.

Pour la motorisation, j'ai choisi un moteur de type NEMA17, avec un réducteur de 14:1 pour avoir suffisamment de couple pour ouvrir (et refermer) le tiroir. Ce moteur pas à pas sera assorti à un driver de type A4988.

J'ai fais mes petits calculs, j'ai mesuré une force nécessaire d'environ 2,800Kg pour ouvrir le tiroir (beaucoup moins pour le refermer). Entre le NEMA17 qui développe 2,2N.cm de couple de détente, avec le réducteur (et son rendement de 0.9), le diamètre de la poulie motrice (12,6mm de diamètre), je vous passe les calculs mais si je ne me suis pas trompé je dois avoir plus de 4,3Kg de force pour ouvrir le tiroir, ça devrait le faire

Et surtout : j'ai quasiment fini d'écrire le code ! Enfin je pense qu'il est complet, mais reste encore à peaufiner, notamment pour l'accélération du moteur pas à pas, et ajuster la course du moteur avec le nombre de tours etc... ;D
Mais j'ai quelques questions :

Est-ce que je peux mélanger des délais avec des unités différentes dans le même programme ?

Par exemple, repris dans le code de Paul Badger, j'ai un "serial print" en millisecondes :

void loop() {
  long start = millis();       // variable avec le temps en cours, récupère la donnée chaque milliseconde
[…]
void loop () Serial.print(millis() - start);       // check on performance in milliseconds
    […]

Et un peu plus loin, pour envoyer les micropas pour faire tourner le moteur pas à pas, j'ai :

for(int x = 0; x<112000; x++) { // 11200 micropas/tour 
  digitalWrite(Step,HIGH);
  delayMicroseconds(112);       // temps entre deux impulsions, 11.2ms = 1tr/sec (si mes calculs sont bons!).
  digitalWrite(Step,LOW);
  delayMicroseconds(112);       // temps entre deux impulsions
   }

A un moment donné j'ai également utilisé la fonction delay : " delay(200); ", est-ce que cette valeur est en millisecondes par défaut ?
Est-ce que je ne devrais pas utiliser des microsecondes partout et à chaque fois ?

Sinon j'utilise arduino IDE, après avoir cliqué sur "vérifier" je n'ai plus de message d'erreur orange, j'espère que c'est déjà bon signe !
Vivement la réception du moteur pas à pas pour que je puisse tester ça !

J'ai également deux petits switch de fin de course, un pour le tiroir fermé, et un pour le tiroir ouvert.
Ces deux fins de course ne fonctionnent pas comme des "boutons" lançant une action, mais juste comme des "autorisations" de mise en mouvement. Par exemple le tiroir sort (moteur fait un certain nombre de tours) si le fin de course "tiroir rentré" est actionné.
Du coup, je n'ai pas besoin de résistance de pull-down, quelqu'un peut-il confirmer ?

Merci d'avance !

lesept · January 28, 2019, 6:24pm

La fonction delay prend un argument en millisecondes. Tu peux allègrement mélanger les millisecondes dans delay et les microsecondes dans l'autre fonction, personne ne te dénoncera à la haute autorité de normalisation des codes arduino...

Guillaume_17 · February 4, 2019, 4:54pm

Salut Lesept, et merci pour l'info

Bon, aujourd'hui je reviens vers vous tous car je pense que je touche au but, je vais exposer ici mon travail :

Pour commencer, voici mon schéma de câblage :

On ne tient pas compte du shunt entre MS1 et MS2, c'était prévu mais je n'ai finalement gardé que MS2

Ensuite, voici le code que j'ai tapé et qui va avec :

//librairies
#include <CapacitiveSensor.h > //librairie pour le capteur capacitif 
#include <Stepper.h>           //librairie pour le stepper           

//affectation des broches :
const int FinDeCourse1 = 11 ;  // fin de course tiroir fermé  (N/C)   
const int FinDeCourse2 = 9 ;   // fin de course tiroir ouvert (N/O)   
const int Step = 7 ;           // pas moteur                          
const int Dir = 6 ;            // Sens de rotation                    
const int Enable = 5 ;         // Active ou désactive le stepper _ HIGH = Desactivé
const int MS2 = 3 ;            // "1/4 step" _ 1 tour moteur = 800 micropas
 // Un tour en sortie du réducteur = 11200 pas. 

CapacitiveSensor   cs_4_2 = CapacitiveSensor(4,2); // bouton tactile _ OK
/* résistance de 10MOhms entre les bornes 4 et 2, ajouter un
 * conducteur sur la pin 2 (fil électrique
 * ou pièce de métal...), ça sera le bouton tactile. */

void setup() {
     
   pinMode(FinDeCourse1, OUTPUT);    // Pin 11 _ Fin de course lorsque tiroir fermé (N/C)
   pinMode(FinDeCourse2, OUTPUT);    // Pin 9  _ Fin de course lorsque tiroir ouvert (N/O) 
   pinMode(Step, OUTPUT);            // Pin 7  _ envoie le nombre de pas moteur
   pinMode(Dir, OUTPUT);             // Pin 6  _ sens de rotation
   pinMode(Enable, OUTPUT);          // Pin 5  _ active ou desactive stepper
   digitalWrite(Enable, HIGH);       // Stepper désactivé en temps normal (roue-libre)
   pinMode(MS2, OUTPUT);             // Pin 3  _ active le 1/4 de step (800 pas par tour moteur)
                                     // moteur réducté de 14:1 _ 800 pas = 1/14è de tour = 11200pas/tour
   
   //bouton tactile :
   cs_4_2.set_CS_AutocaL_Millis(0xFFFFFFFF);  //autocalibration
    Serial.begin(9600);                       // pour récupérer l'info   
}

void loop() {
  long start = millis();                      // variable avec le temps en cours, récupère la donnée chaque milliseconde
  long total1 =  cs_4_2.capacitiveSensor(30); // appel pour savoir quelle valeur a le capteur capacitif
  
  Serial.print(millis() - start);             // check on performance in milliseconds
    Serial.print("\t");                       // valeur de ce qu'il se passe dans le fil, le capteur.
    Serial.print(total1);                     // print capteur total 1
    Serial.print("\r\n");                     // retour ligne


// Scénario #1 : j'appuie sur le bouton, le tiroir est rentré :

if ( total1>50 && FinDeCourse1 == LOW )       // si bouton tactile appuyé et tiroir rentré 
{
digitalWrite(Enable,LOW);                     // LOW active le stepper (à vérifier / tester)
digitalWrite(Dir,HIGH);                       // le moteur tournera dans un sens
digitalWrite(MS2,HIGH);                       // 1/4 pas , résolution moteur = 800 micropas/tour
delay(200);                                   // attendre 200 ms

//faire tourner le moteur pas à pas de 10 tours dans le sens "sortir le tiroir" :
for(int x = 0; x<112000; x++) {               // 11200 micropas/tour car moteur avec réducteur 14:1
  digitalWrite(Step,HIGH);
  delayMicroseconds(112);              // temps entre deux impulsions, 11.2ms = 1tr/sec (si mes calculs sont bons!).
  digitalWrite(Step,LOW);
  delayMicroseconds(112);                      // temps entre deux impulsions
   }
}

// Scénario #2 : j'appuie sur le bouton, le tiroir est sorti :

if ( total1>50 && FinDeCourse2 == HIGH )     // si bouton tactile appuyé et tiroir sorti 
{
digitalWrite(Enable,LOW);                     // LOW active le stepper
digitalWrite(Dir,LOW);                        // le moteur tournera dans l'autre sens
digitalWrite(MS2,HIGH);                       // 1/4 de pas
delay(200);                                   // attendre 200 ms

// faire tourner le moteur pas à pas de 9 tours dans le sens "rentrer le tiroir":
for(int x = 0; x<100800; x++) {               // 11200 pas par tour x 9 tours
  digitalWrite(Step,HIGH);
  delayMicroseconds(112);                     // temps entre deux impulsions, Influe sur la vitesse.
  digitalWrite(Step,LOW);
  delayMicroseconds(112);                     // temps entre deux impulsions, Influe sur la vitesse.
}
// désactiver le stepper pour bénéficier de l'amorti en fin de course de la glissière
digitalWrite(Enable,HIGH);                    // HIGH désactive le stepper
  }

//Scénario #3 : Appui sur bouton, tiroir en position inconnue (entre deux) : "retour position 'HOME' tiroir" :

if ( total1>50 && FinDeCourse1 == HIGH && FinDeCourse2 == LOW ) //bouton tactile appuyé et position tiroir inconnue : 
                                                       //faire tourner le moteur jusqu'à fin de course tiroir sorti :
 {
  digitalWrite(Enable,LOW);                    // LOW active le stepper
  digitalWrite(Dir,LOW);                       // le moteur tournera dans le sens 'rentrer tiroir'
  digitalWrite(MS2,HIGH);                      // 1/4 de pas
  delay(20);                                   // attendre 20 ms
do {
    for(int x = 0; x<200; x++) {     // 200 micropas = environ 0.714mm d'avance (si mes calculs sont bons !)
  digitalWrite(Step,HIGH);
  delayMicroseconds(112);                      // temps entre deux impulsions, Influe sur la vitesse.
  digitalWrite(Step,LOW);
  delayMicroseconds(112);                      // temps entre deux impulsions, Influe sur la vitesse.
}

} while (FinDeCourse2 == HIGH);               //jusqu'à fin de course tiroir sorti
   
}

}

LA SUITE CI-DESSOUS :

Guillaume_17 · February 4, 2019, 5:00pm

Donc la suite :

Je n'ai pas testé ce code, en revanche j'ai voulu faire un essai avec un autre beaucoup plus simplifié : ce deuxième code devrait faire tourner mon moteur pas à pas de seulement un tour juste en touchant le capteur capacitif, le voici :

//librairies
#include <CapacitiveSensor.h > //librairie pour le capteur capacitif 
#include <Stepper.h>           //librairie pour le stepper           

//affectation des broches :
  
const int Step = 7 ;           // pas moteur                          
const int Dir = 6 ;            // Sens de rotation                    
const int Enable = 5 ;         // Active ou désactive le stepper _ HIGH = Desactivé
const int MS2 = 3 ;            // "1/4 step" _ 1 tour moteur = 800 micropas
 // Un tour en sortie du réducteur = 11200 pas. 

CapacitiveSensor   cs_4_2 = CapacitiveSensor(4,2); // bouton tactile _ OK
/* résistance de 10MOhms entre les bornes 4 et 2, ajouter un
 * conducteur sur la pin 2 (fil électrique
 * ou pièce de métal...), ça sera le bouton tactile. */

void setup() {
      
   pinMode(Step, OUTPUT);            // Pin 7  _ envoie le nombre de pas moteur
   pinMode(Dir, OUTPUT);             // Pin 6  _ sens de rotation
   pinMode(Enable, OUTPUT);          // Pin 5  _ active ou desactive stepper
   digitalWrite(Enable, HIGH);       // Stepper désactivé en temps normal (roue-libre)
   pinMode(MS2, OUTPUT);             // Pin 3  _ active le 1/4 de step (800 pas par tour moteur)
                                     // moteur réducté de 14:1 _ 800 pas = 1/14è de tour = 11200pas/tour
   
   //bouton tactile :
   cs_4_2.set_CS_AutocaL_Millis(0xFFFFFFFF);  //autocalibration
    Serial.begin(9600);                       // pour récupérer l'info   
}

void loop() {
  long start = millis();                      // variable avec le temps en cours, récupère la donnée chaque milliseconde
  long total1 =  cs_4_2.capacitiveSensor(30); // appel pour savoir quelle valeur a le capteur capacitif
  
  Serial.print(millis() - start);             // check on performance in milliseconds
    Serial.print("\t");                       // valeur de ce qu'il se passe dans le fil, le capteur.
    Serial.print(total1);                     // print capteur total 1
    Serial.print("\r\n");                     // retour ligne


// Scénario #1 : j'appuie sur le bouton :

if ( total1>11 )       // si bouton tactile appuyé 
{
digitalWrite(Enable,LOW);                     // LOW active le stepper (à vérifier / tester)
digitalWrite(Dir,HIGH);                       // le moteur tournera dans un sens
digitalWrite(MS2,HIGH);                       // 1/4 pas , résolution moteur = 800 micropas/tour
delay(200);                                   // attendre 200 ms

//faire tourner le moteur pas à pas de 2 tours
for(int x = 0; x<22400; x++) {               // 11200 micropas/tour car moteur avec réducteur 14:1
  digitalWrite(Step,HIGH);
  delayMicroseconds(112);              // temps entre deux impulsions, 11.2ms = 1tr/sec (si mes calculs sont bons!).
  digitalWrite(Step,LOW);
  delayMicroseconds(112);                      // temps entre deux impulsions
   }
   delay(10);                            // pour éviter que ça mouline de trop...
}

}

Malheureusement, cela ne fonctionne pas.
Peut-être que le stepper (A4988) n'est pas correctement étalonné, voire il est HS (j'aimerais le changer, il faut que j'en achète un autre...).

Et deuxième point qui me semble important : après avoir téléversé le code dans mon Arduino, en ouvrant le moniteur série, la machine semble pédaler dans la semoule comme pas possible !
Le taux de rafraichissement est d'environ 5 secondes !!

J'ai refait un test en allégeant encore plus et en ne gardant seulement que le bouton tactile et sa librairie capacitiveSensor, et là j'ai un taux de rafraichissement normal de quelques millisecondes, les lignes de chiffres défilent à toute vitesse. Du coup, je pense que mon code est beaucoup trop "lourd" pour un Arduino NANO ?
Je suis un peu perdu… peut-être passer à 115200 au lieu de 9600 pour le "serial.begin" mais est-ce que ça ne ferait pas forcer le système au lieu de réparer la cause du problème qui serait ailleurs ? Normalement je pense que 9600 ça devrait être largement assez...

lesept · February 4, 2019, 5:01pm

ça a l'air plutôt bien.
Pour une meilleur lisibilité, je te conseille de faire des fonctions :

// si bouton tactile appuyé et tiroir rentré 
if ( total1>50 && FinDeCourse1 == LOW ) Scenario1 ();

// Scénario #2 : j'appuie sur le bouton, le tiroir est sorti :
if ( total1>50 && FinDeCourse2 == HIGH ) Scenario2 ();

//Scénario #3 : Appui sur bouton, tiroir en position inconnue (entre deux) : "retour position 'HOME' tiroir" :
if ( total1>50 && FinDeCourse1 == HIGH && FinDeCourse2 == LOW ) Scenario3 ();

Et plus loin :

void Scenario1 ()
{
digitalWrite(Enable,LOW);                     // LOW active le stepper (à vérifier / tester)
digitalWrite(Dir,HIGH);                       // le moteur tournera dans un sens
digitalWrite(MS2,HIGH);                       // 1/4 pas , résolution moteur = 800 micropas/tour
delay(200);                                   // attendre 200 ms

//faire tourner le moteur pas à pas de 10 tours dans le sens "sortir le tiroir" :
for(int x = 0; x<112000; x++) {               // 11200 micropas/tour car moteur avec réducteur 14:1
  digitalWrite(Step,HIGH);
  delayMicroseconds(112);              // temps entre deux impulsions, 11.2ms = 1tr/sec (si mes calculs sont bons!).
  digitalWrite(Step,LOW);
  delayMicroseconds(112);                      // temps entre deux impulsions
   }
}

(etc.)

lesept · February 4, 2019, 5:06pm

J'avais répondu alors que tu tapais le second message.

Ceci :

for(int x = 0; x<22400; x++) {               // 11200 micropas/tour car moteur avec réducteur 14:1
  digitalWrite(Step,HIGH);
  delayMicroseconds(112);              // temps entre deux impulsions, 11.2ms = 1tr/sec (si mes calculs sont bons!).
  digitalWrite(Step,LOW);
  delayMicroseconds(112);                      // temps entre deux impulsions
   }

dure 2 * 112 * 22400 = 5 017 600 microsecondes, soit 5 secondes...

lesept · February 4, 2019, 5:09pm

Après, ça dépend de ce que tu veux faire. Si tu acceptes qu'une action lancée (ouverture du tiroir par exemple) ne peut pas être interrompue, alors c'est OK.

Par contre, si tu veux pouvoir l'interrompre au milieu du chemin pour le rouvrir, alors il faut programmer différemment. Il faut t'inspirer du fonctionnement des machines à état. Il y a des tutos sur le site (section... tutos je crois) et partout ailleurs sur Internet.

Mais avant, il faut que tu saches ce que tu veux faire...

Topic		Replies	Views
Utiliser Arduino pour améliorer l'expérience des restaurants : Des idées pour la cuisine française ? Le bar	9	603	January 16, 2024
controle d un relais par une consigne Français	5	781	May 6, 2021
Utiliser un arduino à la place d'une carte d'acquisition PC Français	4	1852	May 6, 2021
Projet distributeur de nourriture automatique mais le code ne fonctionne pas Français	26	633	February 23, 2024
Remplacer un bouton par un arduino Français	6	1149	May 6, 2021

Automatiser un tiroir.

Related topics