DIY Vending Machine - Mechatronica-project op basis van Arduino

In dit project zullen we leren hoe we een op Arduino gebaseerde doe-het-zelf-automaat kunnen maken. Ik zal je het hele proces van het bouwen laten zien, te beginnen met het snijden en monteren van de MDF-platen, tot het verbinden van alle elektronische onderdelen en het schrijven van de Arduino-code.

Je kunt de volgende video bekijken of de schriftelijke tutorial hieronder lezen.

Overzicht

De automaat heeft vier loseenheden die worden bestuurd via vier continu draaiende servomotoren, een draagsysteem dat wordt bestuurd via stappenmotoren, een LCD-scherm, vier knoppen voor het selecteren van een item en een muntdetector.

Nu denk je misschien dat de itemdrager niet zo handig is voor deze automaat, en ja, je hebt waarschijnlijk gelijk. Maar mijn idee hier was om dit project interessanter of een beetje complexer te maken, zodat je meer nieuwe dingen kunt leren. Ik denk dat dit projectidee geweldig kan zijn voor studenten elektronica of mechatronica die overwegen er een te bouwen als hun laatste jaarproject, evenals voor Arduino-enthousiastelingen.

De automaat bouwen

Ik begon met het op maat zagen van de 8 mm dikke MDF-plaat.

Ik heb eerder een 3D-model gemaakt van de machine waar ik alle metingen vandaan heb gehaald.

U kunt dit 3D-model vinden en downloaden, en het ook verkennen in uw browser op Thangs.

Voor het zagen van de MDF heb ik een cirkelzaag gebruikt. Eigenlijk is dit een zelfgemaakte werkbank met een cirkelzaag, een bovenfrees en een decoupeerzaag, gemaakt door mijn partner Marija en er is een DIY-video voor op haar YouTube-kanaal Creativity Hero.

Nadat ik alle panelen met de cirkelzaag had gesneden, ging ik verder met het maken van de openingen in sommige panelen met behulp van de omgekeerde decoupeerzaag.

Voor de vorige stap kan zelfs een decoupeerzaag worden gebruikt als u geen cirkelzaag heeft. Ik heb de decoupeerzaag ook gebruikt voor het zagen van de kleinere onderdelen die verschillende sneden hadden. Houd er echter rekening mee dat dit gevaarlijke machines zijn, dus u moet heel voorzichtig zijn bij het gebruik ervan.

Toen ik alle MDF-onderdelen klaar had, begon ik ze in elkaar te zetten met wat houtlijm en schroeven. Voor het bevestigen van de panelen heb ik 90 graden hoekklemmen gebruikt. Met behulp van een accuboormachine heb ik eerst geleidegaten gemaakt, daarna wasbakken gemaakt en de 3 mm-schroeven op hun plaats geschroefd. Ik heb dezelfde methode gebruikt om alle panelen te monteren en voor sommige heb ik ook enkele F-klemmen gebruikt.

Spoorsysteem

Op dit punt van de montage ga ik verder met het maken van het railsysteem. Ik gebruik daarvoor aluminium buizen die ik met een metalen handzaag op maat zaag. De diameter van de buis voor de horizontale rail is 16 mm, terwijl de diameter voor de verticale rail 20 mm is. Op massieve houten planken van 18 mm heb ik sleuven voor de buizen gemaakt met een Forstner-bit en vervolgens de buizen eraan bevestigd.

De horizontale rail is gemaakt van twee 27 cm lange buizen, terwijl de verticale rail is gemaakt van drie 45 cm lange buizen.

De volgende zijn de schuifregelaars en hier is hoe ik ze heb gemaakt. Ik gebruikte een houten bord van 21 bij 21 cm waarop ik gaten van 8 mm maakte.

Vervolgens heb ik 8 mm draadstangen door deze gaten gestoken en met behulp van ringen en moeren heb ik de 22 mm lagers vastgezet. Wat betreft de horizontale schuif, ik heb dezelfde methode gebruikt, maar met kleinere lagers met een buitendiameter van 16 mm.

Nadat ik de slider tussen de buisrails had gestoken, merkte ik dat deze een beetje los zat. Om dit probleem op te lossen moest ik de afstand tussen de twee rails verkleinen. Dus eerst heb ik de buissleuven vergroot, daarna loodrechte gleuven door de buizen gemaakt en uiteindelijk met behulp van een draadstang de twee buisrails dichter bij elkaar bevestigd. Hierna zaten de schuiven niet meer los en werkten ze naar behoren.

