Bewegingsgestuurde Rover met behulp van een versnellingsmeter en een RF-zender-ontvangerpaar - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

Hoi, Ooit de wens gehad om een rover te bouwen die je kon besturen met eenvoudige handgebaren, maar nooit de moed kon opbrengen om je in de fijne kneepjes van beeldverwerking te wagen en een webcam met je microcontroller te verbinden, om nog maar te zwijgen van de zware strijd om een slecht bereik en een slechte lijn te overwinnen zicht problemen? Nou, vrees niet … want er is een gemakkelijke uitweg! Zie, terwijl ik u de machtige VERSNELLER presenteer! *ba dom tsss*

Een versnellingsmeter is een echt cool apparaat dat zwaartekrachtversnelling langs een lineaire as meet. Het geeft dit weer als een spanningsniveau dat schommelt tussen aarde en de voedingsspanning, die onze microcontroller inleest als een analoge waarde. Als we onze hersenen een beetje toepassen (alleen een beetje wiskunde en wat Newtoniaanse fysica), kunnen we ze niet alleen gebruiken om lineaire beweging langs een as te meten, maar we kunnen ze ook gebruiken om de hellingshoek te bepalen en trillingen waar te nemen. Maak je geen zorgen! We hebben de wiskunde of de natuurkunde niet nodig; we gaan gewoon te maken hebben met onbewerkte waarden die de versnellingsmeter uitspuugt. In feite hoeft u zich niet veel zorgen te maken over de technische details van een versnellingsmeter voor dit project. Ik zal slechts enkele details aanstippen en slechts zoveel uitwerken als nodig is om het grote geheel te begrijpen. Hoewel, als je geïnteresseerd bent in het bestuderen van de innerlijke mechanica, kijk dan hier.

Je hoeft dit alleen voor nu in gedachten te houden: een versnellingsmeter is de gizmo (vaak in combinatie met een gyroscoop) die deuren opent naar al die bewegingssensorgames die we op onze smartphones spelen; een autoracespel bijvoorbeeld, waarbij we het voertuig besturen door simpelweg onze apparaten in beide richtingen te kantelen. En we kunnen ditzelfde effect nabootsen door een versnellingsmeter (met een paar hulpmiddelen natuurlijk) op een handschoen te plakken. We doen gewoon onze magische handschoenen aan en kantelen onze handen naar links of rechts, naar voren of naar achteren en zien onze rovers dansen op onze deuntjes. Het enige dat we hier moeten doen, is de meetwaarden van de versnellingsmeter vertalen naar digitale signalen die de motoren van de rover kunnen interpreteren en een mechanisme bedenken om deze signalen naar de rover te verzenden. Om dit te bereiken, doen we een beroep op de goede oude Arduino en zijn assistenten voor het experiment van vandaag, een RF-zender-ontvangerpaar dat werkt op 434 MHz, waardoor een bereik van ongeveer 100-150 m in de open ruimte wordt verkregen, wat ons ook redt van line-of- zicht problemen.

Best een handige hack, hè? Laten we erin duiken…

Stap 1: Verzamel uw benodigdheden

• Arduino Nano	x1
• Versnellingsmeter (ADXL335)	x1
• 5V DC-motor + wielen	x2 elk
• Runderwiel*	x1
• L293D Motor Driver + 16-pins IC-aansluiting	x1 elk
• 434 MHz RF-zender	x1
• 434 MHz RF-ontvanger	x1
• HT-12E Encoder-IC + 18-pins IC-socket	x1 elk
• HT-12D-decoder-IC + 18-pins IC-socket	x1 elk
• LM7805 Spanningsregelaar	x1
• Drukknopschakelaar	x2
• Rode LED + 330O weerstand	x2 elk
• Gele LED + 330O weerstand	x1 elk
• Groene LED + 330O weerstand (optioneel)	x4 elk
• 51kO en 1MO weerstanden	x1 elk
• 10 µF radiale condensatoren	x2
Batterijen, batterijconnectoren, USB-kabel, jumperdraden, vrouwelijke headers, 2-pins schroefklemmen, PCB, chassis en uw gebruikelijke soldeeraccessoires

