Scriere Accel (Mână magică): 4 pași (cu imagini)

2025 Autor: John Day | [email protected]. Modificat ultima dată: 2025-01-23 15:04

Introducere

Mâna magică permite persoanelor cu dizabilități și deficiențe ale abilităților motorii să se bucure de creativitatea desenului și scrierii într-un mediu simulat. Mâna magică este o mănușă purtabilă care detectează mișcarea degetului arătător și o traduce în desenarea liniilor pe ecranul computerului.

Materiale necesare

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

Pene Adafruit cu Wifi --- 18,95 USD ---

Firele feminine / feminine --- 1,95 USD ---

Benzi de bandă / Velcro --- 3 USD

Doi magneți cu rezistență egală --- Prețurile variază

Cum functioneaza

Folosind un accelerometru, putem colecta date de accelerație pentru axa y, care ne vor ajuta să stabilim când degetul utilizatorului se mișcă în sus și în jos. Datorită faptului că accelerometrul nostru măsoară accelerația în raport cu centrul pământului, nu putem determina accelerația axei x (stânga sau dreapta). Din fericire placa LSM9DOF conține, de asemenea, un magnetometru care ne permite să adunăm date despre câmpurile magnetice. Așezăm doi magneți la 30 cm distanță și avem mănușa între ele. Dacă datele magnetice sunt pozitive, atunci știm că mănușa se mișcă spre dreapta și invers. După ce toate datele sunt colectate în accelerometru / magnetometru, acesta trimite datele prin cablu către panoul care este conectat la un computer de wifi și apoi transmite datele către computer pe care le putem folosi în codul nostru.

Pasul 1: Prototipul fizic 1

Acest prototip este menit să fie cusut mănușă pe mână pentru a aluneca peste dispozitivele electronice. Dispozitivul electronic va fi apoi atașat prin velcro la baza manșonului sub armură combinat cu o mănușă de bază pe mână. Apoi mănușa verde va aluneca peste bază și dispozitivele electronice …

Pași în realizarea prototipului mănușii:

• Obțineți două bucăți de țesătură suficient de mari pentru a urmări mâna
• Urmați mâna pe ambele bucăți de țesătură și tăiați-le
• Așezați cele două tăieturi manuale astfel încât să fie perfect aliniate
• Apoi, pentru a pregăti mașina de cusut, treceți firul prin punctele indicate de pe mașină
• Când mașina de cusut este instalată, ridicați acul și așezați cele două bucăți de țesătură îmbinate sub ac
• Asigurați-vă că acul este aliniat chiar pe marginea țesăturii, porniți mașina și coaseți de-a lungul marginilor țesăturii, lăsând în același timp cele două piese nețesute la încheietura mâinii, astfel încât o mână să se potrivească.

Pasul 2: Prototipul fizic 2

Prototipul nostru final este o mănușă obișnuită, combinată cu curea din velcro, reglabilă la orice încheietură. Mănușa și cureaua sunt cusute împreună, iar dispozitivele electronice sunt atașate la mănușă prin Velcro.

Pași în realizarea celui de-al doilea prototip al mănușii:

1. Cumpărați o mănușă, materialul mănușii nu contează.
2. Achiziționați o curea de încheietură cu velcro
3. Achiziționați o baterie portabilă
4. Cumpărați Velcro lipicios
5. Cu un ac de cusut, atașați cureaua de încheietură cu velcro la baza mănușii
6. Cureaua pentru încheietura mâinii trebuie să se poată adapta la diferite dimensiuni ale încheieturii mâinii.
7. Atașați banda adezivă la baza accelerometrului și atașați-o la degetul arătător al mănușii
8. Atașați bandă adezivă la pană și atașați-o la partea superioară a mănușii.
9. Folosind fire conectați pinul 3V3 din pană la pinul VIN din accelerometru
10. Folosind fire conectați pinul GND din pană la pinul GND al accelerometrului.
11. Folosind fire conectați pinul SCL din pană la pinul SCL al accelerometrului.
12. Folosind fire conectați pinul SDA din pană la pinul SDA al accelerometrului.
13. Conectați cel puțin o baterie de 5 volți prin USB la pană pentru a furniza energie.

Pasul 3: Magneți

Pasul 1: Puneți cei doi magneți cu putere egală unul față de celălalt.

Pasul 2: Măsurați un spațiu de 30 cm între cei doi magneți

