Pagsusulat ng Accel (Magic Kamay): 4 na Hakbang (na may Mga Larawan)

2025 May -akda: John Day | [email protected]. Huling binago: 2025-01-23 15:13

Panimula

Pinapayagan ng Magic Hand ang mga taong may kapansanan at mga kapansanan sa kasanayan sa motor na tangkilikin ang pagkamalikhain ng pagguhit at pagsusulat sa isang simulate na kapaligiran. Ang Magic Hand ay isang naisusuot na guwantes na nararamdaman ang paggalaw ng iyong hintuturo at isinalin iyon sa pagguhit ng mga linya sa isang computer screen.

Mga Materyal na Kailangan

LSM9DOF Breakout Board --- $ 24.95 ---

Adafruit Feather na may Wifi --- $ 18.95 ---

Mga Wire ng Babae / Babae --- $ 1.95 ---

Tape / Velcro strips --- $ 3

Dalawang magneto ng pantay na lakas --- Mag-iiba ang presyo

Kung paano ito gumagana

Sa pamamagitan ng paggamit ng isang accelerometer, maaari naming tipunin ang data ng pagpabilis para sa y-axis na makakatulong sa amin na matukoy kung kailan gumagalaw pataas ang daliri ng gumagamit. Dahil sa ang katunayan na ang aming accelerometer ay sumusukat sa pagpabilis na patungkol sa gitna ng mundo hindi namin matukoy ang pagpabilis ng x-axis (kaliwa o kanan). Sa kabutihang palad ang LSM9DOF breakout board ay naglalaman din ng isang magnetometer na nagbibigay-daan sa amin upang lumikom ng data sa mga magnetic field. Naglalagay kami ng dalawang magneto na 30 cm ang layo at mayroong guwantes sa pagitan. Kung ang magnetic data ay basahin nang positibo alam natin na ang guwantes ay gumagalaw pakanan at kabaligtaran. Matapos ang lahat ng data ay nakolekta sa accelerometer / magnetometer nagpapadala ito ng data sa pamamagitan ng wire sa feather na konektado sa isang computer ng wifi at pagkatapos ay ipasa ang data sa computer na maaari naming magamit sa aming code.

Hakbang 1: Physical Prototype 1

Ang prototype na ito ay sinadya upang maging isang gwantes na tahiin ng maluwag sa kamay upang ito ay madulas sa mga elektronikong aparato. Ang elektronikong aparato ay maiakabit ng velcro sa ilalim ng base ng manggas ng nakasuot na pinagsama sa isang pangunahing guwantes sa kamay. Pagkatapos ang berdeng guwantes ay madulas sa base at sa mga elektronikong aparato ….

Mga hakbang sa paggawa ng prototype na guwantes:

• Kumuha ng dalawang piraso ng tela na sapat na malaki upang masubaybayan ang kamay
• Bakas ang kamay sa magkabilang piraso ng tela at gupitin ito
• Isama ang dalawang gupit na kamay upang sila ay ganap na nakahanay
• Susunod, upang maihanda ang makina ng pananahi, patakbuhin ang thread sa pamamagitan ng mga ipinahiwatig na mga spot sa makina
• Kapag naayos ang makina ng pananahi, iangat ang karayom at ilagay ang dalawang magkakasamang piraso ng tela sa ilalim ng karayom
• Siguraduhin na ang linya ng karayom ay nakalinya sa gilid ng tela, simulan ang makina, at tahiin kasama ang mga gilid ng tela, habang iniiwan ang dalawang piraso na hindi nakasulat sa pulso upang ang isang kamay ay maaaring magkasya.

Hakbang 2: Physical Prototype 2

Ang aming huling prototype ay isang regular na guwantes na sinamahan ng Velcro strap na naaayos sa anumang pulso. Ang guwantes at strap ay naitala ng magkasama, at ang mga elektronikong aparato ay nakakabit sa guwantes sa pamamagitan ng Velcro.

Mga hakbang sa paggawa ng ika-2 prototype ng guwantes:

1. Bumili ng isang guwantes, ang materyal ng guwantes ay hindi mahalaga.
2. Bumili ng isang velcro wrist strap
3. Bumili ng isang portable na baterya
4. Bumili ng Malagkit na Velcro
5. Gamit ang isang karayom sa pananahi, ilakip ang velcro wrist strap sa base ng guwantes
6. Dapat ayusin ng strap ng pulso ang iba't ibang laki ng pulso.
7. Ikabit ang malagkit na tape sa base ng accelerometer at ilakip ito sa hintuturo ng guwantes
8. Ikabit ang malagkit na tape sa balahibo at ilakip ito sa tuktok ng guwantes.
9. Ang paggamit ng mga wires ay ikonekta ang 3V3 pin sa balahibo sa VIN pin sa accelerometer
10. Ang paggamit ng mga wires ay ikonekta ang pin ng GND sa balahibo sa pin ng GND ang accelerometer.
11. Ang paggamit ng mga wires ay ikonekta ang SCL pin sa balahibo sa SCL pin ang accelerometer.
12. Ang paggamit ng mga wires ay ikonekta ang pin ng SDA sa balahibo sa SDA pin ang accelerometer.
13. Ikonekta ang hindi bababa sa isang 5 volt na baterya sa pamamagitan ng usb sa balahibo upang magbigay ng lakas.

