Accel Pisanje (Magic Hand): 4 koraki (s slikami)

2024 Avtor: John Day | [email protected]. Nazadnje spremenjeno: 2024-01-30 12:08

Uvod

Čarobna roka omogoča invalidom in motoričnim sposobnostim, da uživajo v ustvarjalnosti risanja in pisanja v simuliranem okolju. Čarobna roka je nosljiva rokavica, ki zazna gibanje kazalca in to prevede v risanje črt na zaslonu računalnika.

Potrebni materiali

LSM9DOF Breakout Board --- 24,95 USD ---

Adafruit pero z Wifi --- 18,95 USD ---

Ženske/ženske žice --- 1,95 USD ---

Trakovi/Velcro trakovi --- 3 USD

Dva magneta enake jakosti --- cene se razlikujejo

Kako deluje

Z merilnikom pospeška lahko zberemo podatke o pospeških za os y, ki nam bodo pomagali ugotoviti, kdaj se uporabnikov prst premika gor in dol. Ker naš merilnik pospeška meri pospešek glede na središče zemlje, ne moremo določiti pospeška osi x (levo ali desno). Na srečo odklopna plošča LSM9DOF vsebuje tudi magnetometer, ki nam omogoča zbiranje podatkov o magnetnih poljih. Dva magneta postavimo 30 cm narazen, rokavico pa vmes. Če so magnetni podatki pozitivni, potem vemo, da se rokavica premika desno in obratno. Ko so vsi podatki zbrani v merilniku pospeška/magnetometru, jih po žici pošlje na pero, ki je povezano z računalnikom wifi, nato pa podatke posreduje v računalnik, ki ga lahko nato uporabimo v kodi.

1. korak: Fizični prototip 1

Ta prototip naj bi ohlapno prišit skupaj na rokah, da bi zdrsnil po elektronskih napravah. Elektronska naprava bo nato pritrjena z velcro na podlago pod oklepom v kombinaciji z osnovno rokavico na roki. Nato bo zelena rokavica zdrsnila po podstavku in elektronskih napravah….

Koraki pri izdelavi prototipne rokavice:

• Vzemite dva kosa tkanine, ki sta dovolj velika, da sledite roki
• Z roko potegnite na oba kosa tkanine in ju izrežite
• Dva ročna izreza sestavite skupaj, tako da sta popolnoma poravnana
• Nato za pripravo šivalnega stroja potegnite nit skozi označena mesta na stroju
• Ko je šivalni stroj nastavljen, dvignite iglo in postavite dva sestavljena kosa tkanine pod iglo
• Prepričajte se, da je igla poravnana na samem robu tkanine, zaženite stroj in šivajte vzdolž robov tkanine, pri tem pa dva kosa pustite nezašiti pri zapestju, da se lahko prilega roka.

2. korak: Fizični prototip 2

Naš zadnji prototip je navadna rokavica v kombinaciji z Velcro trakom, ki se prilagodi vsakemu zapestju. Rokavica in trak sta sešita skupaj, elektronske naprave pa so pritrjene na rokavico s pomočjo Velcro.

Koraki pri izdelavi drugega prototipa rokavice:

1. Nakup rokavice, material rokavic ni pomemben.
2. Kupite zapestni trak z ježkom
3. Kupite prenosno baterijo
4. Kupite lepljiv Velcro
5. S šivalno iglo pritrdite zapestni trak z ježkom na dno rokavice
6. Zapestni trak se mora prilagoditi različnim velikostim zapestja.
7. Lepilni trak pritrdite na dno merilnika pospeška in ga pritrdite na kazalec rokavice
8. Na pero pritrdite lepilni trak in ga pritrdite na vrh rokavice.
9. Z žicami priključite zatič 3V3 v perju na pin VIN v merilniku pospeška
10. Z žicami priključite zatič GND v perju na pin GND za merilnik pospeška.
11. Z žicami priključite zatič SCL v pero na zatič SCL za merilnik pospeška.
12. Z žicami priključite zatič SDA v perju na pin SDA za merilnik pospeška.
13. Za napajanje priključite vsaj 5-voltno baterijo prek USB-ja na pero.

Korak: Magneti

1. korak: Dva magneta enake jakosti postavite drug proti drugemu.

2. korak: Izmerite 30 cm vrzeli med magnetoma

3. korak: magnetometer postavite točno na sredino obeh magnetov. Podatke bi morali prejeti okoli 0, medtem ko so na sredini. Če preberete nič, pojdite na korak 5.

4. korak: Če odčitek ni nič ali blizu nič, morate prilagoditi razdaljo magnetov. Če je odčitek negativen, pomaknite levi magnet za cm ali 2 v levo ali dokler odčitek ni nič. Če je pozitiven, naredite isto, razen z desnim magnetom.