Als je je afvraagt waarom we een runderwiel gebruiken, het punt is dat de RF-zender- en ontvangermodules maar 4 datapinnen hebben, wat betekent dat we maar 2 motoren kunnen aandrijven en dus het gebruik van een runderwiel om ondersteunen de structuur. Als je echter denkt dat je rover er een beetje cooler uitziet met vier wielen, maak je geen zorgen, er is een oplossing! In dit geval, kras gewoon het runderwiel van de lijst en voeg nog een paar 5V DC-motoren toe, elk vergezeld van een wiel, en let op de eenvoudige hack die aan het einde van stap 3 is besproken.

Eindelijk, voor de dapperen is er ruimte voor nog een kleine wijziging in het ontwerp, waarbij je je eigen Arduino moet bouwen. Ga naar het bonusgedeelte in de volgende stap en ontdek het zelf. Je hebt ook een paar extra benodigdheden nodig: een ATmega328P, een 28-pins IC-socket, een 16Mhz kristaloscillator, twee 22pF keramische doppen, nog een 7805 spanningsregelaar, nog twee 10μF radiale doppen en 10kΩ, 680Ω, 330Ω weerstanden, en ja, minus de Arduino!

Stap 2: Sluit de zender aan

We splitsen het project op in twee componenten: de zender- en de ontvangercircuits. De zender bestaat uit een versnellingsmeter, een Arduino en een RF-zendermodule gekoppeld aan een HT-12E-encoder-IC, allemaal bedraad volgens het bijgevoegde schema.

De versnellingsmeter, zoals eerder geïntroduceerd, dient om onze handgebaren te herkennen. We gaan een versnellingsmeter met drie assen gebruiken (eigenlijk drie versnellingsmeters met één as in één) om aan onze behoeften te voldoen. Het kan worden gebruikt om versnelling in alle drie de dimensies te meten, en zoals je misschien al geraden hebt, levert het niet één, maar een reeks van drie analoge waarden op ten opzichte van zijn drie assen (x, y en z). Eigenlijk hebben we alleen de versnelling langs de x- en y-assen nodig, omdat we de rover maar in vier richtingen kunnen rijden: vooruit of achteruit (d.w.z. langs de y-as) en naar links of rechts (d.w.z. langs de x-as). We zouden de z-as nodig hebben gehad als we een drone zouden bouwen, zodat we het stijgen of dalen ook konden besturen door middel van gebaren. In ieder geval moeten deze analoge waarden die de accelerometer oplevert omgezet worden naar digitale signalen om de motoren te kunnen aandrijven. Dit wordt verzorgd door de Arduino die deze signalen bij conversie ook via de RF-zendermodule naar de rover zendt.

De RF-zender heeft maar één taak: het verzenden van de "seriële" gegevens die beschikbaar zijn op pin 3 uit de antenne op pin 1. Dit pleit voor het gebruik van de HT-12E, een 12-bits parallel-naar-serieel data-encoder, die tot 4 bits parallelle gegevens van de Arduino op de lijnen AD8 tot en met AD11, waardoor we ruimte kunnen maken voor maximaal 24=16 verschillende I/O-combinaties in tegenstelling tot de enkele datapin op de RF-zender. De overige 8 bits, getrokken uit de lijnen A0 tot en met A7 op de encoder, vormen de adresbyte, die het koppelen van de RF-zender aan een overeenkomstige RF-ontvanger vergemakkelijkt. De 12 bits worden vervolgens samengevoegd en geserialiseerd en doorgegeven aan de datapin van de RF-zender, die op zijn beurt ASK de data moduleert op een draaggolf van 434 MHz en deze via de antenne op pin 1 naar buiten schiet.

