Arduino Ant Hexapod-robot

In deze tutorial laat ik je zien hoe ik een Arduino hexapod heb gebouwd. Zoals de naam al doet vermoeden, heeft de hexapod 6 poten maar daarnaast heeft hij ook een staart of buik, een kop, antennes, kaken en zelfs functionele ogen. Dit alles zorgt ervoor dat de hexapod eruitziet als een mier, daarom kunnen we het ook een Arduino Ant Robot noemen.

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

Overzicht

Voor het besturen van de robot heb ik een op maat gemaakte Android applicatie gemaakt. De app heeft 4 knoppen waarmee we de robot kunnen opdracht geven om vooruit of achteruit te gaan, maar ook om naar links of rechts te draaien. Naast deze hoofdfuncties kan de robot ook zijn kop en staart bewegen, maar ook bijten, dingen grijpen en laten vallen en zelfs aanvallen.

Zoals ik eerder al zei, heeft de robot functionele ogen, of ik heb de kop specifiek ontworpen voor een ultrasone sensor. Dus als we proberen de robotkop aan te raken of onze hand dicht bij de sensor te krijgen, zal de robot zich in eerste instantie voorbereiden op een aanval.

Als we teruggaan, zal de robot de aanval afwijzen, maar als we onze hand dichterbij krijgen, zal hij ons aanvallen en bijten. Dus hoe cool is dat? Blijf in de buurt en je zult precies ontdekken hoe ik het bouw en hoe alles werkt.

Arduino Hexapod - Ant Robot 3D-model

Zoals gewoonlijk begon ik met het ontwerpen van de hexapod met behulp van 3D-modelleringssoftware. De hexapod heeft 6 poten en elk bestaat uit 3 gewrichten of 3 servo's. Dat betekent dat we in totaal 18 servo's nodig hebben en in mijn geval heb ik de MG996R-servo's gebruikt.

Aan de achterkant hebben we de staart die wordt aangedreven door een andere MG996R-servo. De kop van deze mierenrobot heeft twee vrijheidsgraden, of hij kan rollen en kantelen, en opnieuw wordt hij aangedreven door nog twee servo's. We hebben dus in totaal 21 servo's nodig voor dit project, type MG996R en daarnaast nog een kleinere SG90 microservo voor de onderkaken.

Hier hebben we ook de ogen van de mier die zijn ontworpen om op een HC-SR04 ultrasone sensor te passen. Alle onderdelen zijn gemonteerd tussen twee platen en bovendien heb ik een interessante gebogen afdekking voor de bovenplaat gemaakt om alle bedrading, de Arduino en de batterij tussen de twee platen te verbergen.

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

STL-bestanden:

3D-printen van de onderdelen

Ik denk dat je al weet wat de toekomst biedt, en dat is het 3D-printen van de robotonderdelen. Ik gebruikte de Creality CR-10 3D-printer voor alle afdrukken en het deed geweldig werk. Het moeilijkste om af te drukken was de kop, omdat ik een enkele afdruk wilde zijn.

Voor dat doel moest ik een steunoverhanghoek van 60 graden gebruiken, evenals enkele steunblokkers. Hoe dan ook, de Creality CR-10 heeft geweldig werk geleverd en de kop is perfect geworden.

De Arduino Hexapod in elkaar zetten

Zodra we alle onderdelen hebben afgedrukt, kunnen we doorgaan met het monteren van de hexapod. Ik ben begonnen met het monteren van de poten. Voor het bevestigen van de servo's aan de geprinte delen heb ik M3-bouten en -moeren gebruikt, evenals veerringen. De lengte van de bouten moet minimaal 12 mm zijn en in mijn geval heb ik 16 mm lange bouten gebruikt.

We hebben ongeveer 200 bouten nodig voor de hele montage. Om de schakels met elkaar te verbinden gebruiken we de ronde hoorns die als accessoires bij het servopakket worden geleverd. We moeten echter in elk ervan gaten van 3 mm boren zodat de bouten er doorheen kunnen, of we kunnen metalen ronde hoorns gebruiken met M3-schroefdraad en apart verkrijgbaar.

Bij het vastzetten van de links naar de servo's moeten we ervoor zorgen dat we ze altijd op dezelfde positie aansluiten en dat ze het volledige bewegingsbereik hebben.

