Accel Writing (Magic Hand): 4 kroky (s obrázky)

2025 Autor: John Day | [email protected]. Naposledy změněno: 2025-01-13 06:57

Úvod

Kouzelná ruka umožňuje lidem se zdravotním postižením a poruchou motoriky užít si kreativitu kreslení a psaní v simulovaném prostředí. Magic Hand je nositelná rukavice, která snímá pohyb ukazováčku a převádí ji do kreslení čar na obrazovce počítače.

Potřebné materiály

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

Adafruit Feather with Wifi --- 18,95 $ ---

Ženské/ženské dráty --- 1,95 $ ---

Pásky na pásek/suchý zip --- $ 3

Dva magnety stejné síly --- Ceny se liší

Jak to funguje

Pomocí akcelerometru můžeme shromažďovat údaje o zrychlení pro osu y, což nám pomůže určit, kdy se prst uživatele pohybuje nahoru a dolů. Vzhledem k tomu, že náš akcelerometr měří zrychlení vzhledem ke středu země, nemůžeme určit zrychlení osy x (vlevo nebo vpravo). Naštěstí odlomená deska LSM9DOF také obsahuje magnetometr, který nám umožňuje shromažďovat data o magnetických polích. Položíme dva magnety 30 cm od sebe a mezi nimi máme rukavici. Pokud jsou magnetická data pozitivní, víme, že se rukavice pohybují doprava a naopak. Poté, co jsou všechna data shromážděna v akcelerometru/magnetometru, odešle data pomocí drátu do peří, které je připojeno k počítači wifi, a poté předá data do počítače, který pak můžeme použít v našem kódu.

Krok 1: Fyzický prototyp 1

Tento prototyp má být ušitý rukavicí volně na ruce, aby mohl sklouznout přes elektronická zařízení. Elektronické zařízení bude poté připevněno suchým zipem k základně rukávu pod brněním v kombinaci se základní rukavicí na ruce. Pak zelená rukavice sklouzne přes základnu a elektronická zařízení …

Kroky při výrobě prototypu rukavice:

• Získejte dva kusy látky dostatečně velké, aby vystopovaly ruku
• Sledujte oběma kusy látky ruku a vystřihněte je
• Spojte dva ručně vystřihované výřezy dohromady, aby byly dokonale zarovnané
• Dále pro přípravu šicího stroje provlékněte nit uvedenými místy na stroji
• Když je šicí stroj nastaven, zvedněte jehlu a položte dva složené kusy látky pod jehlu
• Ujistěte se, že jehla je zarovnána na samém okraji látky, spusťte stroj a přišijte podél okrajů látky, přičemž ponechte dva kusy nešité na zápěstí, aby se do nich vešla ruka.

Krok 2: Fyzický prototyp 2

Náš konečný prototyp je běžná rukavice v kombinaci s páskem na suchý zip, který lze nastavit na jakékoli zápěstí. Rukavice a popruh jsou sešity a elektronická zařízení jsou k rukavici připevněna suchým zipem.

Kroky při výrobě druhého prototypu rukavice:

1. Kupte si rukavici, na materiálu rukavice nezáleží.
2. Kupte si pásek na zápěstí na suchý zip
3. Kupte si přenosnou baterii
4. Kupte si lepivý suchý zip
5. Pomocí šicí jehly připevněte pásek na zápěstí na spodní část rukavice
6. Poutko na zápěstí by mělo být možné přizpůsobit různým velikostem zápěstí.
7. Přilepte lepicí pásku k základně akcelerometru a připevněte ji k ukazováčku rukavice
8. Na peří připevněte lepicí pásku a připevněte ji k horní části rukavice.
9. Pomocí vodičů připojte pin 3V3 v peří k kolíku VIN na akcelerometru
10. Pomocí vodičů připojte kolík GND v peří ke kolíku GND akcelerometru.
11. Pomocí vodičů připojte pin SCL v peří k kolíku SCL akcelerometru.
12. Pomocí vodičů připojte kolík SDA v peří k kolíku SDA akcelerometru.
13. Připojte alespoň 5 voltovou baterii přes USB k peří, abyste získali energii.

Krok 3: Magnety

Krok 1: Položte dva magnety stejné síly naproti sobě.

Krok 2: Změřte 30 cm mezeru mezi oběma magnety

