Accel -skryfwerk (magiese hand): 4 stappe (met prente)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:27

Inleiding

Met die Magic Hand kan mense met gestremdhede en motoriese gestremdhede die kreatiwiteit van teken en skryf geniet in 'n gesimuleerde omgewing. The Magic Hand is 'n draagbare handskoen wat die beweging van jou wysvinger aanvoel en dit vertaal in die teken van lyne op 'n rekenaarskerm.

Materiaal benodig

LSM9DOF Breakout Board --- $ 24,95 ---

Adafruit Feather with Wifi --- $ 18,95 ---

Wire/Female Wires --- $ 1,95 ---

Band-/klittenbandstroke --- $ 3

Twee magnete van dieselfde sterkte --- Pryse wissel

Hoe dit werk

Deur 'n versnellingsmeter te gebruik, kan ons versnellingsdata vir die y-as versamel, wat ons sal help bepaal wanneer die vinger van die gebruiker op en af beweeg. Omdat ons versnellingsmeter versnelling meet ten opsigte van die middelpunt van die aarde, kan ons nie die versnelling van die x-as (links of regs) bepaal nie. Gelukkig bevat die LSM9DOF -uitbreekbord ook 'n magnetometer waarmee ons data oor magnetiese velde kan versamel. Ons plaas twee magnete 30 cm uitmekaar en het die handskoen tussenin. As die magnetiese data positief lees, weet ons dat die handskoen regs beweeg en omgekeerd. Nadat al die data in die versnellingsmeter/magnetometer versamel is, stuur dit die data via draad na die veer wat aan 'n rekenaar van wifi gekoppel is en stuur dan die data na die rekenaar wat ons dan in ons kode kan gebruik.

Stap 1: Fisiese prototipe 1

Hierdie prototipe is bedoel om 'n handskoen losweg aan die hand vasgemaak te word sodat dit oor die elektroniese toestelle kan gly. Die elektroniese toestel word dan met klittenband aan die onderwapenmou se basis gekoppel, gekombineer met 'n basiese handskoen op die hand. Dan sal die groen handskoen oor die basis en die elektroniese toestelle gly …

Stappe om die prototipe handskoen te maak:

• Kry twee stukke stof wat groot genoeg is om die hand op te spoor
• Trek die hand op albei stukke stof en sny dit uit
• Sit die twee handuitknipsels bymekaar sodat hulle perfek in lyn is
• Om die naaimasjien voor te berei, voer die draad deur die aangeduide plekke op die masjien
• As die naaimasjien opgestel is, lig die naald en plaas die twee stukke stof onder die naald
• Maak seker dat die naald aan die rand van die stof in lyn is, begin die masjien en stik aan die kante van die stof vas, terwyl die twee stukke ongesny aan die pols gelaat word sodat 'n hand kan inpas.

Stap 2: Fisiese prototipe 2

Ons laaste prototipe is 'n gewone handskoen gekombineer met 'n klittenband wat aan elke pols verstelbaar is. Die handskoen en band word aanmekaar vasgewerk, en die elektroniese toestelle word via klittenband aan die handskoen geheg.

Stappe om die tweede prototipe van die handskoen te maak:

1. Koop 'n handskoen, die materiaal van die handskoen maak nie saak nie.
2. Koop 'n klittenbandband
3. Koop 'n draagbare battery
4. Koop klewerige klittenband
5. Bevestig die klittenband met die naald aan die onderkant van die handskoen
6. Die polsband moet by verskillende polsgroottes kan aanpas.
7. Plak die kleeflint aan die onderkant van die versnellingsmeter vas en plak dit aan die wysvinger van die handskoen
8. Plak kleeflint aan die veer vas en plak dit bo -op die handskoen vas.
9. Koppel die 3V3 -pen in die veer met die drade aan die VIN -pen in die versnellingsmeter
10. Verbind die GND -pen in die veer met die versnellingsmeter met die GND -pen.
11. Koppel die SCL -pen in die veer met die versnellingsmeter met die SCL -pen.
12. Verbind die SDA -pen in die veer met die versnellingsmeter met die SDA -pen, die versnellingsmeter.
13. Koppel ten minste 'n 5 volt-battery deur die usb aan die veer om krag te verskaf.

Stap 3: Magnete

Stap 1: Sit die twee magnete van gelyke sterkte teenoor mekaar.

Stap 2: Meet 'n gaping van 30 cm tussen die twee magnete

Stap 3: plaas die magnetometer presies in die middel van die twee magnete. U behoort data rondom 0 te ontvang terwyl dit in die middel is. Gaan na stap 5 as u 'n nullesing ontvang.