5. korak: Napišite kodo, ki sprejema podatke z magnetometra in bere, če so pozitivni ali negativni. Če je koda pozitivna, potegnite črto na desni, če pa je negativna, potegnite črto levo.

4. korak: Koda

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

Uvod:

Za obdelavo podatkov iz merilnika pospeška je treba vzpostaviti odnos med odjemalcem in strežnikom med perjem Adafruit in strežnikom, ki obdeluje podatke (deluje na prenosnem računalniku/namizju). Ustvariti bo treba dve datoteki kod: eno za odjemalca (perje Adafruit) in drugo za strežnik (v tem primeru Jarodin prenosnik). Odjemalec je napisan v C ++, strežnik pa v pythonu. Jezik, ki se uporablja za odjemalca, je pomemben, saj je Arduino večinoma jezik C ++, zato ga je težko spremeniti v drug jezik. Strežnik je lahko pisan v katerem koli jeziku, če ima omrežne funkcije.

Nastavitev odjemalca:

Najprej bomo nastavili kodo odjemalca. Večina kode za povezavo WiFi je na voljo v knjižnicah Adafruit. Začnemo z vključitvijo ustreznih razredov.

#include #include #include #include #include

Nastavite nekaj spremenljivk, ki bodo uporabljene v kodi.

// Povežite se z omrežjem const char* ssid = "MMServer"; const char* password = "Geslo strežnika MMS"; // IP in vrata strežnika, ki bo prejel podatke const char* host = "149.160.251.3"; const int port = 12347; bool connected = false;

// Inicializirajte detektor gibanja

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0 (1000);

Odjemalec WiFiClient;

Ustvarite funkcijo setup (), ki se bo zagnala takoj, ko se bo pero začelo.

// Nastavimo povezavo WiFi in se povežemo s servervoid setup () {Serial.begin (9600); zamuda (100);

Serial.println ();

Serial.println (); Serial.print ("Povezovanje z"); Serial.println (ssid); // Zaženite WiFi WiFi.begin (ssid, geslo); // Povezovanje… while (WiFi.status ()! = WL_CONNECTED) {zamuda (500); Serial.print ("."); } // Uspešno povezan z WiFi Serial.println (""); Serial.println ("WiFi povezan"); Serial.println ("naslov IP:"); Serial.println (WiFi.localIP ());

#ifndef ESP8266

while (! Serijski); #endif Serial.begin (9600); Serial.println ("Preskus senzorja");

// Inicializirajte senzor

if (! lsm.begin ()) {// Pri odkrivanju serijskega.print LSM9DS0 je prišlo do težave (F ("Ooops, ni zaznan LSM9DS0 … Preverite ožičenje ali I2C ADDR!")); medtem ko (1); } Serial.println (F ("Najdeno LSM9DS0 9DOF")); // Začnite povezovanje s strežnikom Serial.print ("Povezovanje z"); Serial.println (gostitelj);

// Preverite uspešno povezavo. Če ne uspe, prekinite

if (! client.connect (gostitelj, vrata)) {Serial.println ("povezava ni uspela"); povezan = napačno; vrnitev; } else {connected = true; }

// Nastavitev ojačitve senzorja in časa integracije

configureSensor (); }

Nato potrebujemo funkcijo zanke, ki se bo ponavljala. V tem primeru se uporablja za večkratno pošiljanje podatkov iz merilnika pospeška na strežnik v obliki »[z_accel]: [y_mag]: [z_mag]«. Client.print (številke); funkcija pošilja podatke strežniku.