We moeten hier opmerken dat de servo's een kleine driehoekige steun aan de bovenzijde hebben die verwijderd moet worden. Ik heb daarvoor een eenvoudig mes gebruikt, dus op die manier kunnen de servo's flitsend worden geplaatst met de afgedrukte delen. Voordat we de derde servo op zijn plaats plaatsen, moeten we eerst een M4-bout plaatsen die zal worden gebruikt om de poot met de grondplaat te verbinden.

Hier is hoe de pootmontage eruit zou moeten zien. Het is eigenlijk heel eenvoudig om het in elkaar te zetten, maar nu hebben we er nog vijf nodig.

Zodra we alle poten klaar hebben, kunnen we doorgaan met het installeren ervan op het lichaam van de robot, of de twee platen. Eerst moeten we de ronde hoorns op het bovenste platform bevestigen met dezelfde methode als eerder, met M3-bouten en moeren. Dan kunnen we ze eenvoudig met de bouten op de servo-assen aansluiten, maar voordat we dat doen, moeten we de positie van de servo's precies in het midden aanpassen.

Dit is nodig zodat we het volledige bewegingsbereik van de servo's kunnen krijgen en ook het aanpassings- of kalibratieproces bij het programmeren van de Arduino kunnen verminderen.

Na het vastzetten van de poten begon dit project al vorm te krijgen en eruit te zien als een hexapod.

Er is nog een ronde hoorn aan de achterkant en dat is voor de staartservo die ook op dit punt moet worden vastgezet.

Vervolgens moeten we de hexapod ondersteboven plaatsen, zodat we de bodemplaat door de M4-bouten van de poten kunnen steken. Daarna heb ik de poten eraan vastgemaakt met behulp van enkele gewone ringen en zelfborgende moeren. We moeten voorzichtig zijn met hoeveel we deze bouten aandraaien, omdat dit eigenlijk de scharnierverbindingen zijn en de poten ook moeten kunnen draaien terwijl ze voldoende stevig zijn.

Vervolgens moeten we de eerste servo voor het hoofd installeren en dat is voor de rolbeweging. Deze servo moet loodrecht op de basisplaten worden geplaatst, daarom heb ik twee kleine plaatjes gemaakt die eerst op de servo worden vastgezet. Dan kunnen we de servo tussen de twee platen plaatsen en kunnen we hem gemakkelijk vastzetten met de M3-bouten en moeren.

Dan hebben we een U-vormige beugel en hier moeten we twee ronde hoorns bevestigen voor het aansluiten van de twee servo's voor de kop. Voordat we de beugel aan de rolservo bevestigen, moeten we ervoor zorgen dat de servo in het midden staat, zodat deze 90 graden in beide richtingen kan draaien.

De volgende is de kantelservobeugel. Dus hier moeten we eerst een M4-bout plaatsen en deze aan de U-vormige beugel bevestigen. Voordat we de kantelmotor monteren, moeten we ook vier M3-bouten plaatsen die later zullen worden gebruikt voor het vastzetten van de kop. Vervolgens kunnen we de kantelservo in de beugel plaatsen en de as voorzichtig op de ronde hoorn monteren. Het is hier een beetje krap, maar de U-vormige beugel kan een beetje buigen.

Ten slotte moeten we de servo met de M3-bouten vastzetten en daarmee is het kopmechanisme voltooid. Nu kan hij zowel rollen als kantelen.

Voordat we de kop aan het mechanisme bevestigen, moeten we deze vooraf monteren, of de onderkaken bevestigen met de kleine SG90-servo en de ultrasone sensor. Ook hier is het een beetje krap, maar het is me toch gelukt om de eerste onderkaak in te brengen en aan het hoofd te bevestigen met een M4-bout.

Je kunt zien dat er een klein gaatje is bij de ogen dat speciaal is ontworpen zodat we door een schroevendraaier kunnen gaan om de bout vast te draaien.

Vervolgens gaat de microservo op zijn plaats en wordt deze met twee schroeven vastgezet. Op de tweede onderkaak moeten we eerst een kleine armhoorn voor de SG90-servo bevestigen.

Vervolgens kunnen we de onderkaak op zijn plaats plaatsen, de twee tandwielen koppelen en met een schroevendraaier aan de motoras bevestigen.

