Accel Writing (Magic Hand) - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:21

Einführung

Die Magic Hand ermöglicht Menschen mit Behinderungen und motorischen Beeinträchtigungen, die Kreativität des Zeichnens und Schreibens in einer simulierten Umgebung zu genießen. Die Magic Hand ist ein tragbarer Handschuh, der die Bewegung Ihres Zeigefingers erkennt und diese in das Zeichnen von Linien auf einem Computerbildschirm übersetzt.

Benötigte Materialien

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

Adafruit Feather mit Wifi --- $18.95 ---

Weibliche/weibliche Drähte --- 1,95 $ ---

Klebeband / Klettstreifen --- $ 3

Zwei gleich starke Magnete --- Preise variieren

Wie es funktioniert

Durch die Verwendung eines Beschleunigungsmessers können wir Beschleunigungsdaten für die y-Achse sammeln, die uns helfen zu bestimmen, wann sich der Finger des Benutzers nach oben und unten bewegt. Da unser Beschleunigungsmesser die Beschleunigung in Bezug auf den Erdmittelpunkt misst, können wir die Beschleunigung der x-Achse (links oder rechts) nicht bestimmen. Glücklicherweise enthält das Breakout-Board LSM9DOF auch ein Magnetometer, mit dem wir Daten zu Magnetfeldern sammeln können. Wir platzieren zwei Magnete im Abstand von 30 cm und haben den Handschuh dazwischen. Wenn die magnetischen Daten positiv sind, wissen wir, dass sich der Handschuh nach rechts bewegt und umgekehrt. Nachdem alle Daten im Beschleunigungsmesser / Magnetometer gesammelt wurden, sendet er die Daten über ein Kabel an die Feder, die mit einem WLAN-Computer verbunden ist, und leitet die Daten dann an den Computer weiter, den wir dann in unserem Code verwenden können.

Schritt 1: Physischer Prototyp 1

Dieser Prototyp soll an der Hand locker zusammengenäht werden, damit er über die elektronischen Geräte gleiten kann. Das elektronische Gerät wird dann mit einem Klettverschluss an der Basis der Unterarmärmel befestigt, kombiniert mit einem Basishandschuh an der Hand. Dann rutscht der grüne Handschuh über die Basis und die elektronischen Geräte….

Schritte zur Herstellung des Handschuh-Prototyps:

• Holen Sie sich zwei Stoffstücke, die groß genug sind, um die Hand zu verfolgen
• Zeichne die Hand auf beide Stoffstücke und schneide sie aus
• Setzen Sie die beiden Handausschnitte zusammen, damit sie perfekt ausgerichtet sind
• Um die Nähmaschine vorzubereiten, führen Sie als nächstes den Faden durch die angezeigten Stellen auf der Maschine
• Wenn die Nähmaschine aufgestellt ist, heben Sie die Nadel an und legen Sie die beiden zusammengefügten Stoffstücke unter die Nadel
• Stellen Sie sicher, dass die Nadel an der äußersten Kante des Stoffes ausgerichtet ist, starten Sie die Maschine und nähen Sie entlang der Stoffkanten, während Sie die beiden Teile am Handgelenk nicht vernähen lassen, damit eine Hand hineinpassen kann.

Schritt 2: Physischer Prototyp 2

Unser letzter Prototyp ist ein normaler Handschuh in Kombination mit einem Klettverschluss, der sich an jedes Handgelenk anpassen lässt. Handschuh und Riemen werden zusammengenäht und die elektronischen Geräte per Klettverschluss am Handschuh befestigt.

Schritte zur Herstellung des 2. Prototyps des Handschuhs:

1. Kaufen Sie einen Handschuh, das Material des Handschuhs spielt keine Rolle.
2. Kaufen Sie ein Klettverschluss-Armband
3. Kaufen Sie einen tragbaren Akku
4. Kaufen Sie klebrigen Klettverschluss
5. Befestigen Sie mit einer Nähnadel das Klettverschluss-Handgelenkband an der Unterseite des Handschuhs
6. Die Handschlaufe sollte sich an unterschiedliche Handgelenksgrößen anpassen können.
7. Bringen Sie das Klebeband an der Unterseite des Beschleunigungsmessers an und befestigen Sie es am Zeigefinger des Handschuhs
8. Bringen Sie Klebeband an der Feder an und befestigen Sie es oben am Handschuh.
9. Verbinden Sie mit Drähten den 3V3-Pin in der Feder mit dem VIN-Pin im Beschleunigungsmesser
10. Verbinden Sie mit Drähten den GND-Pin in der Feder mit dem GND-Pin des Beschleunigungsmessers.
11. Verbinden Sie mit Drähten den SCL-Pin in der Feder mit dem SCL-Pin des Beschleunigungsmessers.
12. Verbinden Sie mit Drähten den SDA-Pin in der Feder mit dem SDA-Pin des Beschleunigungsmessers.
13. Schließen Sie mindestens eine 5-Volt-Batterie über USB an die Feder an, um Strom zu liefern.

Schritt 3: Magnete

Schritt 1: Legen Sie die beiden Magnete gleicher Stärke einander gegenüber.

Schritt 2: Messen Sie 30 cm Abstand zwischen den beiden Magneten

Schritt 3: Platzieren Sie das Magnetometer genau in der Mitte der beiden Magnete. Sie sollten Daten um 0 herum empfangen, während es in der Mitte ist. Wenn Sie eine Anzeige von Null erhalten, fahren Sie mit Schritt 5 fort.

Schritt 4: Wenn der Messwert nicht Null oder nahe Null ist, müssen Sie den Abstand der Magnete anpassen. Wenn der Messwert negativ ist, bewegen Sie den linken Magneten um 1 cm oder 2 nach links oder bis der Messwert Null ist. Wenn es positiv ist, machen Sie dasselbe, außer mit dem richtigen Magneten.

Schritt 5: Schreiben Sie einen Code, der die Daten vom Magnetometer akzeptiert und liest, ob sie positiv oder negativ sind. Wenn positiv, lasse den Code eine Linie nach rechts ziehen und wenn negativ, zeichne eine Linie nach links.

Schritt 4: Code

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

Einführung:

Um Daten vom Beschleunigungsmesser zu verarbeiten, muss eine Client/Server-Beziehung zwischen der Adafruit-Feder und dem Server, der die Daten verarbeitet (der auf einem Laptop/Desktop läuft) hergestellt werden. Es müssen zwei Codedateien erstellt werden: eine für den Client (die Adafruit-Feder) und die andere für den Server (in diesem Fall Jarods Laptop). Der Client ist in C++ geschrieben und der Server ist in Python geschrieben. Die für den Client verwendete Sprache ist wichtig, da Arduino hauptsächlich eine C++-Sprache ist und es schwierig ist, sie zu ändern, um eine andere Sprache zu verwenden. Der Server kann in jeder Sprache geschrieben werden, solange er über Netzwerkfunktionen verfügt.

Client einrichten:

Zuerst richten wir den Client-Code ein. Der Großteil des WiFi-Verbindungscodes ist über die Adafruit-Bibliotheken verfügbar. Wir beginnen mit der Einbeziehung relevanter Klassen.

#einschließen #einschließen #einschließen #einschließen #einschließen

Legen Sie einige Variablen fest, die im gesamten Code verwendet werden.

// Mit einem Netzwerk verbinden const char* ssid = "MMServer"; const char* password = "MMServer-Passwort"; // IP und Port des Servers, der Daten empfängt const char* host = "149.160.251.3"; const int port = 12347; bool verbunden = falsch;

// Bewegungsmelder initialisieren

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0(1000);

WiFiClient-Client;

