- Paunang mga kinakailangan:
- Konsepto sa likod ng proyekto:
- Diagram ng Circuit:
- Programming ang iyong Arduino:
- Pag-program ng iyong Python:
- Pagkontrol ng Kinokontrol na Kompyuter sa Pagkilos:
Kamakailan-lamang na kinokontrol ng Gesture Ang mga laptop o computer ay sumisikat. Ang pamamaraang ito ay tinatawag na Leap motion na nagbibigay-daan sa amin upang makontrol ang ilang mga pagpapaandar sa aming computer / Laptop sa pamamagitan lamang ng pagwagayway ng kamay sa harap nito. Napakalamig at kasiya-siya na gawin ito, ngunit ang mga laptop na ito ay talagang napakataas ang presyo. Kaya sa proyektong ito, subukan nating bumuo ng aming sariling kontrol ng Gesture na Laptop / Computer sa pamamagitan ng pagsasama ng Lakas ng Arduino at Python.
Gumagamit kami ng dalawang mga sensor ng Ultrasonic upang matukoy ang posisyon ng aming kamay at makontrol ang isang media player (VLC) batay sa posisyon. Ginamit ko ito para sa pagpapakita, ngunit kapag naintindihan mo ang proyekto, maaari kang gumawa ng anumang bagay sa pamamagitan lamang ng pagbabago ng ilang mga linya ng code at makontrol ang iyong paboritong application sa iyong paboritong paraan.
Paunang mga kinakailangan:
Nakatakip na kami ng ilang mga proyekto kung saan pinagsasama ang Arduino sa Python. Kaya ipinapalagay ko na na-install mo na ang Python at ang serial library at matagumpay na sinubukan ang ilang mga pangunahing proyekto tulad ng blinking LED. Kung hindi, huwag mag-alala maaari kang bumalik sa Arduino-Python Led Controlling tutorial na ito at makasama ito. Kaya tiyaking na-install mo ang Python at pyserial library bago magpatuloy.
Konsepto sa likod ng proyekto:
Ang konsepto sa likod ng proyekto ay napaka-simple. Ilalagay namin ang dalawang mga sensor ng Ultrasonic (US) sa tuktok ng aming monitor at babasahin ang distansya sa pagitan ng monitor at ng aming kamay gamit ang Arduino, batay sa halagang ito sa distansya ay magsasagawa kami ng ilang mga pagkilos. Upang maisagawa ang mga pagkilos sa aming computer ay gumagamit kami ng Python pyautogui library. Ang mga utos mula sa Arduino ay ipinapadala sa computer sa pamamagitan ng serial port (USB). Ang data na ito ay babasahin ng sawa na tumatakbo sa computer at batay sa binasang data ay isang pagkilos ang isasagawa.
Diagram ng Circuit:
Upang makontrol ang PC gamit ang Mga Hand Gesture, ikonekta lamang ang dalawang mga sensor ng Ultrasonic sa Arduino. Alam namin na gumagana ang sensor ng US sa 5V at samakatuwid pinapagana sila ng on board Voltage regulator ng Arduino. Ang Arduino ay maaaring konektado sa PC / Laptop para sa pagpapatakbo ng module at din para sa Serial na komunikasyon. Kapag tapos na ang mga koneksyon ilagay ang mga ito sa iyong monitor tulad ng ipinakita sa ibaba. Gumamit ako ng isang double side tape upang idikit ito sa aking monitor ngunit maaari mong gamitin ang iyong sariling pagkamalikhain. Matapos ma-secure ito sa isang lugar maaari kaming magpatuloy sa Programming.
Programming ang iyong Arduino:
Ang Arduino ay dapat na program upang mabasa ang distansya ng kamay mula sa US sensor. Ang kumpletong programa ay ibinibigay sa pagtatapos ng pahinang ito; sa ibaba lamang ay nabigyan ko ng paliwanag para sa programa. Kung bago ka sa sensor ng Ultrasonic, dumaan lamang sa Arduino at Ultrason Sensor Batay sa Pagsukat sa Distansya.
Sa pamamagitan ng pagbabasa ng halaga ng distansya maaari naming makarating sa ilang mga pagkilos upang makontrol ng mga galaw, halimbawa sa programang ito na na-program ko ang 5 mga pagkilos bilang isang demo.
Pagkilos 1: Kapag ang parehong mga kamay ay nakalagay bago ang sensor sa isang partikular na malayong distansya pagkatapos ay dapat i-play / I-pause ang video sa VLC player.
Pagkilos 2: Kapag ang kanang kamay ay nakalagay bago ang sensor sa isang partikular na distansya pagkatapos ang video ay dapat na Mabilis na Ipasa ang isang hakbang.
Pagkilos 3: Kapag ang kaliwang kamay ay nakalagay bago ang sensor sa isang partikular na malayong distansya pagkatapos dapat i-rewind ang video ng isang hakbang.
Pagkilos 4: Kapag ang kanang kamay ay nakalagay bago ang sensor sa isang partikular na malapit na distansya at pagkatapos kung inilipat patungo sa sensor ang video ay dapat na mabilis na pasulong at kung inilayo ang video dapat na Rewind.
Pagkilos 5: Kapag ang kaliwang kamay ay inilalagay bago ang sensor sa isang partikular na malapit sa distansya at pagkatapos kung ilipat patungo sa sensor ang dami ng video ay dapat na tumaas at kung inilayo ang dami dapat na Bawasan.
Tingnan natin kung paano nakasulat ang programa upang maisagawa ang mga pagkilos sa itaas. Kaya, tulad ng lahat ng mga programa nagsisimula kami sa pagtukoy sa mga I / O pin tulad ng ipinakita sa ibaba. Ang dalawang sensor ng US ay konektado sa mga Digital pin na 2,3,4 at 5 at pinalakas ng + 5V pin. Ang mga trigger pin ay output pin at ang mga Echo pin ay mga input na pin.
Ang Serial na komunikasyon sa pagitan ng Arduino at python ay tumatagal ng mga lugar sa baud rate na 9600.
Const int trigger1 = 2; // Trigger pin ng 1st Sesnor const int echo1 = 3; // Echo pin ng 1st Sesnor const int trigger2 = 4; // Trigger pin ng 2nd Sesnor const int echo2 = 5; // Echo pin ng 2nd Sesnor void setup () {Serial.begin (9600); pinMode (trigger1, OUTPUT); pinMode (echo1, INPUT); pinMode (trigger2, OUTPUT); pinMode (echo2, INPUT); }
Kailangan nating kalkulahin ang distansya sa pagitan ng Sensor at ng kamay sa bawat oras bago magtapos sa anumang pagkilos. Kaya kailangan nating gawin ito nang maraming beses, na nangangahulugang ang code na ito ay dapat gamitin bilang isang pagpapaandar. Sumulat kami ng isang pagpapaandar na pinangalanang calcul_dist () na ibabalik sa amin ang distansya sa pagitan ng sensor at ng kamay.
/ * ### Pag-andar upang makalkula ang distansya ### * / walang bisa ang calcul_distance (int trigger, int echo) {digitalWrite (trigger, LOW); delayMicroseconds (2); digitalWrite (gatilyo, TAAS); delayMicroseconds (10); digitalWrite (trigger, LOW); time_taken = pulseIn (echo, HIGH); dist = time_taken * 0.034 / 2; kung (dist> 50) dist = 50; }
Sa loob ng aming pangunahing loop sinusuri namin ang halaga ng distansya at isinasagawa ang mga pagkilos na nabanggit sa itaas. Bago ito gumagamit kami ng dalawang variable na distL at distR na na-update sa kasalukuyang halaga ng distansya.
calcul_distance (trigger1, echo1); distL = dist; // kumuha ng distansya ng kaliwang sensor calcul_distance (trigger2, echo2); distR = dist; // kumuha ng distansya ng tamang sensor
Dahil alam namin ang distansya sa pagitan ng parehong mga sensor, maaari na naming ihambing ito sa mga paunang natukoy na halaga at makarating sa ilang mga pagkilos. Halimbawa kung ang parehong mga kamay ay nakalagay sa layo na 40 mc pagkatapos ay i-play / i-pause namin ang video. Narito ang salitang "Play / Pause" ay ipapadala sa pamamagitan ng serial port
kung ((distL> 40 && distR> 40) && (distL <50 && distR <50)) // Detect both hands {Serial.println ("Play / Pause"); antala (500);}
Kung ang kanang kamay lamang ay inilalagay bago ang module pagkatapos ay mabilis nating isinasagawa ang video sa pamamagitan ng isang hakbang at kung ito ay kaliwang kamay ay nire-rewind namin ng isang hakbang. Batay sa aksyon, narito ang salitang "Rewind" o "Forward" ay ipapadala sa pamamagitan ng serial port
kung ((distL> 40 && distL <50) && (distR == 50)) // Detect Left Hand {Serial.println ("Rewind"); antala (500);} kung ((distR> 40 && distR <50) && (distL == 50)) // Detect Right Hand {Serial.println ("Forward"); antala (500);}
Foe detalyadong kontrol ng dami at subay na gumagamit kami ng ibang pamamaraan upang maiwasan ang mga maling pag-trigger. Upang makontrol ang dami kailangan nating mailagay ang kaliwang kamay. Sa distansya na 15 cm, maaari mo itong ilipat alinman sa sensor upang bawasan ang dami ng paglipat nito palayo sa sensor upang madagdagan ang dami. Ang code para sa pareho ay ipinapakita sa ibaba. Batay sa aksyon, narito ang salitang "Vup" o "Vdown" ay ipapadala sa pamamagitan ng serial port
// Lock Left - Control Mode kung (distL> = 13 && distL <= 17) {pagkaantala (100); // Oras ng Paghawak ng Kamay calculusdist (trigger1, echo1); distL = dist; kung (distL> = 13 && distL <= 17) {Serial.println ("Left Locked"); habang (distL <= 40) {calcul_distance (trigger1, echo1); distL = dist; kung (distL <10) // Itinulak ang kamay sa {Serial.println ("Vup"); antala (300);} kung (distL> 20) // Inilabas ng kamay ang {Serial.println ("Vdown"); pagkaantala (300);}}}}
Maaari naming gamitin ang parehong pamamaraan para sa kanang bahagi ng sensor din, upang makontrol ang track ng video. Iyon ay kung ilipat natin ang kanang kamay patungo sa sensor na ito ay mabilis na isusulong ang pelikula at kung ililipat mo ito mula sa sensor ay ire-rewind ang pelikula. Batay sa aksyon, narito ang salitang "Rewind" o "Forward" ay ipapadala sa pamamagitan ng serial port
Maaari mo na ngayong basahin ang kumpletong code para sa kilos na kinokontrol na PC na ibinigay sa dulo ng pahina at subukang i-understate ito bilang isang buo at pagkatapos ay kopyahin ito sa iyong Arduino IDE.
Pag-program ng iyong Python:
Ang programa ng sawa para sa proyektong ito ay napaka-simple. Kailangan lang naming magtaguyod ng isang serial na komunikasyon sa Arduino sa pamamagitan ng tamang rate ng baud at pagkatapos ay magsagawa ng ilang pangunahing mga pagkilos sa keyboard. Ang unang hakbang sa python ay ang i-install ang p yautogui module. Tiyaking susundin mo ang hakbang na ito dahil hindi gagana ang programa nang walang pyautogui module.
Pag-install ng pyautogui module para sa windows:
Sundin ang mga hakbang sa ibaba upang mai-install ang pyautogui para sa mga bintana. Kung gumagamit ka ng iba pang mga platform ang mga hakbang ay magiging higit o mas katulad din. Tiyaking nakakonekta ang iyong computer / Laptop sa internet at magpatuloy sa mga hakbang sa ibaba
Hakbang 1: Buksan ang prompt ng Windows Command at baguhin ang direktoryo sa folder kung saan mo na-install ang sawa. Bilang default dapat ang utos
cd C: \ Python27
Hakbang 2: Sa loob ng iyong direktoryo ng python gamitin ang command python –m pip install –upgrade pip upang mai -upgrade ang iyong pip. Ang pip ay isang tool sa sawa na makakatulong sa amin na mag-install ng mga module ng sawa ng madali. Kapag na-upgrade ang modyul na ito (tulad ng ipinakita sa larawan sa ibaba) magpatuloy sa susunod na hakbang.
python –m pip install –upgrade pip
Hakbang 3: Gamitin ang utos na " python –m pip install pyautogui " upang mai-install ang pyautogui module. Kapag matagumpay ang proseso dapat mong makita ang isang screen ng isang bagay na katulad nito sa ibaba.
python –m pip install –upgrade pip
Ngayon na ang pyautogui module at pyserial module (na-install sa nakaraang tutorial) ay matagumpay na na-install sa python, maaari tayong magpatuloy sa programa ng sawa. Ang kumpletong python code ay ibinibigay sa pagtatapos ng tutorial ngunit ang paliwanag para sa pareho ay ang mga sumusunod.
I-import natin ang lahat ng tatlong kinakailangang mga module para sa proyektong ito. Ang mga ito ay pyautogui, serial python at oras.
i-import ang serial #Serial na na-import para sa Serial na oras ng pag-import ng komunikasyon #Kinakailangan upang magamit ang mga pagpapaandar na pagka-antala ng pag-import ng pyautogui
Susunod na itinataguyod namin ang koneksyon sa Arduino sa pamamagitan ng COM port. Sa aking computer ang Arduino ay konektado sa COM 18. Gumamit ng manager ng aparato upang hanapin kung aling COM port ang iyong Arduino ay konektado at iwasto ang sumusunod na linya nang naaayon.
ArduinoSerial = serial.Serial ('com18', 9600) #Create Serial port object na tinatawag na arduinoSerialData time.s Sleep (2) #hintayin ang 2 segundo para maipagtatag ang komunikasyon
Sa loob ng walang hanggan habang loop, paulit-ulit kaming nakikinig sa port ng COM at ihinahambing ang mga pangunahing salita sa anumang mga gawaing pa-defied at gumawa ng mga pagpindot sa key board nang naaayon.
habang 1: papasok = str (ArduinoSerial.readline ()) # basahin ang serial data at i-print ito bilang papasok na print ng linya kung 'Play / Pause' sa papasok: pyautogui.typewrite (, 0.2) kung 'Rewind' sa papasok: pyautogui. hotkey ('ctrl', 'left') kung 'Forward' sa papasok: pyautogui.hotkey ('ctrl', 'kanan') kung 'Vup' sa papasok: pyautogui.hotkey ('ctrl', 'down') kung ' Vdown 'sa papasok: pyautogui.hotkey (' ctrl ',' pataas ')
Tulad ng nakikita mo, upang pindutin ang isang key kailangan lang naming gamitin ang utos na "pyautogui.typewrite (, 0.2)" na pipindutin ang key space para sa 0.2sec. Kung kailangan mo ng mga hot key tulad ng ctrl + S pagkatapos ay maaari mong gamitin ang hot key command na "pyautogui.hotkey ('ctrl', 's')".
Ginamit ko ang mga kombinasyong ito sapagkat gumagana ang mga ito sa VLC media player maaari mong i-tweak ang mga ito sa anumang paraan na nais mong lumikha ng iyong sariling mga application upang makontrol ang anumang bagay sa computer na may kilos.
Pagkontrol ng Kinokontrol na Kompyuter sa Pagkilos:
Gawin ang mga koneksyon tulad ng tinukoy sa itaas at i-upload ang Arduino code sa iyong Arduino board. Pagkatapos ay gamitin ang python script sa ibaba at ilunsad ang programa sa iyong laptop / computer.
Ngayon ay maaari mo nang i-play ang anumang pelikula sa iyong computer gamit ang VLC media player at gamitin ang iyong kamay upang makontrol ang pelikula tulad ng ipinakita sa video na ibinigay sa ibaba.
Inaasahan kong naintindihan mo ang proyekto at nasiyahan sa paglalaro nito. Ito ay isang demo lamang at maaari mong gamitin ang iyong pagkamalikhain upang makabuo ng mas maraming cool na kilos na kinokontrol na bagay sa paligid nito. Ipaalam sa akin kung ito ay kapaki-pakinabang at kung ano ang iyong lilikhain gamit ito sa seksyon ng komento at nalulugod akong malaman ito.