Accel Writing (Magic Hand): 4 trinn (med bilder)

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:25

Introduksjon

Den magiske hånden lar mennesker med nedsatt funksjonsevne og nedsatt motorisk ferdighet nyte kreativiteten til å tegne og skrive i et simulert miljø. The Magic Hand er en bærbar hanske som kjenner bevegelsen til pekefingeren og oversetter det til tegning av linjer på en dataskjerm.

Materialer som trengs

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

Adafruit fjær med Wifi --- $ 18,95 ---

Kvinnelige/kvinnelige ledninger --- $ 1,95 ---

Tape/borrelåsstrimler --- $ 3

To magneter med lik styrke --- Prisene varierer

Hvordan det fungerer

Ved å bruke et akselerometer kan vi samle akselerasjonsdata for y-aksen som vil hjelpe oss med å bestemme når brukerens finger beveger seg opp og ned. På grunn av at akselerometeret vårt måler akselerasjon i forhold til sentrum av jorden, kan vi ikke bestemme akselerasjonen til x-aksen (venstre eller høyre). Heldigvis inneholder LSM9DOF breakout board også et magnetometer som lar oss samle data om magnetiske felt. Vi plasserer to magneter 30 cm fra hverandre og har hansken mellom. Hvis de magnetiske dataene leser positivt, vet vi at hansken beveger seg til høyre og omvendt. Etter at alle dataene er samlet inn i akselerometeret/magnetometeret, sender de dataene via ledning til fjæren som er koblet til en datamaskin med wifi og videresender deretter dataene til datamaskinen som vi deretter kan bruke i koden vår.

Trinn 1: Fysisk prototype 1

Denne prototypen er ment å bli sydd løst sammen på hånden for å gli over de elektroniske enhetene. Den elektroniske enheten vil deretter bli festet med borrelås til underpansret ermet base kombinert med en grunnhanske på hånden. Da vil den grønne hansken gli over basen og de elektroniske enhetene ….

Fremgangsmåte for å lage prototyphansken:

• Få to stoffstykker som er store nok til å spore hånden
• Spor hånden på begge stoffbitene og klipp dem ut
• Sett de to håndklippene sammen slik at de er perfekt tilpasset
• Deretter kjører du tråden gjennom de angitte stedene på maskinen for å klargjøre symaskinen
• Når symaskinen er satt opp, løfter du nålen og legger de to stoffbitene under nålen
• Sørg for at nålen er stilt opp helt på stoffkanten, start maskinen og sy langs stoffets kanter, mens de to delene er usydde ved håndleddet slik at en hånd kan passe inn.

Trinn 2: Fysisk prototype 2

Vår siste prototype er en vanlig hanske kombinert med borrelåsstropp som kan justeres til ethvert håndledd. Hansken og stroppen sys sammen, og de elektroniske enhetene festes til hansken via borrelås.

Trinn i å lage den andre prototypen av hansken:

1. Kjøp en hanske, materialet i hansken spiller ingen rolle.
2. Kjøp en borrelåsrem for håndleddet
3. Kjøp et bærbart batteri
4. Kjøp Sticky Velcro
5. Fest en borrelåsrem til bunnen av hansken med en synål
6. Håndleddsstroppen skal kunne justeres til forskjellige håndleddstørrelser.
7. Fest teipen til bunnen av akselerometeret og fest den til pekefingeren på hansken
8. Fest tape til fjæren og fest den til toppen av hansken.
9. Koble 3V3 -pinnen i fjæren til VIN -pinnen i akselerometeret ved hjelp av ledninger
10. Koble GND -pinnen i fjæren til GND -pinnen akselerometeret ved hjelp av ledninger.
11. Koble SCL -pinnen i fjæren til SCL -pinnen med akselerometeret ved hjelp av ledninger.
12. Koble SDA -pinnen i fjæren til SDA -pinnen akselerometeret ved hjelp av ledninger.
13. Koble minst et 5 volt batteri gjennom usb til fjæren for å gi strøm.

Trinn 3: Magneter

Trinn 1: Sett de to magneter med lik styrke overfor hverandre.

Trinn 2: Mål 30 cm mellomrom mellom de to magnetene

Trinn 3: plasser magnetometeret nøyaktig i midten av de to magnetene. Du bør motta data rundt 0 mens den er i midten. Gå til trinn 5 hvis du får nulllesning.

