Accel Writing (maagiline käsi): 4 sammu (piltidega)

2025 Autor: John Day | [email protected]. Viimati modifitseeritud: 2025-01-13 06:57

Sissejuhatus

Maagiline käsi võimaldab puudega ja motoorsete oskustega inimestel simuleeritud keskkonnas nautida joonistamise ja kirjutamise loovust. Maagiline käsi on kantav kinnas, mis tajub teie nimetissõrme liikumist ja teisendab selle arvutiekraanil joonte joonistamiseks.

Vajalikud materjalid

LSM9DOF Breakout Board --- 24,95 dollarit ---

Adafruit Feather koos WiFi-ga-18,95 dollarit ---

Naiste/naiste juhtmed --- 1,95 dollarit ---

Lindi/takjaribad-3 dollarit

Kaks võrdse tugevusega magnetit --- Hinnad on erinevad

Kuidas see töötab

Kiirendusmõõturi abil saame koguda y-telje kiirendusandmeid, mis aitavad meil kindlaks teha, millal kasutaja sõrm liigub üles ja alla. Kuna meie kiirendusmõõtur mõõdab kiirendust Maa keskpunkti suhtes, ei saa me x-telje (vasakule või paremale) kiirendust määrata. Õnneks sisaldab LSM9DOF -i plaat ka magnetomeetrit, mis võimaldab meil koguda andmeid magnetväljade kohta. Asetame kaks magnetit 30 cm kaugusele ja kinnas on nende vahel. Kui magnetandmed on positiivsed, siis teame, et kinnas liigub paremale ja vastupidi. Kui kõik andmed on kiirendusmõõturisse/magnetomeetrisse kogutud, saadab see andmed traadi kaudu sulele, mis on ühendatud WiFi -arvutiga, ja edastab andmed arvutisse, mida saame seejärel oma koodis kasutada.

Samm: füüsiline prototüüp 1

See prototüüp on ette nähtud kätele lõdvalt kokku õmmeldud kindaks, et see libiseks üle elektroonikaseadmete. Seejärel kinnitatakse elektrooniline seade takjakinnitusega soomuse all oleva varruka aluse külge koos põhikindaga käes. Siis libiseb roheline kinnas üle aluse ja elektroonikaseadmete …

Prototüübi kinda valmistamise sammud:

• Hankige kaks kangatükki, mis on käe jälgimiseks piisavalt suured
• Joonista käsi mõlemale kangatükile ja lõika need välja
• Pange kaks käsitsi lõigatud välja, nii et need oleksid ideaalselt joondatud
• Seejärel ajage õmblusmasina ettevalmistamiseks niit läbi masinal näidatud punktide
• Kui õmblusmasin on üles seatud, tõstke nõel üles ja asetage kaks kokku pandud kangatükki nõela alla
• Veenduge, et nõel oleks kanga servale joondatud, käivitage masin ja õmblege mööda kanga servi, jättes need kaks tükki randmest õmblemata, nii et käsi mahuks.

2. etapp: füüsiline prototüüp 2

Meie viimane prototüüp on tavaline kinnas koos Velcro rihmaga, mis on reguleeritav igale randmele. Kinnas ja rihm õmmeldakse kokku ning elektroonilised seadmed kinnitatakse kinnastele takjakinnituse abil.

Kinda teise prototüübi valmistamise sammud:

1. Ostke kinnas, kinda materjal pole oluline.
2. Osta velcro randmepael
3. Ostke kaasaskantav aku
4. Ostke kleepuv velcro
5. Kinnitage õmblusnõelaga velcro randmepael kinnase aluse külge
6. Randmepael peaks olema kohandatav erinevate randme suurustega.
7. Kinnitage kleeplint kiirendusmõõturi alusele ja kinnitage see kinda nimetissõrme külge
8. Kinnitage sulgedele kleeplint ja kinnitage see kinda ülaosale.
9. Ühendage juhtmete abil sulgede 3V3 tihvt kiirendusmõõturi VIN -tihvtiga
10. Ühendage juhtmete abil sulgede GND tihvt kiirendusmõõturi GND tihvtiga.
11. Ühendage juhtmete abil sulgi SCL -tihvt kiirendusmõõturi SCL -tihvtiga.
12. Juhtmete abil ühendage sulgis olev SDA tihvt kiirendusmõõturi SDA tihvtiga.
13. Toite saamiseks ühendage sulgedega vähemalt 5-voldine aku USB kaudu.

Samm: magnetid

Samm: asetage kaks võrdse tugevusega magnetit üksteise vastu.

Samm: Mõõtke kahe magneti vahel 30 cm vahe

Samm: asetage magnetomeeter täpselt kahe magneti keskele. Andmeid peaksite saama umbes 0 ajal, kui need on keskel. Kui näitaja on null, jätkake 5. sammuga.