Hakbang 3: Mga magnet

Hakbang 1: Ilagay ang dalawang magneto ng katumbas na lakas sa tapat ng bawat isa.

Hakbang 2: Sukatin ang 30 cm na agwat sa pagitan ng dalawang magnet

Hakbang 3: ilagay ang Magnetometer nang eksakto sa gitna ng dalawang magnet. Dapat kang makatanggap ng data sa paligid ng 0 habang nasa gitna ito. Kung nakatanggap ka ng isang pagbasa ng zero laktawan ang hakbang 5.

Hakbang 4: Kung ang pagbabasa ay hindi zero o malapit sa zero pagkatapos ay dapat mong ayusin ang distansya ng mga magnet. Kung ang pagbabasa ay negatibo ilipat ang kaliwang magnet ng isang cm o 2 sa kaliwa o hanggang sa pagbabasa ay zero. Kung positibo gawin ang parehong bagay maliban sa tamang magnet.

Hakbang 5: Sumulat ng code na tumatanggap ng data mula sa magnetometer at binabasa kung positibo o negatibo ito. Kung positibo ang code gumuhit ng isang linya sa kanan at kung negatibong gumuhit ng isang linya sa kaliwa.

Hakbang 4: Code

github.iu.edu/ise-e101-F17/MuscleMemory-Sw…

Panimula:

Upang maproseso ang data mula sa accelerometer, dapat na maitatag ang isang ugnayan ng client / server sa pagitan ng feather ng Adafruit at ng server na nagpoproseso ng data (tumatakbo sa isang laptop / desktop). Dalawang mga file ng code ang kailangang malikha: isa para sa kliyente (ang Adafruit feather), at ang isa pa para sa server (sa kasong ito, ang laptop ni Jarod). Ang kliyente ay nakasulat sa C ++, at ang server ay nakasulat sa sawa. Ang wikang ginagamit para sa kliyente ay mahalaga dahil ang Arduino ay pangunahin na isang C ++ na wika, at ang pagpapalit nito upang magamit ang ibang wika ay mahirap. Maaaring isulat ang server sa anumang wika, hangga't mayroon itong mga tampok sa network.

Pagse-set up ng Client:

Una, i-set up namin ang client code. Karamihan sa koneksyon sa WiFi code ay madaling magagamit sa pamamagitan ng mga aklatan ng Adafruit. Nagsisimula kami sa pamamagitan ng pagsasama ng mga nauugnay na klase.

#include #include #include #include #include

Magtakda ng ilang mga variable kung ano ang gagamitin sa buong code.

// Kumonekta sa isang network const char * ssid = "MMServer"; const char * password = "MMServer-Password"; // IP at port ng server na makakatanggap ng data const char * host = "149.160.251.3"; Const int port = 12347; konektado sa bool = false;

// Pinasimulan ang detektor ng paggalaw

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0 (1000);

Client ng WiFiClient;

Lumikha ng isang pag-andar () na function na tatakbo sa lalong madaling magsimula ang balahibo.

// Setup WiFi connection, at kumonekta sa pag-setup ng servervoid () {Serial.begin (9600); pagkaantala (100);

Serial.println ();

Serial.println (); Serial.print ("Kumokonekta sa"); Serial.println (ssid); // Start WiFi WiFi.begin (ssid, password); // Kumonekta … habang (WiFi.status ()! = WL_CONNected) {pagkaantala (500); Serial.print ("."); } // Matagumpay na konektado sa WiFi Serial.println (""); Serial.println ("Konektado sa WiFi"); Serial.println ("IP address:"); Serial.println (WiFi.localIP ());

#ifndef ESP8266

habang (! Serial); #endif Serial.begin (9600); Serial.println ("Sensor Test");

// Ipasimula ang sensor