Trinn 4: Hvis avlesningen ikke er null eller nær null, må du justere avstanden til magnetene. Hvis avlesningen er negativ, flytt venstre magnet en cm eller 2 til venstre eller til avlesningen er null. Hvis det er positivt, gjør det samme bortsett fra med riktig magnet.

Trinn 5: Skriv kode som godtar dataene fra magnetometeret og les om den er positiv eller negativ. Hvis koden er positiv, tegner du en linje til høyre og hvis den negative, tegner du en linje til venstre.

Trinn 4: Kode

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

Introduksjon:

For å behandle data fra akselerometeret må det etableres et klient/server -forhold mellom Adafruit -fjæren og serveren som behandler dataene (kjører på en bærbar/stasjonær). To kodefiler må opprettes: en for klienten (Adafruit -fjæren) og den andre for serveren (i dette tilfellet Jarods bærbare datamaskin). Klienten er skrevet i C ++, og serveren er skrevet i python. Språket som brukes for klienten, ettersom Arduino hovedsakelig er et C ++ - språk, og det er vanskelig å endre det til å bruke et annet språk. Serveren kan skrives på alle språk, så lenge den har nettverksfunksjoner.

Sette opp klienten:

Først setter vi opp klientkoden. Det meste av WiFi -tilkoblingskoden er lett tilgjengelig via Adafruit -bibliotekene. Vi begynner med å inkludere relevante klasser.

#include #include #include #include #include

Angi noen variabler for hva som skal brukes i hele koden.

// Koble til et nettverk const char* ssid = "MMServer"; const char* password = "MMServer-Password"; // IP og port på serveren som vil motta data const char* host = "149.160.251.3"; const int port = 12347; bool tilkoblet = false;

// Initialiser bevegelsesdetektor

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0 (1000);

WiFiClient -klient;

Lag en setup () -funksjon som kjøres så snart fjæren starter.

// Konfigurer WiFi -tilkobling, og koble til servervoid -oppsettet () {Serial.begin (9600); forsinkelse (100);

Serial.println ();

Serial.println (); Serial.print ("Koble til"); Serial.println (ssid); // Start WiFi WiFi. Begynn (ssid, passord); // Kobler til … mens (WiFi.status ()! = WL_CONNECTED) {forsinkelse (500); Serial.print ("."); } // Koble til WiFi Serial.println (""). Serial.println ("WiFi tilkoblet"); Serial.println ("IP -adresse:"); Serial.println (WiFi.localIP ());

#ifndef ESP8266

mens (! Seriell); #endif Serial.begin (9600); Serial.println ("Sensortest");

// Initialiser sensoren

if (! lsm.begin ()) {// Det oppstod et problem med å oppdage LSM9DS0 Serial.print (F ("Ooops, ingen LSM9DS0 oppdaget … Sjekk ledningene eller I2C ADDR!")); mens (1); } Serial.println (F ("Fant LSM9DS0 9DOF")); // Begynn å koble til serveren Serial.print ("Koble til"); Serial.println (vert);

// Se etter tilkobling. Hvis mislykkes, avbryt

if (! client.connect (host, port)) {Serial.println ("tilkobling mislyktes"); tilkoblet = usant; komme tilbake; } annet {tilkoblet = sant; }

// Sett opp sensorforsterkning og integrasjonstid

configureSensor (); }

Vi trenger da en loop -funksjon som vil gjentatte ganger sløyfe. I dette tilfellet brukes det til å gjentatte ganger sende data fra akselerometeret til serveren i form av "[z_accel]: [y_mag]: [z_mag]". Klienten. Utskrift (tall); funksjon er det som sender data til serveren.

