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

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:46

Introduktion

Den magiska handen låter personer med funktionsnedsättningar och motoriska funktionsnedsättningar njuta av kreativiteten i att rita och skriva i en simulerad miljö. The Magic Hand är en bärbar handske som känner av pekfingrets rörelse och översätter det till ritning av linjer på en datorskärm.

Material behövs

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

Adafruit fjäder med wifi --- $ 18,95 ---

Kvinnliga/kvinnliga ledningar --- $ 1,95 ---

Tejp/kardborreband --- $ 3

Två magneter med samma styrka --- Priserna varierar

Hur det fungerar

Genom att använda en accelerometer kan vi samla in accelerationsdata för y-axeln som hjälper oss att avgöra när användarens finger rör sig upp och ner. På grund av det faktum att vår accelerometer mäter acceleration i förhållande till jordens centrum kan vi inte bestämma accelerationen för x-axeln (vänster eller höger). Lyckligtvis innehåller LSM9DOF -brytkortet också en magnetometer som gör att vi kan samla in data om magnetfält. Vi placerar två magneter med 30 cm mellanrum och har handsken däremellan. Om magnetiska data läser positivt vet vi att handsken rör sig åt höger och vice versa. Efter att all data har samlats in i accelerometern/magnetometern skickar den data via tråd till fjädern som är ansluten till en wifi -dator och vidarebefordrar sedan data till datorn som vi sedan kan använda i vår kod.

Steg 1: Fysisk prototyp 1

Denna prototyp är avsedd att sys handskar löst ihop på handen för att den ska glida över de elektroniska enheterna. Den elektroniska enheten kommer sedan att fästas med kardborrband på underarmour -fodralet i kombination med en bashandske på handen. Då kommer den gröna handsken att glida över basen och de elektroniska enheterna ….

Steg för att göra prototyphandsken:

• Få två tygstycken som är tillräckligt stora för att spåra handen
• Spåra handen på båda tygbitarna och klipp ut dem
• Sätt ihop de två handutskärningarna så att de är perfekt anpassade
• Dra sedan tråden genom de angivna fläckarna på maskinen för att förbereda symaskinen
• När symaskinen är klar lyfter du nålen och lägger de två sammansatta tygbitarna under nålen
• Se till att nålen är uppradad på ytterkanten av tyget, starta maskinen och sy längs kanterna på tyget, medan de två bitarna är osyade vid handleden så att en hand kan passa in.

Steg 2: Fysisk prototyp 2

Vår sista prototyp är en vanlig handske i kombination med kardborreband som kan justeras till vilken handled som helst. Handsken och remmen sys ihop och de elektroniska enheterna fästs på handsken via kardborreband.

Steg för att göra den andra prototypen av handsken:

1. Köp en handske, handskmaterialet spelar ingen roll.
2. Köp ett kardborreband
3. Köp ett bärbart batteri
4. Köp klibbig kardborre
5. Med en synål fäster du kardborrebandet på handsken
6. Handledsremmen ska kunna anpassas till olika handledsstorlekar.
7. Fäst tejpen på accelerometerns bas och fäst den på handskens pekfinger
8. Fäst tejp på fjädern och fäst den på toppen av handsken.
9. Använd trådar för att ansluta 3V3 -stiftet i fjädern till VIN -stiftet i accelerometern
10. Använd trådar för att ansluta GND -stiftet i fjädern till GND -stiftet accelerometer.
11. Anslut SCL -stiftet i fjädern till SCL -stiftets accelerometer med hjälp av trådar.
12. Anslut SDA -stiftet i fjädern till accelerationsmätaren med SDA -stiftet med hjälp av trådar.
13. Anslut minst ett 5 volts batteri via usb till fjädern för att ge ström.

Steg 3: Magneter

Steg 1: Sätt de två magneterna med lika stor styrka mittemot varandra.

Steg 2: Mät upp 30 cm mellanrum mellan de två magneterna

Steg 3: placera magnetometern exakt i mitten av de två magneterna. Du bör få data runt 0 medan den är i mitten. Om du får en avläsning på noll, gå till steg 5.