Conceptueel zou elke RF-ontvanger die luistert op 434 Mhz deze gegevens moeten kunnen onderscheppen, demoduleren en decoderen. De adreslijnen op de HT-12E en die op de HT-12D-tegenhanger (een 12-bits serieel-naar-parallelle datadecoder), stellen ons echter in staat om een RF-zender-ontvangerpaar uniek te maken door de gegevens alleen naar de bedoelde ontvanger, waardoor de communicatie met alle anderen wordt beperkt. Het enige dat van ons wordt gevraagd, is om de adreslijnen op beide fronten identiek te configureren. Omdat we bijvoorbeeld alle adreslijnen voor onze HT-12E hebben geaard, moeten we hetzelfde doen voor de HT-12D aan de ontvangende kant, anders kan de rover de signalen niet ontvangen. Op deze manier kunnen we ook meerdere rovers besturen met een enkel zendercircuit door de adreslijnen op de HT-12D's bij elk van de ontvangers identiek te configureren. Of we kunnen twee handschoenen aantrekken, elk bevestigd met een zendercircuit met een afzonderlijke adreslijnconfiguratie (bijvoorbeeld één met alle adreslijnen geaard en de andere met allemaal hoog gehouden, of één met één lijn geaard terwijl de overige zeven worden vastgehouden hoog en de andere met twee lijnen aan de grond terwijl de overige zes hoog worden gehouden, of een andere combinatie daarvan) en elk stuurt meerdere identiek geconfigureerde rovers. Speel de maestro bij een Android-symfonie!

Een belangrijk ding om op te merken bij het samenstellen van het circuit is de waarde van Rosc. De HT-12E heeft een intern oscillatorcircuit tussen pinnen 15 en 16, die mogelijk wordt gemaakt door een weerstand, Rosc genaamd, tussen die pinnen aan te sluiten. De voor Rosc geselecteerde waarde bepaalt in feite de oscillatorfrequentie, die kan variëren afhankelijk van de voedingsspanning. Het selecteren van een geschikte waarde voor Rosc is cruciaal voor het functioneren van de HT-12E! Idealiter zou de oscillatorfrequentie van de HT-12E 1/50 keer die van de HT-12D-tegenhanger moeten zijn. Omdat we op 5V werken, hebben we daarom gekozen voor weerstanden van 1MΩ en 51kΩ als Rosc voor respectievelijk de HT-12E- en HT-12D-circuits. Als u van plan bent om de circuits op een andere voedingsspanning te gebruiken, raadpleeg dan de grafiek "Oscillatorfrequentie versus voedingsspanning" op pagina 11 van het bijgevoegde HT-12E-gegevensblad om de exacte oscillatorfrequentie en weerstand te bepalen die moeten worden gebruikt.

Even terzijde: we zullen hier vrouwelijke headers gebruiken (die een soortgelijk doel dienen als IC-sockets) om de accelerometer, de RF-zender en de Arduino in het circuit aan te sluiten in plaats van ze direct op de PCB te solderen. De bedoeling is om een kleine herbruikbaarheid van componenten te accommoderen. Zeg, het is een tijdje geleden dat je je gebarengestuurde rover hebt ontworpen en hij zit daar gewoon, half bedekt met stof, bovenop je trofeeplank en je stuit op een andere geweldige instructable die gebruikmaakt van de werkzaamheid van een versnellingsmeter. Dus wat doe je? Je trekt hem gewoon uit je rover en duwt hem naar je nieuwe circuit. Het is niet nodig om de "Amazones" op te roepen om een nieuwe te krijgen:-p

Bonus: doe de Arduino weg, en toch niet

Voor het geval je je een beetje avontuurlijker voelt, en vooral als je denkt dat het uitgeven van dit prachtig ontworpen wonder (de Arduino natuurlijk) voor zo'n triviale taak als de onze een beetje overdreven is, geduld met me nog een beetje langer; en zo niet, ga dan gerust naar de volgende stap.

Ons doel hier is om de Arduino (in feite het brein van de Arduino; ja, ik heb het over de ATmega IC!) een vast lid van het team te maken. De ATmega zou worden geprogrammeerd om slechts één enkele schets steeds opnieuw uit te voeren, zodat het als een eeuwigdurend onderdeel van het circuit zou kunnen dienen, net als de HT-12E - een louter IC, gewoon daar, en doet wat het moet doen. Is dit niet hoe een echt embedded systeem hoort te zijn?