Vervolgens kunnen we de ultrasone sensor plaatsen. De ooggaten zijn precies zo gemaakt dat ze op de ultrasone sensor passen, dus ik heb gewoon een paar druppels AC-lijm gebruikt om de sensor aan het hoofd te bevestigen.

Er moet nog een detail aan de kop worden toegevoegd en dat zijn de antennes. Voor dat doel heb ik 3 mm tekendraad gebruikt, die ik ongeveer 13 cm lang heb geknipt en licht gebogen om de gewenste vorm te krijgen. Opnieuw gebruikte ik een paar druppels AC-lijm om ze aan het hoofd te bevestigen. Eindelijk kunnen we de kop aan het rol- en kantelmechanisme bevestigen met de vier bouten die we eerder hebben geplaatst.

Het hoofd is nu volledig functioneel, het kan rollen, kantelen en zelfs bijten. Er moeten nog twee 3D-geprinte onderdelen worden geïnstalleerd. Dat is de staart die eenvoudig in de staartbeugel kan schuiven en de gebogen kap die we aan het einde daadwerkelijk zullen gebruiken om de elektronica te bedekken. Dit is dus de laatste verschijning van onze mierenrobot en ik vind het erg leuk hoe hij is geworden in deze blauw-witte kleurencombinatie.

Arduino Ant Robot-schakelschema

Oké, nu kunnen we verder met de elektronica. Hier is het schakelschema van dit project, dat eigenlijk eenvoudig is, hoewel het er een beetje ingewikkeld uitziet vanwege de vele servo-aansluitingen.

Naast de 22 servo's hebben we een HC-05 Bluetooth-module nodig voor de smartphone-communicatie en enkele condensatoren en weerstanden. Het brein van de robot is natuurlijk een Arduino-bord, en in dit geval is dat de Arduino Mega omdat het het enige bord is dat meer dan 12 servo's kan besturen met behulp van de servo-bibliotheek.

Gerelateerde tutorial:Hoe servomotoren werken en hoe servo's te bedienen met Arduino

Voor het aandrijven van de robot zal ik een 3S LiPo-batterij gebruiken met een spanning van ongeveer 12V. LiPo-batterijen kunnen een grotere stroomopname aan, dus ze zijn geschikt voor dit project, omdat als alle servo's tegelijkertijd bij volledige belasting worden ingeschakeld, ze ongeveer 10 ampère stroom kunnen trekken. De bedrijfsspanning van de servo's is echter beperkt van 4,8 tot 7,2 V, wat betekent dat ik een DC-DC buck-converter moet gebruiken om de 12V naar 5V te converteren. Zelfs als we een 2S LiPo-batterij gebruiken die een spanning heeft van ongeveer 7,4 V of 8,4 V wanneer deze volledig is geladen, moeten we nog steeds een buck-converter gebruiken. De buck-converter die ik voor dit project zal gebruiken, kan tot 8 ampère stroom aan, maar ik zou aanraden om er een te gebruiken van 10 tot 15A om er zeker van te zijn dat je genoeg stroom hebt en niet oververhit raakt. In mijn geval was de maximale stroomafname die ik van de robot opmerkte tijdens het rijden ongeveer 6 ampère.

U kunt de benodigde componenten voor dit project vinden via de onderstaande links:

• MG996R servomotor…………………….….
• SG90 microservomotor ……..…….….…….
• HC-05 Bluetooth-module ……………….… 
• Arduino Mega-bord ……………………….….
• 3S LiPo-batterij ……………………..………….. 
• DC-DC Buck-converter …………………….

Een PCB ontwerpen voor de Arduino Hexapod

