- Förutsättningar
- Kretsschema
- Processflöde för luftmusen
- Programmering av Arduino för Air Mouse
- Python Driver Script
- Testar Arduino Air Mouse
Har någonsin undrat hur vår värld går mot den uppslukande verkligheten. Vi hittar kontinuerligt nya sätt och metoder för att interagera med vår omgivning med virtuell verklighet, blandad verklighet, förstärkt verklighet etc. Nya enheter kommer ut varje dag med dessa snabba tekniker för att imponera på deras nya interaktiva teknik.
Dessa uppslukande tekniker används i spel, interaktiva aktiviteter, underhållning och många andra applikationer. I den här handledningen kommer vi att veta om en sådan interaktiv metod som ger dig ett nytt sätt att interagera med ditt system istället för att använda en tråkig mus. Våra spelnördar måste veta att Nintendo för några år tillbaka säljer ut en idé om en 3D-interaktiv metod för att interagera med sina konsoler med hjälp av en handhållen styrenhet som kallas Wii-kontroller. Den använder accelerometern för att hitta dina gester för ett spel och skicka den trådlöst till systemet. Om du vill veta mer om denna teknik kan du kolla in deras patent EP1854518B1, detta ger dig en fullständig uppfattning om hur denna teknik fungerar.
Inspirerad av denna idé ska vi skapa en "Air mus", för att interagera med system bara genom att flytta konsolen i luften, men istället för att använda tredimensionella koordinatreferenser, kommer vi bara att använda 2-dimensionella koordinatreferenser så vi kan imitera datormusens handlingar eftersom musen fungerar i två dimensioner X och Y.
Konceptet bakom denna trådlösa 3D-luftmus är mycket enkelt, vi kommer att använda en accelerometer för att få värdet av accelerationen av åtgärderna och rörelserna från ”Luftmusen” längs x- och y-axeln, och sedan baserat på accelerometern kommer vi att styra muspekaren och utföra vissa åtgärder med hjälp av python-mjukvarudrivrutiner som körs på datorn.
Förutsättningar
- Arduino Nano (vilken modell som helst)
- Accelerometer ADXL335-modul
- Bluetooth HC-05-modul
- Trycka på knappar
- Python-installerad dator
För att lära dig mer om att installera python i datorn, följ den föregående handledningen om Arduino-Python LED-styrning.
Kretsschema
För att styra din dator med handrörelserna behöver du en accelerometer som ger accelerationen längs X- och Y-axeln och för att göra hela systemet trådlöst används en Bluetooth-modul för att överföra signalen trådlöst till ditt system.
Här används en ADXL335-accelerometer, det är en MEMS-baserad trippelaxelmodul som matar ut accelerationen längs X-, Y- och Z-axeln men som tidigare sagt för att kontrollera musen skulle vi bara behöva accelerationen längs X- och Y-axeln. Lär dig mer om att använda ADXL335 accelerometer med Arduino med våra tidigare projekt:
- Arduino-baserat varningssystem för bilolyckor med GPS, GSM och accelerometer
- Ping Pong Game med Arduino och Accelerometer
- Accelerometerbaserad handgeststyrd robot med Arduino
- Jordbävningsdetektorlarm med Arduino
Här är Xout- och Yout-stiftet på accelerometern ansluten till Analog-, A0- och A1-stiften på Arduino och för överföring av signalerna från Arduino till systemet används Bluetooth-modul HC-05, eftersom Bluetooth fungerar över Tx och Rx stiftanslutningar, så vi använder seriella stift D2 och D3 för programvara. Den ansluts med hjälp av mjukvaruserie, för om vi ansluter Bluetooth till maskinvaruserien och börjar få avläsningarna över pythonkonsolen skulle det visa fel för den felaktiga överföringshastigheten eftersom Bluetooth skulle kommunicera med pythonen på sin egen baudhastighet. Lär dig mer om att använda Bluetooth-modulen genom att gå igenom olika Bluetooth-baserade projekt med olika mikrokontroller, inklusive Arduino.
Här har vi använt tre tryckknappar - en för att utlösa luftmusen och andra två för vänster och högerklick som visas i bilden nedan:
Processflöde för luftmusen
Flödesschemat visar processflödet för Arduino-baserade Air Mouse:
1. Systemet kontrollerar kontinuerligt om den mekaniska avtryckaren ska tryckas tills den inte trycks in, vi kan träna normalt med datormusen.
2. När systemet upptäcker knapptryckning överförs kontrollen för musen till luftmusen.
3. När du trycker på avtryckarknappen börjar systemet överföra mätvärdena till datorn. Systemavläsningen består av accelerometeravläsningarna och avläsningarna för vänster och högerklick.
4. Systemavläsningarna består av dataströmmen på 1 byte eller 8 bitar, där de första tre bitarna består av X-koordinaterna, den andra tre bitarna består av Y-koordinaterna, den näst sista biten är statusbiten för att få status för musens vänstra klick och den sista biten är statusbit för att få status för högerklick.
5. Värdet för de första tre bitarna, dvs X-koordinaten kan sträcka sig från 100 <= Xcord <= 999, medan värdet för Y-koordinaten kan sträcka sig från 100 <= Ycord <= 800. Värdena för högerklick och vänsterklick är de binära värdena antingen 0 eller 1 där 1 anger att klicket har gjorts och 0 att klicket inte görs av användaren.
6. För att inte låta knappen studsas påverka markörens position, hålls en känd fördröjning på 4 sekunder efter varje klick på musens utlösarknapp.
7. För höger- och vänsterklick i luftmusen måste vi först trycka antingen på vänster eller höger tryckknapp, och efter det måste vi trycka på avtryckarknappen för att flytta till luftmusens position där vi vill.
Programmering av Arduino för Air Mouse
Arduino bör programmeras för att läsa accelerationsvärdena i X- och Y-axeln. Det fullständiga programmet ges i slutet, nedan är de viktiga kodavsnitten.
Ställa in de globala variablerna
Som tidigare sagt kommer vi att ansluta Bluetooth-modulen med programvarans seriella stift. Så för att ställa in programvarans serie måste vi deklarera programvarans bibliotek och ställa in stiften för Tx och Rx. I Arduino kan Nano och Uno Pin 2 och 3 fungera som en mjukvaruserie. Därefter förklarar vi Bluetooth-objektet från programvarans seriella bibliotek för att ställa in stiftet för Tx och Rx.
#omfatta
Ogiltig installation ()
I installationsfunktionen ska vi ställa in variablerna för att berätta för programmet om de kommer att fungera som ingång eller utgång. Utlösarknappen skulle ställas in som ingångsuppdrag, och vänster och höger klick deklareras som ingång och ställs in som Hög för att få dem att fungera som ingångsuppdrag.
Ställ också in överföringshastigheten för serie- och Bluetooth-kommunikation till 9600.
ogiltig installation () { pinMode (x, INPUT); pinMode (y, INPUT); pinMode (trigger, INPUT_PULLUP) pinMode (lklicka, INPUT); pinMode (rclick, INPUT); pinMode (led, OUTPUT); digitalWrite (lclick, HIGH); digitalWrite (rclick, HIGH); Serial.begin (9600); Bluetooth.begin (9600); }
Annullerad slinga ()
Eftersom vi skulle behöva utlösarknappen för att berätta när vi behöver skicka dataströmmen till systemet, så ställer vi in hela koden inuti while- slingan som kontinuerligt kommer att övervaka det digitala tillståndet för pull-up-utlösaren, eftersom den går låg skicka vidare till behandlingen.
Eftersom vi har anslutit en lysdiod för att informera oss om systemets status när utlösarknappen trycks in, ställde vi inledningsvis ledningen till låg utanför while- slingan eftersom den är standardförhållande och hög inuti while- slingan som lyser upp ledningen när avtryckaren trycks ned.
För att läsa status för vänster- och högerklickknappen har vi globalt deklarerat två variabler lklick och rklick vars värden ursprungligen var inställda på 0.
Och i slingan , ställ in värdet på dessa variabler enligt den digitala statusen för vänster och högerklick-knappen för att kontrollera om knapparna trycks in eller inte.
Vi skulle läsa värdena på X- och Y-stiften på accelerometern med hjälp av analogRead- funktionen och skulle kartlägga dessa värden till skärmstorleken så att muspekaren rör sig över hela skärmen. Eftersom skärmstorleken är pixlarna på skärmen måste vi ställa in den i enlighet därmed och eftersom vi behöver utgångsvärdet vara tre siffror har vi medvetet ställt in intervallet för X som 100 <= X <= 999 och på liknande sätt värde för Y som 100 <= Y <= 800. Kom ihåg att pixlarna läses upp från det övre vänstra hörnet, dvs. det övre vänstra hörnet har värdet (0,0), men eftersom vi har deklarerat tre siffror för x och y kommer våra värden att läsas från punkten (100,100).
Skriv ut värdet på koordinaterna och statusen för klicket över serien och Bluetooth med hjälp av Serial.print och bluetooth.print- funktioner som de hjälper till att få värdena på seriell bildskärm och över ditt system via Bluetooth.
Äntligen, på grund av studsande av en knapp kan ett enda värde upprepas vilket skulle få en muspekare att dröja kvar över en enda position, så för att bli av med detta måste vi lägga till denna fördröjning.
void loop () { digitalWrite (led, LOW); medan (digitalRead (trigger) == LOW) { digitalWrite (led, HIGH); lstate = digitalRead (lclick); rstate = digitalRead (rclick); xh = analogRead (x); yh = analogRead (y); xcord = karta (xh, 286,429,100,999); ycord = karta (yh, 282,427,100,800); Serial.print (xcord); Serial.print (ycord); if (lstate == LOW) Serial.print (1); annat Serial.print (0); if (rstate == LOW) Serial.print (1); annat Serial.print (0); bluetooth.print (xcord); bluetooth.print (ycord); om (lstate == LOW) bluetooth.print (1); annan bluetooth.print (0); om (rstate == LOW) bluetooth.print (1); annars bluetooth.print (0); fördröjning (4000); }}
Python Driver Script
Från och med nu har vi slutfört med hårdvaran och dess firmware-del, nu för att få luftmusen att fungera behöver vi ha ett drivrutinsskript som kan avkoda signalerna från luftmusen till markörrörelserna, så för detta har vi valt Pytonorm. Python är ett skriptspråk och med skript här menar vi att det hjälper oss att få kontroll över det andra programmet, eftersom vi här kontrollerar muspekaren.
Så öppna ditt pythonskal och få följande bibliotek installerade med kommandona nedan:
pip installera seriell pip installera pyautogui
Den seriella är ett bibliotek för Python som hjälper oss att få data från seriella gränssnitt såsom COM-portar och även låter oss manipulera det medan pyautogui är bibliotek för Python att få kontroll över de grafiska funktioner, i detta fall, mus.
Låt oss nu komma till koden för drivrutinerna, det första vi behöver göra är att importera serie- och pyautogui-biblioteken, och sedan från det seriella biblioteket måste vi ställa in porten för kommunikationen med en överföringshastighet på 9600, samma som Bluetooth.serial fungerar vid. För detta måste du ansluta Bluetooth-modulen till ditt system och sedan i systeminställningarna måste du kolla vilken port den är ansluten till.
Nästa sak är att läsa seriekommunikationen från Bluetooth till systemet och att hålla den igång kontinuerligt hålla resten av koden i en kontinuerlig slinga med hjälp av medan 1.
Som sagt tidigare att Arduino skickar ut 8 bitar, första 6 för koordinaterna och de två sista för status för klickknapparna. Så läs alla bitar med hjälp av serelläs och ställ in längden till 8 bitar.
Därefter delar du bitarna för markörkoordinaterna och klickar genom att skära dem över och skär sedan ner markörbitarna i X- och Y-koordinaterna separat. Samma sak gäller vänster och högerklick.
Nu från kommunikationen får vi en byte-sträng och vi måste konvertera den till ett heltal så att de kan passa in i koordinaterna, vi gör detta genom att avkoda dem och sedan skriva dem i heltal.
För att flytta markören använder vi pyautogui moveto- funktionen, som tar dessa heltalskoordinater som argument och flyttar markören till den positionen.
Nästa kontroll för klick, vi gör det genom att använda de två sista bitarna och pyautoguis klickfunktion, dess standardklick är kvar en, men vi kan ställa in det till höger genom att deklarera knappvärdet till höger, vi kan också definiera antalet klick till ställ in det till ett dubbelklick genom att ställa in klickparametern på 2.
Nedan följer den fullständiga Python-koden som ska köras på datorn:
importera serieimport pyautogui ser = serial.Serial ('com3', 9600) medan 1: k = ser.läs (8) markör = k klicka = k x = markör y = markör l = klicka r = klicka xcor = int (x.decode ('utf-8')) ycor = int (y.decode ('utf-8')) pyautogui.moveTo (xcor, ycor) om l == 49: pyautogui.click (klick = 2) elif r = = 49: pyautogui.click (knapp = 'höger', klick = 2)
Testar Arduino Air Mouse
Så för att använda Air Mouse ska du ansluta en strömkälla till den. Det kan vara från Arduino Nano USB-kortplats eller från den 5v-reglerade strömförsörjningen med 7805 IC. Kör sedan python-drivrutinsskriptet genom att ställa in komporten som din Bluetooth är ansluten till. När skriptet körs skulle du se en tidsfördröjning när Bluetooth blinkar betyder det att den är ansluten till ditt system. Klicka sedan på avtryckarknappen för att använda den så ser du att koordinaternas position ändras och om du vill ha vänster- eller högerklick, tryck sedan först på vänster eller höger tryckknapp och utlösarknapp tillsammans, du skulle se åtgärden för klicket på en ändrad plats för markören.
Kontrollera detaljerade arbetar Video nedan.