Escritura acelerada (mano mágica): 4 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:44

Introducción

La Mano Mágica permite que las personas con discapacidades y deficiencias motoras disfruten de la creatividad del dibujo y la escritura en un entorno simulado. La Mano Mágica es un guante portátil que detecta el movimiento de su dedo índice y lo traduce en el dibujo de líneas en la pantalla de una computadora.

Materiales necesitados

Tablero de ruptura LSM9DOF --- $ 24.95 ---

Pluma de Adafruit con Wifi --- $ 18.95 ---

Cables hembra / hembra --- $ 1.95 ---

Cinta / tiras de velcro --- $ 3

Dos imanes de igual fuerza --- Los precios varían

Cómo funciona

Al usar un acelerómetro, podemos recopilar datos de aceleración para el eje y que nos ayudarán a determinar cuándo el dedo del usuario se mueve hacia arriba y hacia abajo. Debido al hecho de que nuestro acelerómetro mide la aceleración con respecto al centro de la Tierra, no podemos determinar la aceleración del eje x (izquierda o derecha). Afortunadamente, la placa de conexión LSM9DOF también contiene un magnetómetro que nos permite recopilar datos sobre campos magnéticos. Colocamos dos imanes a 30 cm de distancia y tenemos el guante en el medio. Si los datos magnéticos son positivos, sabemos que el guante se mueve hacia la derecha y viceversa. Después de que todos los datos se recopilan en el acelerómetro / magnetómetro, envía los datos a través de un cable a la pluma que está conectada a una computadora de wifi y luego envía los datos a la computadora que luego podemos usar en nuestro código.

Paso 1: Prototipo físico 1

Este prototipo está destinado a ser cosido con guantes sin apretar en la mano para que se deslice sobre los dispositivos electrónicos. Luego, el dispositivo electrónico se sujetará con velcro a la base de la manga debajo de la armadura combinada con un guante básico en la mano. Entonces el guante verde se deslizará sobre la base y los dispositivos electrónicos….

Pasos para hacer el guante prototipo:

• Consiga dos piezas de tela lo suficientemente grandes para trazar la mano
• Trace la mano en ambas piezas de tela y recórtelas.
• Junte los dos recortes de las manos para que queden perfectamente alineados
• A continuación, para preparar la máquina de coser, pase el hilo por los puntos indicados en la máquina.
• Cuando la máquina de coser esté configurada, levante la aguja y coloque las dos piezas de tela juntas debajo de la aguja.
• Asegúrese de que la aguja esté alineada en el borde mismo de la tela, encienda la máquina y cosa a lo largo de los bordes de la tela, dejando las dos piezas sin coser en la muñeca para que entre una mano.

Paso 2: Prototipo físico 2

Nuestro prototipo final es un guante normal combinado con una correa de velcro que se ajusta a cualquier muñeca. El guante y la correa se cosen juntos y los dispositivos electrónicos se fijan al guante mediante velcro.

Pasos para realizar el segundo prototipo del guante:

1. Compre un guante, el material del guante no importa.
2. Compra una muñequera con velcro
3. Compra una batería portátil
4. Compra de velcro adhesivo
5. Con una aguja de coser, coloque la muñequera de velcro en la base del guante
6. La correa de muñeca debe poder ajustarse a diferentes tamaños de muñeca.
7. Pegue la cinta adhesiva a la base del acelerómetro y fíjela al dedo índice del guante
8. Pegue cinta adhesiva a la pluma y péguela a la parte superior del guante.
9. Usando cables, conecte el pin 3V3 en la pluma al pin VIN en el acelerómetro
10. Usando cables, conecte el pin GND en la pluma al pin GND del acelerómetro.
11. Usando cables, conecte el pasador SCL en la pluma al pasador SCL del acelerómetro.
12. Usando cables, conecte el pin SDA en la pluma al pin SDA del acelerómetro.
13. Conecte al menos una batería de 5 voltios a través de USB a la pluma para proporcionar energía.

Paso 3: imanes

Paso 1: coloque los dos imanes de igual fuerza uno frente al otro.

Paso 2: Mida un espacio de 30 cm entre los dos imanes

