Accel írás (varázslatos kéz): 4 lépés (képekkel)

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:43

Bevezetés

A varázslatos kéz lehetővé teszi a fogyatékkal élő és mozgássérült emberek számára, hogy szimulált környezetben élvezhessék a rajzolás és írás kreativitását. A Varázslatos kéz egy viselhető kesztyű, amely érzékeli a mutatóujja mozgását, és lefordítja a vonalak rajzolásához a számítógép képernyőjén.

Szükséges anyagok

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

Adafruit toll Wifivel --- 18,95 USD ---

Női/női vezetékek --- 1,95 USD ---

Szalag/tépőzáras szalagok-$ 3

Két azonos erősségű mágnes --- Az árak eltérőek

Hogyan működik

Gyorsulásmérő segítségével összegyűjthetjük az y tengely gyorsulási adatait, amelyek segítenek meghatározni, hogy a felhasználó ujja mikor mozog felfelé és lefelé. Mivel a gyorsulásmérőnk a Föld középpontjához viszonyítva méri a gyorsulást, nem tudjuk meghatározni az x tengely (bal vagy jobb) gyorsulását. Szerencsére az LSM9DOF kitörőtábla tartalmaz egy magnetométert is, amely lehetővé teszi számunkra, hogy adatokat gyűjtsünk a mágneses mezőkről. Két mágnest helyezünk el 30 cm -re egymástól, és a kesztyűt tartjuk közöttük. Ha a mágneses adat pozitív, akkor tudjuk, hogy a kesztyű jobbra mozog, és fordítva. Miután minden adatot összegyűjtött a gyorsulásmérőben/magnetométeren, az adatokat vezetéken keresztül elküldi a tollhoz, amely csatlakozik a wifi számítógéphez, majd továbbítja az adatokat a számítógépnek, amelyet aztán a kódunkban használhatunk.

1. lépés: Fizikai prototípus 1

Ezt a prototípust lazán össze kell varrni a kézre, hogy átcsússzon az elektronikus eszközökön. Az elektronikus eszközt ezután tépőzárral rögzítik a páncél alatti hüvely aljához, és egy alapkesztyűt a kézben. Ezután a zöld kesztyű átcsúszik az alapon és az elektronikus eszközökön.

A prototípus kesztyű elkészítésének lépései:

• Szerezzen két olyan szövetdarabot, amely elég nagy ahhoz, hogy nyomon tudja követni a kezét
• Rajzolja a kezét mindkét szövetdarabra, és vágja ki őket
• Tegye össze a két kézzel kivágott részt, hogy tökéletesen illeszkedjenek
• Ezután a varrógép előkészítéséhez futtassa a cérnát a gép jelzett pontjain
• A varrógép üzembe helyezésekor emelje fel a tűt, és tegye a két összerakott szövetdarabot a tű alá
• Győződjön meg arról, hogy a tű a szövet szélén sorakozik, indítsa el a gépet, és varrja végig a szövet széleit, miközben a két darabot varratlanul hagyja a csuklóján, hogy egy kéz beférjen.

2. lépés: 2. fizikai prototípus

A végső prototípusunk egy normál kesztyű tépőzáras szíjjal kombinálva, amely bármilyen csuklóhoz állítható. A kesztyűt és a hevedert összevarrják, az elektronikus eszközöket pedig tépőzárral rögzítik a kesztyűhöz.

A kesztyű második prototípusának elkészítése:

1. Vásároljon kesztyűt, a kesztyű anyaga nem számít.
2. Vásároljon tépőzáras csuklópántot
3. Vásároljon hordozható akkumulátort
4. Sticky tépőzár vásárlása
5. Varró tűvel rögzítse a tépőzáras csuklópántot a kesztyű aljához
6. A csuklópántnak képesnek kell lennie a különböző csuklóméretekhez való alkalmazkodásra.
7. Rögzítse a ragasztószalagot a gyorsulásmérő alapjához, és rögzítse a kesztyű mutatóujjához
8. Ragasszon ragasztószalagot a tollra, és rögzítse a kesztyű tetejére.
9. Vezetékek segítségével csatlakoztassa a toll 3V3 -as érintkezőjét a gyorsulásmérő VIN -tűjéhez
10. Vezetékek segítségével csatlakoztassa a tollban lévő GND csapot a gyorsulásmérő GND csapjához.
11. Vezetékek segítségével csatlakoztassa a tollban lévő SCL csapot a gyorsulásmérő SCL csapjához.
12. Vezetékek segítségével csatlakoztassa a toll SDA csapját a gyorsulásmérő SDA csapjához.
13. Csatlakoztasson legalább 5 voltos akkumulátort USB-n keresztül a tollhoz az áramellátáshoz.

3. lépés: Mágnesek

1. lépés: Helyezze a két azonos erősségű mágnest egymással szemben.

2. lépés: Mérjen ki 30 cm távolságot a két mágnes között

3. lépés: Helyezze a magnetométert pontosan a két mágnes közepére. 0 körül kell adatokat kapnia, amíg azok középen vannak. Ha nulla értéket kap, ugorjon az 5. lépésre.