Stap 4: As die lesing nie nul of naby nul is nie, moet u die afstand van die magnete aanpas. As die lesing negatief is, skuif die linker magneet 'n cm of 2 na links of totdat die lesing nul is. As dit positief is, doen dieselfde, behalwe met die regte magneet.

Stap 5: Skryf kode wat die data van die magnetometer aanvaar en lees of dit positief of negatief is. As die kode positief is, trek 'n lyn na regs en as negatief, trek 'n lyn na links.

Stap 4: Kode

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

Inleiding:

Om data vanaf die versnellingsmeter te verwerk, moet 'n kliënt/bediener -verhouding tussen die Adafruit -veer en die bediener wat die data verwerk (op 'n skootrekenaar/tafelblad) verwerk word. Twee kode lêers moet geskep word: een vir die kliënt (die Adafruit -veer) en die ander vir die bediener (in hierdie geval, die skootrekenaar van Jarod). Die kliënt is in C ++ geskryf, en die bediener is in python geskryf. Die taal wat vir die kliënt aangewend word, aangesien Arduino hoofsaaklik 'n C ++ - taal is, en dit is moeilik om dit te verander om 'n ander taal te gebruik. Die bediener kan in enige taal geskryf word, solank dit netwerkfunksies het.

Die opstel van die kliënt:

Eerstens stel ons die kliëntkode op. Die meeste van die WiFi -verbindingskode is geredelik beskikbaar via die Adafruit -biblioteke. Ons begin deur relevante klasse in te sluit.

#include #include #include #include #include

Stel 'n paar veranderlikes wat deur die kode gebruik sal word.

// Koppel aan 'n netwerk const char* ssid = "MMServer"; const char* password = "MMServer-Password"; // IP en poort van die bediener wat data const char* host = "149.160.251.3" sal ontvang; const int poort = 12347; bool verbind = vals;

// Initialiseer bewegingsdetektor

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0 (1000);

WiFiClient -kliënt;

Skep 'n setup () -funksie wat uitgevoer sal word sodra die veer begin.

// Stel WiFi -verbinding op en maak verbinding met die servervoid setup () {Serial.begin (9600); vertraging (100);

Serial.println ();

Serial.println (); Serial.print ("Koppel aan"); Serial.println (ssid); // Begin WiFi WiFi. Begin (ssid, wagwoord); // Verbind… terwyl (WiFi.status ()! = WL_CONNECTED) {vertraging (500); Serial.print ("."); } // Suksesvol gekoppel aan WiFi Serial.println (""); Serial.println ("WiFi gekoppel"); Serial.println ("IP -adres:"); Serial.println (WiFi.localIP ());

#ifndef ESP8266

terwyl (! Serial); #endif Serial.begin (9600); Serial.println ("Sensortoets");

// Initialiseer die sensor

if (! lsm.begin ()) {// Kon nie die LSM9DS0 Serial.print opspoor nie (F ("Oeps, geen LSM9DS0 opgespoor nie … Kontroleer u bedrading of I2C ADDR!")); terwyl (1); } Serial.println (F ("LSM9DS0 9DOF gevind")); // Begin met die bediener Serial.print ("Koppel aan"); Serial.println (gasheer);

// Kyk of die verbinding suksesvol is. As dit misluk, stop dan

if (! client.connect (host, port)) {Serial.println ("verbinding misluk"); verbind = vals; terugkeer; } anders {verbind = waar; }

// Stel die sensorversterking en integrasietyd in

configureSensor (); }

Ons benodig dan 'n lusfunksie wat herhaaldelik sal loop. In hierdie geval word dit gebruik om herhaaldelik data van die versnellingsmeter na die bediener te stuur in die vorm van "[z_accel]: [y_mag]: [z_mag]". Die kliënt.afdruk (nommers); funksie is wat data na die bediener stuur.