Als we nu proberen alles met elkaar te verbinden wordt het door de vele servo-aansluitingen nogal een rommeltje. Daarom heb ik een aangepaste PCB ontworpen met behulp van de gratis EasyEDA-software voor online circuitontwerp. Deze PCB zal in feite fungeren als een Arduno Mega Shield voor de Hexapod omdat we hem direct bovenop het Arduino Mega Board kunnen aansluiten. Ik heb de servo-aansluitingen dicht bij elkaar geplaatst en ernaast twee grote condensatoren geplaatst om de spanning stabieler te houden. Ook heb ik een aansluiting voor een NRF24L01 transceiver module bijgevoegd voor het geval we de robot radiografisch willen aansturen. Er zijn meerdere digitale en analoge pin-aansluitingen, 5V- en massa-aansluitingen, twee LED-aansluitingen en een aansluiting voor het bewaken van de accuspanning. De 12V-batterijspanning gaat door een spanningsdeler bestaande uit twee weerstanden R1 en R2 die de spanning tot onder 5V zullen verlagen, zodat de analoge pin deze veilig kan lezen. Op deze manier weten we wanneer de batterij moet worden opgeladen.

Hier is een link naar de projectbestanden van dit PCB-ontwerp. Dus toen ik eenmaal klaar was met het ontwerp, genereerde ik de Gerber-bestandsbehoefte voor het vervaardigen van de PCB.

Gerber-bestand:

Toen bestelde ik de PCB bij JLCPCB, die eigenlijk de sponsor van deze video is.

Hier kunnen we eenvoudig het Gerber-bestand slepen en neerzetten en eenmaal geüpload, kunnen we onze PCB bekijken in de Gerber-viewer. Als alles in orde is, kunnen we doorgaan en de eigenschappen selecteren die we voor onze PCB willen. In dit geval heb ik de kleur van de printplaat blauw gekozen om overeen te komen met de kleur van het Arduino-bord. En dat is het, nu kunnen we eenvoudig onze PCB bestellen tegen een redelijke prijs. Houd er rekening mee dat als het uw eerste bestelling bij JLCPCB is, u tot 10 PCB's kunt krijgen voor slechts $ 2.

Na enkele dagen zijn de PCB's gearriveerd. De kwaliteit van de PCB's is geweldig en alles is precies hetzelfde als in het ontwerp.

Montage van de print

Ok, nu kunnen we verder gaan en de printplaat monteren. Ik begon met het solderen van mannelijke pin-headers op de PCB die worden gebruikt om deze op het Arduino-bord aan te sluiten. Zodra we de pin-headers aan de onderkant hebben geplaatst, kunnen we een soort plaat gebruiken om de pinnen vast te houden en het bord om te draaien. Nu moeten we ze allemaal op de PCB solderen. Als we daarmee klaar zijn, kunnen we verder met de servo-aansluitingen waarvoor we ook mannelijke pin-headers nodig hebben.

Op dit punt kunnen we de pin-headers voor alle verbindingen invoegen en dezelfde methode gebruiken om de PCB om te draaien en alle pinnen erop te solderen. Aan het einde moeten we de weerstanden, de condensatoren en de aansluitblokken solderen. En dat is alles, het Arduino Mega Shield voor onze Ant Robot is nu klaar. Nu kunnen we het eenvoudig op het Arduino-bord plaatsen.

Vervolgens moeten we de uitgangsspanning van de buck-converter instellen op 5V. Dat kunnen we doen door de potentiometer van de buck-converter aan te passen. Je kunt hier zien dat ik een aan / uit-schakelaar aan de ingang heb toegevoegd en de batterij 12V heb aangesloten op de 12V-pin op de print die alleen zal worden gebruikt voor het bewaken van de batterijspanning.

Onthoud dat de hoofdingang naar de PCB 5V moet zijn.

Dus nu kunnen we de elektronische componenten tussen de twee platen plaatsen. Wederom is het een beetje krap, maar toch kunnen we alles erin passen. Eerst gaat de batterij die ik hem heb vastgezet met een tape, en daar bovenop komt de Arduino samen met de PCB die we hebben gemaakt. Vervolgens kunnen we de NRF24L01-transceiver of alleen de Bluetooth-module aansluiten, afhankelijk van het type communicatie dat we zullen gebruiken. Ik heb ook een LED geplaatst om aan te geven wanneer de batterij moet worden opgeladen, of als de spanning onder de 11V volt daalt. Ten slotte moeten we alle servo's aansluiten op de servopinnen. Zorg ervoor dat u daarbij noteert op welk pinnummer u elke servo hebt aangesloten. Nadat we alle servo's hebben aangesloten, kunnen we eenvoudig de gebogen kap op de bovenplaat plaatsen en zijn we eigenlijk klaar met dit project.