void loop () {delay (250); hvis (tilkoblet) {// Dette sender data til serveren sensors_event_t accel, mag, gyro, temp; lsm.getEvent (& accel, & mag, & gyro, & temp); String tall; tall += accel.acceleration.z; tall += ":"; tall += mag.magnetisk.y; tall += ":"; tall += mag.magnetisk.z; Serial.print (tall); client.print (tall); Serial.println (); } annet {etablereConnection (); }}

For noen verktøyfunksjoner trenger vi en for å etablere forbindelsen mellom fjæren og serveren.

void etablereConnection () {if (! client.connect (host, port)) {Serial.println ("tilkobling mislyktes"); tilkoblet = usant; komme tilbake; } annet {tilkoblet = sant; }}

Vi må også konfigurere sensoren og gi den verdiområdet den vil lese. For eksempel har akselerasjon 5 alternativer for området: 2g, 4g, 6g, 8g og 16g.

void configureSensor (void) {// Angi akselerometerområdet //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); // Still inn magnetometerfølsomheten //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_2GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_4GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_8GAUSS); lsm.setupMag (lsm. LSM9DS0_MAGGAIN_12GAUSS);

// Sett opp gyroskopet

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

Sette opp serveren:

Serveren vil være en python -fil som kjøres på kommandolinjen på en datamaskin. For å starte, importer de nødvendige klassene.

import socketimport re import pyautogui

socket brukes til nettverk. re brukes til regex eller strengmanipulasjoner. pyautogui er et python -bibliotek som lar tegningen skje (diskutert senere).

Deretter bør vi definere noen variabler. Disse vil være globale variabler, så de får tilgang til flere funksjoner. De vil bli brukt senere i koden.

i = 0n = 0 linje = 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 = Falsk

first_data = Sant

Vi trenger nå en funksjon for å lage en server og åpne den for innkommende tilkoblinger.

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 -adresse og port host = " 149.160.251.3 "port = 12347 server_address = (vert, port) # Åpne serveren og lytt etter innkommende tilkoblinger skrive ut ('Starter server på %s port %s' %server_address) serversocket.bind (server_address) serversocket.listen (5) # Vent på tilkoblinger…) sant: # Motta dataene og send dem for behandling av 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 if (i <51): calibData (accel_data) else: movingAcce l (accel_data [0]) processData (accel_data) first_data = Feil til slutt: # Lukk kontakten for å forhindre unødvendig datalekkasje clientsocket.close ()

Vi krever nå funksjonene som skal behandle alle dataene. Det første trinnet å ta, og den første funksjonen som kalles, er kalibrering av sensoren for beregningsformål.

def calibData (liste): global z_calib global z_offset global mag_data global mag_calib_y global mag_offset_y z_calib += float (liste [0]) mag_calib_y += float (liste [1]) hvis (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)

Deretter lager vi en akselerasjonsforskyvning i bevegelse. Dette gjør det slik at programmet gjenkjenner når noen slutter å bevege fingeren fordi alle verdiene for akselerasjon som sendes til serveren, bør være de samme på den tiden.

def movingAccel (num): global z_calib global z_diff global z_moving_offset global z_offset global data_list global n global keep_offset hvis (n 0.2 eller z_diff <-0.2): # bevegelse oppdaget i data, start keep_offset = True n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = pause hvis ikke keep_offset: # stationary in data, set new 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 = Falsk keep_offset = Falsk

Deretter gjør vi hovedtyngden av regnestykket. Dette innebærer å oversette akselerasjonsdataene til posisjonsdata som lar oss fortelle hvilken retning brukeren beveger fingeren.

def processData (liste): #[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 (liste [0]) - z_offset

mag_y = list [1] mag_z = list [2] left = False right = False # Ikke behandle akselerasjon før den er helt sikker på at den har akselerert # Forhindrer at mekanisk støy bidrar til posisjon hvis (z_real -0.20): z_real = 0 #Begin integrasjoner for å finne posisjon hvis (første_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) annet: 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): høyre = True elif (float (mag_data [1]) - float (mag_data [0]) <-0.03): left = True if (høyre): bevegelse (50, int (z_pos*) 1000)) elif (venstre): bevegelse (-50, int (z_pos*1000)) z_velo = 0 z_pos = 0

Endelig flytter vi markøren! For å gjøre dette åpnet vi et malingsvindu og gjorde det i fullskjerm. Pyautogui -biblioteket inneholder en funksjon som heter pyautogui.dragRel (x, y); som vi bruker til å dra musemarkøren fra ett punkt til det neste. Den bruker relative posisjonsdata, slik at bevegelsen er i forhold til den siste posisjonen til markøren.

def -bevegelse (x, y): print ("flytte til", x, -y) pyautogui.dragRel (x, -y)

Til slutt må vi ringe hovedfunksjonen for å tillate all denne koden å kjøre.

# Ringer til funksjonen for å starte serverstartServer ()