- LM393 Snelheidssensormodule (H206)
- H206 Sensor montage-inrichting
- DIY Arduino LM393 Snelheidssensor Robot schakelschema
- Logica achter het meten van snelheid met LM393 snelheidssensormodule
- Logica achter het meten van de afgelegde afstand door het wiel
- Logica achter het meten van de hoek van de bot
- Arduino Robotcode
- Testen van de Arduino Robot voor het meten van afstand, snelheid en hoek
Robots zijn langzaamaan in onze samenleving gaan kruipen om ons leven eenvoudiger te maken. We kunnen de zeswielige robots voor het bezorgen van voedsel van Starship al op de wegen van het VK vinden, slim navigeren tussen de burgers om hun bestemming te bereiken. Elke mobiele robot die de omgeving in navigeert, moet zich altijd bewust zijn van zijn positie en oriëntatie ten opzichte van de echte wereld. Er zijn veel manieren om dit te bereiken door verschillende technologieën te gebruiken zoals GPS, RF Triangulatie, Accelerometers, Gyroscopen enz. Elke techniek heeft zijn eigen voordeel en is uniek op zichzelf. In deze Arduino LM393 snelheidssensor tutorial zullen we de eenvoudige en gemakkelijk verkrijgbare LM393 snelheidssensormodule gebruikenom enkele vitale parameters te meten, zoals snelheid, afgelegde afstand en hoek van de robot met Arduino. Met deze parameters kan de robot zijn werkelijke status kennen en deze gebruiken om veilig te navigeren.
Arduino is de meest populaire keuze onder hobbyisten voor het bouwen van robots, van een eenvoudige lijnvolger tot een meer complexe zelfbalancerende of vloerreinigingsrobot. Je kunt alle soorten robots bekijken in het gedeelte Robotica.
We gaan een kleine robot bouwen die wordt aangedreven door een lithiumbatterij en deze besturen met een joystick. Tijdens de looptijd kunnen we de snelheid, afstand en hoek van de robot meten en deze real-time weergeven op het LCD- scherm dat is aangesloten op Arduino. Dit project helpt je alleen bij het meten van deze parameters, als je hiermee klaar bent, kun je deze parameters gebruiken om je bot naar behoefte autonoom te laten werken. Klinkt interessant toch? Dus laten we beginnen.
LM393 Snelheidssensormodule (H206)
Voordat we ingaan op het schakelschema en de code voor het project, moeten we eerst de LM393 snelheidssensormodule begrijpen, aangezien deze een cruciale rol speelt in het project. De H206 snelheidssensormodule bestaat uit een infraroodlichtsensor geïntegreerd met een LM393 spanningsvergelijker-IC, vandaar de naam LM393 snelheidssensor. De module bestaat ook uit een roosterplaat die op de roterende as van de motor moet worden gemonteerd. Alle componenten zijn gelabeld in onderstaande afbeelding.
De infraroodlichtsensor bestaat uit een IR-LED en een fototransistor gescheiden door een kleine opening. De gehele sensoropstelling is in een zwarte behuizing geplaatst zoals hierboven weergegeven. De roosterplaat bestaat uit gleuven, de plaat is zo tussen de opening van de infraroodlichtsensor geplaatst dat de sensor de openingen in de roosterplaat kan detecteren. Elke opening in de roosterplaat activeert de IR-sensor wanneer deze door de opening gaat; deze triggers worden vervolgens omgezet in spanningssignalen met behulp van de comparator. De comparator is niets anders dan een LM393 IC van ON halfgeleiders. De module heeft drie pinnen, waarvan er twee worden gebruikt om de module van stroom te voorzien en één outputpin wordt gebruikt om het aantal triggers te tellen.
H206 Sensor montage-inrichting
Het monteren van dit soort sensoren is een beetje lastig. Hij kan alleen worden gemonteerd op motoren waarvan de as aan beide zijden uitsteekt. De ene kant van de as is verbonden met het wiel terwijl de andere kant wordt gebruikt om de roosterplaat te monteren zoals hierboven weergegeven.
Omdat het wiel en de plaat met dezelfde as zijn verbonden, roteren beide met dezelfde snelheid en kunnen we dus door de snelheid van de plaat te meten de snelheid van het wiel meten. Zorg ervoor dat de openingen in de roosterplaat door de IR-sensor gaan, alleen dan kan de sensor het aantal passages tellen dat is gepasseerd. U kunt ook uw eigen mechanische opstelling bedenken om de sensor te monteren, zolang deze aan de gespecificeerde voorwaarde voldoet. IR-sensor wordt over het algemeen in veel robotica-projecten gebruikt om de robot over de obstakels te leiden.
De hierboven getoonde roosterplaat heeft 20 sleuven (roosters). Dit betekent dat de sensor 20 openingen zal vinden voor een volledige rotatie van het wiel. Door het aantal gaten te tellen dat de sensor heeft gedetecteerd, kunnen we de afstand berekenen die door het wiel is afgelegd, op dezelfde manier door te meten hoe snel de sensor de gaten vindt, kunnen we de snelheid van het wiel detecteren. In onze robot zullen we deze sensor op beide wielen hebben gemonteerd en dus kunnen we ook de hoek van de robot bepalen. De rotatiehoek kan echter verstandiger worden berekend met behulp van de versnellingsmeter of gyroscoop, leer hier om de versnellingsmeter en de gyroscoop met Arduino te verbinden en probeer de rotatiehoek met behulp van deze te meten.
DIY Arduino LM393 Snelheidssensor Robot schakelschema
Het complete schakelschema van deze snelheids- en afstandsmeetrobot wordt hieronder weergegeven. De Bot bestaat uit Arduino Nano als brein, de twee DC motoren voor de wielen worden aangedreven door de L298N H-Bridge Motor Driver module. De joystick wordt gebruikt om de snelheid en richting van de bot te regelen en de twee snelheidssensoren H206 worden gebruikt om de snelheid, afstand en hoek van de bot te meten. De gemeten waarden worden vervolgens weergegeven in de 16x2 LCD-module. De potentiometer die is aangesloten op het LCD-scherm kan worden gebruikt om het contrast van het LCD-scherm aan te passen en de weerstand wordt gebruikt om de stroom die naar de achtergrondverlichting van het LCD-scherm vloeit te beperken.
Het volledige circuit wordt gevoed door een 7,4 V lithiumcel. Deze 7,4 V wordt geleverd aan de 12 V pin van de Motor driver module. De spanningsregelaar op de motorbesturingsmodule converteert vervolgens de 7,4 V naar gereguleerde + 5 V die wordt gebruikt om de Arduino, LCD, sensoren en joystick van stroom te voorzien.
De motor wordt bestuurd door de digitale pinnen 8, 9, 10 en 11 van de Arduino. Aangezien de snelheid van de motor ook moet worden geregeld, moeten we PWM-signalen aan de positieve pool van de motor leveren. Daarom hebben we pin 9 en 10 die beide PWM-compatibele pinnen zijn. De X- en Y-waarden van de joystick worden gelezen met respectievelijk de analoge pinnen A2 en A3.
Zoals we weten, genereert de H206-sensor een trigger wanneer de opening in de roosterplaat wordt gedetecteerd. Aangezien deze triggers niet altijd nauwkeurig moeten worden gelezen om de juiste snelheid en afstand te berekenen, zijn beide trigger (output) pinnen verbonden met de External interrupt pin 2 en 3 van het Arduino Board. Monteer het hele circuit op een chassis en monteer de snelheidssensor zoals uitgelegd, mijn bot zag er ongeveer zo uit als hieronder nadat de verbindingen waren voltooid. Je kunt ook de video aan het einde van deze pagina bekijken om te weten hoe de sensor is gemonteerd.
Nu het hardwaregedeelte is voltooid, gaan we in op de logica van hoe we de snelheid, afstand en single van de bot gaan meten en gaan we verder met het programmeergedeelte.
Logica achter het meten van snelheid met LM393 snelheidssensormodule
Bij de montage van de sensor moet u er rekening mee houden dat de LM393 snelheidssensormodule (H206) alleen de openingen meet die aanwezig zijn in de roosterplaat. Tijdens de montage moet ervoor worden gezorgd dat het wiel (waarvan de snelheid moet worden gemeten) en de roosterplaat met dezelfde snelheid draaien. Zoals hier, aangezien we zowel het wiel als de plaat op dezelfde as hebben gemonteerd, zullen ze uiteraard allebei met dezelfde snelheid draaien.
In onze opstelling hebben we voor elk wiel twee sensoren gemonteerd om de hoek van de bot te meten. Maar als het uw doel is om alleen de snelheid en afstand te meten, kunnen we de sensor op elk wiel monteren. De uitgang van de sensor (triggersignalen) wordt meestal verbonden met een externe onderbrekingspin van een microcontroller. Elke keer dat het gat in de rasterplaat wordt gedetecteerd, wordt er een interrupt geactiveerd en wordt de code in de ISR (Interrupt-serviceroutine) uitgevoerd. Als we het tijdsinterval tussen twee van dergelijke triggers kunnen berekenen, kunnen we de snelheid van het wiel berekenen.
In Arduino kunnen we dit tijdsinterval eenvoudig berekenen met behulp van de millis () functie. Deze millisefunctie wordt steeds met 1 verhoogd voor elke milliseconde vanaf het moment dat het apparaat wordt opgestart. Dus wanneer de eerste interrupt optreedt, kunnen we de waarde van millis () opslaan in een dummy-variabele (zoals pevtime in deze code) en wanneer de tweede interrupt optreedt, kunnen we de tijd berekenen door de pevtime- waarde af te trekken van de millis ().
Genomen tijd = huidige tijd - vorige tijd timetaken = millis () - pevtime ; // timetaken in millisec
Zodra we de benodigde tijd hebben berekend, kunnen we eenvoudig de waarde van rpm berekenen met behulp van de onderstaande formules, waarbij (1000 / tijdsopname) de RPS (omwentelingen per seconde) geeft en deze wordt vermenigvuldigd met 60 om RPS om te rekenen naar RPM (omwentelingen per minuut).
rpm = (1000 / dienstregeling) * 60;
Na het berekenen van het toerental kunnen we de snelheid van het voertuig berekenen met behulp van de onderstaande formules, op voorwaarde dat we de straal van het wiel kennen.
Snelheid = 2π × RPS × straal van wiel. v = radius_of_wheel * rpm * 0.104
Let op, de bovenstaande formule is voor het berekenen van de snelheid in m / s, als je wilt berekenen in km / uur, vervang dan 0,0104 door 0,376. Als je nieuwsgierig bent naar hoe de waarde 0,104 is verkregen, probeer dan de formule V = 2π × RPS × straal van wiel te vereenvoudigen.
Dezelfde techniek wordt gebruikt, zelfs als een Hall-sensor wordt gebruikt om de snelheid van een roterend object te meten. Maar voor de H206-sensor is er een vangst, de roosterplaat heeft 20 slots en daarom zal voor het meten van de tijd tussen twee slots de microcontroller overbelast raken. Daarom meten we de snelheid alleen bij een volledige rotatie van een wiel. Aangezien er voor elke opening twee interrupts worden gegenereerd (een aan het begin en een andere aan het einde van de opening) , krijgen we in totaal 40 interrupts voor het wiel om een volledige rotatie te maken. We wachten dus op 40 interrupts voordat we daadwerkelijk de snelheid van het wiel berekenen. De code voor hetzelfde wordt hieronder weergegeven
if (rotatie> = 40) { timetaken = millis () - pevtime; // timetaken in millisec rpm = (1000 / timetaken) * 60; // formules om rpm te berekenen pevtime = millis (); rotatie = 0; }
Een ander nadeel van deze methode is dat de waarde van de snelheid niet tot nul zal dalen, aangezien de onderbreking altijd wacht tot het wiel één rotatie voltooit voor het berekenen van de toerentalwaarde. Dit nadeel kan gemakkelijk worden ondervangen door een eenvoudige code toe te voegen die het tijdsinterval tussen twee interrupts bewaakt en als dit groter is dan normaal, kunnen we de waarde van rpm en snelheid dwingen om nul te zijn. Link in de onderstaande code hebben we variabele dtime gebruikt om het verschil in tijd te controleren en als het meer is dan 500 milli seconden, wordt de waarde van snelheid en rpm gedwongen nul te zijn.
/ * Om naar nul te dalen als het voertuig stopte * / if (millis () - dtime> 500) // geen onderbreking gevonden gedurende 500ms { rpm = v = 0; // maak rpm en snelheid als nul dtime = millis (); }
Logica achter het meten van de afgelegde afstand door het wiel
We weten al dat de Arduino 40 interrupts zal detecteren wanneer het wiel een volledige omwenteling maakt. Dus voor elke rotatie gemaakt door het wiel is het duidelijk dat de afstand die het wiel aflegt gelijk is aan de omtrek van het wiel. Omdat we de straal van het wiel al kennen, kunnen we de afgelegde afstand gemakkelijk berekenen met behulp van de onderstaande formule
Afstand = 2πr * aantal rotaties afstand = (2 * 3.141 * radius_of_wheel) * (left_intr / 40)
Waarbij de omtrek van het wiel wordt berekend met de formule 2πr en vervolgens wordt vermenigvuldigd met het aantal rotaties dat door het wiel wordt gemaakt.
Logica achter het meten van de hoek van de bot
Er zijn veel manieren om de engel van de robot te bepalen. Versnellingsmeters en gyroscopen worden normaal gesproken gebruikt om deze waarden te bepalen. Maar een andere goedkope benadering is om de H206-sensor op beide wielen te gebruiken. Op deze manier zouden we weten hoeveel beurten elk wiel heeft gemaakt. De onderstaande afbeelding illustreert hoe de hoek wordt berekend.
Wanneer de robot wordt geïnitialiseerd, wordt de hoek waarnaar hij kijkt beschouwd als 0 °. Van daaruit draait het naar links, de hoek wordt negatief verhoogd en als het naar rechts draait, wordt de engel positief verhoogd. Laten we voor een goed begrip kijken naar het bereik van -90 tot +90, zoals weergegeven in de afbeelding. In een dergelijke opstelling, aangezien beide wielen dezelfde diameter hebben, als een van de wielen een volledige rotatie maakt, draaien we de bot onder een hoek van 90 °.
Als het linkerwiel bijvoorbeeld een volledige rotatie maakt (80 onderbrekingen), dan zal de bot 90 ° naar links draaien en op dezelfde manier als het rechterwiel een volledige rotatie maakt (80 onderbrekingen), dan zal de bot -90 ° naar rechts draaien. Nu weten we dat als de Arduino 80 interrupts op één wiel detecteert, de bot 90 ° is gedraaid en op basis van welk wiel we kunnen zien of de bot positief (rechts) of negatief (links) is gedraaid. Dus de linker- en rechterhoek kunnen worden berekend met behulp van de onderstaande formules
int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80);
Waarbij 90 de hoek is die wordt afgelegd bij het maken van een interrupt van 80. De resulterende waarde is vermenigvuldigd met het aantal interrupts. We hebben ook een modulus van 360 gebruikt zodat de resulterende waarde nooit hoger is dan 36. Als we eenmaal zowel de linker- als de rechte hoek hebben berekend, kan de effectieve hoek waaronder de bot wordt geconfronteerd, eenvoudig worden verkregen door de linkerhoek van de rechte hoek af te trekken.
angle = angle_right - angle_left;
Arduino Robotcode
De volledige Arduino-code voor deze snelheids- en hoekmeetrobot vindt u aan het einde van deze pagina. Het doel van het programma is om de snelheid, afstand en hoek van de bot te berekenen met behulp van de bovenstaande logica en deze op het LCD-scherm weer te geven. Afgezien daarvan zou het een optie moeten bieden om de bot met de joystick te besturen.
We starten het programma door de digitale I / O-pinnen voor de twee motoren te definiëren. Houd er rekening mee dat we ook de snelheid van de motor moeten regelen en daarom moeten we de PWM-pinnen op Arduino gebruiken om de motoren te besturen. Hier hebben we de pin 8,9,10 en 11 gebruikt.
#define LM_pos 9 // linker motor #define LM_neg 8 // linker motor #define RM_pos 10 // rechter motor #define RM_neg 11 // rechter motor #define joyX A2 #define joyY A3
Om de snelheid en de afgelegde afstand te meten, moeten we de straal van het wiel kennen, de waarde meten en deze in meters invoeren zoals hieronder weergegeven. Voor mijn bot was de straal 0,033 meter, maar het kan voor jou verschillen op basis van je bot.
zweven radius_of_wheel = 0,033; // Meet de straal van uw wiel en voer deze hier in cm in
Binnen de setup- functie initialiseren we alle waarden op nul en geven we vervolgens een intro-tekst weer op het LCD-scherm. We hebben ook de seriële monitor geïnitialiseerd voor foutopsporing. Vervolgens hebben we vermeld dat de snelheidssensoren H206 zijn aangesloten op pin 2 en 3 als externe interrupts. Dat is waar de interrupt wordt gedetecteerd, de ISR-functie Left_ISR en Right_ISR worden dienovereenkomstig uitgevoerd.
leegte setup () { rotatie = rpm = pevtime = 0; // Initialiseer alle variabelen op nul Serial.begin (9600); lcd.begin (16, 2); // Initialiseer 16 * 2 LCD lcd.print ("Bot Monitor"); // Intro Message line 1 lcd.setCursor (0, 1); lcd.print ("- CircuitDigest"); // Intro Message line 2 delay (2000); lcd.clear (); lcd.print ("Lt: Rt:"); lcd.setCursor (0, 1); lcd.print ("S: D: A:"); pinMode (LM_pos, OUTPUT); pinMode (LM_neg, OUTPUT); pinMode (RM_pos, OUTPUT); pinMode (RM_neg, OUTPUT); digitalWrite (LM_neg, LOW); digitalWrite (RM_neg, LOW); attachInterrupt (digitalPinToInterrupt (2), Left_ISR, CHANGE); // Left_ISR wordt aangeroepen wanneer de linkerwielsensor wordt geactiveerd attachInterrupt (digitalPinToInterrupt (3), Right_ISR, CHANGE); // Right_ISR wordt aangeroepen wanneer de rechterwielsensor wordt geactiveerd }
Binnen de Left_ISR-routine verhogen we eenvoudigweg een variabele genaamd left_intr die later zal worden gebruikt om de hoek van de bot te meten. Binnen de Right_ISR doen we hetzelfde, maar dan berekenen we hier ook de snelheid. De variabele rotatie wordt verhoogd voor elke interrupt en vervolgens wordt de bovenstaande logica gebruikt om de snelheid te berekenen.
void Left_ISR () { left_intr ++; delay (10); } void Right_ISR () { right_intr ++; vertraging (10); rotatie ++; dtime = millis (); if (rotatie> = 40) { timetaken = millis () - pevtime; // timetaken in millisec rpm = (1000 / timetaken) * 60; // formules om rpm te berekenen pevtime = millis (); rotatie = 0; } }
Binnen de belangrijkste oneindige lusfunctie bewaken we de waarden van X en Y vanaf de joystick. Op basis van de waarde als de joystick wordt verplaatst, besturen we de bot dienovereenkomstig. De snelheid van de bot hangt af van hoe ver de joystick wordt geduwd.
int xValue = analogRead (joyX); int yValue = analogRead (joyY); int versnelling = kaart (xValue, 500, 0, 0, 200); if (xValue <500) { analogWrite (LM_pos, versnelling); analogWrite (RM_pos, versnelling); } else { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } if (yValue> 550) analogWrite (RM_pos, 80); if (yValue <500) analogWrite (LM_pos, 100);
Dit zal de gebruiker helpen om de bot te verplaatsen en te controleren of de verkregen waarden zijn zoals verwacht. Eindelijk kunnen we de snelheid, afstand en hoek van de bot berekenen met behulp van de bovenstaande logica en deze op het LCD-scherm weergeven met behulp van de onderstaande code.
v = radius_of_wheel * rpm * 0.104; //0.033 is de straal van het wiel in meterafstand = (2 * 3.141 * radius_of_wheel) * (left_intr / 40); int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80); angle = angle_right - angle_left; lcd.setCursor (3, 0); lcd.print (""); lcd.setCursor (3, 0); lcd.print (left_intr); lcd.setCursor (11, 0); lcd.print (""); lcd.setCursor (11, 0); lcd.print (right_intr); lcd.setCursor (2, 1); lcd.print (""); lcd.setCursor (2, 1); lcd.print (v); lcd.setCursor (9, 1); lcd.print (""); lcd.setCursor (9, 1); lcd.print (afstand); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.print (hoek);
Testen van de Arduino Robot voor het meten van afstand, snelheid en hoek
Zodra je hardware klaar is, upload je de code naar je Arduino en gebruik je de joystick om je bot te verplaatsen. de snelheid van de bot, de afstand die erdoor wordt afgelegd en de hoek worden weergegeven op het LCD-scherm zoals hieronder weergegeven.
Op het LCD-scherm staat de term Lt en Rt voor respectievelijk Left Interrupt Count en Right Interrupt Count. U kunt zien dat deze waarden worden verhoogd voor elke opening die door de sensor wordt gedetecteerd. De tem S geeft de snelheid van de bot in m / sec aan en de term D geeft de afgelegde afstand in meters aan. De hoek van de bot wordt aan het einde weergegeven, waarbij 0 ° voor recht is en negatief voor rotatie tegen de klok in en positief voor rotatie met de klok mee.
Je kunt ook de video aan het einde van deze pagina bekijken om te begrijpen hoe de bot werkt. Ik hoop dat je het project hebt begrepen en met plezier hebt gebouwd. Als je je zorgen maakt, laat ze dan achter in het commentaargedeelte en ik zal proberen zo goed mogelijk te reageren. U kunt ook forums gebruiken voor snelle technische hulp.