Paso 3: coloca el magnetómetro exactamente en el medio de los dos imanes. Debería recibir datos alrededor de 0 mientras está en el medio. Si recibe una lectura de cero, vaya al paso 5.

Paso 4: Si la lectura no es cero o cercana a cero, entonces debe ajustar la distancia de los imanes. Si la lectura es negativa, mueva el imán izquierdo un cm o 2 hacia la izquierda o hasta que la lectura sea cero. Si es positivo, haga lo mismo excepto con el imán correcto.

Paso 5: Escriba un código que acepte los datos del magnetómetro y lea si es positivo o negativo. Si es positivo, haga que el código dibuje una línea a la derecha y si es negativo, dibuje una línea a la izquierda.

Paso 4: Código

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

Introducción:

Para procesar los datos del acelerómetro, se debe establecer una relación cliente / servidor entre la pluma Adafruit y el servidor que procesa los datos (que se ejecuta en una computadora portátil / computadora de escritorio). Será necesario crear dos archivos de código: uno para el cliente (la pluma de Adafruit) y el otro para el servidor (en este caso, la computadora portátil de Jarod). El cliente está escrito en C ++ y el servidor está escrito en Python. El lenguaje utilizado para el cliente es importante, ya que Arduino es principalmente un lenguaje C ++, y cambiarlo para usar un lenguaje diferente es difícil. El servidor se puede escribir en cualquier idioma, siempre que tenga funciones de red.

Configuración del cliente:

Primero, configuraremos el código del cliente. La mayor parte del código de conexión WiFi está disponible a través de las bibliotecas de Adafruit. Comenzamos por incluir clases relevantes.

#incluir #incluir #incluir #incluir #incluir

Establezca algunas variables que se utilizarán a lo largo del código.

// Conectarse a una red const char * ssid = "MMServer"; const char * contraseña = "MMServer-Password"; // IP y puerto del servidor que recibirá los datos const char * host = "149.160.251.3"; const int port = 12347; bool conectado = falso;

// Inicializar el detector de movimiento

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0 (1000);

Cliente WiFiClient;

Cree una función setup () que se ejecutará tan pronto como comience la pluma.

// Configure la conexión WiFi y conéctese al servervoid setup () {Serial.begin (9600); retraso (100);

Serial.println ();

Serial.println (); Serial.print ("Conectando a"); Serial.println (ssid); // Inicie WiFi WiFi.begin (ssid, contraseña); // Conectando… while (WiFi.status ()! = WL_CONNECTED) {delay (500); Serial.print ("."); } // Conectado con éxito a WiFi Serial.println (""); Serial.println ("WiFi conectado"); Serial.println ("dirección IP:"); Serial.println (WiFi.localIP ());

#ifndef ESP8266

mientras (! Serial); #endif Serial.begin (9600); Serial.println ("Prueba de sensor");

// Inicializar el sensor

if (! lsm.begin ()) {// Hubo un problema al detectar el LSM9DS0 Serial.print (F ("Ooops, no LSM9DS0 detectado… ¡Verifique su cableado o DIRECCIÓN I2C!")); mientras (1); } Serial.println (F ("Encontrado LSM9DS0 9DOF")); // Comience a conectarse al servidor Serial.print ("Conectando a"); Serial.println (host);

// Verifique la conexión exitosa. Si falla, aborta

if (! client.connect (host, puerto)) {Serial.println ("error de conexión"); conectado = falso; regreso; } más {conectado = verdadero; }

// Configurar la ganancia del sensor y el tiempo de integración

configureSensor (); }

Entonces necesitamos una función de bucle que se repetirá repetidamente. En este caso, se utiliza para enviar datos repetidamente desde el acelerómetro al servidor en forma de “[z_accel]: [y_mag]: [z_mag]”. El cliente.print (números); La función es la que envía datos al servidor.