Hoe dan ook, om door te gaan met deze upgrade, wijzigt u het circuit volgens het tweede bijgevoegde schema. Hier vervangen we eenvoudig de vrouwelijke headers voor de Arduino door een IC-socket voor de ATmega, voegen een 10K pull-up-weerstand toe aan de reset-pin (pin 1) van de IC en pompen deze op met een externe klok tussen pin 9 en 10 Als we de Arduino afschaffen, laten we helaas ook de ingebouwde spanningsregelaars los; dus we moeten het LM7805-circuit dat we voor de ontvanger hadden gebruikt ook hier nabootsen. Daarnaast maken we ook gebruik van een spanningsdeler om de 3,3V te trekken die nodig is om de versnellingsmeter van stroom te voorzien.

Nu is de enige andere addertje onder het gras het programmeren van de ATmega om zijn werk te doen. Je zult er echter op moeten wachten tot stap 4. Dus blijf op de hoogte…

Stap 3: En, de ontvanger

De ontvanger bestaat uit een RF-ontvangermodule gekoppeld aan een HT-12D-decoder-IC en een paar DC-motoren die worden bediend met behulp van een L293D-motordriver, allemaal bedraad volgens het bijgevoegde schema.

De enige taak van de RF-ontvanger is om de draaggolf (ontvangen via de antenne op pin 1) te demoduleren en de opgehaalde "seriële" gegevens op pin 7 weer te geven vanwaar het wordt opgepikt door de HT-12D voor deserialisatie. Nu, ervan uitgaande dat de adreslijnen (A0 t/m A7) op de HT-12D identiek zijn geconfigureerd als zijn HT-12E tegenhanger, worden de 4 parallelle databits geëxtraheerd en doorgegeven via de datalijnen (D8 t/m D11) op de HT-12D, aan de motorbestuurder, die op zijn beurt deze signalen interpreteert om de motoren aan te drijven.

Nogmaals, let op de waarde van Rosc. De HT-12D heeft ook een intern oscillatorcircuit tussen pinnen 15 en 16, die mogelijk wordt gemaakt door een weerstand, Rosc genaamd, tussen die pinnen aan te sluiten. De voor Rosc geselecteerde waarde bepaalt in feite de oscillatorfrequentie, die kan variëren afhankelijk van de voedingsspanning. Het selecteren van een geschikte waarde voor Rosc is cruciaal voor het functioneren van de HT-12D! Idealiter zou de oscillatorfrequentie van de HT-12D 50 keer die van de HT-12E-tegenhanger moeten zijn. Omdat we op 5V werken, hebben we daarom gekozen voor weerstanden van 1MΩ en 51kΩ als Rosc voor respectievelijk de HT-12E- en HT-12D-circuits. Als u van plan bent om de circuits op een andere voedingsspanning te laten werken, raadpleeg dan de grafiek "Oscillatorfrequentie versus voedingsspanning" op pagina 5 van het bijgevoegde HT-12D-gegevensblad om de exacte oscillatorfrequentie en weerstand te bepalen die moeten worden gebruikt.

Vergeet ook niet de vrouwelijke headers voor de RF-ontvanger.

Optioneel kan een LED worden aangesloten via een stroombegrenzingsweerstand van 330 op elk van de 4 datapinnen van de HT-12D om te helpen bepalen welk bit op die pin wordt ontvangen. De LED gaat branden als het ontvangen bit HOOG is (1) en dimt als het ontvangen bit LAAG (0) is. Als alternatief kan een enkele LED worden gekoppeld aan de VT-pin van de HT-12D (opnieuw via een stroombeperkende weerstand van 330), die zou oplichten in het geval van een geldige transmissie.