void loop () {zakasnitev (250); if (connected) {// To bo poslalo podatke strežniku sensors_event_t accel, mag, gyro, temp; lsm.getEvent (& accel, & mag, & gyro, & temp); Številke nizov; številke += pospešek.pospešek.z; številke += ":"; številke += mag.magnetic.y; številke += ":"; številke += mag.magnetic.z; Serial.print (številke); client.print (številke); Serial.println (); } else {installConnection (); }}

Za nekatere pomožne funkcije potrebujemo eno, da vzpostavimo povezavo med perjem in strežnikom.

void installConnection () {if (! client.connect (gostitelj, vrata)) {Serial.println ("povezava ni uspela"); povezan = napačno; vrnitev; } else {connected = true; }}

Prav tako moramo konfigurirati senzor in mu dati razpon vrednosti, ki jih bo prebral. Na primer, pospešek ima 5 možnosti za obseg: 2g, 4g, 6g, 8g in 16g.

void configureSensor (void) {// Nastavite obseg merilnika pospeška //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); // Nastavitev občutljivosti magnetometra //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_2GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_4GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_8GAUSS); lsm.setupMag (lsm. LSM9DS0_MAGGAIN_12GAUSS);

// Nastavitev žiroskopa

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

Nastavitev strežnika:

Strežnik bo datoteka python, ki se bo izvajala v ukazni vrstici računalnika. Za začetek uvozite zahtevane razrede.

import socketimport re import pyautogui

vtičnica se uporablja za mreženje. re se uporablja za regex ali manipulacije nizov. pyautogui je knjižnica python, ki bo omogočila risbo (obravnavano kasneje).

Nato bi morali določiti nekaj spremenljivk. To bodo globalne spremenljivke, zato bodo do njih dostopali v več funkcijah. Kasneje bodo uporabljeni v kodi.

i = 0n = 0 vrstica = 1

seznam_podatkov =

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 = Napačno

first_data = Res

Zdaj potrebujemo funkcijo za ustvarjanje strežnika in njegovo odpiranje za dohodne povezave.

def startServer (): globalni i globalni prvi_podatki # inicializirajte vtičnico strežnika serversocket = socket.socket (socket. AF_INET, socket. SOCK_STREAM) serversocket.setsockopt (socket. SOL_SOCKET, socket. SO_REUSEADDR, 1) # IP naslov strežnika in gostitelja vrat = " 149.160.251.3 "port = 12347 server_address = (host, port) # Odprite strežnik in poslušajte dohodne povezave print ('Zagon strežnika na %s vratih %s' %server_address) serversocket.bind (server_address) serversocket.listen (5) # Počakajte na povezave … medtem ko je True: print ('Čakanje na povezavo …') # Sprejmite dohodno povezavo (clientsocket, naslov) = serversocket.accept () # Poskusite razčleniti prejete podatke try: print ('Povezava vzpostavljena iz', naslov) medtem ko je True: # Prejemajte podatke in jih pošljite v obdelavo podatkov = 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 if (i <51): calibData (accel_data) else: movingAcce l (accel_data [0]) processData (accel_data) first_data = False končno: # Zaprite vtičnico, da preprečite nepotrebno puščanje podatkov clientsocket.close ()

Zdaj potrebujemo funkcije, ki bodo obdelale vse podatke. Prvi korak in prva poklicana funkcija je kalibracija senzorja za namene izračuna.

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

Nato ustvarimo premik premika pospeška. Zaradi tega program prepozna, ko nekdo preneha premikati prst, ker morajo biti vse vrednosti za pospešek, ki so poslane strežniku, iste.

def movingAccel (num): globalno z_calib globalno z_diff globalno z_moving_offset globalno z_offset globalno data_list globalno n globalno keep_offset če (n 0,2 ali z_diff <-0,2): # gibanje zaznano znotraj podatkov, znova zaženi keep_offset = True n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = break, če ne keep_offset: # stacionarno v podatkih, nastavite nov z_offset z_offset = z_moving_offset print ("New z_offset:") print (z_offset) n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = keep_offset = False keep_offset = False

Nato naredimo največjo računico. To vključuje pretvorbo podatkov o pospeševanju v podatke o položaju, ki nam bodo omogočili, da povemo smer, v kateri uporabnik premakne prst.

def processData (seznam): #[accel.z, mag.y] globalni z_offset globalni z_real globalni z_velo globalni z_pos globalni prvi_podatki globalni mag_data

z_real = float (seznam [0]) - z_offset

mag_y = seznam [1] mag_z = seznam [2] levo = napačno desno = napačno # Ne pospešujte pospeševanja, dokler ni popolnoma prepričano, da je pospešeno # Preprečuje, da bi mehanski hrup prispeval k položaju, če (z_real -0,20): z_real = 0 # Začni integracije za iskanje položaja if (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) else: 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): right = True elif (float (mag_data [1]) - float (mag_data [0]) <-0,03): left = True if (desno): premik (50, int (z_pos* 1000)) elif (levo): premik (-50, int (z_pos*1000)) z_velo = 0 z_pos = 0

Zdaj končno premaknemo kazalec! V ta namen smo odprli okno za barvanje in ga naredili na celotnem zaslonu. Knjižnica pyautogui vsebuje funkcijo, imenovano pyautogui.dragRel (x, y); s katerim povlečemo kazalec miške od ene točke do druge. Uporablja podatke o relativnem položaju, zato je premik glede na zadnji položaj kazalke.

def motion (x, y): print ("premikanje v", x, -y) pyautogui.dragRel (x, -y)

Nazadnje moramo poklicati glavno funkcijo, da celo omogočimo izvajanje te kode.

# Pokliče funkcijo, da zažene serverstartServer ()