Scrittura Accel (Mano Magica): 4 Passaggi (con Immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

introduzione

La Mano Magica consente alle persone con disabilità e disabilità motorie di godere della creatività del disegno e della scrittura in un ambiente simulato. The Magic Hand è un guanto indossabile che rileva il movimento del dito indice e lo traduce nel disegno di linee sullo schermo di un computer.

Materiale necessario

Scheda Breakout LSM9DOF --- $ 24,95 ---

Piuma Adafruit con Wifi --- $ 18,95 ---

Cavi femmina/femmina --- $1,95 ---

Nastro/strisce in velcro --- $3

Due magneti di uguale forza --- I prezzi variano

Come funziona

Utilizzando un accelerometro, possiamo raccogliere dati di accelerazione per l'asse y che ci aiuteranno a determinare quando il dito dell'utente si muove su e giù. A causa del fatto che il nostro accelerometro misura l'accelerazione rispetto al centro della terra, non possiamo determinare l'accelerazione dell'asse x (sinistra o destra). Per fortuna la breakout board LSM9DOF contiene anche un magnetometro che ci permette di raccogliere dati sui campi magnetici. Mettiamo due magneti a 30 cm di distanza e in mezzo abbiamo il guanto. Se i dati magnetici sono positivi, allora sappiamo che il guanto si sta muovendo a destra e viceversa. Dopo che tutti i dati sono stati raccolti nell'accelerometro/magnetometro, invia i dati via filo alla piuma che è collegata a un computer di wifi e quindi inoltra i dati al computer che possiamo quindi utilizzare nel nostro codice.

Passaggio 1: prototipo fisico 1

Questo prototipo è pensato per essere cucito insieme a un guanto sulla mano in modo che possa scivolare sui dispositivi elettronici. Il dispositivo elettronico verrà quindi fissato tramite velcro alla base della manica sotto armatura abbinata a un guanto base sulla mano. Poi il guanto verde scivolerà sulla base e sui dispositivi elettronici….

Fasi per realizzare il guanto prototipo:

• Prendi due pezzi di tessuto abbastanza grandi da tracciare la mano
• Traccia la mano su entrambi i pezzi di tessuto e ritagliali
• Metti insieme i due ritagli delle mani in modo che siano perfettamente allineati
• Quindi, per preparare la macchina da cucire, fai passare il filo attraverso i punti indicati sulla macchina
• Quando la macchina da cucire è pronta, sollevare l'ago e posizionare i due pezzi di tessuto uniti sotto l'ago
• Assicurati che l'ago sia allineato sul bordo del tessuto, avvia la macchina e cuci lungo i bordi del tessuto, lasciando i due pezzi non cuciti al polso in modo che una mano possa entrare.

Passaggio 2: prototipo fisico 2

Il nostro prototipo finale è un guanto normale combinato con cinturino in velcro regolabile su qualsiasi polso. Il guanto e il cinturino sono cuciti insieme e i dispositivi elettronici sono fissati al guanto tramite velcro.

Fasi nella realizzazione del 2° prototipo del guanto:

1. Acquista un guanto, il materiale del guanto non ha importanza.
2. Acquista un cinturino da polso in velcro
3. Acquista una batteria portatile
4. Acquista velcro adesivo
5. Con un ago da cucito, attacca il cinturino in velcro alla base del guanto
6. Il cinturino da polso dovrebbe essere in grado di adattarsi a diverse dimensioni del polso.
7. Attacca il nastro adesivo alla base dell'accelerometro e attaccalo al dito indice del guanto
8. Attacca il nastro adesivo alla piuma e attaccalo alla parte superiore del guanto.
9. Usando i fili, collega il pin 3V3 nella piuma al pin VIN nell'accelerometro
10. Usando i fili, collega il pin GND nella piuma al pin GND dell'accelerometro.
11. Utilizzando i fili, collegare il pin SCL nella piuma al pin SCL dell'accelerometro.
12. Usando i fili, collega il pin SDA nella piuma al pin SDA dell'accelerometro.
13. Collega almeno una batteria da 5 volt tramite USB alla piuma per fornire alimentazione.

Passaggio 3: magneti

Passaggio 1: posiziona i due magneti di uguale forza uno di fronte all'altro.

Passaggio 2: misurare lo spazio di 30 cm tra i due magneti

Fase 3: posizionare il Magnetometro esattamente al centro dei due magneti. Dovresti ricevere dati intorno a 0 mentre è nel mezzo. Se ricevi una lettura pari a zero, vai al passaggio 5.

Passaggio 4: se la lettura non è zero o vicina allo zero, è necessario regolare la distanza dei magneti. Se la lettura è negativa, spostare il magnete sinistro di un cm o 2 verso sinistra o finché la lettura non è zero. Se è positivo fai la stessa cosa tranne che con il magnete giusto.

Passaggio 5: scrivere il codice che accetta i dati dal magnetometro e legge se è positivo o negativo. Se positivo, fai tracciare al codice una linea a destra e se negativo traccia una linea a sinistra.

Passaggio 4: codice

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

Introduzione:

Per elaborare i dati dall'accelerometro, è necessario stabilire una relazione client/server tra la piuma Adafruit e il server che elabora i dati (in esecuzione su un laptop/desktop). Sarà necessario creare due file di codice: uno per il client (la piuma di Adafruit) e l'altro per il server (in questo caso, il laptop di Jarod). Il client è scritto in C++ e il server è scritto in python. Il linguaggio utilizzato per il client è importante poiché Arduino è principalmente un linguaggio C++ e cambiarlo per utilizzare un linguaggio diverso è difficile. Il server può essere scritto in qualsiasi lingua, purché disponga di funzionalità di rete.

Configurazione del cliente:

Per prima cosa, imposteremo il codice client. La maggior parte del codice di connessione WiFi è prontamente disponibile tramite le librerie Adafruit. Iniziamo includendo le classi pertinenti.

#include #include #include #include #include

Imposta alcune variabili che verranno utilizzate in tutto il codice.

// Connetti a una rete const char* ssid = "MMServer"; const char* password = "MMServer-Password"; // IP e porta del server che riceverà i dati const char* host = "149.160.251.3"; const int porta = 12347; bool connesso = falso;

// Inizializza il rilevatore di movimento

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0(1000);

client WiFi Client;

Crea una funzione setup() che verrà eseguita non appena la piuma inizia.

// Imposta la connessione WiFi e connettiti al servervoid setup() { Serial.begin(9600); ritardo(100);

Serial.println();

Serial.println(); Serial.print("Connessione a "); Serial.println(ssid); // Avvia WiFi WiFi.begin(ssid, password); // Connessione… while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } // Collegato con successo a WiFi Serial.println(""); Serial.println("WiFi connesso"); Serial.println("Indirizzo IP: "); Serial.println(WiFi.localIP());

#ifndef ESP8266

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

// Inizializza il sensore

if(!lsm.begin()) { // Si è verificato un problema durante il rilevamento di LSM9DS0 Serial.print(F("Ooops, nessun LSM9DS0 rilevato… Controlla il cablaggio o I2C ADDR!")); mentre(1); } Serial.println(F("Trovato LSM9DS0 9DOF")); // Inizia la connessione al server Serial.print("Connessione a"); Serial.println(host);

// Verifica la connessione riuscita. Se fallisce, abortisci

if (!client.connect(host, port)) { Serial.println("connessione fallita"); connesso = falso; Restituzione; } else { connesso = vero; }

//Imposta il guadagno del sensore e il tempo di integrazione

configureSensor(); }

Abbiamo quindi bisogno di una funzione di ciclo che eseguirà ripetutamente il ciclo. In questo caso, viene utilizzato per inviare ripetutamente dati dall'accelerometro al server sotto forma di "[z_accel]:[y_mag]:[z_mag]". Il client.print(numeri); la funzione è ciò che invia i dati al server.

void loop() { ritardo(250); if(connected){ // Questo invierà i dati al server sensor_event_t accel, mag, gyro, temp; lsm.getEvent(&accel, &mag, &gyro, &temp); Numeri di stringa; numeri += accel.accelerazione.z; numeri += ":"; numeri += mag.magnetic.y; numeri += ":"; numeri += mag.magnetic.z; Serial.print(numeri); client.print(numeri); Serial.println(); } else { stabilireConnessione(); } }

Per alcune funzioni di utilità, ne abbiamo bisogno per stabilire la connessione tra la piuma e il server.

void stabilireConnection(){ if (!client.connect(host, port)) { Serial.println("connessione fallita"); connesso = falso; Restituzione; } else { connesso = vero; } }

Dobbiamo anche configurare il sensore e dargli l'intervallo di valori che leggerà. Ad esempio, l'accelerazione ha 5 opzioni per l'intervallo: 2 g, 4 g, 6 g, 8 g e 16 g.

void configureSensor(void){ // Imposta l'intervallo dell'accelerometro //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); // Imposta la sensibilità del magnetometro //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_2GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_4GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_8GAUSS); lsm.setupMag(lsm. LSM9DS0_MAGGAIN_12GAUSS);

// Imposta il giroscopio

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

Configurazione del server:

Il server sarà un file python che verrà eseguito sulla riga di comando di un computer. Per iniziare, importa le classi richieste.

import socketimport reimport pyautogui

socket è utilizzato per la rete. re viene utilizzato per regex o manipolazioni di stringhe. pyautogui è una libreria python che consentirà il disegno (discusso in seguito).

Successivamente, dovremmo definire alcune variabili. Queste saranno variabili globali, quindi sarà possibile accedervi in più funzioni. Verranno utilizzati in seguito nel codice.

i = 0n = 0 linea = 1

lista_dati =

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

Ora abbiamo bisogno di una funzione per creare un server e aprirlo per le connessioni in entrata.

def startServer(): global i global first_data # inizializza il socket del server serversocket = socket.socket(socket. AF_INET, socket. SOCK_STREAM) serversocket.setsockopt(socket. SOL_SOCKET, socket. SO_REUSEADDR, 1) # Indirizzo IP del server e porta host = " 149.160.251.3" port = 12347 server_address = (host, port) # Apre il server e ascolta le connessioni in entrata print ('Avvio del server su %s porta %s' % server_address) serversocket.bind(server_address) serversocket.listen(5) # Attendi connessioni… while True: print ('In attesa di connessione…') # Accetta una connessione in entrata (clientsocket, address) = serversocket.accept() # Prova ad analizzare i dati ricevuti try: print ('Connessione stabilita da ', address) while True: # Ricevi i dati e inviali per l'elaborazione 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 = False infine: # Chiude il socket per evitare perdite di dati non necessarie clientsocket.close()

Ora sono necessarie le funzioni che elaboreranno tutti i dati. Il primo passo da compiere, e la prima funzione richiamata, è la calibrazione del sensore ai fini del calcolo.

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

Successivamente, creiamo un offset di accelerazione in movimento. Questo fa in modo che il programma riconosca quando qualcuno smette di muovere il dito perché tutti i valori per l'accelerazione che vengono inviati al server dovrebbero essere gli stessi in quel momento.

def MovingAccel(num): globale z_calib globale z_diff globale z_moving_offset globale z_offset globale data_list globale n globale keep_offset if(n 0.2 o z_diff < -0.2): # movimento rilevato all'interno dei dati, riavvia keep_offset = True n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = break if not keep_offset: # stazionario nei dati, imposta un nuovo z_offset z_offset = z_moving_offset print("Nuovo z_offset: ") print(z_offset) n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list] keep_offset = Falso keep_offset = Falso

Successivamente, facciamo il peso maggiore della matematica. Ciò comporta la traduzione dei dati di accelerazione in dati di posizione che ci consentiranno di dire la direzione in cui l'utente muove il dito.

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

z_real = float(list[0]) - z_offset

mag_y = list[1] mag_z = list[2] left = False right = False # Non elabora l'accelerazione fino a quando non è assolutamente sicuro che abbia accelerato # Impedisce al rumore meccanico di contribuire alla posizione if(z_real -0.20): z_real = 0 #Begin integrazioni per trovare la posizione 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): motion(50, int(z_pos* 1000)) elif(sinistra): movimento(-50, int(z_pos*1000)) z_velo = 0 z_pos = 0

Ora, finalmente, spostiamo il cursore! Per fare ciò, abbiamo aperto una finestra di pittura e l'abbiamo resa a schermo intero. La libreria pyautogui contiene una funzione chiamata pyautogui.dragRel(x, y); che usiamo per trascinare il cursore del mouse da un punto all'altro. Utilizza i dati di posizione relativa in modo che il movimento sia relativo all'ultima posizione del cursore.

def movimento(x, y): print("spostamento a", x, -y) pyautogui.dragRel(x, -y)

Infine, dobbiamo chiamare la funzione principale per consentire anche l'esecuzione di tutto questo codice.

# Chiama la funzione per avviare serverstartServer()