Steg 4: Om avläsningen inte är noll eller nära noll måste du justera magneternas avstånd. Om avläsningen är negativ, flytta vänster magnet en cm eller 2 till vänster eller tills avläsningen är noll. Om det är positivt gör samma sak utom med rätt magnet.

Steg 5: Skriv kod som accepterar data från magnetometern och läser om den är positiv eller negativ. Om koden är positiv, rita en linje till höger och om negativ rita en linje till vänster.

Steg 4: Kod

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

Introduktion:

För att kunna bearbeta data från accelerometern måste ett klient/server -förhållande upprättas mellan Adafruit -fjädern och servern som behandlar data (körs på en bärbar dator/skrivbord). Två kodfiler måste skapas: en för klienten (Adafruit -fjädern) och den andra för servern (i detta fall Jarods bärbara dator). Klienten skrivs i C ++ och servern är skriven i python. Språket som används för klienten är viktigt eftersom Arduino huvudsakligen är ett C ++ -språk, och det är svårt att ändra det för att använda ett annat språk. Servern kan skrivas på alla språk, så länge den har nätverksfunktioner.

Konfigurera klienten:

Först konfigurerar vi klientkoden. Det mesta av WiFi -anslutningskoden är lätt tillgängligt via Adafruit -biblioteken. Vi börjar med att inkludera relevanta klasser.

#include #include #include #include #include

Ange några variabler vad som ska användas i hela koden.

// Anslut till ett nätverk const char* ssid = "MMServer"; const char* password = "MMServer-Password"; // IP och port på servern som kommer att ta emot data const char* host = "149.160.251.3"; const int port = 12347; bool ansluten = falsk;

// Initiera rörelsedetektor

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0 (1000);

WiFiClient -klient;

Skapa en setup () -funktion som körs så snart fjädern startar.

// Konfigurera WiFi -anslutning och anslut till servervoid setup () {Serial.begin (9600); fördröjning (100);

Serial.println ();

Serial.println (); Serial.print ("Ansluter till"); Serial.println (ssid); // Starta WiFi WiFi.begin (ssid, lösenord); // Ansluter … medan (WiFi.status ()! = WL_CONNECTED) {fördröjning (500); Serial.print ("."); } // Anslutet till WiFi Serial.println (""); Serial.println ("WiFi ansluten"); Serial.println ("IP -adress:"); Serial.println (WiFi.localIP ());

#ifndef ESP8266

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

// Initiera sensorn

if (! lsm.begin ()) {// Det uppstod ett problem med att upptäcka LSM9DS0 Serial.print (F ("Oj, ingen LSM9DS0 upptäcktes … Kontrollera din ledning eller I2C ADDR!")); medan (1); } Serial.println (F ("Hittade LSM9DS0 9DOF")); // Börja ansluta till servern Serial.print ("Ansluter till"); Serial.println (värd);

// Kontrollera om anslutningen lyckades. Om det misslyckas, avbryt

if (! client.connect (host, port)) {Serial.println ("anslutningen misslyckades"); ansluten = falsk; lämna tillbaka; } annat {anslutet = sant; }

// Ställ in sensorförstärkning och integrationstid

configureSensor (); }

Vi behöver då en loop -funktion som upprepade gånger kommer att loopa. I det här fallet används det för att upprepade gånger skicka data från accelerometern till servern i form av "[z_accel]: [y_mag]: [z_mag]". Client.print (siffror); funktion är det som skickar data till servern.