Erstellen Sie eine setup()-Funktion, die ausgeführt wird, sobald die Feder startet.

// WLAN-Verbindung einrichten und mit servervoid setup () { Serial.begin (9600); Verzögerung (100);

Serial.println();

Serial.println(); Serial.print ("Verbinden mit"); Serial.println (ssid); // Starten Sie WiFi WiFi.begin(ssid, Passwort); // Verbindung wird hergestellt… while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } // Erfolgreich mit WiFi verbunden Serial.println (""); Serial.println ("WiFi verbunden"); Serial.println("IP-Adresse:"); Serial.println (WiFi.localIP());

#ifndef ESP8266

while(!Seriell); #endif Serial.begin(9600); Serial.println ("Sensortest");

// Initialisieren Sie den Sensor

if (!lsm.begin ()) {// Es gab ein Problem beim Erkennen des LSM9DS0 Serial.print (F ("Ooops, kein LSM9DS0 erkannt … Überprüfen Sie Ihre Verkabelung oder I2C-ADDR!")); während(1); } Serial.println (F ("Gefunden LSM9DS0 9DOF")); // Beginnen Sie mit der Verbindung zum Server Serial.print ("Connecting to "); Serial.println (Host);

// Auf erfolgreiche Verbindung prüfen. Wenn fehlgeschlagen, dann abbrechen

if (!client.connect(host, port)) {Serial.println("Verbindung fehlgeschlagen"); verbunden = falsch; Rückkehr; aufrechtzuerhalten. Sonst { verbunden = wahr; }

// Richten Sie die Sensorverstärkung und die Integrationszeit ein

configureSensor(); }

Wir brauchen dann eine Schleifenfunktion, die sich wiederholt wiederholt. In diesem Fall wird es verwendet, um wiederholt Daten vom Beschleunigungsmesser in Form von „[z_accel]:[y_mag]:[z_mag]“an den Server zu senden. Die client.print(Zahlen); Funktion ist das, was Daten an den Server sendet.

Void Schleife () { Verzögerung (250); if(connected){// Dies sendet Daten an den Server Sensoren_event_t accel, mag, gyro, temp; lsm.getEvent(&accel, &mag, &gyro, &temp); String-Nummern; Zahlen += Beschleunigung.z; Zahlen += ":"; Zahlen += mag.magnetisch.y; Zahlen += ":"; Zahlen += mag.magnetisch.z; Serial.print (Zahlen); client.print (Zahlen); Serial.println(); aufrechtzuerhalten. Sonst { EstablishConnection(); } }

Für einige Utility-Funktionen benötigen wir eine, um die Verbindung zwischen der Feder und dem Server herzustellen.

Void EstablishConnection () { if (!client.connect (host, port)) { Serial.println ("Verbindung fehlgeschlagen"); verbunden = falsch; Rückkehr; aufrechtzuerhalten. Sonst { verbunden = wahr; } }

Wir müssen auch den Sensor konfigurieren und ihm den Wertebereich zuweisen, den er lesen wird. Die Beschleunigung hat beispielsweise 5 Optionen für den Bereich: 2 g, 4 g, 6 g, 8 g und 16 g.

Void configureSensor (void) {// Stellen Sie den Beschleunigungsmesserbereich ein // 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); // Stellen Sie die Magnetometerempfindlichkeit ein //lsm.setupMag (lsm. LSM9DS0_MAGGAIN_2GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_4GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_8GAUSS); lsm.setupMag(lsm. LSM9DS0_MAGGAIN_12GAUSS);

// Richten Sie das Gyroskop ein

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

Einrichten des Servers:

Der Server ist eine Python-Datei, die auf der Befehlszeile eines Computers ausgeführt wird. Importieren Sie zunächst die erforderlichen Klassen.

import socketimport re import pyautogui

Socket wird für die Vernetzung verwendet. re wird für Regex oder String-Manipulationen verwendet. pyautogui ist eine Python-Bibliothek, die das Zeichnen ermöglicht (wird später besprochen).

Als nächstes sollten wir einige Variablen definieren. Dies sind globale Variablen, sodass auf sie in mehreren Funktionen zugegriffen wird. Sie werden später im Code verwendet.

i = 0n = 0 Linie = 1

Datenliste =

mag_daten =

mag_calib_y = 0 mag_offset_y = 0

z_kalib = 0

z_offset = 0 z_moving_offset = 0 z_diff = 0 z_real = 0 z_velo = 0 z_pos = 0

keep_offset = Falsch

first_data = True

Wir brauchen nun eine Funktion, um einen Server zu erstellen und ihn für eingehende Verbindungen zu öffnen.

def startServer(): global i global first_data # initialize server socket serverocket = socket.socket(socket. AF_INET, socket. SOCK_STREAM) serverocket.setsockopt(socket. SOL_SOCKET, socket. SO_REUSEADDR, 1) # Server IP-Adresse und Port host = " 149.160.251.3" port = 12347 server_address = (host, port) # Server öffnen und auf eingehende Verbindungen warten print ('Server wird auf %s Port %s gestartet' % server_address) serverocket.bind(server_address) serverocket.listen(5) # Auf Verbindungen warten… während True: print ('Warten auf Verbindung…') # Eine eingehende Verbindung akzeptieren (Clientsocket, Adresse) = serverocket.accept() # Versuchen, empfangene Daten zu analysieren try: print ('Verbindung hergestellt von ', Adresse) while True: # Empfangen Sie die Daten und senden Sie sie zur Verarbeitung 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 finally: # Schließen Sie den Socket, um unnötigen Datenverlust zu vermeiden.clientsocket.close()

Wir benötigen nun die Funktionen, die alle Daten verarbeiten. Der erste Schritt und die erste aufgerufene Funktion ist die Kalibrierung des Sensors zu Berechnungszwecken.

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_y = mag_calib_y / 50 z_calib = 0 mag_calib_y = 0 mag_data.append(mag_offset_y)

Als nächstes erstellen wir einen beweglichen Beschleunigungsoffset. Dadurch erkennt das Programm, wenn jemand aufhört, den Finger zu bewegen, da alle Beschleunigungswerte, die an den Server gesendet werden, zu diesem Zeitpunkt gleich sein sollten.

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 oder z_diff < -0.2): # Bewegung in Daten erkannt, Neustart keep_offset = True n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = break if not keep_offset: # stationär in Daten, setze neuen 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 = Falsch keep_offset = Falsch

Als nächstes machen wir die Hauptlast der Mathematik. Dies beinhaltet die Übersetzung der Beschleunigungsdaten in Positionsdaten, die es uns ermöglichen, die Richtung anzugeben, in die der Benutzer seinen Finger bewegt.

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 # Beschleunigung erst verarbeiten, wenn sie absolut sicher ist # Verhindert, dass mechanisches Rauschen zur Position beiträgt if(z_real -0,20): z_real = 0 #Begin Integrationen, um die Position zu finden 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(links): Bewegung(-50, int(z_pos*1000)) z_velo = 0 z_pos = 0

Jetzt bewegen wir endlich den Cursor! Dazu öffneten wir ein Malfenster und machten es als Vollbild. Die Bibliothek pyautogui enthält eine Funktion namens pyautogui.dragRel(x, y); mit dem wir den Mauszeiger von einem Punkt zum nächsten ziehen. Es verwendet relative Positionsdaten, sodass die Bewegung relativ zur letzten Position des Cursors erfolgt.

def Bewegung(x, y): print("bewegen nach", x, -y) pyautogui.dragRel(x, -y)

Schließlich müssen wir die main-Funktion aufrufen, damit der gesamte Code ausgeführt werden kann.

# Ruft die Funktion auf, um serverstartServer() zu starten