leemte -lus () {vertraging (250); as (gekoppel) {// Dit stuur data na die bediener sensors_event_t accel, mag, gyro, temp; lsm.getEvent (& accel, & mag, & gyro, & temp); Stringgetalle; getalle += accel.acceleration.z; getalle += ":"; getalle += mag.magnetic.y; getalle += ":"; getalle += mag.magnetic.z; Reeks.afdruk (nommers); kliënt.afdruk (nommers); Serial.println (); } anders {establishmentConnection (); }}

Vir sommige nutfunksies het ons een nodig om die verbinding tussen die veer en die bediener te vestig.

void establishmentConnection () {if (! client.connect (host, port)) {Serial.println ("verbinding misluk"); verbind = vals; terugkeer; } anders {verbind = waar; }}

Ons moet ook die sensor konfigureer en die reeks waardes gee wat dit sal lees. Versnelling het byvoorbeeld 5 opsies vir die reeks: 2g, 4g, 6g, 8g en 16g.

void configureSensor (void) {// Stel die versnellingsmeterbereik in //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); // Stel die magnetometer sensitiwiteit in //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_2GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_4GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_8GAUSS); lsm.setupMag (lsm. LSM9DS0_MAGGAIN_12GAUSS);

// Stel die gyroscoop op

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

Die opstel van die bediener:

Die bediener sal 'n python -lêer wees wat op die opdragreël van 'n rekenaar uitgevoer word. Voer die vereiste klasse in om te begin.

invoer socketimport weer invoer pyautogui

socket word gebruik vir netwerk. re word gebruik vir regex, of string manipulasies. pyautogui is 'n luislangbiblioteek waarmee die tekening kan plaasvind (later bespreek).

Vervolgens moet ons 'n paar veranderlikes definieer. Dit sal globale veranderlikes wees, en daar sal toegang tot hulle wees in verskeie funksies. Hulle sal later in die kode gebruik word.

i = 0n = 0 reël = 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 = Onwaar

first_data = Waar

Ons benodig nou 'n funksie om 'n bediener te skep en oop te maak vir inkomende verbindings.

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 and port host = " 149.160.251.3 "poort = 12347 server_address = (gasheer, poort) # Maak die bediener oop en luister na inkomende verbindings druk ('Begin bediener op %s poort %s' %server_address) serversocket.bind (server_address) serversocket.listen (5) # Wag vir verbindings … terwyl dit waar is: druk ('Wag op verbinding …') # Aanvaar 'n inkomende verbinding (klienteknop, adres) = serversocket.accept () # Probeer om data wat ontvang is, te ontleed: druk ('Verbinding tot stand gebring vanaf', adres) terwyl dit waar is: # Ontvang die data en stuur dit vir die verwerking van 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] druk (accel_data) i+= 1 as (i <51): calibData (accel_data) anders: movingAcce l (accel_data [0]) processData (accel_data) first_data = uiteindelik onwaar: # Maak die sok toe om onnodige data lek te voorkom clientsocket.close ()

Ons benodig nou die funksies wat al die data sal verwerk. Die eerste stap om te neem, en die eerste funksie wat genoem word, is die kalibrasie van die sensor vir die berekeningsdoeleindes.

def calibData (lys): globale z_calib globale z_offset globale mag_data globale mag_calib_y globale mag_offset_y z_calib += float (lys [0]) mag_calib_y += float (lys [1]) as (i == 50): z_offset = z_calib / 50 mag_offset_ = mag_calib_y / 50 z_calib = 0 mag_calib_y = 0 mag_data.append (mag_offset_y)

Vervolgens skep ons 'n bewegende versnellingsverset. Dit maak dat die program herken dat iemand ophou om sy vinger te beweeg, want al die versnellingswaardes wat na die bediener gestuur word, moet dieselfde wees.

def movingAccel (num): global z_calib global z_diff global z_moving_offset global z_offset global data_list global n global keep_offset if (n 0.2 or z_diff <-0.2): # beweging opgespoor binne data, herbegin keep_offset = True n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = breek indien nie keep_offset: # stil in data, stel nuwe 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 = Onwaar keep_offset = Onwaar

Vervolgens doen ons die swaarste van die wiskunde. Dit behels die vertaling van die versnellingsdata in 'n posisiesdata waarmee ons die rigting kan aandui waarin die gebruiker sy vinger beweeg.

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

z_real = float (lys [0]) - z_offset

mag_y = lys [1] mag_z = lys [2] links = Onwaar regs = Onwaar # Moenie versnelling verwerk totdat dit heeltemal seker is dat dit versnel het nie # Voorkom dat meganiese geraas bydra tot posisie as (z_real -0.20): z_real = 0 #Begin integrasies om posisie te vind as (eerste_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) anders: 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): regs = Ware elif (float (mag_data [1]) - float (mag_data [0]) <-0.03): links = Waar as (regs): beweging (50, int (z_pos* 1000)) elif (links): beweging (-50, int (z_pos*1000)) z_velo = 0 z_pos = 0

Nou, uiteindelik, skuif ons die wyser! Om dit te doen, het ons 'n verfvenster oopgemaak en dit op die volle skerm gemaak. Die pyautogui -biblioteek bevat 'n funksie genaamd pyautogui.dragRel (x, y); wat ons gebruik om die muiswyser van die een punt na die ander te sleep. Dit gebruik relatiewe posisie data, sodat die beweging relatief is tot die laaste posisie van die wyser.

def beweging (x, y): druk ("beweeg na", x, -y) pyautogui.dragRel (x, -y)

Laastens moet ons die hooffunksie bel om selfs al hierdie kode te laat loop.

# Roep die funksie op om die serverstartServer () te begin