Distributeur automatique de bricolage - Projet mécatronique basé sur Arduino

Dans ce projet, nous allons apprendre à fabriquer un distributeur automatique basé sur Arduino. Je vais vous montrer tout le processus de construction, à partir de la découpe et de l'assemblage des panneaux MDF, jusqu'à la connexion de toutes les pièces électroniques et l'écriture du code Arduino.

Vous pouvez regarder la vidéo suivante ou lire le didacticiel écrit ci-dessous.

Aperçu

Le distributeur comprend quatre unités de décharge contrôlées par quatre servomoteurs à rotation continue, un système de support contrôlé par des moteurs pas à pas, un écran LCD, quatre boutons pour sélectionner un article et un détecteur de pièces.

Vous pensez peut-être maintenant que le porte-objets n'est pas si utile pour ce distributeur automatique, et oui, vous avez probablement raison. Mais mon idée ici était de rendre ce projet plus intéressant ou un peu plus complexe afin que vous puissiez apprendre plus de nouvelles choses. Je pense que cette idée de projet peut être idéale pour les étudiants en électronique ou en mécatronique qui envisagent d'en construire un comme projet de fin d'année, ainsi que pour tous les passionnés d'Arduino.

Construire le distributeur automatique

J'ai commencé par découper le panneau MDF de 8 mm d'épaisseur.

J'ai précédemment réalisé un modèle 3D de la machine à partir duquel j'ai obtenu toutes les mesures.

Vous pouvez trouver et télécharger ce modèle 3D, ainsi que l'explorer dans votre navigateur sur Thangs.

Pour couper le MDF, j'ai utilisé une scie circulaire. En fait, il s'agit d'un établi fait maison avec une scie circulaire, une toupie et une scie sauteuse, fabriqué par ma partenaire Marija et il y a une vidéo de bricolage sur sa chaîne YouTube Creativity Hero.

Après avoir coupé tous les panneaux à l'aide de la scie circulaire, j'ai continué à faire des ouvertures dans certains panneaux à l'aide de la scie sauteuse inversée.

En fait, une scie sauteuse peut même être utilisée pour l'étape précédente au cas où vous n'auriez pas de scie circulaire. J'ai également utilisé la scie sauteuse pour couper les petites pièces qui avaient plusieurs coupes. Cependant, notez que ce sont des machines dangereuses, vous devez donc être très prudent lorsque vous les utilisez.

Une fois toutes les pièces en MDF prêtes, j'ai commencé à les assembler avec de la colle à bois et des vis. Pour fixer les panneaux, j'ai utilisé des pinces à angle de 90 degrés. À l'aide d'une perceuse sans fil, j'ai d'abord fait des avant-trous, puis j'ai fait des contre-éviers et j'ai vissé les vis de 3 mm en place. J'ai utilisé la même méthode pour assembler tous les panneaux et pour certains d'entre eux, j'ai également utilisé des pinces F.

Système ferroviaire

À ce stade de l'assemblage, je vais continuer avec la fabrication du système de rails. Pour cela, j'utilise des tubes en aluminium que je découpe à l'aide d'une scie à métaux. Le diamètre du tube pour le rail horizontal est de 16 mm, tandis que pour le rail vertical, le diamètre est de 20 mm. Sur des planches de bois massif de 18 mm, j'ai fait des fentes pour les tubes à l'aide d'un foret Forstner, puis j'ai fixé les tubes dessus.

Le rail horizontal est composé de deux tubes de 27 cm de long, tandis que le rail vertical est composé de trois tubes de 45 cm de long.

Viennent ensuite les curseurs et voici comment je les ai créés. J'ai utilisé une planche de bois de 21 par 21 cm sur laquelle j'ai fait des trous de 8 mm.

Ensuite, j'ai inséré des tiges filetées de 8 mm à travers ces trous et à l'aide de rondelles et d'écrous, j'ai fixé les roulements de 22 mm. Quant au curseur horizontal, j'ai utilisé la même méthode mais avec des roulements plus petits de 16 mm de diamètre extérieur.

Après avoir inséré le curseur entre les rails du tube, j'ai remarqué qu'il était un peu lâche. Pour résoudre ce problème, j'ai dû réduire la distance entre les deux rails. J'ai donc d'abord élargi les fentes des tubes, puis j'ai fait des fentes perpendiculaires à travers les tubes, et enfin, à l'aide d'une tige filetée, j'ai fixé les deux rails de tube plus près l'un de l'autre. Après cela, les curseurs n'étaient plus desserrés et ils fonctionnaient correctement.