kung (! lsm.begin ()) {// Mayroong isang problema sa pagtuklas ng LSM9DS0 Serial.print (F ("Ooops, walang nakitang LSM9DS0 … Suriin ang iyong mga kable o I2C ADDR!")); habang (1); } Serial.println (F ("Natagpuan LSM9DS0 9DOF")); // Simulang kumonekta sa server Serial.print ("Kumokonekta sa"); Serial.println (host);

// Suriin para sa matagumpay na koneksyon. Kung nabigo pagkatapos ay i-abort

kung (! client.connect (host, port)) {Serial.println ("Nabigo ang koneksyon"); konektado = false; bumalik; } iba pa {konektado = totoo; }

// Setup ang pagkuha ng sensor at oras ng pagsasama

configureSensor (); }

Kailangan namin ng isang pag-andar ng loop na paulit-ulit na mag-loop. Sa kasong ito, ginagamit ito upang paulit-ulit na magpadala ng data mula sa accelerometer sa server sa anyo ng "[z_accel]: [y_mag]: [z_mag]". Ang client.print (mga numero); Ang pagpapaandar ay kung ano ang nagpapadala ng data sa server.

void loop () {pagkaantala (250); kung (konektado) {// Magpapadala ito ng data sa server sensors_event_t accel, mag, gyro, temp; lsm.getEvent (& accel, & mag, & gyro, & temp); Mga numero ng string; mga numero + = accel.acceleration.z; mga numero + = ":"; mga numero + = mag.magnetic.y; mga numero + = ":"; mga numero + = mag.magnetic.z; Serial.print (mga numero); client.print (numero); Serial.println (); } iba pa {establishConnection (); }}

Para sa ilang mga pagpapaandar sa utility, kailangan namin ng isa upang maitaguyod ang koneksyon sa pagitan ng balahibo at ng server.

void establishConnection () {if (! client.connect (host, port)) {Serial.println ("Nabigo ang koneksyon"); konektado = false; bumalik; } iba pa {konektado = totoo; }}

Kailangan din naming i-configure ang sensor at bigyan ito ng saklaw ng mga halagang babasahin nito. Halimbawa, ang pagpabilis ay may 5 mga pagpipilian para sa saklaw: 2g, 4g, 6g, 8g, at 16g.

void configureSensor (void) {// Itakda ang saklaw ng accelerometer //lsm.setupAccel(lsm. LSM9DS0_ACCELRANGE_2G); lsm.setupAccel (lsm. LSM9DS0_ACCELRANGE_4G); //lsm.setupAccel(lsm. LSM9DS0_ACCELRANGE_6G); //lsm.setupAccel(lsm. LSM9DS0_ACCELRANGE_8G); //lsm.setupAccel(lsm. LSM9DS0_ACCELRANGE_16G); // Itakda ang pagiging sensitibo ng magnetometer //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_2GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_4GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_8GAUSS); lsm.setupMag (lsm. LSM9DS0_MAGGAIN_12GAUSS);

// Setup ang gyroscope

lsm.setupGyro (lsm. LSM9DS0_GYROSCALE_245DPS); //lsm.setupGyro(lsm. LSM9DS0_GYROSCALE_500DPS); //lsm.setupGyro(lsm. LSM9DS0_GYROSCALE_2000DPS); }

Pagse-set up ng Server:

Ang server ay magiging isang python file na tatakbo sa linya ng utos ng isang computer. Upang magsimula, i-import ang kinakailangang mga klase.

i-import ang socketimport muling i-import ang pyautogui

ginagamit ang socket para sa networking. Ginagamit ang re para sa regex, o mga manipulasyong string. Ang pyautogui ay isang python library na papayagan ang pagguhit na mangyari (tatalakayin sa paglaon).

Susunod, dapat nating tukuyin ang ilang mga variable. Ito ang magiging mga variable ng mundo, kaya maa-access ang mga ito sa maraming mga pag-andar. Magagamit ang mga ito sa ibang pagkakataon sa code.

i = 0n = 0 linya = 1

data_list =

mag_data =

mag_calib_y = 0 mag_offset_y = 0

z_calib = 0

z_offset = 0 z_moving_offset = 0 z_diff = 0 z_real = 0 z_velo = 0 z_pos = 0

keep_offset = Mali

first_data = Tama

Kailangan namin ngayon ng isang pagpapaandar upang lumikha ng isang server at buksan ito para sa mga papasok na koneksyon.

def startServer (): global i global first_data # initialize server socket serversocket = socket.socket (socket. AF_INET, socket. SOCK_STREAM) serversocket.setsockopt (socket. SOL_SOCKET, socket. SO_REUSEADDR, 1) # Server IP address at port host = " 149.160.251.3 "port = 12347 server_address = (host, port) # Buksan ang server at makinig para sa papasok na mga koneksyon i-print ('Simula ng server sa% s port% s'% server_address) serversocket.bind (server_address) serversocket.listen (5) # Maghintay para sa mga koneksyon … habang Tama: i-print ('Naghihintay para sa koneksyon …') # Tanggapin ang isang papasok na koneksyon (clientsocket, address) = serversocket.accept () # Subukang i-parse ang natanggap na data subukan: i-print ('Ang koneksyon ay itinatag mula sa', address) habang Totoo: # Tanggapin ang data at ipadala ito para sa pagproseso ng data = clientsocket.recv (25) accel_data = re.split ('[:]', str (data)) accel_data [0] = accel_data [0] [2:] accel_data [1] = accel_data [1] accel_data [2] = accel_data [2] [1: -1] print (accel_data) i + = 1 kung (i <51): calibData (accel_data) iba pa: movingAcce l (accel_data [0]) processData (accel_data) first_data = Mali sa wakas: # Isara ang socket upang maiwasan ang hindi kinakailangang pagtagas ng clientsocket.close ()

Kinakailangan namin ngayon ang mga pagpapaandar na magproseso ng lahat ng data. Ang unang hakbang na gagawin, at ang unang pag-andar na tinawag, ay ang pagkakalibrate ng sensor para sa mga layunin sa pagkalkula.

def calibData (list): global z_calib global z_offset global mag_data global mag_calib_y global mag_offset_y z_calib + = float (list [0]) mag_calib_y + = float (list [1]) if (i == 50): z_offset = z_calib / 50 mag_offset_y = mag_calib_y / 50 z_calib = 0 mag_calib_y = 0 mag_data.append (mag_offset_y)

Susunod, lumikha kami ng isang gumagalaw na offset ng acceleration. Ginagawa ito upang makilala ng programa kapag may huminto sa paggalaw ng kanilang daliri dahil ang lahat ng mga halaga para sa pagpapabilis na ipinadala sa server ay dapat na pareho sa oras na iyon.

def movingAccel (num): global z_calib global z_diff global z_moving_offset global z_offset global data_list global n global keep_offset kung (n 0.2 o z_diff <-0.2): # paggalaw ang nakita sa loob ng data, i-restart ang keep_offset = True n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = masira kung hindi keep_offset: # nakatigil sa data, magtakda ng bagong z_offset z_offset = z_moving_offset print ("Bagong z_offset:") print (z_offset) n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = keep_offset = False keep_offset = Mali

Susunod, ginagawa namin ang pinuno ng matematika. Nagsasangkot ito ng pagsasalin ng data ng pagpabilis sa isang data ng posisyon na magpapahintulot sa amin na sabihin ang direksyon na igagalaw ng gumagamit ang kanilang daliri.

def processData (list): # [accel.z, mag.y] global z_offset global z_real global z_velo global z_pos global first_data global mag_data

z_real = float (listahan [0]) - z_offset

mag_y = list [1] mag_z = list [2] pakaliwa = Mali pakanan = Mali # Huwag iproseso ang pagpabilis hanggang sa ganap na matiyak na napabilis nito # Pinipigilan ang ingay ng makina mula sa pag-aambag sa posisyon kung (z_real -0.20): z_real = 0 #Begin pagsasama upang makahanap ng posisyon kung (first_data): mag_data.append (mag_y) z_pos = (0.5 * z_real * 0.25 * 0.25) + (z_velo * 0.25) + z_pos z_velo = z_real * 0.25 pyautogui.moveTo (1500, 1000) iba pa: z_pos = (0.5 * z_real * 0.25 * 0.25) + (z_velo * 0.25) + z_pos z_velo = (z_real * 0.25) + z_velo del mag_data [0] mag_data.append (mag_y) if (float (mag_data [1]) - float (mag_data [0])> 0.03): kanan = True elif (float (mag_data [1]) - float (mag_data [0]) <-0.03): left = True if (right): movement (50, int (z_pos * 1000)) elif (kaliwa): kilusan (-50, int (z_pos * 1000)) z_velo = 0 z_pos = 0

Ngayon, sa wakas, ilipat natin ang cursor! Upang magawa ito, binuksan namin ang isang window ng pintura at ginawang buong screen. Naglalaman ang pyautogui library ng isang pagpapaandar na tinatawag na pyautogui.dragRel (x, y); na ginagamit namin upang i-drag ang mouse cursor mula sa isang punto patungo sa susunod. Gumagamit ito ng data ng kamag-anak na posisyon kaya't ang paggalaw ay kaugnay sa huling posisyon ng cursor.

kilusan ng def (x, y): i-print ("paglipat sa", x, -y) pyautogui.dragRel (x, -y)

Panghuli, kailangan nating tawagan ang pangunahing pagpapaandar upang pahintulutan pang tumakbo ang lahat ng code na ito.

# Tawag sa pagpapaandar upang simulan ang serverstartServer ()