Accel Writing (burvju roka): 4 soļi (ar attēliem)

2025 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2025-01-23 14:59

Ievads

Burvju roka ļauj cilvēkiem ar invaliditāti un kustību traucējumiem izbaudīt zīmēšanas un rakstīšanas radošumu simulētā vidē. Burvju roka ir valkājams cimds, kas uztver jūsu rādītājpirksta kustību un pārvērš to līniju zīmēšanā datora ekrānā.

Nepieciešamie materiāli

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

Adafruit spalva ar Wifi --- 18,95 USD ---

Sieviešu/sieviešu vadi --- 1,95 ASV dolāri ---

Lentes/Velcro sloksnes --- 3 ASV dolāri

Divi vienāda stipruma magnēti --- Cenas atšķiras

Kā tas strādā

Izmantojot akselerometru, mēs varam apkopot y ass paātrinājuma datus, kas palīdzēs mums noteikt, kad lietotāja pirksts pārvietojas uz augšu un uz leju. Sakarā ar to, ka mūsu akselerometrs mēra paātrinājumu attiecībā pret zemes centru, mēs nevaram noteikt x ass (pa kreisi vai pa labi) paātrinājumu. Par laimi LSM9DOF sadalīšanas panelī ir arī magnetometrs, kas ļauj apkopot datus par magnētiskajiem laukiem. Mēs ievietojam divus magnētus 30 cm attālumā viens no otra, un starp tiem ir cimds. Ja magnētiskie dati ir pozitīvi, mēs zinām, ka cimds pārvietojas pa labi un otrādi. Kad visi dati ir savākti akselerometrā/magnetometrā, tas ar vadu palīdzību nosūta datus uz spalvu, kas ir savienota ar wifi datoru, un pēc tam pārsūta datus uz datoru, ko mēs varam izmantot savā kodā.

1. darbība: 1. fiziskais prototips

Šis prototips ir paredzēts cimdiem, kas brīvi sašūti kopā ar roku, lai tas varētu paslīdēt pāri elektroniskajām ierīcēm. Pēc tam elektroniskā ierīce ar velcro palīdzību tiks piestiprināta pie bruņu piedurknes pamatnes kopā ar pamata cimdu uz rokas. Tad zaļais cimds slīdēs virs pamatnes un elektroniskajām ierīcēm …

Cimdu prototipa izgatavošanas soļi:

• Iegūstiet divus pietiekami lielus auduma gabalus, lai varētu izsekot rokai
• Izvelciet roku uz abiem auduma gabaliem un izgrieziet tos
• Salieciet abus roku izgriezumus kopā, lai tie būtu pilnīgi saskaņoti
• Tālāk, lai sagatavotu šujmašīnu, pavediet pavedienu caur norādītajām mašīnas vietām
• Kad šujmašīna ir uzstādīta, paceliet adatu un novietojiet divus saliktos auduma gabalus zem adatas
• Pārliecinieties, ka adata ir novietota pašā auduma malā, iedarbiniet mašīnu un šujiet gar auduma malām, vienlaikus atstājot abus gabalus pie šuvēm pie plaukstas, lai roka varētu iederēties.

2. solis: 2. fiziskais prototips

Mūsu pēdējais prototips ir parasts cimds kopā ar Velcro siksnu, kas ir regulējams jebkurai plaukstas locītavai. Cimds un siksna ir sašūti kopā, un elektroniskās ierīces ir piestiprinātas cimdam, izmantojot Velcro.

Cimda otrā prototipa izgatavošanas soļi:

1. Pērciet cimdu, cimda materiālam nav nozīmes.
2. Iegādājieties velcro rokas siksnu
3. Iegādājieties pārnēsājamu akumulatoru
4. Iegādājieties Sticky Velcro
5. Ar šujamo adatu piestipriniet velcro rokas siksnu pie cimda pamatnes
6. Plaukstas siksnai jāspēj pielāgoties dažādiem plaukstas izmēriem.
7. Piestipriniet līmlenti pie akselerometra pamatnes un piestipriniet to pie cimda rādītājpirksta
8. Piestipriniet līmlenti pie spalvas un piestipriniet to pie cimda augšdaļas.
9. Izmantojot vadus, savienojiet spalvu 3V3 tapu ar akselerometra VIN tapu
10. Izmantojot vadus, savienojiet spalvu GND tapu ar GND tapu akselerometru.
11. Izmantojot vadus, savienojiet spalvas SCL tapu ar SCL tapu akselerometru.
12. Izmantojot vadus, savienojiet spalvas SDA tapu ar SDA tapu akselerometru.
13. Pievienojiet spalvai vismaz 5 voltu akumulatoru caur USB, lai nodrošinātu barošanu.

3. solis: magnēti

1. solis: novietojiet abus vienāda stipruma magnētus viens pret otru.

2. solis: Izmēriet 30 cm atstarpi starp diviem magnētiem

3. solis: novietojiet magnetometru tieši divu magnētu vidū. Jums vajadzētu saņemt datus ap 0, kamēr tie atrodas vidū. Ja saņemat nulles rādījumu, pārejiet uz 5. darbību.

4. solis: ja rādījums nav nulle vai tuvu nullei, jums jāpielāgo magnētu attālums. Ja rādījums ir negatīvs, pārvietojiet kreiso magnētu par cm vai 2 pa kreisi vai līdz rādījums ir nulle. Ja tas ir pozitīvs, dariet to pašu, izņemot ar pareizo magnētu.

5. solis: uzrakstiet kodu, kas pieņem datus no magnetometra un nolasa, vai tas ir pozitīvs vai negatīvs. Ja pozitīvs, kodam uzvelciet līniju pa labi un, ja negatīvs, velciet līniju pa kreisi.

4. solis: kods

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

Ievads:

Lai apstrādātu akselerometra datus, starp Adafruit spalvu un serveri, kas apstrādā datus (darbojas klēpjdatorā/galddatorā), ir jāizveido klienta/servera attiecības. Būs jāizveido divi koda faili: viens klientam (Adafruit spalva) un otrs serverim (šajā gadījumā Jarod klēpjdators). Klients ir rakstīts C ++, bet serveris - python. Klientam izmantotā valoda ir svarīga, jo Arduino galvenokārt ir C ++ valoda, un ir grūti mainīt to, lai lietotu citu valodu. Serveri var rakstīt jebkurā valodā, ja vien tam ir tīkla funkcijas.

Klienta iestatīšana:

Pirmkārt, mēs iestatīsim klienta kodu. Lielākā daļa WiFi savienojuma koda ir viegli pieejami Adafruit bibliotēkās. Mēs sākam, iekļaujot atbilstošās nodarbības.

#iekļaut #iekļaut #iekļaut #iekļaut #iekļaut

Iestatiet dažus mainīgos, kas tiks izmantoti visā kodā.

// Pieslēgties tīklam const char* ssid = "MMServer"; const char* parole = "MMServer-Password"; // IP un servera ports, kas saņems datus const char* host = "149.160.251.3"; const int osta = 12347; bool savienots = nepatiess;

// Inicializēt kustības detektoru

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0 (1000);

WiFiClient klients;

Izveidojiet iestatīšanas () funkciju, kas tiks palaista, tiklīdz spalvas sākums.

// Iestatiet WiFi savienojumu un izveidojiet savienojumu ar serveriVid setup () {Serial.begin (9600); kavēšanās (100);

Sērijas.println ();

Sērijas.println (); Serial.print ("Savienojuma izveide"); Serial.println (ssid); // Sākt WiFi WiFi.begin (ssid, parole); // Savienojums… while (WiFi.status ()! = WL_CONNECTED) {delay (500); Sērijas nospiedums ("."); } // Veiksmīgi izveidots savienojums ar WiFi Serial.println (""); Serial.println ("savienots WiFi"); Serial.println ("IP adrese:"); Serial.println (WiFi.localIP ());