Samm: kui näit ei ole null või nullilähedane, peate reguleerima magnetite kaugust. Kui näit on negatiivne, liigutage vasakut magnetit cm või 2 vasakule või kuni näit on null. Kui see on positiivne, tehke sama, välja arvatud õige magnetiga.

Samm: kirjutage kood, mis aktsepteerib magnetomeetri andmeid ja loeb, kas see on positiivne või negatiivne. Kui positiivne, laske koodil tõmmata joon paremale ja negatiivse korral joon vasakule.

4. samm: kood

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

Sissejuhatus:

Kiirendusmõõturi andmete töötlemiseks tuleb luua kliendi ja serveri suhe Adafruit sulgede ja andmeid töötleva serveri vahel (töötab süle- või lauaarvutis). Tuleb luua kaks koodifaili: üks kliendile (Adafruit sulg) ja teine serverile (antud juhul Jarodi sülearvuti). Klient on kirjutatud C ++ keeles ja server on kirjutatud pythonis. Kliendi jaoks kasutatav keel on oluline, kuna Arduino on peamiselt C ++ keel ja selle muutmine teise keele kasutamiseks on keeruline. Serverit saab kirjutada mis tahes keeles, kui sellel on võrgufunktsioonid.

Kliendi seadistamine:

Esiteks seadistame kliendi koodi. Enamik WiFi -ühenduse koodist on Adafruit'i raamatukogude kaudu hõlpsasti saadaval. Alustame asjakohaste klasside kaasamisega.

#kaasamine #kaasamine #kaasamine #kaasamine #kaasamine

Määrake mõned muutujad, mida kogu koodis kasutatakse.

// Võrguga ühenduse loomine char* ssid = "MMServer"; const char* parool = "MMS-serveri parool"; // IP ja serveri port, mis võtab vastu andmeid const char* host = "149.160.251.3"; const int port = 12347; bool ühendatud = vale;

// Liikumisanduri initsialiseerimine

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0 (1000);

WiFiClient klient;

Looge setup () funktsioon, mis käivitatakse kohe, kui sulg käivitub.

// Seadistage WiFi -ühendus ja looge serveriga ühendusvoid setup () {Serial.begin (9600); viivitus (100);

Serial.println ();

Serial.println (); Serial.print ("Ühendamine"); Serial.println (ssid); // Käivita WiFi WiFi.begin (ssid, parool); // Ühendamine… while (WiFi.status ()! = WL_CONNECTED) {delay (500); Seeria.print ("."); } // Edukalt ühendatud WiFi Serialiga.println (""); Serial.println ("WiFi ühendatud"); Serial.println ("IP -aadress:"); Serial.println (WiFi.localIP ());

#ifndef ESP8266

while (! Seeria); #endif Serial.begin (9600); Serial.println ("Anduritest");

// Vormindage andur

if (! lsm.begin ()) {// LSM9DS0 Serial.print tuvastamisel tekkis probleem (F ("Oih, LSM9DS0 ei tuvastatud … kontrollige juhtmestikku või I2C ADDR!"); samas (1); } Serial.println (F ("Leitud LSM9DS0 9DOF")); // Alusta ühenduse loomist serveriga Serial.print ("Ühendamine"); Serial.println (host);

// Ühenduse õnnestumise kontrollimine. Kui ebaõnnestus, katkesta

if (! client.connect (host, port)) {Serial.println ("ühendus nurjus"); ühendatud = vale; tagasipöördumine; } else {ühendatud = tõsi; }

// Seadistage anduri võimendus ja integreerimisaeg

configureSensor (); }

Seejärel vajame tsüklifunktsiooni, mis korduvalt loopib. Sel juhul kasutatakse seda korduvalt kiirendusmõõturilt serverisse andmete saatmiseks kujul “[z_accel]: [y_mag]: [z_mag]”. Klient.print (numbrid); funktsioon on see, mis saadab andmed serverisse.