Als je nu op zoek bent naar de hack met de motoren waar ik het in stap één over had, is het verdomd eenvoudig! Sluit de twee motoren in elke set gewoon parallel aan, zoals weergegeven in het tweede schema. Dit werkt zoals het hoort, omdat de motoren in elke set (de voor- en achtermotoren aan de linkerkant en de voor- en achtermotoren aan de rechterkant) nooit in tegengestelde richting worden aangedreven. Dat wil zeggen, om de rover naar rechts te laten draaien, moeten de voorste en achterste motoren aan de linkerkant beide naar voren worden aangedreven en de voorste en achterste motoren aan de rechterkant moeten beide achteruit worden aangedreven. Evenzo, om de rover naar links te laten draaien, moeten de voorste en achterste motoren aan de linkerkant beide naar achteren worden aangedreven en de voorste en achterste motoren aan de rechterkant moeten beide naar voren worden aangedreven. Daarom is het veilig om hetzelfde paar spanningen toe te voeren aan beide motoren in een set. En de manier om dit te doen is door ze simpelweg parallel aan elkaar te koppelen.

Stap 4: Op naar de code

Er is nog maar één ding te doen om de rover aan de gang te krijgen. Ja, je raadt het goed! (Ik hoop dat je dat deed) We moeten de metingen van de versnellingsmeter nog vertalen in een vorm die de motorbestuurder kan interpreteren om de motoren te kunnen aandrijven. Als je denkt dat, aangezien de metingen van de versnellingsmeter analoog zijn en de motorbestuurder digitale signalen verwacht, we een soort van ADC moeten implementeren, nou ja, niet technisch, maar dat is wat we eigenlijk moeten doen. En het is vrij eenvoudig.

We weten dat een versnellingsmeter zwaartekrachtversnelling meet langs een lineaire as en dat deze versnelling wordt weergegeven als een spanningsniveau dat schommelt tussen de grond en de voedingsspanning, die onze microcontroller inleest als een analoge waarde variërend tussen 0 en 1023. Maar aangezien we Als je de accelerometer op 3,3V gebruikt, is het raadzaam dat we de analoge referentie voor de 10-bit ADC (die in de ATmeaga aan boord van een Arduino is geïntegreerd) instellen op 3,3V. Het maakt de dingen alleen maar eenvoudiger om te begrijpen; hoewel, het zal niet veel uitmaken voor ons kleine experiment, zelfs als we dat niet deden (we zullen de code gewoon een beetje moeten aanpassen). Om dit te doen, verbinden we echter eenvoudig de AREF-pin op de Arduino (pin 21 op de ATmega) met 3,3 V en geven we deze verandering in code aan door analogReference (EXTERNAL) aan te roepen.

Als we nu de versnellingsmeter plat en analoog leggen. Lees de versnelling langs de x- en y-assen (weet je nog? we hebben alleen deze twee assen nodig), we krijgen een waarde van ongeveer 511 (dwz halverwege tussen 0 en 1023), wat slechts een manier om te zeggen dat er 0 versnelling is langs deze assen. In plaats van in de details van het feit te graven, stelt u zich dit eens voor als de x- en y-assen in een grafiek, waarbij de waarde 511 de oorsprong aangeeft en 0 en 1023 de eindpunten zoals weergegeven in de afbeelding; oriënteer de versnellingsmeter zodanig dat de pinnen naar beneden wijzen en dichter bij u worden gehouden, anders zou u de assen kunnen omkeren/verwisselen. Dit betekent dat, als we de versnellingsmeter naar rechts kantelen, we een waarde groter dan 511 langs de x-as zouden moeten lezen, en als we de versnellingsmeter naar links kantelen, zouden we een waarde moeten krijgen die lager is dan 511 langs de x-as. Evenzo, als we de versnellingsmeter naar voren kantelen, zouden we een waarde groter dan 511 langs de y-as moeten lezen, en als we de versnellingsmeter naar achteren kantelen, zouden we een waarde lager dan 511 langs de y-as moeten lezen. En dit is hoe we in code de richting afleiden waarin de rover moet worden gereden. Maar dit betekent ook dat we de versnellingsmeter echt stabiel moeten houden en parallel uitgelijnd met een plat oppervlak om een 511 langs beide assen te kunnen lezen om de rover stil te laten staan. Om deze taak een beetje te vergemakkelijken, definiëren we bepaalde drempels die een grens vormen, zoals de afbeelding laat zien, zodat de rover stationair blijft zolang de x- en y-waarden binnen de grenzen liggen en we zeker weten dat de rover in beweging zodra de drempel wordt overschreden.

