Escriptura Accel (mà màgica): 4 passos (amb imatges)

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:16

Introducció

La mà màgica permet a les persones amb discapacitat i deficiències motores gaudir de la creativitat del dibuix i l’escriptura en un entorn simulat. La mà màgica és un guant usable que detecta el moviment del dit índex i el tradueix en el dibuix de línies a la pantalla d’un ordinador.

Materials necessaris

LSM9DOF Breakout Board --- 24,95 $ ---

Ploma d'Adafruit amb Wifi --- 18,95 $ ---

Filferro femení / femení --- 1,95 dòlars ---

Cintes / tires de velcro --- 3 $

Dos imants de força igual --- Els preus varien

Com funciona

Mitjançant l’ús d’un acceleròmetre, podem recollir dades d’acceleració de l’eix y que ens ajudaran a determinar quan el dit de l’usuari es mou cap amunt i cap avall. A causa del fet que el nostre acceleròmetre mesura l’acceleració respecte al centre de la terra, no podem determinar l’acceleració de l’eix x (esquerra o dreta). Afortunadament, el tauler LSM9DOF també conté un magnetòmetre que ens permet recollir dades sobre camps magnètics. Posem dos imants separats a 30 cm i tenim el guant entremig. Si les dades magnètiques són positives, sabem que el guant es mou cap a la dreta i viceversa. Després de recollir totes les dades a l’acceleròmetre / magnetòmetre, envia les dades per cable a la ploma que està connectada a un ordinador de wifi i, a continuació, reenvia les dades a l’ordinador que podem utilitzar al nostre codi.

Pas 1: prototip físic 1

Aquest prototip s'ha de cosir guant junt a la mà perquè pugui relliscar sobre els dispositius electrònics. A continuació, el dispositiu electrònic s’adherirà mitjançant un velcro a la base de la màniga inferior de l’armadura combinada amb un guant bàsic a la mà. Aleshores, el guant verd relliscarà sobre la base i els dispositius electrònics …

Passos per fer el prototip de guant:

• Aconsegueix dos trossos de tela prou grans com per traçar les mans
• Traça la mà sobre els dos trossos de tela i retalla'ls
• Ajunteu les dues retallades manuals perquè quedin perfectament alineades
• A continuació, per preparar la màquina de cosir, passeu el fil pels punts indicats a la màquina
• Quan la màquina de cosir estigui configurada, aixequeu l’agulla i col·loqueu els dos trossos de tela junts sota l’agulla
• Assegureu-vos que l’agulla estigui alineada a la vora del teixit, engegueu la màquina i cosiu al llarg de les vores del teixit, deixant les dues peces sense cosir al canell perquè hi pugui cabre una mà.

Pas 2: prototip físic 2

El nostre prototip final és un guant regular combinat amb corretja de velcro que es pot ajustar a qualsevol canell. El guant i la corretja estan cosits i els dispositius electrònics s’uneixen al guant mitjançant velcro.

Passos per fer el 2n prototip del guant:

1. Compra un guant, el material del guant no té importància.
2. Compra una corretja de velcro
3. Compreu una bateria portàtil
4. Compra velcro enganxós
5. Amb una agulla de cosir, fixeu la corretja de velcro a la base del guant
6. La corretja de canell hauria de poder ajustar-se a diferents mides de canell.
7. Col·loqueu la cinta adhesiva a la base de l’acceleròmetre i fixeu-la al dit índex del guant
8. Col·loqueu cinta adhesiva a la ploma i fixeu-la a la part superior del guant.
9. Mitjançant cables, connecteu el pin 3V3 de la ploma al pin VIN de l’acceleròmetre
10. Mitjançant cables, connecteu el pin GND de la ploma al pin GND de l’acceleròmetre.
11. Mitjançant cables, connecteu el pin SCL de la ploma al pin SCL de l’acceleròmetre.
12. Mitjançant cables, connecteu el pin SDA de la ploma al pin SDA de l’acceleròmetre.
13. Connecteu com a mínim una bateria de 5 volts mitjançant USB a la ploma per proporcionar energia.

Pas 3: imants

Pas 1: poseu els dos imants d’igual força entre si.

Pas 2: mesureu un espai de 30 cm entre els dos imants