Krok 3: Umístěte magnetometr přesně doprostřed obou magnetů. Měli byste přijímat data kolem 0, zatímco jsou uprostřed. Pokud obdržíte hodnotu nula, přejděte ke kroku 5.

Krok 4: Pokud není hodnota nulová nebo se blíží nule, musíte upravit vzdálenost magnetů. Pokud je naměřená hodnota záporná, posuňte levý magnet o cm nebo 2 doleva nebo dokud není hodnota nulová. Pokud je kladný, proveďte totéž, kromě pravého magnetu.

Krok 5: Napište kód, který přijme data z magnetometru a přečte, zda je kladný nebo záporný. Pokud je kladný, kód nakreslete čáru doprava a pokud záporný, nakreslete čáru vlevo.

Krok 4: Kód

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

Úvod:

Aby bylo možné zpracovávat data z akcelerometru, musí být vytvořen vztah klient/server mezi perem Adafruit a serverem, který data zpracovává (běží na notebooku/stolním počítači). Bude třeba vytvořit dva soubory kódu: jeden pro klienta (peří Adafruit) a druhý pro server (v tomto případě Jarodův notebook). Klient je napsán v C ++ a server je napsán v pythonu. Jazyk používaný pro klienta je důležitý, protože Arduino je hlavně jazyk C ++ a jeho změna na jiný jazyk je obtížná. Server může být napsán v jakémkoli jazyce, pokud má síťové funkce.

Nastavení klienta:

Nejprve nastavíme klientský kód. Většina kódu připojení WiFi je snadno dostupná prostřednictvím knihoven Adafruit. Začínáme zařazením příslušných tříd.

#include #include #include #include #include

Nastavte některé proměnné, které budou použity v celém kódu.

// Připojení k síti const char* ssid = "MMServer"; const char* heslo = "MMServer-heslo"; // IP a port serveru, který bude přijímat data const char* host = "149.160.251.3"; const int port = 12347; bool připojen = false;

// Inicializace detektoru pohybu

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0 (1000);

Klient WiFiClient;

Vytvořte funkci setup (), která bude spuštěna, jakmile se peří spustí.

// Nastavte připojení WiFi a připojte se k serveru, vyhněte se setup () {Serial.begin (9600); zpoždění (100);

Serial.println ();

Serial.println (); Serial.print („Připojování k“); Serial.println (ssid); // Spusťte WiFi WiFi.begin (ssid, heslo); // Připojování … while (WiFi.status ()! = WL_CONNECTED) {delay (500); Serial.print ("."); } // Úspěšně připojeno k WiFi Serial.println (""); Serial.println („WiFi připojeno“); Serial.println ("IP adresa:"); Serial.println (WiFi.localIP ());

#ifndef ESP8266

while (! Serial); #endif Serial.begin (9600); Serial.println („Test senzoru“);

// Inicializace senzoru

if (! lsm.begin ()) {// Vyskytl se problém s detekcí LSM9DS0 Serial.print (F ("Jejda, nebyl detekován žádný LSM9DS0 … Zkontrolujte zapojení nebo ADR I2C!")); zatímco (1); } Serial.println (F ("Found LSM9DS0 9DOF")); // Začněte se připojovat k serveru Serial.print ("Připojování k"); Serial.println (hostitel);

// Zkontrolujte úspěšné připojení. Pokud selže, přerušte

if (! client.connect (host, port)) {Serial.println ("připojení se nezdařilo"); připojeno = nepravda; vrátit se; } else {připojeno = true; }

// Nastavení zisku a doby integrace senzoru

configureSensor (); }

Potom potřebujeme funkci smyčky, která bude opakovaně smyčku. V tomto případě se používá k opakovanému odesílání dat z akcelerometru na server ve formě „[z_accel]: [y_mag]: [z_mag]“. The client.print (čísla); funkce je to, co odesílá data na server.