4. lépés: Ha a leolvasás nem nulla vagy nulla közelében, akkor be kell állítania a mágnesek távolságát. Ha a leolvasott érték negatív, mozgassa a bal oldali mágnest egy cm -rel vagy 2 -rel balra, vagy amíg az érték nulla lesz. Ha pozitív, tegye ugyanezt, kivéve a megfelelő mágnest.

Lépés: Írjon olyan kódot, amely elfogadja a magnetométer adatait, és elolvassa, hogy pozitív vagy negatív. Ha pozitív, akkor a kód húzzon egy vonalat jobbra, és ha negatív, húzzon egy vonalat balra.

4. lépés: Kód

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

Bevezetés:

A gyorsulásmérőből származó adatok feldolgozásához ügyfél/szerver kapcsolatot kell létrehozni az Adafruit toll és az adatokat feldolgozó szerver között (laptopon/asztali számítógépen fut). Két kódfájlt kell létrehozni: az egyik a kliensnek (az Adafruit toll), a másik a szervernek (ebben az esetben a Jarod laptopja). Az ügyfél C ++ nyelven, a szerver python nyelven íródott. Az ügyfél által használt nyelv fontos, mivel az Arduino főleg C ++ nyelv, és nehéz megváltoztatni azt egy másik nyelv használatára. A szerver bármilyen nyelven írható, amennyiben rendelkezik hálózati funkciókkal.

Az ügyfél beállítása:

Először beállítjuk az ügyfélkódot. A legtöbb WiFi -kód könnyen elérhető az Adafruit könyvtárain keresztül. Kezdjük a megfelelő osztályok bevonásával.

#befoglalás #befoglalás #befoglalás #befoglalás #befoglalás

Állítson be néhány változót, amelyeket használni fog a kódban.

// Csatlakozás a hálózathoz const char* ssid = "MMServer"; const char* password = "MMSszerver-jelszó"; // A szerver IP -címe és portja, amely adatokat fog fogadni const char* host = "149.160.251.3"; const int port = 12347; bool csatlakoztatva = hamis;

// Inicializálja a mozgásérzékelőt

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0 (1000);

WiFiClient kliens;

Hozzon létre egy setup () függvényt, amely a toll elindulása után fut.

// Állítsa be a WiFi kapcsolatot, és csatlakozzon a szerverhez void setup () {Serial.begin (9600); késleltetés (100);

Sorozat.println ();

Sorozat.println (); Serial.print ("Csatlakozás"); Soros.println (ssid); // Indítsa el a WiFi WiFi.begin (ssid, jelszó); // Csatlakozás… while (WiFi.status ()! = WL_CONNECTED) {delay (500); Soros.nyomtatás ("."); } // Sikeresen csatlakozott a WiFi Serial -hoz.println (""); Serial.println ("WiFi csatlakoztatva"); Serial.println ("IP -cím:"); Serial.println (WiFi.localIP ());

#ifndef ESP8266

while (! Sorozat); #endif Serial.begin (9600); Serial.println ("Érzékelő teszt");

// Inicializálja az érzékelőt

if (! lsm.begin ()) {// Hiba történt az LSM9DS0 Serial.print észlelésekor (F ("Hoppá, LSM9DS0 nem észlelhető … Ellenőrizze a vezetékeket vagy az I2C ADDR!"); míg (1); } Serial.println (F ("Talált LSM9DS0 9DOF")); // Csatlakozás a szerverhez Serial.print ("Csatlakozás"); Serial.println (gazdagép);

// Ellenőrizze a sikeres csatlakozást. Ha nem sikerül, akkor szakítsa meg

if (! client.connect (host, port)) {Serial.println ("a kapcsolat nem sikerült"); csatlakoztatva = hamis; Visszatérés; } else {csatlakoztatva = igaz; }

// Az érzékelő erősítésének és integrálási idejének beállítása

configureSensor (); }

Ezután szükségünk van egy ciklusfüggvényre, amely többször is ciklusba lép. Ebben az esetben arra használják, hogy ismételten adatokat küldjenek a gyorsulásmérőről a szerverre „[z_accel]: [y_mag]: [z_mag]” formában. A kliens.nyomat (számok); függvény az, ami adatokat küld a szervernek.