Cependant, à ce stade, j'ai dû démonter les rails afin d'y ajouter les autres éléments. J'ai d'abord ajouté un boulon de 5 mm sur le côté gauche des rails sur lequel je vais fixer une poulie pour la courroie de distribution horizontale, ainsi que deux autres roulements qui coulisseront sur le rail vertical gauche.

De l'autre côté droit du rail, j'ai dû fixer le moteur pas à pas pour le mouvement horizontal. J'ai d'abord fixé le moteur sur un panneau MDF de 8 mm, puis j'y ai ajouté un morceau de bois de support et j'ai également fixé la partie fendue dessus. Enfin j'ai fixé l'ensemble sur le coulisseau vertical à l'aide d'une colle à bois et de deux vis.

Ensuite, j'ai continué en ajoutant le conteneur sur le curseur horizontal. Pour cela j'ai utilisé des petits morceaux de bois que j'ai assemblés à l'aide d'une colle à bois. Une fois que j'ai eu fini avec cela, j'étais prêt à assembler le système de rails. J'ai utilisé de l'époxy dans les fentes des rails et ajouté une planche de bois supplémentaire sur le côté des rails pour rendre l'ensemble du système de rails plus rigide.

À l'étape suivante, j'ai inséré l'assemblage entre les rails verticaux et je les ai également fixés en place. Le résultat final des curseurs et du système de rails s'est avéré excellent.

J'ai continué avec l'installation de la courroie de distribution horizontale. J'ai mesuré la longueur dont j'avais besoin, je l'ai coupé à la bonne taille et je l'ai fixé au curseur à l'aide d'une attache zippée. En ce qui concerne le curseur vertical, j'ai fixé le moteur pas à pas sur le dessus de la machine à l'aide d'un morceau de MDF et de quelques boulons. En bas, j'ai attaché la poulie et installé de la même manière la courroie de distribution.

Unités de décharge

Ensuite, je suis passé à l'unité de déchargement des articles. J'ai fabriqué une bobine hélicoïdale à partir d'un fil métallique de 3 mm en l'enroulant autour d'une bombe de peinture en aérosol de 7 cm de diamètre.

Après cela, à l'aide d'un pistolet à colle, je l'ai fixé à un servomoteur à rotation continue.

Panneau avant

Vient ensuite le panneau de la porte d'entrée que j'ai attaché au distributeur automatique à l'aide de simples charnières, et pour le verrouiller, j'ai utilisé un loquet de porte magnétique. Ensuite, j'ai utilisé un acrylique de 5 mm pour couvrir la grande ouverture avant, tandis que pour la plus petite ouverture sur le côté droit, j'ai utilisé une plaque d'aluminium très étain. Ici, j'ai fait 4 trous pour les boutons, ainsi que des ouvertures pour les pièces et l'écran LCD. J'ai utilisé une perceuse et une scie à métaux pour les fabriquer. Une fois que j'ai fixé les pièces électroniques à la plaque en aluminium, je les ai ensuite fixées au panneau de porte avant à l'aide de boulons de 5 mm.

Pour positionner le transporteur à sa position de départ j'ai installé deux micro-interrupteurs et pour les pièces j'ai collé un guide qui guidera la pièce pour qu'elle glisse vers le bas de la machine.

Le détecteur de pièces est un simple capteur de proximité infrarouge, donc lorsqu'une pièce passera près de lui, le capteur nous donnera une rétroaction positive.

Schéma du circuit

Vient ensuite la partie amusante, connectant tous les composants électroniques à la carte Arduino. Voici le schéma de circuit complet pour ce projet de distributeur automatique de bricolage.

Nous avons donc besoin d'une alimentation 12V, avec au moins 2 ampères. Nous avons besoin du 12V pour les deux moteurs pas à pas, ainsi que des bandes lumineuses à LED que je fixerai plus tard sur la porte d'entrée. Cependant, pour tous les autres composants, nous avons besoin de 5V, j'ai donc utilisé un convertisseur abaisseur pour réduire le 12V à 5V. Les servomoteurs à rotation continue DS04-NFC sont alimentés en 5V et contrôlés via des signaux PWM provenant de la carte Arduino, tandis que les moteurs pas à pas sont contrôlés via les pilotes A4988. Les quatre boutons et les deux micro-interrupteurs sont connectés à la masse et aux broches numériques Arduino, donc en utilisant les résistances de rappel internes de la carte Arduino, nous pouvons facilement détecter quand ils sont pressés.

Vous pouvez obtenir les composants nécessaires pour ce didacticiel Arduino à partir des liens ci-dessous :

