Het is allemaal begonnen met een klein spel uit de middeleeuwen genaamd "Mario", vanaf het moment dat ik een klein mannetje was dat op eenden springt om mijn prinses te redden tot een mannelijke knappe prins die ronddwaalt in Perzië (Prins van Perzië) vecht tegen de duisternis Om mijn wereld achter mij te redden, ben ik een grote fan geweest van het spelen van videogames en ben ik opgegroeid met het spelen ervan. Maar ze vervelen zich soms wel en ik voel me er minder bij betrokken. Tegenwoordig maken de geavanceerde gameconsoles virtueel gamen mogelijk en helpen ze ons om het spel veel beter te voelen dan een toetsenbord of muis.
Als Arduino-liefhebber was ik het spelen van het beroemde spel "Angry Birds" met toetsenbord en muis moe en besloot ik mijn eigen gamecontroller te bouwen met een flexibele sensor en een potentiometer. Wanneer aan de flex-sensor wordt getrokken, wordt ook aan de vogel op de katapult getrokken en kun je met de potmeter de richting bepalen waarin hij moet worden gelanceerd. Als je dan de flex-sensor loslaat, wordt de vogel gelanceerd. Ik vond het best leuk om te doen, dus als je iets soortgelijks wilt bouwen, dan zal deze tutorial nuttig zijn. Deze tutorial is ook nuttig bij het besturen van de muiscursor met behulp van een potentiometer.
Software- en hardwarevereisten:
Software:
- Arduino IDE
- Verwerking IDE
- Angry Birds Game op computer
Hardware:
- Arduino (elke versie)
- Potentiometer
- Flex-sensor
- 47K ohm weerstand
- Verbindingsdraden
- Breadboard
Concept achter:
Het Arduino-bord leest de waarden van de Potentiometer en Flex Senor en verzendt deze naar de laptop / pc via de USB COM-poort via de normale Serial.write () -functie. We lezen deze informatie vervolgens met Processing en besturen de muiscursor met behulp van de Robot-klasse in Java die wordt ondersteund door IDE-verwerking. We hebben de verwerkings-IDE zo geprogrammeerd dat wanneer aan de Flex-sensor wordt getrokken, een muisklik wordt gemaakt en op basis van hoeveel eraan wordt getrokken, de muisaanwijzer in X-richting beweegt. Vervolgens zullen we op basis van de waarde van de potentiometer de muiscursor in de Y-richting verplaatsen, op deze manier kunnen we de richting instellen waarin de vogel moet worden gelanceerd.
Schakelschema:
Het circuit voor het spelen van de Angry Bird met behulp van de Flex-sensor en de potentiometer is eenvoudig.
We hebben eenvoudig een potentiometer en een flexsensor aangesloten op de analoge ingangen (A0, A1) van de Arduino. De output van de Flex-sensor wordt ook naar beneden getrokken met behulp van een 47K pull-down-weerstand.
Je kunt het rechtstreeks op een breadboard aansluiten of ze op een Perf-bord solderen en het op een handschoenen of iets anders monteren om het creatiever te maken. Ik heb gewoon een breadboard gebruikt om mijn verbindingen tot stand te brengen, zoals hieronder wordt weergegeven:
Arduino-programma:
De volledige Arduino-code wordt aan het einde van de tutorial gegeven. Enkele belangrijke regels worden hieronder uitgelegd.
We initialiseren het programma om te werken met 9600 baudrate en beginnen de waarden van de Flex-sensor en Potentiometer te lezen. Zoals we weten, kan de functie serial.write () slechts één byte aan gegevens tegelijk verzenden. Omdat één byte 8 bits is en 2 ^ 8 = 256. We kunnen waarden verzenden van 0 tot 256. We moeten dus de waarden van de Flex-sensoruitgang en de potentiometeruitgang comprimeren naar 0 tot 256.
Om dat te doen gebruiken we de map () functie in Arduino. Alle waarden van de flex-sensor worden omgezet van 5 naar 100, dus wanneer we de sensor buigen, wordt hij verhoogd van 5 en wanneer hij wordt losgelaten, gaat hij terug naar 5. Om de muisklikken te noemen, wordt de waarde 1 en 0 gebruikt. Wanneer 1 wordt verzonden, wordt de muis ingedrukt en wanneer 0 wordt verzonden, wordt de muis losgelaten.
if (FlexValue> = 65 && FlexValue <= 120) // mijn flex-sensor varieert van 65 tot 120, uw kan een andere zijn {FlexValue = map (FlexValue, 120,65,0,100); // gebaseerd op buiging omzetten naar 0 tot 100 als (FlexValue> = 5) // 1 en 0 wordt gebruikt voor muisklik, dus begin bij 5 {Mclick = true; Serial.write (1); // 1 wordt verzonden om de muis met de linkermuisknop te laten klikken Serial.write (FlexValue); // Flex-waarde is de afstand om de muis in X-richting te bewegen} anders {Mclick = false; Serial.write (0);}}
Op dezelfde manier worden de waarden van de potentiometer omgezet van 101 naar 200 via de map () -functie en worden ze naar de COM-poort van de laptops gestuurd met de functie Serial.write () , zoals hieronder wordt weergegeven.
if (potValue <= 200) {potValue = map (potValue, 0,200,101,201); // Gebaseerd op zijn beurt converteren naar 101 naar 201 Serial.write (potValue); // Potwaarde is de afstand om de muis in Y-richting te bewegen}
De rest van het programma wordt uitgelegd aan de hand van de opmerkingen.
Verwerkingscode:
Processing is een open-source ontwikkelapplicatie en kan eenvoudig worden gedownload en gebruikt voor het ontwikkelen van interessante projecten met Arduino of andere microcontrollers. We hebben al een paar projecten gedaan met Processing en u kunt ze bekijken door op de onderstaande links te klikken.
- DIY FM-radio met behulp van verwerking
- Virtual Reality / Gesture control met Arduino
- Privéchatroom met Arduino.
- Arduino-radarsysteem met behulp van verwerkings-APP en ultrasone sensor
- Realtime gezichtsherkenning en tracking met Arduino
- DIY-snelheidsmeter met Arduino en verwerking
- Pingpongspel met Arduino Accelerometer
- Tweevoetige Robot met Arduino
- DIY Arduino warmtebeeldcamera
In dit project hebben we de verwerkings-IDE gebruikt om de COM-poortwaarden te lezen en de muisaanwijzer te besturen op basis van de waarden die via de COM-poort worden ontvangen. De volledige verwerkingscode voor deze Angry Bird Game Controller kan worden gedownload via de onderstaande link:
- Verwerkingscode voor deze Angry Bird Game Controller (klik met de rechtermuisknop en 'Link opslaan als')
Het Arduino-programma is te vinden aan het einde van deze tutorial. De verwerkingscode is aangepast aan ons doel van de code die door yoggy op zijn GitHub-pagina is gegeven.
De gegevens die van de COM-poort komen, moeten worden gelezen in dezelfde baudrate als waarmee ze zijn verzonden vanaf Arduino. Controleer ook met behulp van de apparaatbeheerder op welke COM-poort uw Arduino is aangesloten. Mijn Arduino was verbonden met COM3 en het was de 0 ste poort op mijn computer en de baudrate in Arduino was 9600, dus de code is als volgt
port = new Serial (this, Serial.list (), 9600);
Zodra we de waarden beginnen te lezen, onderscheiden we deze door deze te herkennen op basis van de waarde op basis van hoe we vanuit Arduino hebben verzonden. De waarden worden opnieuw toegewezen van 0 tot 100, zodat we de muis kunnen besturen op basis van die waarde.
if (port.available ()> 0) {data = port.read (); println (gegevens); // Lees de gegevens van de COM-poort en sla deze op in data} if (data> = 101 && data <= 201) // Als de waarde van 101 tot 201 is, dan moet deze van Potentiometer {Turn = int (map (data 101,201,0,100)); // Gebruik die waarde om de catapullt te draaien} if (data> = 5 && data <= 100) // Als de waarde tussen 5 en 100 ligt, moet deze van Flex Sensor {Pull = int (map (data, 5,100, 0,100));} // Gebruik die waarde om de katapult te trekken if (data == 1) click = true; // Gebruik die waarde om op de muisknop te drukken if (data == 0) click = false; // Gebruik die waarde om de muisknop los te laten
Zodra we de gegevens hebben gecategoriseerd, kunnen we de muis besturen met behulp van de Robot Java Class in Processing. Het commando robot.mouseMove (crntX-Pull, crntY + Turn); kan worden gebruikt om de muis naar elke gewenste positie te verplaatsen en de lijnen robot.mousePress (InputEvent.BUTTON1_DOWN_MASK); en robot.mouseRelease (InputEvent.BUTTON1_DOWN_MASK); kan worden gebruikt om respectievelijk de muisknop in te drukken of los te laten.
if (click == false) // wanneer Flex Sesnor niet wordt opgehaald {crntX = (int) p.getX (); crntY = (int) p.getY (); if (Pull> 50) robot.mouseRelease (InputEvent.BUTTON1_DOWN_MASK); // Laat de muisknop los} if (click == true) // wanneer Flex Sesnor wordt getrokken {robot.mousePress (InputEvent.BUTTON1_DOWN_MASK); // Druk op de muisknop robot.mouseMove (crntX-Pull, crntY + Turn); // Verplaats de muis op basis van de Flex- en POT-waarde}}
Wanneer de verwerkings-IDE wordt gestart, wordt ook een klein dialoogvenster weergegeven waarin u de waarden van trekken, draaien en de status van muisklik kunt vinden, zoals hieronder weergegeven
Dit detail kan worden gebruikt om het programma te debuggen of om eventuele vereiste gegevens te corrigeren.
Werken:
Om dit Angry Bird Project te laten werken met behulp van de meegeleverde code, monteert u uw hardware volgens het schakelschema en uploadt u de gegeven Arduino-code. Noteer vervolgens op welke COM-poort uw Arduino is aangesloten en breng de nodige wijzigingen aan in de verwerkingscode en start de verwerkingsschets.
Start nu simpelweg het boze vogelspel en plaats je cursor naast de katapult en trek aan de flex-sensor om de vogel te trekken en de richting in te stellen met behulp van de potentiometer. Zodra de richting is ingesteld, laat u de Flex-sensor los
EEEEWWWWWEEEEEEEEEE !!!!!!!!!!……………
Je vogel wordt zo de lucht in gegooid en BOOM !! Op de zwijntjes. De volledige werking is te vinden in de onderstaande video.
Ik hoop dat je genoten hebt van het project en iets soortgelijks hebt kunnen bouwen. Als je twijfels hebt, kun je me bereiken in het commentaargedeelte of je vraag op het forum stellen voor technische vragen.
Nu, tijd om tegen die spaarpotten te botsen en onze vogeleieren terug te krijgen !!!!