void loop () {viivitus (250); if (connected) {// See saadab andmed serverisse sensors_event_t accel, mag, gyro, temp; lsm.getEvent (& accel, & mag, & gyro, & temp); Stringide numbrid; numbrid += kiirenduskiirendus.z; numbrid += ":"; numbrid += mag.magnetiline.y; numbrid += ":"; numbrid += mag.magnetiline.z; Serial.print (numbrid); klient.print (numbrid); Serial.println (); } else {createConnection (); }}

Mõne utiliidi funktsiooni jaoks vajame seda sulgede ja serveri vahelise ühenduse loomiseks.

void createConnection () {if (! client.connect (host, port)) {Serial.println ("ühendus nurjus"); ühendatud = vale; tagasipöördumine; } else {ühendatud = tõsi; }}

Samuti peame anduri konfigureerima ja andma talle selle väärtuste vahemiku, mida see loeb. Näiteks kiirendusel on vahemiku jaoks 5 võimalust: 2g, 4g, 6g, 8g ja 16g.

void configureSensor (void) {// Määra kiirendusmõõturi vahemik //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); // Määra magnetomeetri tundlikkus //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_2GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_4GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_8GAUSS); lsm.setupMag (lsm. LSM9DS0_MAGGAIN_12GAUSS);

// Güroskoobi seadistamine

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

Serveri seadistamine:

Serveriks on python -fail, mis käivitatakse arvuti käsureal. Alustuseks importige vajalikud klassid.

import pistikupesa import uuesti import pyautogui

pistikupesa kasutatakse võrkude loomiseks. re kasutatakse regulaaravaldiste või stringidega manipuleerimiseks. pyautogui on pythoni raamatukogu, mis võimaldab joonistamist (arutatakse hiljem).

Järgmisena peaksime määratlema mõned muutujad. Need on globaalsed muutujad, nii et neile pääseb juurde mitme funktsiooniga. Neid kasutatakse koodis hiljem.

i = 0n = 0 rida = 1

andmete_loend =

mag_andmed =

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 = Vale

first_data = Tõsi

Nüüd vajame funktsiooni serveri loomiseks ja sissetulevate ühenduste jaoks selle avamiseks.

def startServer (): global i global first_data # initsialiseeri serveripesa serveripesa 149.160.251.3 "port = 12347 server_address = (host, port) # Avage server ja kuulake sissetulevaid ühendusi printida ('Serveri käivitamine %s pordil %s' %server_address) serverocket.bind (server_address) serverocket.listen (5) # Oodake ühendusi… samas tõsi: print ('Ootab ühendust…') # Aktsepteerige sissetulevat ühendust (klientide pistikupesa, aadress) = serverocket.accept () # Proovige saadud andmeid sõeluda proovige: print ('Ühendus on loodud', aadress) kuigi tõsi: # Võtke andmed vastu ja saatke need andmete töötlemiseks = 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 = Lõpuks vale: # Sulgege pistikupesa, et vältida tarbetut andmete lekkimist customersocket.close ()

Nüüd vajame funktsioone, mis töötlevad kõiki andmeid. Esimene samm ja esimene kutsutud funktsioon on anduri kalibreerimine arvutamise eesmärgil.

def calibData (nimekiri): globaalne z_calib globaalne z_offset globaalne mag_andmed globaalne mag_calib_y globaalne mag_offset_y z_calib += float (list [0]) mag_calib_y += float (list [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)

Järgmisena loome liikuva kiirenduse nihke. See teeb programmist äratuntavaks, kui keegi lõpetab sõrme liigutamise, sest kõik kiirendusväärtused, mis serverile saadetakse, peaksid sel ajal olema samad.

def moveAccel (num): globaalne z_calib globaalne z_diff globaalne z_moving_offset globaalne z_offset globaalne andmete_loend globaalne n globaalne Keep_offset if (n 0,2 või z_diff <-0,2): # liikumises tuvastatud liikumine, taaskäivita keep_offset = True n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = katkestus, kui mitte hoida off_offset: # statsionaarne andmetes, määrake uus 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 = Vale keep_offset = Vale

Järgmisena tegeleme matemaatikaga. See hõlmab kiirendusandmete teisendamist asukohaandmetesse, mis võimaldavad meil öelda, millises suunas kasutaja sõrme liigutab.

def processData (nimekiri): #[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 (loend [0]) - z_nihe

mag_y = list [1] mag_z = list [2] left = False right = False # Ärge töödelge kiirendust enne, kui olete täiesti kindel, et see on kiirenenud # Väldib mehaanilise müra panust positsiooni, kui (z_real -0,20): z_real = 0 # Algus integratsioonid positsiooni leidmiseks, kui (esimene_andmed): 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_andmed [0])> 0.03): paremal = tõeline elif (float (mag_data [1]) - float (mag_data [0]) <-0.03): left = True if (right): motion (50, int (z_pos*) 1000)) elif (vasakul): liikumine (-50, int (z_pos*1000)) z_velo = 0 z_pos = 0

Lõpuks liigutame kursorit! Selleks avasime värviakna ja tegime selle täisekraaniks. Pyautogui raamatukogu sisaldab funktsiooni nimega pyautogui.dragRel (x, y); mida kasutame hiirekursori lohistamiseks ühest punktist teise. See kasutab suhtelise asukoha andmeid, nii et liikumine on kursori viimase positsiooni suhtes.

def liikumine (x, y): print ("liigub", x, -y) pyautogui.dragRel (x, -y)

Lõpuks peame helistama põhifunktsioonile, et isegi lubada kogu selle koodi käitamine.

# Kutsub funktsiooni käivitama serverStartServer ()