Op dit punt moest ik echter de rails demonteren om de andere elementen eraan toe te voegen. Eerst heb ik een bout van 5 mm aan de linkerkant van de rails toegevoegd waarop ik een katrol voor de horizontale distributieriem zal bevestigen, evenals twee andere lagers die op de linker verticale rail zullen schuiven.

Aan de andere rechterkant van de rail moest ik de stappenmotor bevestigen voor de horizontale beweging. Eerst heb ik de motor op een MDF-plaat van 8 mm vastgemaakt, er vervolgens een ondersteunend stuk hout aan toegevoegd en ook het gleufgedeelte eraan vastgemaakt. Uiteindelijk heb ik dit hele geheel op de verticale schuif bevestigd met houtlijm en twee schroeven.

Vervolgens ging ik verder met het toevoegen van de container op de horizontale schuifregelaar. Daarvoor heb ik wat kleine stukjes hout gebruikt die ik met houtlijm aan elkaar heb geplakt. Toen ik hiermee klaar was, was ik klaar om het railsysteem te monteren. Ik heb wat epoxy in de railsleuven gebruikt en een extra houten plank aan de zijkant van de rails toegevoegd om het hele railsysteem stijver te maken.

In de volgende stap heb ik het geheel tussen de verticale rails gestoken en ook op hun plaats vastgezet. Het eindresultaat van de sliders en het railsysteem bleek uitstekend te werken.

Ik ging verder met het installeren van de horizontale distributieriem. Ik mat de lengte die ik nodig had, knipte het op maat en bevestigde het aan de schuif met een ritssluiting. Wat betreft de verticale schuif, ik heb de stappenmotor op de bovenkant van de machine bevestigd met behulp van een stuk MDF en enkele bouten. Onderaan heb ik de poelie bevestigd en op dezelfde manier de distributieriem gemonteerd.

Afvoereenheden

Vervolgens ging ik verder met de eenheid voor het lossen van artikelen. Ik heb een spiraalvormige spoel gemaakt van 3 mm dik metaaldraad door het om een ​​spuitbus met een diameter van 7 cm te wikkelen.

Daarna heb ik het met een lijmpistool vastgemaakt aan een servomotor met continue rotatie.

Voorpaneel

Het volgende is het voordeurpaneel dat ik met eenvoudige scharnieren aan de automaat heb bevestigd en voor het vergrendelen heb ik een magnetische deurvanger gebruikt. Daarna gebruikte ik een 5 mm tick acryl om de grote opening aan de voorkant af te dekken, terwijl ik voor de kleinere opening aan de rechterkant een zeer tinnen aluminium plaat gebruikte. Hier heb ik 4 gaten gemaakt voor de knoppen, evenals openingen voor de munten en het LCD-scherm. Ik heb een boormachine en een zaag gebruikt om ze te maken. Nadat ik de elektronische onderdelen op de aluminium plaat had bevestigd, heb ik ze vervolgens aan het voordeurpaneel bevestigd met bouten van 5 mm.

Om de drager in de uitgangspositie te plaatsen, heb ik twee microschakelaars geïnstalleerd en voor de munten heb ik een geleider gelijmd die de munt naar de bodem van de machine zal schuiven.

De muntdetector is een eenvoudige infrarood-nabijheidssensor, dus als er een munt in de buurt komt, geeft de sensor ons een positieve feedback.

Circuitschema

Vervolgens komt het leuke gedeelte, het aansluiten van alle elektronische componenten op het Arduino-bord. Hier is het volledige schakelschema voor dit doe-het-zelf-automaatproject.

We hebben dus een 12V-voeding nodig, met minimaal 2 ampère. We hebben de 12V nodig voor de twee stappenmotoren, evenals de LED-stripverlichting die ik later op de voordeur zal bevestigen. Voor alle andere componenten hebben we echter 5V nodig, dus daarom heb ik een buck-converter gebruikt om de 12V naar 5V te verlagen. De DS04-NFC continu-rotatie servomotoren worden aangedreven met 5V en bestuurd via PWM-signalen afkomstig van het Arduino-bord, terwijl de stappenmotoren worden bestuurd via de A4988-stuurprogramma's. De vier knoppen en de twee microschakelaars zijn verbonden met Ground en de Arduino digitale pinnen, dus met behulp van de interne pull-up weerstanden van het Arduino-bord kunnen we gemakkelijk detecteren wanneer ze worden ingedrukt.