Convertisseur abaisseur DC-DC LM2596 …………..
LCD 16×2 …………………………………………………..
Servomoteur continu à 360 degrés…
Moteur pas à pas NEMA 17 ……………………….
A4988 Pilote de moteur pas à pas ……………….
Capteur de proximité infrarouge ………………………………..
Boutons …………………………………………………….
Micro-interrupteur de fin de course ………………………………….
Carte Arduino …………………………………………

J'ai connecté les composants électroniques à l'aide de quelques câbles de démarrage. C'est devenu un peu désordonné avec autant de fils, mais tout a fonctionné correctement. À la fin, j'ai attaché deux bandes lumineuses LED sur le panneau de porte pour éclairer l'intérieur du distributeur automatique.

Code Arduino

Il ne reste plus qu'à programmer l'Arduino et voici le code que j'ai créé pour ce projet. En dessous, il y a une description du code.

/*     DIY Vending Machine - Arduino based Mechatronics Project

    by Dejan Nedelkovski, www.HowToMechatronics.com

*/

#include <LiquidCrystal.h> // includes the LiquidCrystal Library
#include <Servo.h>

LiquidCrystal lcd(27, 26, 25, 24, 23, 22); // Creates an LC object. Parameters: (rs, enable, d4, d5, d6, d7)
Servo servo1, servo2, servo3, servo4;   // DS04-NFC motors

// Stepper motors pins
#define dirPinVertical 0
#define stepPinVertical 1
#define dirPinHorizontal 2
#define stepPinHorizontal 3

#define coinDetector 9

#define button1 13
#define button2 12
#define button3 11
#define button4 10

#define microSwitchV 15
#define microSwitchH 14

int buttonPressed;

void setup() {
  lcd.begin(16, 2); // Initializes the interface to the LCD screen, and specifies the dimensions (width and height) of the display

  servo1.attach(4);
  servo2.attach(5);
  servo3.attach(6);
  servo4.attach(7);

  pinMode(dirPinVertical, OUTPUT);
  pinMode(stepPinVertical, OUTPUT);
  pinMode(dirPinHorizontal, OUTPUT);
  pinMode(stepPinHorizontal, OUTPUT);

  pinMode(coinDetector, INPUT);

  // Activating the digital pins pull up resistors
  pinMode(button1, INPUT_PULLUP);
  pinMode(button2, INPUT_PULLUP);
  pinMode(button3, INPUT_PULLUP);
  pinMode(button4, INPUT_PULLUP);

  pinMode(microSwitchV, INPUT_PULLUP);
  pinMode(microSwitchH, INPUT_PULLUP);

  // Vertical starting position
  digitalWrite(dirPinVertical, HIGH); // Set the stepper to move in a particular direction
  while (true) {
    if (digitalRead(microSwitchV) == LOW) { // If the micro switch is pressed, move the platfor a little bit up and exit the while loop
      moveUp(70);
      break;
    }
    // Move the carrier up until the micro switch is pressed
    digitalWrite(stepPinVertical, HIGH);
    delayMicroseconds(300);
    digitalWrite(stepPinVertical, LOW);
    delayMicroseconds(300);
  }
  // Horizontal starting position
  digitalWrite(dirPinHorizontal, LOW);
  while (true) {
    if (digitalRead(microSwitchH) == LOW) {
      moveLeft(350);
      break;
    }
    digitalWrite(stepPinHorizontal, HIGH);
    delayMicroseconds(300);
    digitalWrite(stepPinHorizontal, LOW);
    delayMicroseconds(300);
  }
}
void loop() {
  // Print "Insert a coin!" on the LCD
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Insert a coin!");
  
  // Wait until a coin is detected
  while (true) {
    if (digitalRead(coinDetector) == LOW) { // If a coin is detected, exit the from the while loop
      break;
    }
  }
  
  delay(10);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Select your item");
  lcd.setCursor(0, 1);
  lcd.print(" 1, 2, 3 or 4?");
  
  // Wait until a button is pressed
  while (true) {
    if (digitalRead(button1) == LOW) {
      buttonPressed = 1;
      break;
    }
    if (digitalRead(button2) == LOW) {
      buttonPressed = 2;
      break;
    }
    if (digitalRead(button3) == LOW) {
      buttonPressed = 3;
      break;
    }
    if (digitalRead(button4) == LOW) {
      buttonPressed = 4;
      break;
    }
  }
  
  // Print "Delivering..." 
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Delivering...");
  
  // Depending on the pressed button, move the carrier to that position and discharge the selected item 
  switch (buttonPressed) {
    case 1:
      // Move the container to location 1
      moveUp(4900); // Move up 4900 steps (Note: the stepper motor is set in Quarter set resolution)
      delay(200);
      moveLeft(1700); // Move left 1700 steps
      delay(300);
      // Rotate the helical coil, discharge the selected item
      servo1.writeMicroseconds(2000); // rotate
      delay(950);
      servo1.writeMicroseconds(1500);  // stop
      delay(500);
      // Move the container back to starting position
      moveRight(1700);
      delay(200);
      moveDown(4900);
      break;
      
     case 2:
      // Move the container to location 2
      moveUp(4900);
      delay(200);
      // Rotate the helix, push the selected item
      servo2.writeMicroseconds(2000); // rotate
      delay(950);
      servo2.writeMicroseconds(1500);  // stop
      delay(500);
      moveDown(4900);
      break;

      case 3:
      // Move the container to location 3
      moveUp(2200); 
      delay(200);
      moveLeft(1700);
      delay(300);
      // Rotate the helix, push the selected item
      servo3.writeMicroseconds(2000); // rotate
      delay(950);
      servo3.writeMicroseconds(1500);  // stop
      delay(500);
      // Move the container back to starting position
      moveRight(1700);
      delay(200);
      moveDown(2200);
      break;

      case 4:
      // Move the container to location 4
      moveUp(2200); // Move verticaly 4800 steps
      delay(200);
      // Rotate the helix, push the selected item
      servo4.writeMicroseconds(2000); // rotate
      delay(950);
      servo4.writeMicroseconds(1500);  // stop
      delay(500);
      moveDown(2200);
      break;
  }
  
  lcd.clear(); // Clears the display
  lcd.setCursor(0, 0);
  lcd.print("Item delivered!"); // Prints on the LCD
  delay(2000);
}