#ifndef ESP8266

kamēr (! Seriāls); #endif Serial.begin (9600); Serial.println ("Sensora tests");

// Inicializējiet sensoru

if (! lsm.begin ()) {// Radās problēma, nosakot LSM9DS0 Serial.print (F ("Oi, LSM9DS0 netika konstatēts … Pārbaudiet elektroinstalāciju vai I2C ADDR!"); kamēr (1); } Serial.println (F ("Atrasts LSM9DS0 9DOF")); // Sāciet savienojumu ar serveri Serial.print ("Savienojums ar"); Serial.println (resursdators);

// Pārbaudiet veiksmīgu savienojumu. Ja neizdodas, pārtrauc

if (! client.connect (resursdators, ports)) {Serial.println ("savienojums neizdevās"); savienots = nepatiess; atgriešanās; } cits {savienots = patiess; }

// Iestatiet sensora pastiprinājumu un integrācijas laiku

configureSensor (); }

Pēc tam mums ir nepieciešama cilpas funkcija, kas atkārtoti cilpos. Šajā gadījumā to izmanto, lai atkārtoti nosūtītu datus no akselerometra uz serveri šādā formā:

void loop () {kavēšanās (250); ja (savienots) {// Tas nosūtīs datus uz serveri sensor_event_t accel, mag, gyro, temp; lsm.getEvent (& accel, & mag, & gyro, & temp); Stīgu skaitļi; skaitļi += accel.acceleration.z; skaitļi += ":"; skaitļi += mag.magnetic.y; skaitļi += ":"; skaitļi += mag.magnetic.z; Sērijas nospiedums (skaitļi); klients.druka (skaitļi); Sērijas.println (); } cits {createConnection (); }}

Dažām lietderības funkcijām mums ir nepieciešama viena, lai izveidotu savienojumu starp spalvu un serveri.

void createConnection () {if (! client.connect (resursdators, ports)) {Serial.println ("savienojums neizdevās"); savienots = nepatiess; atgriešanās; } cits {savienots = patiess; }}

Mums arī jākonfigurē sensors un jānorāda tam vērtību diapazons, ko tas nolasīs. Piemēram, paātrinājumam ir 5 diapazona iespējas: 2g, 4g, 6g, 8g un 16g.

void configureSensor (void) {// Iestatiet akselerometra diapazonu //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); // Iestatiet magnetometra jutību //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_2GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_4GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_8GAUSS); lsm.setupMag (lsm. LSM9DS0_MAGGAIN_12GAUSS);

// Uzstādiet žiroskopu

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

Servera iestatīšana:

Serveris būs pitona fails, kas darbosies datora komandrindā. Lai sāktu, importējiet nepieciešamās klases.

importēt socketimport atkārtoti importēt pyautogui

ligzda tiek izmantota tīklošanai. re tiek izmantots regex vai virkņu manipulācijām. pyautogui ir pitona bibliotēka, kas ļaus izdarīt zīmējumu (apspriests vēlāk).

Tālāk mums vajadzētu definēt dažus mainīgos. Tie būs globāli mainīgie, tāpēc tiem varēs piekļūt vairākās funkcijās. Tie tiks izmantoti vēlāk kodā.

i = 0n = 0 līnija = 1

datu_saraksts =

mag_data =

mag_calib_y = 0 mag_offset_y = 0

z_kalibs = 0

z_ nobīde = 0 z_moving_offset = 0 z_diff = 0 z_real = 0 z_velo = 0 z_pos = 0

keep_offset = Nepareizi

first_data = Patiess

Tagad mums ir nepieciešama funkcija, lai izveidotu serveri un atvērtu to ienākošajiem savienojumiem.

def startServer (): global i global first_data # inicializēt servera ligzdu serverocket = socket.socket (socket. AF_INET, socket. SOCK_STREAM) serverocket.setsockopt (socket. SOL_SOCKET, socket. SO_REUSEADDR, 1) # Servera IP adrese un porta resursdators = " 149.160.251.3 "port = 12347 server_address = (resursdators, ports) # Atveriet serveri un klausieties ienākošo savienojumu drukāšanu ('Servera palaišana %s portā %s' %server_adrese) serverocket.bind (servera_adrese) serverocket.listen (5) # Gaidiet savienojumus… kamēr True: drukājiet ('Gaida savienojumu …') # Pieņemiet ienākošo savienojumu (klienta ligzda, adrese) = serverocket.accept () # Mēģiniet parsēt saņemtos datus mēģiniet: print ('Savienojums izveidots no', adrese), kamēr True: # Saņemiet datus un nosūtiet tos datu apstrādei = 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] drukāt (accel_data) i+= 1, ja (i <51): calibData (accel_data) else: moveAcce l (accel_data [0]) processData (accel_data) first_data = False beidzot: # Aizveriet ligzdu, lai novērstu nevajadzīgu datu noplūdi customersocket.close ()

Tagad mums ir vajadzīgas funkcijas, kas apstrādās visus datus. Pirmais solis, kas jādara, un pirmā funkcija, ko sauc, ir sensora kalibrēšana aprēķinu vajadzībām.

def calibData (saraksts): global z_calib global z_offset global mag_data global mag_calib_y global 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)

Tālāk mēs izveidojam kustīgu paātrinājuma nobīdi. Tādējādi programma atpazīst, kad kāds pārstāj kustināt pirkstu, jo visām paātrinājuma vērtībām, kas tiek nosūtītas uz serveri, tajā pašā laikā jābūt vienādām.

def moveAccel (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): # kustībā konstatēta kustība, restart keep_offset = True n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = pārtraukums, ja nav saglabāts_ nobīde: # stacionārs datos, iestatiet jaunu 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 = Nepareizi keep_offset = Nepareizi

Tālāk mēs veicam vislielāko matemātiku. Tas ietver paātrinājuma datu pārvēršanu pozīcijas datos, kas ļaus mums noteikt virzienu, kādā lietotājs pārvieto pirkstu.

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

z_real = pludiņš (saraksts [0]) - z_ nobīde

mag_y = saraksts [1] mag_z = saraksts [2] pa kreisi = Nepareizi pa labi = False # Neapstrādājiet paātrinājumu, kamēr neesat pilnīgi pārliecināts, ka tas ir paātrinājies # Novērš mehāniskā trokšņa ietekmi uz pozīciju, ja (z_real -0,20): z_real = 0 #Sākt integrācijas, lai atrastu pozīciju, ja (pirmais_dats): 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) cits: 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): pa labi = True elif (float (mag_data [1]) - float (mag_data [0]) <-0.03): left = True if (right): kustība (50, int (z_pos*) 1000)) elif (pa kreisi): kustība (-50, int (z_pos*1000)) z_velo = 0 z_pos = 0

Visbeidzot, mēs pārvietojam kursoru! Lai to izdarītu, mēs atvērām krāsas logu un padarījām to pilnekrāna. Pyautogui bibliotēkā ir funkcija ar nosaukumu pyautogui.dragRel (x, y); ar kuru mēs pārvietojam peles kursoru no viena punkta uz otru. Tas izmanto relatīvās pozīcijas datus, tāpēc kustība ir relatīva attiecībā pret kursora pēdējo pozīciju.

def kustība (x, y): print ("pārvietojas uz", x, -y) pyautogui.dragRel (x, -y)

Visbeidzot, mums ir jāizsauc galvenā funkcija, lai pat ļautu palaist visu šo kodu.

# Izsauc funkciju, lai sāktu serveru startServer ()