void loop () {zpoždění (250); if (připojeno) {// To odešle data na server sensor_event_t accel, mag, gyro, temp; lsm.getEvent (& accel, & mag, & gyro, & temp); Řetězcová čísla; čísla += accel.acceleration.z; čísla += ":"; čísla += mag.magnetic.y; čísla += ":"; čísla += mag.magnetic.z; Serial.print (čísla); client.print (čísla); Serial.println (); } else {navázatConnection (); }}

U některých pomocných funkcí potřebujeme jednu k navázání spojení mezi perem a serverem.

void institConnection () {if (! client.connect (host, port)) {Serial.println ("připojení se nezdařilo"); připojeno = nepravda; vrátit se; } else {připojeno = true; }}

Musíme také nakonfigurovat senzor a dát mu rozsah hodnot, které bude číst. Zrychlení má například 5 možností rozsahu: 2g, 4g, 6g, 8g a 16g.

void configureSensor (void) {// Nastavení rozsahu akcelerometru //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); // Nastavit citlivost magnetometru //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_2GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_4GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_8GAUSS); lsm.setupMag (lsm. LSM9DS0_MAGGAIN_12GAUSS);

// Nastavení gyroskopu

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

Nastavení serveru:

Server bude soubor pythonu, který poběží na příkazovém řádku počítače. Chcete -li začít, importujte požadované třídy.

import socketimport re import pyautogui

soket se používá pro vytváření sítí. re se používá pro regex nebo manipulaci s řetězci. pyautogui je knihovna pythonu, která umožní kreslení (diskutováno později).

Dále bychom měli definovat některé proměnné. Půjde o globální proměnné, takže k nim bude přistupováno ve více funkcích. Budou použity později v kódu.

i = 0n = 0 řádek = 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 = Nepravda

first_data = Pravda

Nyní potřebujeme funkci pro vytvoření serveru a jeho otevření pro příchozí připojení.

def startServer (): globální i globální první_data # inicializace serverové zásuvky serverocket = socket.socket (socket. AF_INET, socket. SOCK_STREAM) serverocket.setsockopt (socket. SOL_SOCKET, socket. SO_REUSEADDR, 1) # IP adresa serveru a port host = " 149.160.251.3 "port = 12347 adresa_serveru = (hostitel, port) # Otevřete server a poslouchejte příchozí připojení tisk („ Spouštění serveru na %s portu %s “%adresa_serveru) serverocket.bind (adresa_serveru) serverocket.listen (5) # Počkejte na připojení… zatímco True: tisk („Čekání na připojení…“) # Přijměte příchozí připojení (clientsocket, adresa) = serverocket.accept () # Zkuste analyzovat přijatá data try: print („Připojení navázáno od“, adresa) while True: # Přijměte data a odešlete je ke zpracování dat = 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] tisk (accel_data) i+= 1 if (i <51): calibData (accel_data) else: movingAcce l (accel_data [0]) processData (accel_data) first_data = Konečně nepravda: # Zavřete soket, abyste zabránili zbytečnému úniku dat clientsocket.close ()

Nyní požadujeme funkce, které budou zpracovávat všechna data. Prvním krokem a první funkcí, kterou je třeba provést, je kalibrace senzoru pro účely výpočtu.

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

Dále vytvoříme posunutí zrychlení pohybu. Díky tomu program rozpozná, když někdo přestane hýbat prstem, protože všechny hodnoty zrychlení, které jsou odeslány na server, by v té době měly být stejné.

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 or z_diff <-0.2): # motion identified within data, restart keep_offset = True n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = break if not keep_offset: # stacionární v datech, 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

Dále provedeme hlavní zátěž matematiky. To zahrnuje převod dat zrychlení do dat o poloze, což nám umožní určit směr, kterým uživatel pohybuje prstem.

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

mag_y = seznam [1] mag_z = seznam [2] left = False right = False # Nezpracovávejte zrychlení, dokud si nejste zcela jisti, že se zrychlil # Zabraňuje mechanickému hluku přispívat do polohy, pokud (z_real -0,20): z_real = 0 #Begin integrace k nalezení polohy, pokud (první_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): pohyb (50, int (z_pos* 1000)) elif (vlevo): pohyb (-50, int (z_pos*1000)) z_velo = 0 z_pos = 0

Nyní konečně přesuneme kurzor! Za tímto účelem jsme otevřeli okno s barvou a převedli ho na celou obrazovku. Knihovna pyautogui obsahuje funkci nazvanou pyautogui.dragRel (x, y); pomocí kterého přetáhneme kurzor myši z jednoho bodu do druhého. Používá data o relativní poloze, takže pohyb je relativní k poslední pozici kurzoru.

def pohyb (x, y): print ("přesun na", x, -y) pyautogui.dragRel (x, -y)

Nakonec musíme zavolat hlavní funkci, abychom dokonce umožnili spuštění celého tohoto kódu.

# Volá funkci pro spuštění serverstartServer ()