Pasul 3: amplasați magnetometrul exact în mijlocul celor doi magneți. Ar trebui să primiți date în jurul valorii de 0 în timp ce sunt în mijloc. Dacă primiți o citire de zero treceți la pasul 5.

Pasul 4: Dacă citirea nu este zero sau aproape de zero, atunci trebuie să reglați distanța magneților. Dacă citirea este negativă, mutați magnetul stâng cu un cm sau 2 la stânga sau până când citirea este zero. Dacă este pozitiv, faceți același lucru, cu excepția magnetului potrivit.

Pasul 5: Scrieți un cod care acceptă datele de pe magnetometru și citește dacă este pozitiv sau negativ. Dacă este pozitiv, codul trasează o linie spre dreapta, iar dacă este negativ, trage o linie la stânga.

Pasul 4: Cod

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

Introducere:

Pentru a procesa date de pe accelerometru, trebuie să se stabilească o relație client / server între panoul Adafruit și serverul care procesează datele (care rulează pe un laptop / desktop). Va trebui să fie create două fișiere de cod: unul pentru client (panoul Adafruit) și celălalt pentru server (în acest caz, laptopul lui Jarod). Clientul este scris în C ++, iar serverul este scris în python. Limbajul utilizat pentru client contează, deoarece Arduino este în principal un limbaj C ++, iar schimbarea acestuia pentru a utiliza un alt limbaj este dificilă. Serverul poate fi scris în orice limbă, atâta timp cât are caracteristici de rețea.

Configurarea clientului:

Mai întâi, vom configura codul clientului. Majoritatea codului de conexiune WiFi este ușor disponibil prin bibliotecile Adafruit. Începem prin a include clase relevante.

#include #include #include #include #include

Setați câteva variabile ce vor fi utilizate în întregul cod.

// Conectați-vă la o rețea const char * ssid = "MMServer"; const char * password = "MMServer-Password"; // IP și portul serverului care va primi date const char * host = "149.160.251.3"; const int port = 12347; bool conectat = false;

// Inițializați detectorul de mișcare

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0 (1000);

Client WiFiClient;

Creați o funcție setup () care va fi executată de îndată ce începe pene.

// Configurați conexiunea WiFi și conectați-vă la servervoid setup () {Serial.begin (9600); întârziere (100);

Serial.println ();

Serial.println (); Serial.print („Conectarea la”); Serial.println (ssid); // Porniți WiFi WiFi.begin (ssid, parolă); // Conectarea … în timp ce (WiFi.status ()! = WL_CONNECTED) {întârziere (500); Serial.print ("."); } // Conectat cu succes la WiFi Serial.println (""); Serial.println ("WiFi conectat"); Serial.println ("adresa IP:"); Serial.println (WiFi.localIP ());

#ifndef ESP8266

while (! Serial); #endif Serial.begin (9600); Serial.println ("Test senzor");

// Inițializați senzorul

if (! lsm.begin ()) {// A apărut o problemă la detectarea LSM9DS0 Serial.print (F ("Ooops, nu a fost detectat LSM9DS0 … Verificați cablajul sau I2C ADDR!")); în timp ce (1); } Serial.println (F ("Găsit LSM9DS0 9DOF")); // Începeți conectarea la serverul Serial.print („Conectarea la”); Serial.println (gazdă);

// Verificați conexiunea cu succes. Dacă nu reușiți, atunci anulați

if (! client.connect (host, port)) {Serial.println ("conexiunea a eșuat"); conectat = false; întoarcere; } else {conectat = adevărat; }

// Configurați câștigul senzorului și timpul de integrare

configureSensor (); }

Apoi avem nevoie de o funcție de buclă care se va bucla în mod repetat. În acest caz, este utilizat pentru a trimite în mod repetat date de pe accelerometru către server sub forma „[z_accel]: [y_mag]: [z_mag]”. Clientul.print (numere); funcția este cea care trimite date către server.