// == Custom functions ==

void moveUp (int steps) {
  digitalWrite(dirPinVertical, LOW);
  for (int x = 0; x < steps; x++) {
    digitalWrite(stepPinVertical, HIGH);
    delayMicroseconds(300);
    digitalWrite(stepPinVertical, LOW);
    delayMicroseconds(300);
  }
}
void moveDown (int steps) {
  digitalWrite(dirPinVertical, HIGH);
  for (int x = 0; x < steps; x++) {
    digitalWrite(stepPinVertical, HIGH);
    delayMicroseconds(300);
    digitalWrite(stepPinVertical, LOW);
    delayMicroseconds(300);
  }
}
void moveLeft (int steps) {
  digitalWrite(dirPinHorizontal, HIGH);
  for (int x = 0; x < steps; x++) {
    digitalWrite(stepPinHorizontal, HIGH);
    delayMicroseconds(300);
    digitalWrite(stepPinHorizontal, LOW);
    delayMicroseconds(300);
  }
}
void moveRight (int steps) {
  digitalWrite(dirPinHorizontal, LOW);
  for (int x = 0; x < steps; x++) {
    digitalWrite(stepPinHorizontal, HIGH);
    delayMicroseconds(300);
    digitalWrite(stepPinHorizontal, LOW);
    delayMicroseconds(300);
  }
}Code language: Arduino (arduino)

Explication du code source

Nous devons d'abord inclure les bibliothèques Servo et LiquidCrystal, définir les broches LCD, les quatre servomoteurs, les broches des moteurs pas à pas, le détecteur de pièces ainsi que les quatre boutons et les deux micro-interrupteurs.

Dans la section de configuration, nous définissons les modes de broche pour chacune des broches mentionnées ci-dessus. Nous pouvons noter que pour les boutons et les broches des micro-interrupteurs, nous avons activé les résistances de rappel internes. Cela signifie que le niveau logique de ces broches sera tout le temps ÉLEVÉ, et une fois que nous les aurons pressées, le niveau logique tombera à BAS.

Avant d'entrer dans la boucle principale, nous réglons également le transporteur à sa position de départ qui est définie par les deux micro-interrupteurs. Ainsi, avec la boucle while, nous continuons à déplacer le chariot vers sa position de départ et une fois que les deux micro-interrupteurs seront enfoncés, les moteurs s'arrêteront et se déplaceront vers la position de départ souhaitée.

// Vertical starting position
  digitalWrite(dirPinVertical, HIGH); // Set the stepper to move in a particular direction
  while (true) {
    if (digitalRead(microSwitchV) == LOW) { // If the micro switch is pressed, move the platfor a little bit up and exit the while loop
      moveUp(70);
      break;
    }
    // Move the carrier up until the micro switch is pressed
    digitalWrite(stepPinVertical, HIGH);
    delayMicroseconds(300);
    digitalWrite(stepPinVertical, LOW);
    delayMicroseconds(300);
  }
  // Horizontal starting position
  digitalWrite(dirPinHorizontal, LOW);
  while (true) {
    if (digitalRead(microSwitchH) == LOW) {
      moveLeft(350);
      break;
    }
    digitalWrite(stepPinHorizontal, HIGH);
    delayMicroseconds(300);
    digitalWrite(stepPinHorizontal, LOW);
    delayMicroseconds(300);
  }Code language: Arduino (arduino)

