- Förutsättningar:
- Koncept bakom projektet:
- Kretsschema:
- Programmering av din Arduino:
- Programmering av din Python:
- Geststyrd dator i aktion:
Nyligen Geststyrda bärbara datorer eller datorer blir väldigt kända. Denna teknik kallas Leap motion som gör det möjligt för oss att kontrollera vissa funktioner på vår dator / bärbara dator genom att helt enkelt vifta med handen framför den. Det är väldigt coolt och roligt att göra det, men dessa bärbara datorer är verkligen mycket höga priser. Så i det här projektet låt oss försöka bygga vår egen gestkontrollbärbar dator / dator genom att kombinera kraften från Arduino och Python.
Vi kommer att använda två ultraljudssensorer för att bestämma handens position och styra en mediaspelare (VLC) baserat på positionen. Jag har använt detta för demonstration, men när du förstår projektet kan du göra vad som helst genom att bara ändra några kodrader och styra din favoritapplikation på ditt favorit sätt.
Förutsättningar:
Vi har redan täckt några projekt som kombinerar Arduino med Python. Så jag antar att du redan har installerat Python och dess seriella bibliotek och framgångsrikt har provat några grundläggande projekt som blinkande lysdiod. Om inte, oroa dig inte, du kan falla tillbaka till den här Arduino-Python Led-kontrollhandledningen och komma överens med den. Så se till att du har installerat Python och pyserialt bibliotek innan du fortsätter.
Koncept bakom projektet:
Konceptet bakom projektet är väldigt enkelt. Vi kommer att placera två ultraljudssensorer (USA) ovanpå vår bildskärm och kommer att läsa avståndet mellan bildskärmen och vår hand med Arduino, baserat på detta avståndsvärde kommer vi att utföra vissa åtgärder. För att utföra åtgärder på vår dator använder vi Python pyautogui- biblioteket. Kommandona från Arduino skickas till datorn via seriell port (USB). Dessa data kommer sedan att läsas av python som körs på datorn och baserat på läsdata kommer en åtgärd att utföras.
Kretsschema:
För att styra datorn med handgester, anslut bara de två ultraljudssensorerna med Arduino. Vi vet att amerikanska sensorer arbetar med 5V och de drivs därför av Arduinos inbyggda spänningsregulator. Arduino kan anslutas till PC / Laptop för att driva modulen och även för seriell kommunikation. När anslutningarna är klara placerar du dem på din bildskärm enligt nedan. Jag har använt en dubbel sidoband för att fästa den på min bildskärm men du kan använda din egen kreativitet. Efter att ha säkrat den på en plats kan vi fortsätta med programmeringen.
Programmering av din Arduino:
Arduino bör programmeras för att läsa avståndet mellan handen och den amerikanska sensorn. Det fullständiga programmet ges i slutet av denna sida; strax nedan har jag gett förklaringen till programmet. Om du är ny med Ultraljudssensor, gå bara igenom Arduino & Ultraljudsbaserad avståndsmätning.
Genom att läsa avståndets värde kan vi komma fram till vissa åtgärder som ska styras med gester, till exempel i detta program har jag programmerat 5 åtgärder som en demo.
Åtgärd 1: När båda händerna är placerade framför sensorn på ett särskilt långt avstånd ska videon i VLC-spelaren spela / pausa.
Åtgärd 2: När höger hand är placerad framför sensorn på ett särskilt långt avstånd ska videon spola framåt ett steg.
Åtgärd 3: När vänster hand är placerad framför sensorn på ett särskilt långt avstånd ska videon spola tillbaka ett steg.
Åtgärd 4: När höger hand är placerad framför sensorn på ett visst nära avstånd och om den flyttas mot sensorn ska videon spola framåt och om den flyttas bort bör videon spola tillbaka.
Åtgärd 5: När vänster hand är placerad framför sensorn på ett särskilt nära avstånd och om den flyttas mot sensorn bör videovolymen öka och om den flyttas bort bör volymen minska.
Låt oss se hur programmet skrivs för att utföra ovanstående åtgärder. Så som alla program börjar vi med att definiera I / O-stiften enligt nedan. De två amerikanska sensorerna är anslutna till digitala stift 2,3,4 och 5 och drivs av + 5V stift. Utlösarstiften är utgångsstift och ekostiftar är ingångsstift.
Seriekommunikationen mellan Arduino och python sker med en överföringshastighet på 9600.
const int trigger1 = 2; // Trigger pin of 1st Sesnor const int echo1 = 3; // Echo pin of 1st Sesnor const int trigger2 = 4; // Trigger pin of 2nd Sesnor const int echo2 = 5; // Echo pin of 2nd Sesnor void setup () {Serial.begin (9600); pinMode (trigger1, OUTPUT); pinMode (echo1, INPUT); pinMode (trigger2, OUTPUT); pinMode (echo2, INPUT); }
Vi måste beräkna avståndet mellan sensorn och handen varje gång innan vi avslutar någon åtgärd. Så vi måste göra det många gånger, vilket innebär att den här koden ska användas som en funktion. Vi har skrivit en funktion som heter Calc_distance () som ger oss avståndet mellan sensorn och handen.
/ * ### Funktion för att beräkna avstånd ### * / ogiltig beräkna_distans (int trigger, int echo) {digitalWrite (trigger, LOW); delayMicroseconds (2); digitalWrite (trigger, HIGH); delayMicroseconds (10); digitalWrite (trigger, LOW); time_taken = pulseIn (echo, HIGH); dist = time_taken * 0,034 / 2; om (dist> 50) dist = 50; }
Inuti vår huvudslinga kontrollerar vi värdet på avståndet och utför de åtgärder som nämns ovan. Innan det använder vi två variabler distL och distR som uppdateras med aktuellt avståndsvärde.
beräkna avstånd (trigger1, echo1); distL = dist; // få avstånd från vänster sensor beräkningsavstånd (trigger2, echo2); distR = dist; // få avstånd från höger sensor
Eftersom vi vet avståndet mellan båda sensorerna kan vi nu jämföra det med fördefinierade värden och komma fram till vissa åtgärder. Till exempel om båda händerna är placerade på ett avstånd av 40 mc så spelar / pausar vi videon. Här skickas ordet "Spela upp / pausa" via seriell port
if ((distL> 40 && distR> 40) && (distL <50 && distR <50)) // Upptäck båda händerna {Serial.println ("Spela / pausa"); fördröjning (500);}
Om den högra handen ensam placeras före modulen, spolar vi framåt med ett steg och om det är vänster hand spolar vi tillbaka ett steg. Baserat på åtgärden skickas ordet ”Spola tillbaka” eller ”Vidarebefordra” ut via serieporten
if ((distL> 40 && distL <50) && (distR == 50)) // Detektera vänster hand {Serial.println ("Rewind"); delay (500);} if ((distR> 40 && distR <50) && (distL == 50)) // Detect Right Right {Serial.println ("Forward"); fördröjning (500);}
Mot detaljerad kontroll av volym och spår använder vi en annan metod för att förhindra falska utlösare. För att reglera volymen måste vi placera vänster hand ca. På ett avstånd av 15 cm kan du antingen flytta den mot sensorn för att minska volymen för att flytta den bort från sensorn för att öka volymen. Koden för detsamma visas nedan. Baserat på åtgärden skickas ordet "Vup" eller "Vdown" här via seriell port
// Lås vänster - Kontrollläge om (distL> = 13 && distL <= 17) {fördröjning (100); // Handhållstid beräkningsavstånd (trigger1, echo1); distL = dist; if (distL> = 13 && distL <= 17) {Serial.println ("Left Locked"); medan (distL <= 40) {beräkna avstånd (trigger1, echo1); distL = dist; if (distL <10) // Hand tryckt in {Serial.println ("Vup"); fördröjning (300);} om (distL> 20) // Hand dras ut {Serial.println ("Vdown"); fördröjning (300);}}}}
Vi kan använda samma metod för sensorn på höger sida också för att styra spåret på videon. Det vill säga om vi flyttar höger hand mot sensorn kommer den att spola framåt och om du flyttar bort den från sensorn spolar den tillbaka filmen. Baserat på åtgärden skickas ordet ”Spola tillbaka” eller ”Vidarebefordra” ut via serieporten
Du kan nu läsa över hela koden för denna geststyrda dator som ges i slutet av sidan och försöka underskatta den som en helhet och sedan kopiera den till din Arduino IDE.
Programmering av din Python:
Python-programmet för detta projekt är mycket enkelt. Vi måste bara skapa en seriekommunikation med Arduino genom rätt baudhastighet och sedan utföra några grundläggande tangentbordsåtgärder. Det första steget med python skulle vara att installera p yautogui- modulen. Se till att du följer detta steg eftersom programmet inte fungerar utan pyautogui-modulen.
Installera pyautogui-modul för Windows:
Följ stegen nedan för att installera pyautogui för Windows. Om du använder andra plattformar kommer stegen också att vara mer eller mindre lika. Se till att din dator / bärbara dator är ansluten till internet och fortsätt med stegen nedan
Steg 1: Öppna Windows Command prompt och ändra katalogen till den mapp där du har installerat python. Som standard ska kommandot vara
cd C: \ Python27
Steg 2: Använd kommandot python –m pip install –upgrade pip i din python-katalog för att uppgradera din pip. Pip är ett verktyg i python som hjälper oss att enkelt installera pythonmoduler. När denna modul har uppgraderats (som visas på bilden nedan), fortsätt till nästa steg.
python –m pip install –upgrade pip
Steg 3: Använd kommandot " python – m pip install pyautogui " för att installera pyautogui-modulen. När processen har lyckats bör du se en skärm som liknar den här nedan.
python –m pip install –upgrade pip
Nu när pyautogui- modulen och pyserialmodulen (installerad i föregående handledning) lyckades installeras med python, kan vi fortsätta med python-programmet. Den kompletta pytonkoden ges i slutet av självstudien men förklaringen till densamma är som följer.
Låt oss importera alla de tre modulerna som krävs för detta projekt. De är pyautogui, seriell python och tid.
importera serienummer # Serien importeras för seriell kommunikation importtid # Krävs för att använda fördröjningsfunktioner importera pyautogui
Därefter upprättar vi anslutning till Arduino via COM-port. På min dator är Arduino ansluten till COM 18. Använd enhetshanteraren för att hitta till vilken COM-port din Arduino är ansluten till och korrigera följande rad i enlighet därmed.
ArduinoSerial = serial.Serial ('com18', 9600) #Create Serial port object called arduinoSerialData time.sleep (2) #vänta i 2 sekunder för att kommunikationen ska bli etablerad
Inne i oändliga medan slingan vi gång på gång lyssna till COM-port och jämföra nyckelorden med alla pre-trotsade verk och göra viktiga ombord pressar därefter.
medan 1: inkommande = str (ArduinoSerial.readline ()) #läs seriell data och skriv ut den som radutskrift inkommande om 'Spela / Paus' i inkommande: pyautogui.typewrite (, 0.2) om 'Spola tillbaka' i inkommande: pyautogui. snabbtangent ('ctrl', 'vänster') om 'Vidarebefordra' i inkommande: pyautogui.hotkey ('ctrl', 'höger') om 'Vup' i inkommande: pyautogui.hotkey ('ctrl', 'ner') om ' Vdown 'i inkommande: pyautogui.hotkey (' ctrl ',' up ')
Som du kan se, för att trycka på en tangent måste vi helt enkelt använda kommandot "pyautogui.typewrite (, 0.2)" som kommer att trycka på tangentutrymmet i 0,2sek. Om du behöver snabbtangenter som ctrl + S kan du använda snabbtangentkommandot "pyautogui.hotkey ('ctrl', 's')".
Jag har använt dessa kombinationer eftersom de fungerar på VLC mediaspelare, du kan justera dem på vilket sätt du vill skapa dina egna applikationer för att styra vad som helst i datorn med gester.
Geststyrd dator i aktion:
Gör anslutningarna enligt ovan och ladda upp Arduino-koden på ditt Arduino-kort. Använd sedan python-skriptet nedan och starta programmet på din bärbara dator / dator.
Nu kan du spela vilken film som helst på din dator med VLC-mediaspelaren och använda din hand för att styra filmen som visas i videon nedan.
Hoppas du förstod projektet och tyckte om att leka med det. Detta är bara en demo och du kan använda din kreativitet för att bygga mycket mer coola geststyrda saker runt detta. Låt mig veta om detta var användbart och vad du kommer att skapa med hjälp av detta i kommentarsektionen och jag kommer gärna att veta det.