Als de y-as bijvoorbeeld 543 aangeeft, weten we dat de versnellingsmeter naar voren is gekanteld, dus we moeten de rover naar voren sturen. Dit doen we door pinnen D2 en D4 HOOG en pinnen D3 en D5 LAAG in te stellen. Omdat deze pinnen nu rechtstreeks op de HT-12E zijn aangesloten, worden de signalen geserialiseerd en worden ze door de RF-zender uitgezonden om te worden opgevangen door de RF-ontvanger die op de rover zit, die met behulp van de HT-12D de signalen deserialiseert en geeft ze door aan de L293D, die op zijn beurt deze signalen interpreteert en de motoren vooruit drijft

Misschien wilt u deze drempels echter wijzigen om de gevoeligheid te kalibreren. Een gemakkelijke manier om dit te doen, is door eenvoudig uw versnellingsmeter op uw Arduino aan te sluiten en een schets uit te voeren die de x- en y-waarden op de seriële monitor uitspuugt. Beweeg nu gewoon de versnellingsmeter een beetje, kijk door de meetwaarden en bepaal de drempels.

En dat is het! Upload de code naar je Arduino en geniet ervan!! Of misschien niet zo snel:-(Als je het bonusgedeelte niet hebt overgeslagen, zou het uploaden van de code naar je ATmega wat meer werk betekenen. Je hebt twee opties:

Optie A: Gebruik een USB-naar-serieel apparaat zoals de FTDI FT232 basis breakout-kaart. Leid eenvoudig draden van de TTL-header naar de overeenkomstige pinnen op de ATmega volgens de onderstaande afbeelding:

Pinnen op het Breakout-bord	Pinnen op de microcontroller
DTR/GRN	RST/reset (pin 1) via 0,1 µF dop
Rx	Tx (pin 3)
Tx	Rx (pin 2)
Vcc	+5v-uitgang
CTS	(ongebruikt)
Gnd	Grond

Sluit nu het ene uiteinde van een USB-kabel aan op het breakout-bord en het andere op uw pc en upload de code zoals u normaal zou doen: start de Arduino IDE, selecteer een geschikte seriële poort, stel het bordtype in, compileer de schets en klik op uploaden.

Optie B: Gebruik een UNO als je er ergens een hebt liggen. Sluit gewoon je ATmega aan op de UNO, upload de code zoals je normaal zou doen, trek de IC eruit en duw hem terug in het zendercircuit. Zo eenvoudig als taart!

Elk van deze opties zou moeten werken, ervan uitgaande dat je slim genoeg was om de bootloader van tevoren op je ATmega te branden, of, als je nog slimmer was om een ATmega te kopen met de bootloader al geïnstalleerd in de eerste plaats. Zo niet, ga je gang en doe dit door de hier beschreven stappen te volgen.

Andddd, we zijn officieel klaar! Ik hoop dat je genoten hebt van deze bizar lange instructable. Ga nu verder, voltooi het bouwen van je rover als je nog niet klaar bent, speel er een tijdje mee en kom terug om de opmerkingen hieronder te overspoelen met vragen en/of opbouwende kritiek.

Bedankt

PS De reden dat ik geen foto's van het voltooide project heb geüpload, is, nou ja, omdat ik het niet zelf heb voltooid. Halverwege het bouwen dacht ik aan enkele verbeteringen, zoals snelheidsregeling, obstakelvermijding en misschien een LCD op de rover, wat eigenlijk niet zo moeilijk is als we een microcontroller gebruiken aan zowel de zend- als de ontvangende kant. Maar waarom zou je het niet op de moeilijke manier doen?! Dus ik werk momenteel in die richting en ik zal een update plaatsen zodra het vruchten afwerpt. Ik heb de code en het ontwerp echter uitgetest met behulp van een snel prototype dat ik heb gebouwd met behulp van modules uit een van mijn eerdere projecten; je kunt de video hier bekijken.