void loop () {delay (250); om (ansluten) {// Detta skickar data till servern sensors_event_t accel, mag, gyro, temp; lsm.getEvent (& accel, & mag, & gyro, & temp); Strängnummer; nummer += accel.acceleration.z; siffror += ":"; siffror += mag.magnetic.y; siffror += ":"; siffror += mag.magnetic.z; Serial.print (siffror); client.print (nummer); Serial.println (); } annat {etableraConnection (); }}

För vissa verktygsfunktioner behöver vi en för att upprätta anslutningen mellan fjädern och servern.

void etableraConnection () {if (! client.connect (host, port)) {Serial.println ("anslutningen misslyckades"); ansluten = falsk; lämna tillbaka; } annat {anslutet = sant; }}

Vi måste också konfigurera sensorn och ge den intervallet av värden den kommer att läsa. Till exempel har acceleration 5 alternativ för intervallet: 2g, 4g, 6g, 8g och 16g.

void configureSensor (void) {// Ange accelerometerintervallet //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); // Ställ in magnetometerkänsligheten //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_2GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_4GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_8GAUSS); lsm.setupMag (lsm. LSM9DS0_MAGGAIN_12GAUSS);

// Ställ in gyroskopet

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

Konfigurera servern:

Servern kommer att vara en pythonfil som körs på en dators kommandorad. För att börja, importera de obligatoriska klasserna.

import socketimport re import pyautogui

uttag används för nätverk. re används för regex eller strängmanipulationer. pyautogui är ett pythonbibliotek som tillåter ritningen att hända (diskuteras senare).

Därefter bör vi definiera några variabler. Dessa kommer att vara globala variabler, så de kommer att nås i flera funktioner. De kommer att användas senare i koden.

i = 0n = 0 rad = 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 = Falskt

first_data = Sant

Vi behöver nu en funktion för att skapa en server och öppna den för inkommande anslutningar.

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 -adress och portvärd = " 149.160.251.3 "port = 12347 server_address = (värd, port) # Öppna servern och lyssna efter inkommande anslutningar skriv ut ('Starta server på %s port %s' %server_address) serversocket.bind (server_address) serversocket.listen (5) # Vänta på anslutningar … medan Sant: skriv ut ('Väntar på anslutning …') # Acceptera en inkommande anslutning (klientuttag, adress) = serversocket.accept () # Försök att analysera mottagna data försök: skriv ut ('Anslutning upprättad från', adress) medan True: # Ta emot data och skicka dem för bearbetning 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 = Falskt slutligen: # Stäng uttaget för att förhindra onödiga dataläckage clientsocket.close ()

Vi behöver nu de funktioner som kommer att behandla all data. Det första steget att ta, och den första funktionen som kallas, är kalibrering av sensorn för beräkningsändamål.

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

Därefter skapar vi en rörlig accelerationsförskjutning. Detta gör det så att programmet känner igen när någon slutar röra fingret eftersom alla värden för acceleration som skickas till servern bör vara desamma vid 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 om (n 0,2 eller z_diff <-0,2): # rörelse upptäckt i data, starta om keep_offset = True n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = bryt om inte keep_offset: # stationärt i data, ställ in nytt 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 = Falskt keep_offset = Falskt

Därefter gör vi brunten av matematiken. Detta innebär att accelerationsdata översätts till en positionsdata som gör att vi kan berätta i vilken riktning användaren rör sitt finger.

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

mag_y = lista [1] mag_z = lista [2] vänster = falsk höger = falsk # Behandla inte accelerationen förrän helt säker på att den har accelererat # Förhindrar att mekaniskt buller bidrar till position om (z_real -0.20): z_real = 0 #Begin integrationer för att hitta position om (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) annars: 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öger = True elif (float (mag_data [1]) - float (mag_data [0]) <-0.03): left = True if (right): movement (50, int (z_pos*) 1000)) elif (vänster): rörelse (-50, int (z_pos*1000)) z_velo = 0 z_pos = 0

Nu äntligen flyttar vi markören! För att göra detta öppnade vi ett färgfönster och gjorde det till helskärm. Pyautogui -biblioteket innehåller en funktion som kallas pyautogui.dragRel (x, y); som vi använder för att dra muspekaren från en punkt till en annan. Den använder data om relativ position så att rörelsen är relativt markörens sista position.

def -rörelse (x, y): print ("flyttar till", x, -y) pyautogui.dragRel (x, -y)

Slutligen måste vi ringa till huvudfunktionen för att tillåta att all denna kod körs.

# Anropar funktionen för att starta serverstartServer ()