U kunt de benodigde componenten voor deze Arduino-zelfstudie verkrijgen via de onderstaande links:

• DC-DC LM2596 Buck-converter …………..
• 16×2 LCD ………………………………………………..
• 360 graden continue servomotor …
• Stappenmotor NEMA 17 ……………………….
• A4988 Stappenmotorstuurprogramma ……………….
• IR-nabijheidssensor ……………………………..
• Knoppen …………………………………………………….
• Micro-eindschakelaar ………………………………….
• Arduino-bord …………………………………………

Ik heb de elektronische componenten aangesloten met behulp van enkele springdraden. Het werd een beetje rommelig met zoveel draden maar alles werkte naar behoren. Aan het einde heb ik twee LED-lichtstrips op het deurpaneel bevestigd om de binnenkant van de automaat te verlichten.

Arduino-code

Wat nu overblijft is het programmeren van de Arduino en hier is de code die ik voor dit project heb gemaakt. Hieronder staat een beschrijving van de 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)

Uitleg broncode

Eerst moeten we de Servo- en LiquidCrystal-bibliotheken opnemen, de LCD-pinnen, de vier servomotoren, de stappenmotorpinnen, de muntdetector en de vier knoppen en de twee microschakelaars definiëren.

In de setup-sectie stellen we de pin-modi in voor elk van de bovengenoemde pins. We kunnen opmerken dat we voor de knoppen en de pinnen van de microschakelaars de interne pull-up-weerstanden hebben geactiveerd. Dit betekent dat het logische niveau op deze pinnen altijd HOOG zal zijn, en zodra we erop drukken, zal het logische niveau naar LAAG zakken.

Voordat we de hoofdlus ingaan, zetten we ook de drager in de startpositie die wordt bepaald door de twee microschakelaars. Dus met de while-lus blijven we de drager naar de startpositie verplaatsen en zodra de twee microschakelaars worden ingedrukt, stoppen de motoren en gaan ze naar de gewenste startpositie.

// 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)

In het hoofdprogramma begint u door op het LCD-scherm de melding “Plaats een munt” af te drukken. Dan komen we vast te zitten in de while-lus. Zodra een munt is ingebracht en deze in de buurt van de nabijheidssensor komt, zal de logische status bij de muntdetectorpin dalen tot LAAG en in dat geval zullen we uit de while-lus komen met behulp van de break-instructie.

// 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)

Dan printen we het bericht "Selecteer je item" en we komen vast te zitten in een andere while-lus.

// 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)

Deze while-lus wacht tot we op een van de vier knoppen drukken, en zodra we dat doen, komen we eruit en drukken we het bericht "Bezorgen" af.

Nu, afhankelijk van de ingedrukte knop, voeren we één van de gevallen in de switch-instructie uit. Als we op de eerste knop hebben gedrukt, begint de koerier omhoog te gaan met behulp van de op maat gemaakte "moveUp()" -functie.

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)

Als we naar deze functie kijken, kunnen we zien dat deze de stappenmotor eenvoudig in een bepaalde richting zet en het aantal stappen maakt dat we als argument hebben ingevoerd.

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)

We kunnen hier opmerken dat ik de A4988-stappendriver heb ingesteld om te werken in een resolutie van een kwartstap, en met wat proeven kwam ik tot de conclusie dat ik 4900 stappen nodig had om de drager in de bovenste positie te krijgen. Op een vergelijkbare manier verplaatsen we de drager naar links totdat deze het locatienummer 1 bereikt.

Meteen daarna draaien we de continu-rotatiemotor 950 milliseconden zodat de spiraal een volledige cyclus maakt.

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

Houd er rekening mee dat deze waarden soms kunnen variëren en afhankelijk zijn van de motor zelf. Met behulp van de aangepaste functies moveRight() en moveDown() brengen we de drager terug naar de startpositie. Op dezelfde manier kunnen we elk van de vier items ontladen.

Aan het einde printen we gewoon het bericht "Artikel afgeleverd".

Zo simpel is het dus, en ik hoop dat je deze video leuk vond en iets nieuws hebt geleerd. Stel gerust een vraag in de opmerkingen hieronder en bekijk mijn Arduino Projects-collectie.