bucla void () {întârziere (250); if (conectat) {// Aceasta va trimite date către server sensors_event_t accel, mag, gyro, temp; lsm.getEvent (& accel, & mag, & gyro, & temp); Numere de șiruri; numere + = accel.acceleration.z; numere + = ":"; numere + = mag.magnetic.y; numere + = ":"; numere + = mag.magnetic.z; Serial.print (numere); client.print (numere); Serial.println (); } else {determineConnection (); }}

Pentru unele funcții utilitare, avem nevoie de una pentru a stabili conexiunea dintre pene și server.

void enableConnection () {if (! client.connect (host, port)) {Serial.println ("conexiunea a eșuat"); conectat = false; întoarcere; } else {conectat = adevărat; }}

De asemenea, trebuie să configurăm senzorul și să îi oferim gama de valori pe care le va citi. De exemplu, accelerația are 5 opțiuni pentru interval: 2g, 4g, 6g, 8g și 16g.

void configureSensor (void) {// Setați intervalul accelerometrului //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); // Setați sensibilitatea magnetometrului //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_2GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_4GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_8GAUSS); lsm.setupMag (lsm. LSM9DS0_MAGGAIN_12GAUSS);

// Configurați giroscopul

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

Configurarea serverului:

Serverul va fi un fișier python care va rula pe linia de comandă a unui computer. Pentru a începe, importați clasele necesare.

import socketimport re import pyautogui

socket este utilizat pentru rețea. re este folosit pentru regex sau manipulări de șiruri. pyautogui este o bibliotecă python care va permite desenul să se întâmple (discutat mai târziu).

În continuare, ar trebui să definim câteva variabile. Acestea vor fi variabile globale, deci vor fi accesate în mai multe funcții. Acestea vor fi utilizate mai târziu în cod.

i = 0n = 0 linie = 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 = False

first_data = Adevărat

Acum avem nevoie de o funcție pentru a crea un server și a-l deschide pentru conexiunile primite.

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 address and port host = " 149.160.251.3 "port = 12347 server_address = (host, port) # Deschideți serverul și ascultați conexiunile primite tipăriți ('Pornirea serverului pe% s port% s'% server_address) serversocket.bind (server_address) serversocket.listen (5) # Așteptați conexiunile … în timp ce este adevărat: print („Se așteaptă conexiunea …”) # Acceptați o conexiune primită (client, adresă) = serversocket.accept () # Încercați să analizați datele primite încercați: print („Conexiune stabilită din”, adresă) în timp ce este adevărat: # Primiți datele și trimiteți-le pentru procesarea datelor = 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 = False în cele din urmă: # Închideți soclul pentru a preveni scurgerea de date inutile clientsocket.close ()

Acum avem nevoie de funcțiile care vor procesa toate datele. Primul pas de făcut și prima funcție numită este calibrarea senzorului în scopuri de calcul.

def calibData (listă): 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_ = mag_calib_y / 50 z_calib = 0 mag_calib_y = 0 mag_data.append (mag_offset_y)

Apoi, creăm un offset de accelerație în mișcare. Acest lucru face ca programul să recunoască când cineva nu mai mișcă degetul, deoarece toate valorile de accelerație trimise către server ar trebui să fie aceleași în acel moment.

def movingAccel (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 sau z_diff <-0.2): # mișcare detectată în date, reporniți keep_offset = True n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = break if not 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 = False keep_offset = False

Apoi, facem greul matematicii. Aceasta implică traducerea datelor de accelerație într-o poziție care ne va permite să spunem direcția în care utilizatorul își mișcă degetul.

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

mag_y = list [1] mag_z = list [2] left = False right = False # Nu procesați accelerarea până nu sunteți absolut sigur că a accelerat # Previne zgomotul mecanic să contribuie la poziție dacă (z_real -0.20): z_real = 0 #Begin integrări pentru a găsi poziția if (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) 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_data [0])> 0.03): right = True elif (float (mag_data [1]) - float (mag_data [0]) <-0.03): left = True if (right): movement (50, int (z_pos *) 1000)) elif (stânga): mișcare (-50, int (z_pos * 1000)) z_velo = 0 z_pos = 0

Acum, în sfârșit, mutăm cursorul! Pentru a face acest lucru, am deschis o fereastră de vopsea și am făcut-o pe ecran complet. Biblioteca pyautogui conține o funcție numită pyautogui.dragRel (x, y); pe care îl folosim pentru a trage cursorul mouse-ului de la un punct la altul. Folosește date relative de poziție, astfel încât mișcarea este relativă la ultima poziție a cursorului.

mișcare def (x, y): print („mutare la”, x, -y) pyautogui.dragRel (x, -y)

În cele din urmă, trebuie să apelăm la funcția principală pentru a permite chiar să ruleze tot acest cod.

# Apelează funcția pentru a începe serverstartServer ()