Pas 3: col·loqueu el magnetòmetre exactament al mig dels dos imants. Heu de rebre dades al voltant de 0 mentre es troben al mig. Si rebeu una lectura de zero, aneu al pas 5.

Pas 4: si la lectura no és nul·la o propera a zero, haureu d'ajustar la distància dels imants. Si la lectura és negativa, moveu l'imant esquerre un cm o 2 cap a l'esquerra o fins que la lectura sigui zero. Si és positiu, feu el mateix excepte amb l'imant adequat.

Pas 5: escriviu un codi que accepti les dades del magnetòmetre i es llegeixi si és positiu o negatiu. Si és positiu, el codi traça una línia cap a la dreta i, si és negatiu, traça una línia cap a l'esquerra.

Pas 4: Codi

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

Introducció:

Per processar les dades de l’acceleròmetre, s’ha d’establir una relació client / servidor entre la ploma d’Adafruit i el servidor que processa les dades (que s’executen en un ordinador portàtil / escriptori). Caldrà crear dos fitxers de codi: un per al client (la ploma d’Adafruit) i l’altre per al servidor (en aquest cas, el portàtil de Jarod). El client està escrit en C ++ i el servidor està escrit en python. El llenguatge utilitzat per al client és important, ja que Arduino és principalment un llenguatge C ++ i és difícil canviar-lo per utilitzar un idioma diferent. El servidor es pot escriure en qualsevol idioma, sempre que tingui funcions de xarxa.

Configuració del client:

En primer lloc, configurarem el codi de client. La majoria del codi de connexió WiFi està disponible fàcilment a través de les biblioteques Adafruit. Comencem incloent classes rellevants.

#include #include #include #include #include

Definiu algunes variables que s'utilitzaran al llarg del codi.

// Connectar-se a una xarxa const char * ssid = "MMServer"; const char * password = "Contrasenya del servidor MMS"; // IP i port del servidor que rebrà dades const char * host = "149.160.251.3"; port port int = 12347; bool connectat = fals;

// Inicialitzar el detector de moviment

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0 (1000);

Client WiFiClient;

Creeu una funció setup () que s'executarà tan aviat com s'iniciï la ploma.

// Configureu la connexió WiFi i connecteu-vos a la configuració de servervoid () {Serial.begin (9600); retard (100);

Serial.println ();

Serial.println (); Serial.print ("Connexió a"); Serial.println (ssid); // Iniciar WiFi WiFi.begin (ssid, contrasenya); // Connectant … mentre que (WiFi.status ()! = WL_CONNECTED) {delay (500); Serial.print ("."); } // S'ha connectat correctament a WiFi Serial.println (""); Serial.println ("WiFi connectat"); Serial.println ("adreça IP:"); Serial.println (WiFi.localIP ());

#ifndef ESP8266

mentre que (! sèrie); #endif Serial.begin (9600); Serial.println ("Prova del sensor");

// Inicialitzeu el sensor

if (! lsm.begin ()) {// Hi ha hagut un problema en detectar el LSM9DS0 Serial.print (F ("Vaja, no s'ha detectat LSM9DS0 … Comproveu el cablejat o l'ADDR I2C!")); mentre que (1); } Serial.println (F ("Trobat LSM9DS0 9DOF")); // Comenceu a connectar-vos al servidor Serial.print ("Connexió a"); Serial.println (amfitrió);

// Comproveu si la connexió és correcta. Si falla, avorteu

if (! client.connect (host, port)) {Serial.println ("connexió fallida"); connectat = fals; tornar; } else {connectat = cert; }

// Configureu el guany i el temps d'integració del sensor

configureSensor (); }

A continuació, necessitem una funció de bucle que es repeteixi repetidament. En aquest cas, s’utilitza per enviar dades repetidament des de l’acceleròmetre al servidor en forma de “[z_accel]: [y_mag]: [z_mag]”. El client.print (números); La funció és la que envia dades al servidor.