Arduino Hexapod-code

Wat je in deze video nog moet doen, is kijken hoe het Arduino-programma werkt. Omdat de code wat langer is, zal ik voor een beter begrip de broncode van het programma in secties plaatsen met een beschrijving voor elke sectie. En aan het einde van dit artikel zal ik de volledige broncode posten.

Dus voor het aansturen van de servo's zullen we de basis Servo-bibliotheek gebruiken en voor de Bluetooth-communicatie moeten we ook de SoftwareSerial-bibliotheek opnemen. Eerst moeten we alle servo-objecten definiëren, evenals enkele variabelen die nodig zijn voor het onderstaande programma.

#include <Servo.h>
#include <SoftwareSerial.h>

#define trigPin 7
#define echoPin 6
#define ledB 10

SoftwareSerial Bluetooth(12, 9); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)

// Create servo object
Servo s24;
Servo s23;
Servo s22;Code language: Arduino (arduino)

In het setup-gedeelte moeten we de Bluetooth-communicatie, de pin-modi voor de ultrasone sensor, de LED initialiseren en ook de pinnen definiëren waarop de servo's zijn aangesloten.

void setup() {
  Serial.begin(38400);
  Bluetooth.begin(38400); // Default baud rate of the Bluetooth module
  Bluetooth.setTimeout(1);
  delay(20);
  pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
  pinMode(echoPin, INPUT); // Sets the echoPin as an Input
  pinMode(ledB, OUTPUT);
  // Head
  s15.attach(36, 600, 2400);
  s14.attach(35, 600, 2400);
  s13.attach(34, 600, 2400); //grip
  // Tail
  s5.attach(26, 600, 2400); // Tail
  // Leg 4
  s10.attach(31, 600, 2400);
  s11.attach(32, 600, 2400);
  s12.attach(33, 600, 2400); //rot
  // Leg 5
  s7.attach(28, 600, 2400);
  s8.attach(29, 600, 2400);
  s9.attach(30, 600, 2400); //rot
  // Leg 6
  s1.attach(22, 600, 2400);
  s2.attach(23, 600, 2400);
  s3.attach(24, 600, 2400); //rot
  // Leg 1
  s18.attach(39, 600, 2400);
  s17.attach(38, 600, 2400);
  s16.attach(37, 600, 2400); //rot
  // Leg 2
  s21.attach(42, 600, 2400);
  s20.attach(41, 600, 2400);
  s19.attach(40, 600, 2400); //rot
  // Leg 3
  s24.attach(45, 600, 2400);
  s23.attach(44, 600, 2400);
  s22.attach(43, 600, 2400); //rotCode language: Arduino (arduino)

Vervolgens gebruiken we de functies write() om de servo's naar hun oorspronkelijke positie te verplaatsen. Hier kunnen we onze servo's kalibreren. Houd er rekening mee dat u niet elke servo op de exacte positie kunt instellen wanneer u de robot monteert, maar hier kunnen we aanpassingen doen en onze initiële waarden achterhalen en van daaruit kunnen we de robotbeweging programmeren.

// == Move to initial position
  // Head
  s15.write(72);
  s14.write(50);
  s13.write(90); // Grip
  
  s5.write(65); // Tail
  
  // Leg 4
  s10.write(65);
  s11.write(35);
  s12.write(40);
  // Leg 5
  s7.write(80);
  s8.write(50);
  s9.write(25);
  // Leg 6
  s1.write(90);
  s2.write(45);
  s3.write(60);

  // Leg 1
  s18.write(60);
  s17.write(90);
  s16.write(100);
  // Leg 2
  s21.write(50);
  s20.write(85);
  s19.write(75);
  // Leg 3
  s24.write(50);
  s23.write(80);
  s22.write(80);Code language: Arduino (arduino)

Als het gaat om het programmeren van een hexapod-beweging, zijn er verschillende manieren om dit te doen, zoals het gebruik van een voorwaartse of inverse kinematica. Deze methoden omvatten serieuze wiskunde waarbij de positie van elk gewricht wordt berekend op basis van de invoer voor de gewenste uiteindelijke positie van het lichaam. Ik besloot het echter wat minder ingewikkeld te maken omdat de servo's die ik gebruik sowieso niet goed genoeg zijn voor een dergelijke taak. Dat komt omdat mijn servo's de goedkope versie zijn van de MG996R-servo. Ze hebben niet het juiste koppel en ze positioneren niet altijd op de exact gewenste positie.

Dus laten we eens kijken hoe ik de hexapod heb laten lopen. Ik heb een aparte aangepaste functie gemaakt voor het verplaatsen van elk been. Een beencyclus omvat twee fasen, zwaai en stand genoemd. In de zwaaifase beweegt het been van een beginpositie naar een eindpositie door de lucht, terwijl in de standfase het been vanuit de eindpositie terug naar de beginpositie beweegt waarbij de beenuiteinde-effector de grond raakt. Op deze manier zal het lichaam van de hexapod naar voren bewegen.

Dus programmeer ik handmatig de posities van elke servo om deze bewegingen te bereiken met behulp van de hoofdlus en enkele tellers.

void moveLeg1() {
  // Swign phase - move leg though air - from initial to final position
  // Rise the leg
  if (i1L1 <= 10) {
    s18.write(60 - i1L1 * 2);
    s17.write(90 - i1L1 * 3);
    i1L1++;
  }
  // Rotate the leg
  if (i2L1 <= 30) {
    s16.write(100 - i2L1);
    i2L1++;

  }
  // Move back to touch the ground
  if (i2L1 > 20 & i3L1 <= 10) {
    s18.write(40 + i3L1 * 2);
    s17.write(60 + i3L1 * 3);
    i3L1++;
  }
  // Stance phase - move leg while touching the ground
  // Rotate back to initial position
  if (i2L1 >= 30) {
    s16.write(70 + i4L1);
    i4L1++;
    l1status = HIGH;
  }
  // Reset the counters for repeating the process
  if (i4L1 >= 30) {
    i1L1 = 0;
    i2L1 = 0;
    i3L1 = 0;
    i4L1 = 0;
    i5L1 = 0;
  }
  // Each iteration or step is executed in the main loop section where there is also a delay time for controlling the speed of movement
}Code language: Arduino (arduino)

Dus eerst stijgen de twee buitenste servo's het been en de derde servo die op het lichaam is aangesloten, begint in een bepaalde richting te draaien. Wanneer de derde servo 10 stappen is voordat deze stopt met draaien, beginnen we de buitenste twee servo's naar achteren te verplaatsen op dezelfde positie om de grond te raken. Dit voltooit de zwaaifase, of het been verplaatst van de beginpositie naar de eindpositie. Dan draaien we de derde servo terug van de laatste naar de beginpositie, en dat voltooit de standfase. Nadat het been één cyclus heeft uitgevoerd, worden de tellers gereset en zal het been de cyclus keer op keer herhalen. Elke iteratie of stap wordt uitgevoerd in de hoofdlussectie waar er ook een vertragingstijd is die de snelheid van servo's regelt. Ik heb functies zoals deze gemaakt voor alle andere benen, evenals enkele extra functies om de benen in tegengestelde richting te bewegen voor het bereiken van achterwaartse, linkse en rechtse bewegingen. Op dezelfde manier, met behulp van tellers om de stappen bij te houden, programmeerde ik de rest van de functies, zoals het bewegen van het hoofd, het bewegen van de staart, de onderkaken enzovoort.

Dus als we de robot bijvoorbeeld vooruit willen laten gaan, moeten we de zes aangepaste moveLeg()-functies aanroepen die constant in de hoofdlus worden herhaald.

// Move forward
  if (m == 2) {
    moveLeg1();
    moveLeg3();
    moveLeg5();
    if (l1status == HIGH) {
      moveLeg2();
      moveLeg4();
      moveLeg6();
    }
  }Code language: Arduino (arduino)

Je kunt zien dat de 3 poten versprongen zijn, dus als de pootnummers 1 3 en 5 zich in de zwaaifase bevinden, zijn de andere drie poten, 2, 4 en 6 in de standfase. Als we naar links willen gaan, roepen we de juiste moveLeft()-functies aan.

Deze commando's komen eigenlijk van de Bluetooth-module of de op maat gemaakte Android-applicatie van onze smartphone.

// Check for incoming data
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.read();  // Read the dataCode language: Arduino (arduino)

Android-app Arduino Ant Robot

Laten we nu eens naar de app kijken en zien wat voor soort gegevens het daadwerkelijk naar de Arduino verzendt. Ik heb de app gemaakt met behulp van de online applicatie MIT App Inventor en hier is hoe het werkt.

Dus de afbeeldingen van de app zijn eigenlijk afbeeldingen die ik heb gemaakt en als knoppen heb geplaatst. Onderaan hebben we een schuifregelaar om de snelheid van de robot te regelen en bovenaan hebben we de knoppen om verbinding te maken met de Bluetooth-module.

Laten we eens kijken naar het programma of de blokken achter de app.

Dus als we bijvoorbeeld op de knop Doorsturen klikken, worden de blokken in het "if" -statement uitgevoerd. Dat betekent dat we het nummer 2 naar de Arduino sturen en dat de volgende reeks functies uitvoert. Tegelijkertijd kunnen we opmerken dat we de afbeelding van de knop wijzigen in de andere gemarkeerde versie van dezelfde afbeelding. Als we opnieuw op dezelfde knop drukken, worden nu de blokken in de "else" -opdracht uitgevoerd en dat zal het nummer 0 naar de Arduino sturen, die alle tellers zal resetten en de robot naar zijn beginposities zal verplaatsen. Ook hebben we de oorspronkelijke afbeelding van die knop teruggezet. Dus ik gebruikte hetzelfde principe voor alle andere knoppen.

Hier is een downloadbestand van het bovenstaande MIT App Inventor-project, evenals de Android-app die klaar is om op uw smartphone te worden geïnstalleerd:

Laten we eens kijken naar nog twee functies in het Arduino-programma en dat is de batterijspanningsmonitor en ultrasone sensor.

// Monitor the battery voltage
    int sensorValue = analogRead(A3);
    float voltage = sensorValue * (5.00 / 1023.00) * 2.9; // Convert the reading values from 5v to suitable 12V i
    Serial.println(voltage);
    // If voltage is below 11V turn on the LED
    if (voltage < 11) {
      digitalWrite(ledB, HIGH);
    }
    else {
      digitalWrite(ledB, LOW);
    }Code language: Arduino (arduino)

Dus als de batterijspanning lager is dan 11 volt, schakelen we de LED in en als de ultrasone sensor een object dichterbij dan 40 cm detecteert, zal de robot zich voorbereiden op een aanval.

// Get the distance from the ultrasonic sensor
    if (getDistance() > 40) {
      att = 0;
    }
    if (getDistance() <= 40) {
      att = 1;
      dataIn = 99;
    }Code language: Arduino (arduino)

Als er geen object meer aan de voorkant is, zal het de aanval afwijzen en als het object nog steeds aanwezig is en dichter bij het hoofd, zal de robot aanvallen.

// If there is an object in front of the sensor prepare for attack
  if (att == 1) {
    prepareAttack();
    if (aStatus == HIGH) {
      while (a == 0) {
        delay(2000);
        a = 1;
      }
      if (getDistance() > 30) {
        att = 2;
        a = 0;
        aStatus = LOW;
        initialPosHead();
      }
      if (getDistance() < 30) {
        att = 3;
        a = 0;
        aStatus = LOW;
        initialPosHead();
      }
    }
  }
  // If there is no longer object in front, dismiss the attack
  if (att == 2) {
    dismissAttack();
    if (aStatus == HIGH) {
      dataIn = 0;
      att = 0;
    }
  }
  // If there is closer to the sensor attack
  if (att == 3) {
    attack();
    if (attStatus == HIGH) {
      while (aa == 0) {
        delay(2000);
        aa = 1;
      } attStatus = LOW;
    }
    if (aStatus == HIGH) {
      while (a == 0) {
        delay(2000);
        a = 1;
      }
      dataIn = 0;
      att = 0;
      initialPosHead();
    }
  }Code language: Arduino (arduino)

Dus dat is zo'n beetje alles voor deze video.

Hier kunt u de volledige code voor dit Arduino Hexapod-project downloaden:

Merk op dat als je besluit om dit project te bouwen, je voorbereid moet zijn op een aantal uitdagingen. Het grootste probleem voor mij waren de slechte prestaties van de servo's die ik gebruikte. 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.