void loop () {delay (250); if (connected) {// Ez adatokat küld a szervernek sensors_event_t accel, mag, gyro, temp; lsm.getEvent (& accel, & mag, & gyro, & temp); String számok; számok += felgyorsulás.z; számok += ":"; számok += mágneses.y; számok += ":"; számok += mágneses.z; Sorozat.nyomtatás (számok); client.print (számok); Sorozat.println (); } else {createConnection (); }}

Néhány segédprogramhoz szükségünk van egy kapcsolatra a toll és a szerver között.

void createConnection () {if (! client.connect (hoszt, port)) {Serial.println ("a kapcsolat nem sikerült"); csatlakoztatva = hamis; Visszatérés; } else {csatlakoztatva = igaz; }}

Be kell állítanunk az érzékelőt, és meg kell adnunk az értékek tartományát, amelyet olvasni fog. Például a gyorsításnak 5 lehetősége van a tartományhoz: 2g, 4g, 6g, 8g és 16g.

void configureSensor (void) {// Állítsa be a gyorsulásmérő tartományát //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); // A magnetométer érzékenységének beállítása //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_2GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_4GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_8GAUSS); lsm.setupMag (lsm. LSM9DS0_MAGGAIN_12GAUSS);

// A giroszkóp beállítása

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

A szerver beállítása:

A szerver egy python fájl lesz, amely a számítógép parancssorán fog futni. A kezdéshez importálja a szükséges osztályokat.

import socketimport re import pyautogui

aljzatot a hálózatépítéshez használják. re regex vagy karakterlánc manipulációk. A pyautogui egy python könyvtár, amely lehetővé teszi a rajz elkészítését (később tárgyaljuk).

Ezután meg kell határoznunk néhány változót. Ezek globális változók lesznek, ezért több funkcióban érhetők el. Ezeket később a kódban fogják használni.

i = 0n = 0 sor = 1

data_list =

mag_data =

mag_calib_y = 0 mag_offset_y = 0

z_kalib = 0

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

keep_offset = Hamis

first_data = Igaz

Most egy funkcióra van szükségünk a szerver létrehozásához és a bejövő kapcsolatok számára történő megnyitásához.

def startServer (): globális i globális first_data # inicializálja a szerver socket szerver foglalat = socket.socket (socket. AF_INET, socket. SOCK_STREAM) serverocket.setsockopt (socket. SOL_SOCKET, socket. SO_REUSEADDR, 1) # Szerver IP címe és port hoszt = " 149.160.251.3 "port = 12347 server_address = (gazdagép, port) # Nyissa meg a szervert, és figyelje a bejövő kapcsolatokat nyomtatás ('Kiszolgáló indítása %s porton %s' %szerver_cím) serverocket.bind (szerver_cím) serverocket.listen (5) # Várjon a kapcsolatokra… míg Igaz: print ('Várakozás a kapcsolatra …') # Fogadja el a bejövő kapcsolatot (clientocket, address) = serverocket.accept () # Próbálja elemezni a kapott adatokat try: print ('Kapcsolat létrejött', cím) míg igaz: # Fogadja az adatokat és küldje el az adatok feldolgozására = customersocket.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: moveAcce l (accel_data [0]) processData (accel_data) first_data = Hamis végül: # Zárja be az aljzatot, hogy megakadályozza a felesleges adatszivárgást customersocket.close ()

Most szükségünk van az összes adatot feldolgozó funkciókra. Az első lépés, és az első meghívott funkció az érzékelő kalibrálása a számítás céljából.

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

Ezután létrehozunk egy mozgó gyorsulási eltolást. Ezáltal a program felismeri, ha valaki abbahagyja az ujja mozgatását, mert a gyorsításnak a szervernek küldött összes értékének azonosnak kell lennie abban az időben.

def moveAccel (szám): globális z_calib globális z_diff globális z_moving_offset globális z_offset globális adat_lista globális n globális globális globális eltolás if (n 0,2 vagy z_diff <-0,2): # mozgás észlelve az adatokon belül, újraindítás keep_offset = Igaz n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = szünet, ha nem keep_offset: # stacionárius az adatokban, új z_offset beállítása 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 = Hamis keep_offset = Hamis

Ezután végezzük a matematikai feladatokat. Ez magában foglalja a gyorsulási adatok helyzetadatokká történő lefordítását, amelyek lehetővé teszik számunkra, hogy megmondjuk, milyen irányba mozgatja a felhasználó az ujját.

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

z_real = lebegés ([0] lista) - z_eltolás

mag_y = lista [1] mag_z = lista [2] bal = Hamis jobb = Hamis # Ne dolgozza fel a gyorsítást, amíg nem biztos abban, hogy felgyorsult # Megakadályozza, hogy a mechanikai zaj hozzájáruljon a pozícióhoz, ha (z_real -0,20): z_real = 0 # Kezdés integrációk a pozíció megtalálására, ha (első_adatok): = (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 (right): motion (50, int (z_pos*) 1000)) elif (balra): mozgás (-50, int (z_pos*1000)) z_velo = 0 z_pos = 0

Most végre mozgatjuk a kurzort! Ehhez kinyitottunk egy festőablakot, és teljes képernyősé tettük. A pyautogui könyvtár tartalmaz egy pyautogui nevű függvényt.dragRel (x, y); amellyel az egérmutatót egyik pontról a másikra húzzuk. Relatív helyzetadatokat használ, így a mozgás a kurzor utolsó pozíciójához képest történik.

def mozgás (x, y): print ("költözés", x, -y) pyautogui.dragRel (x, -y)

Végül meg kell hívnunk a fő függvényt, hogy lehetővé tegyük az összes kód futtatását.

# Meghívja a függvényt a szerverektartServer () elindításához