Dans le programme principal, commencez par imprimer sur l'écran LCD le message « Insérez une pièce ». Ensuite, nous restons coincés dans la boucle while. Une fois que vous insérez une pièce et qu'elle passe près du capteur de proximité, l'état logique de la broche du détecteur de pièces tombera à LOW et dans ce cas, nous sortirons de la boucle while en utilisant l'instruction break.

// Wait until a coin is detected
  while (true) {
    if (digitalRead(coinDetector) == LOW) { // If a coin is detected, exit the from the while loop
      break;
    }
  }Code language: Arduino (arduino)

Ensuite, nous imprimons le message "Sélectionnez votre article" et nous restons bloqués dans une autre boucle while.

// Wait until a button is pressed
  while (true) {
    if (digitalRead(button1) == LOW) {
      buttonPressed = 1;
      break;
    }
    if (digitalRead(button2) == LOW) {
      buttonPressed = 2;
      break;
    }
    if (digitalRead(button3) == LOW) {
      buttonPressed = 3;
      break;
    }
    if (digitalRead(button4) == LOW) {
      buttonPressed = 4;
      break;
    }
  }Code language: Arduino (arduino)

Cette boucle while attend que nous appuyions sur l'un des quatre boutons, et une fois que nous l'avons fait, nous en sortons et imprimons le message "Delivering".

Maintenant, en fonction du bouton enfoncé, nous exécutons une fois les cas dans l'instruction switch. Si nous avons appuyé sur le premier bouton, le transporteur commencera à monter en utilisant la fonction personnalisée "moveUp()".

switch (buttonPressed) {
    case 1:
      // Move the container to location 1
      moveUp(4900); // Move up 4900 steps (Note: the stepper motor is set in Quarter set resolution)
      delay(200);
      moveLeft(1700); // Move left 1700 steps
      delay(300);
      // Rotate the helical coil, discharge the selected item
      servo1.writeMicroseconds(2000); // rotate
      delay(950);
      servo1.writeMicroseconds(1500);  // stop
      delay(500);
      // Move the container back to starting position
      moveRight(1700);
      delay(200);
      moveDown(4900);
      break;
}Code language: Arduino (arduino)

Si nous jetons un coup d'œil à cette fonction, nous pouvons voir qu'elle configure simplement le moteur pas à pas pour qu'il se déplace dans une direction particulière et effectue le nombre de pas que nous avons entré en tant qu'argument.

void moveUp (int steps) {
  digitalWrite(dirPinVertical, LOW);
  for (int x = 0; x < steps; x++) {
    digitalWrite(stepPinVertical, HIGH);
    delayMicroseconds(300);
    digitalWrite(stepPinVertical, LOW);
    delayMicroseconds(300);
  }
}Code language: Arduino (arduino)

Nous pouvons noter ici que j'ai configuré le pilote pas à pas A4988 pour qu'il fonctionne en résolution d'un quart de pas, et avec quelques dégustations, j'ai conclu qu'il me fallait 4900 pas pour que le support atteigne la position supérieure. De la même manière, nous déplaçons le transporteur vers la gauche jusqu'à ce qu'il atteigne l'emplacement numéro 1.

Juste après cela, nous faisons tourner le moteur à rotation continue pendant 950 millisecondes afin que la bobine hélicoïdale fasse un cycle complet.

// Rotate the helical coil, discharge the selected item
      servo1.writeMicroseconds(2000); // rotate
      delay(950);
      servo1.writeMicroseconds(1500);  // stopCode language: Arduino (arduino)

Notez ici que ces valeurs peuvent parfois varier et dépendent du moteur lui-même. En utilisant les fonctions personnalisées moveRight() et moveDown(), nous ramenons le porteur à la position de départ. De la même manière, nous pouvons décharger n'importe lequel des quatre éléments.

À la fin, nous imprimons simplement le message "Article livré".

C'est donc aussi simple que cela, et j'espère que vous avez apprécié cette vidéo et appris quelque chose de nouveau. N'hésitez pas à poser des questions dans la section des commentaires ci-dessous et à consulter ma collection de projets Arduino.

Machine à cintrer les fils Arduino 3D Projet de système de sécurité et d'alarme Arduino