bucle buit () {delay (250); if (connectat) {// Això enviarà dades al servidor sensors_event_t accel, mag, gyro, temp; lsm.getEvent (& accel, & mag, & gyro, & temp); Números de cadena; números + = accel.acceleration.z; números + = ":"; números + = mag.magnetic.y; números + = ":"; números + = mag.magnetic.z; Serial.print (números); client.print (números); Serial.println (); } else {establirConnexió (); }}

Per a algunes funcions d’utilitat, en necessitem una per establir la connexió entre la ploma i el servidor.

void establirConnexió () {if (! client.connect (host, port)) {Serial.println ("connexió fallida"); connectat = fals; tornar; } else {connectat = cert; }}

També hem de configurar el sensor i donar-li l’interval de valors que llegirà. Per exemple, l'acceleració té 5 opcions per al rang: 2g, 4g, 6g, 8g i 16g.

void configureSensor (void) {// Estableix l'interval de l'acceleròmetre //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); // Estableix la sensibilitat del magnetòmetre //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_2GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_4GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_8GAUSS); lsm.setupMag (lsm. LSM9DS0_MAGGAIN_12GAUSS);

// Configureu el giroscopi

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

Configuració del servidor:

El servidor serà un fitxer python que s’executarà a la línia d’ordres d’un ordinador. Per començar, importeu les classes necessàries.

import socketimport re import pyautogui

el socket s’utilitza per fer xarxes. re s’utilitza per a manipulacions regulars o de cadenes. pyautogui és una biblioteca python que permetrà que es faci el dibuix (es parlarà més endavant).

A continuació, hauríem de definir algunes variables. Aquestes seran variables globals, de manera que s’accedirà a elles en múltiples funcions. S’utilitzaran més endavant al codi.

i = 0n = 0 línia = 1

llista_dades =

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

first_data = True

Ara necessitem una funció per crear un servidor i obrir-lo per a les connexions entrants.

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) # Adreça IP del servidor i host del port = " 149.160.251.3 "port = 12347 server_address = (host, port) # Obriu el servidor i escolteu les impressions de connexions entrants ('Inici del servidor a% s port% s'% server_address) serversocket.bind (server_address) serversocket.listen (5) # Espereu les connexions … mentre és cert: imprimeu ("S'està esperant la connexió …") # Accepteu una connexió entrant (clientsocket, adreça) = serversocket.accept () # Proveu d'analitzar les dades rebudes proveu: print ("Connexió establerta des de", adreça) mentre és cert: # Rebeu les dades i envieu-les per processar dades = 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] imprimir (accel_data) i + = 1 if (i <51): calibData (accel_data) else: movingAcce l (accel_data [0]) processData (accel_data) first_data = Finalment fals: # Tanqueu el sòcol per evitar fuites de dades innecessàries clientsocket.close ()

Ara necessitem les funcions que processaran totes les dades. El primer pas que cal fer, i la primera funció anomenada, és el calibratge del sensor a efectes de càlcul.

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

A continuació, creem un desplaçament d’acceleració en moviment. Això fa que el programa reconegui quan algú deixa de moure el dit perquè tots els valors d’acceleració que s’envien al servidor haurien de ser els mateixos en aquell 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 o z_diff <-0.2): # moviment detectat a les dades, reinicieu 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 = Fals keep_offset = Fals

A continuació, fem el pes de les matemàtiques. Això implica traduir les dades d’acceleració en dades de posició que ens permetran indicar la direcció en què l’usuari mou el dit.

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

mag_y = llista [1] mag_z = llista [2] left = False right = False # No processeu l'acceleració fins que no estigueu absolutament segur que s'ha accelerat # Evita que el soroll mecànic contribueixi a la posició si (z_real -0.20): z_real = 0 #Begin integracions per trobar la posició 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 (esquerra): moviment (-50, int (z_pos * 1000)) z_velo = 0 z_pos = 0

Ara, per fi, movem el cursor. Per fer-ho, vam obrir una finestra de pintura i la vam fer pantalla completa. La biblioteca pyautogui conté una funció anomenada pyautogui.dragRel (x, y); que fem servir per arrossegar el cursor del ratolí d’un punt a l’altre. Utilitza dades de posició relativa pel que el moviment és relatiu a la darrera posició del cursor.

moviment def (x, y): print ("passant a", x, -y) pyautogui.dragRel (x, -y)

Per últim, hem de trucar a la funció principal per permetre que tot aquest codi s’executi.

# Crida a la funció per iniciar el serverstartServer ()