bucle vacío () {retraso (250); if (conectado) {// Esto enviará datos al servidor sensors_event_t accel, mag, gyro, temp; lsm.getEvent (& accel, & mag, & gyro, & temp); Números de cadena; números + = acel.aceleración.z; números + = ":"; números + = mag.magnetico.y; números + = ":"; números + = mag.magnetic.z; Serial.print (números); client.print (números); Serial.println (); } más {establecerConnección (); }}

Para algunas funciones de utilidad, necesitamos una para establecer la conexión entre la pluma y el servidor.

void EstablishConnection () {if (! client.connect (host, puerto)) {Serial.println ("error de conexión"); conectado = falso; regreso; } más {conectado = verdadero; }}

También necesitamos configurar el sensor y darle el rango de valores que leerá. Por ejemplo, la aceleración tiene 5 opciones para el rango: 2g, 4g, 6g, 8g y 16g.

void configureSensor (void) {// Establezca el rango del acelerómetro //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); // Establecer la sensibilidad del magnetómetro //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_2GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_4GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_8GAUSS); lsm.setupMag (lsm. LSM9DS0_MAGGAIN_12GAUSS);

// Configurar el giroscopio

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

Configuración del servidor:

El servidor será un archivo Python que se ejecutará en la línea de comandos de una computadora. Para comenzar, importe las clases requeridas.

import socketimport re import pyautogui

socket se utiliza para la creación de redes. re se usa para expresiones regulares o manipulaciones de cadenas. pyautogui es una biblioteca de Python que permitirá que suceda el dibujo (discutido más adelante).

A continuación, debemos definir algunas variables. Estas serán variables globales, por lo que se accederá a ellas en múltiples funciones. Se utilizarán más adelante en el código.

i = 0n = 0 línea = 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 = Falso

first_data = Verdadero

Ahora necesitamos una función para crear un servidor y abrirlo para conexiones entrantes.

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) # Dirección IP del servidor y puerto host = " 149.160.251.3 "port = 12347 dirección_servidor = (host, puerto) # Abra el servidor y escuche las conexiones entrantes print ('Iniciando servidor en% s puerto% s'% dirección_servidor) serversocket.bind (dirección_servidor) serversocket.listen (5) # Espere conexiones … mientras es True: print ('Esperando conexión …') # Acepte una conexión entrante (clientsocket, dirección) = serversocket.accept () # Intente analizar los datos recibidos try: print ('Conexión establecida desde', dirección) while True: # Reciba los datos y envíelos para su procesamiento 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 finalmente: # Cierre el socket para evitar fugas de datos innecesarias clientsocket.close ()

Ahora necesitamos las funciones que procesarán todos los datos. El primer paso a tomar, y la primera función llamada, es la calibración del sensor para fines de cálculo.

def calibData (lista): 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 (lista [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)

A continuación, creamos un desplazamiento de aceleración en movimiento. Esto hace que el programa reconozca cuando alguien deja de mover el dedo porque todos los valores de aceleración que se envían al servidor deben ser los mismos en ese momento.

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): # movimiento detectado dentro de los datos, reiniciar keep_offset = True n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = break si no keep_offset: # estacionario en datos, establecer nuevo 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 = Falso

A continuación, hacemos la peor parte de las matemáticas. Esto implica traducir los datos de aceleración en datos de posición que nos permitirán decir la dirección en la que el usuario mueve su dedo.

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

mag_y = list [1] mag_z = list [2] left = False right = False # No procese la aceleración hasta que esté absolutamente seguro de que ha acelerado # Evita que el ruido mecánico contribuya a la posición if (z_real -0.20): z_real = 0 #Begin integraciones para encontrar la posición 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): derecha = Verdadero elif (float (mag_data [1]) - float (mag_data [0]) <-0.03): izquierda = Verdadero si (derecha): movimiento (50, int (z_pos * 1000)) elif (izquierda): movimiento (-50, int (z_pos * 1000)) z_velo = 0 z_pos = 0

¡Ahora, finalmente, movemos el cursor! Para hacer esto, abrimos una ventana de pintura y la convertimos en pantalla completa. La biblioteca pyautogui contiene una función llamada pyautogui.dragRel (x, y); que usamos para arrastrar el cursor del mouse de un punto al siguiente. Utiliza datos de posición relativa para que el movimiento sea relativo a la última posición del cursor.

def movimiento (x, y): print ("moviendo a", x, -y) pyautogui.dragRel (x, -y)

Por último, necesitamos llamar a la función principal para permitir incluso que se ejecute todo este código.

# Llama a la función para iniciar serverstartServer ()