„Accel Writing“(stebuklinga ranka): 4 žingsniai (su paveikslėliais)

2024 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2024-01-30 10:49

Įvadas

„Magic Hand“leidžia neįgaliesiems ir motorinių įgūdžių negalią turintiems žmonėms mėgautis piešimo ir rašymo kūrybiškumu imituojamoje aplinkoje. „Magiškoji ranka“yra dėvima pirštinė, kuri jaučia jūsų rodomojo piršto judesį ir paverčia tai linijų piešimu kompiuterio ekrane.

Reikalingos medžiagos

LSM9DOF Breakout Board --- 24,95 USD ---

„Adafruit“plunksna su „Wi-Fi“--- 18,95 USD ---

Moterų/moterų laidai --- 1,95 USD ---

Juostos/Velcro juostelės --- 3 USD

Du vienodo stiprumo magnetai --- Kainos skiriasi

Kaip tai veikia

Naudodami akselerometrą, galime surinkti y ašies pagreičio duomenis, kurie padės nustatyti, kada vartotojo pirštas juda aukštyn ir žemyn. Kadangi mūsų akselerometras matuoja pagreitį žemės centro atžvilgiu, negalime nustatyti x ašies (kairės arba dešinės) pagreičio. Laimei, LSM9DOF išjungimo plokštėje taip pat yra magnetometras, leidžiantis rinkti duomenis apie magnetinius laukus. Mes dedame du magnetus 30 cm atstumu vienas nuo kito ir tarp jų yra pirštinė. Jei magnetiniai duomenys yra teigiami, mes žinome, kad pirštinė juda į dešinę ir atvirkščiai. Kai visi duomenys yra surinkti akselerometre/magnetometre, jie siunčia duomenis laidu į plunksną, kuri yra prijungta prie „Wi -Fi“kompiuterio, ir tada persiunčia duomenis į kompiuterį, kurį galime naudoti savo kodu.

1 žingsnis: 1 fizinis prototipas

Šis prototipas skirtas pirštinei laisvai susiūti ant rankos, kad ji galėtų slysti per elektroninius prietaisus. Tuomet elektroninis prietaisas velcro pagalba bus pritvirtintas prie šarvuotų rankovių pagrindo kartu su pagrindine pirštine ant rankos. Tada žalia pirštinė slysta virš pagrindo ir elektroninių prietaisų …

Pirštinės prototipo kūrimo žingsniai:

• Paimkite du pakankamai didelius audinio gabalus, kad galėtumėte atsekti ranką
• Nubrėžkite ranką ant abiejų audinio dalių ir iškirpkite jas
• Sujunkite abi rankomis iškirptas dalis taip, kad jos būtų visiškai suderintos
• Tada, norėdami paruošti siuvimo mašiną, perbraukite siūlą per nurodytas mašinos vietas
• Kai siuvimo mašina bus sumontuota, pakelkite adatą ir po adata sudėkite du audinio gabalus
• Įsitikinkite, kad adata yra ant paties audinio krašto, paleiskite mašiną ir siūkite išilgai audinio kraštų, palikdami dvi dalis nesiūtas prie riešo, kad ranka tilptų.

2 žingsnis: 2 fizinis prototipas

Galutinis mūsų prototipas yra įprastos pirštinės kartu su Velcro dirželiu, kuris reguliuojamas prie bet kurio riešo. Pirštinė ir dirželis susiuvami, o elektroniniai prietaisai prie pirštinės pritvirtinami per Velcro.

Antrojo pirštinės prototipo kūrimo žingsniai:

1. Pirkite pirštinę, pirštinės medžiaga nesvarbi.
2. Įsigykite velcro riešo dirželį
3. Įsigykite nešiojamą bateriją
4. Įsigykite „Sticky Velcro“
5. Siuvimo adata pritvirtinkite velcro riešo diržą prie pirštinės pagrindo
6. Riešo dirželis turėtų sugebėti prisitaikyti prie skirtingų riešo dydžių.
7. Pritvirtinkite lipnią juostą prie akselerometro pagrindo ir pritvirtinkite prie pirštinės rodomojo piršto
8. Prie plunksnos pritvirtinkite lipnią juostą ir pritvirtinkite prie pirštinės viršaus.
9. Naudodami laidus, prijunkite plunksnos 3V3 kaištį prie akselerometro VIN kaiščio
10. Naudodami laidus, prijunkite plunksnoje esantį GND kaištį prie akselerometro GND kaiščio.
11. Naudodami laidus, prijunkite plunksnoje esantį SCL kaištį prie akselerometro SCL kaiščio.
12. Naudodami laidus, prijunkite plunksnoje esantį SDA kaištį prie akselerometro SDA kaiščio.
13. Prijunkite bent 5 voltų bateriją per USB prie plunksnos, kad gautumėte energijos.

3 žingsnis: magnetai

1 žingsnis: padėkite du vienodo stiprumo magnetus vienas prieš kitą.

2 žingsnis: išmatuokite 30 cm tarpą tarp dviejų magnetų

3 žingsnis: padėkite magnetometrą tiksliai dviejų magnetų viduryje. Turėtumėte gauti duomenis apie 0, kol jie yra viduryje. Jei rodomas nulis, pereikite prie 5 veiksmo.

4 žingsnis: Jei rodmuo nėra nulis arba artimas nuliui, turite sureguliuoti magnetų atstumą. Jei rodmuo yra neigiamas, kairįjį magnetą perkelkite cm arba 2 į kairę arba tol, kol rodmuo bus lygus nuliui. Jei jis teigiamas, darykite tą patį, išskyrus tinkamą magnetą.

5 veiksmas: parašykite kodą, kuris priima duomenis iš magnetometro ir nuskaito teigiamą ar neigiamą. Jei teigiamas kodas, nubrėžkite liniją į dešinę, o jei neigiamas - nubrėžkite liniją į kairę.

4 žingsnis: kodas

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

Įvadas:

Kad būtų galima apdoroti duomenis iš pagreičio matuoklio, tarp „Adafruit“plunksnos ir duomenis apdorojančio serverio (veikia nešiojamajame/staliniame kompiuteryje) turi būti užmegzti kliento ir serverio santykiai. Reikės sukurti du kodo failus: vieną klientui („Adafruit“plunksna), o kitą - serveriui (šiuo atveju - „Jarod“nešiojamąjį kompiuterį). Klientas parašytas C ++, o serveris - python. Klientui naudojama kalba yra svarbi, nes „Arduino“daugiausia yra C ++ kalba, todėl sunku ją pakeisti kita kalba. Serveris gali būti parašytas bet kuria kalba, jei jis turi tinklo funkcijų.

Kliento nustatymas:

Pirmiausia nustatysime kliento kodą. Dauguma „WiFi“ryšio kodo yra lengvai prieinami „Adafruit“bibliotekose. Mes pradedame įtraukdami atitinkamas klases.

#įtraukimas #įtraukimas #įtraukimas #įtraukimas #įtraukimas

Nustatykite kai kuriuos kintamuosius, kurie bus naudojami visame kode.

// Prisijungimas prie tinklo const char* ssid = "MMServer"; const char* password = "MMServer-Password"; // IP ir serverio prievadas, kuris gaus duomenis const char* host = "149.160.251.3"; const int prievadas = 12347; bool prijungtas = klaidingas;

// Inicijuoti judesio detektorių

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0 (1000);

„WiFiClient“klientas;

Sukurkite sąrankos () funkciją, kuri bus paleista vos prasidėjus plunksnai.

// Nustatykite „WiFi“ryšį ir prisijunkite prie serveriovoid setup () {Serial.begin (9600); vėlavimas (100);

Serial.println ();

Serial.println (); Serial.print („Prisijungimas prie“); Serial.println (ssid); // Paleisti WiFi WiFi.begin (ssid, slaptažodis); // Prisijungiama… while (WiFi.status ()! = WL_CONNECTED) {delay (500); Serijinis atspaudas ("."); } // Sėkmingai prijungtas prie „WiFi Serial.println“(„“); Serial.println („WiFi prijungtas“); Serial.println ("IP adresas:"); Serial.println (WiFi.localIP ());

#ifndef ESP8266

while (! Serial); #endif Serial.begin (9600); Serial.println („Jutiklio testas“);

// Inicijuokite jutiklį

if (! lsm.begin ()) {// Kilo problema aptikti LSM9DS0 Serial.print (F ("Oi, LSM9DS0 neaptiktas … Patikrinkite laidus ar I2C ADDR!"); tuo tarpu (1); } Serial.println (F ("Rasta LSM9DS0 9DOF")); // Pradėkite prisijungti prie serverio Serial.print ("Prisijungimas"); Serial.println (priegloba);

// Patikrinkite, ar sėkmingai prisijungėte. Jei nepavyko, nutraukite

if (! client.connect (priegloba, prievadas)) {Serial.println ("nepavyko prisijungti"); prijungtas = klaidingas; grįžti; } else {prijungtas = tiesa; }

// Nustatykite jutiklio stiprinimą ir integravimo laiką

configureSensor (); }

Tada mums reikia ciklo funkcijos, kuri pakartotinai kartosis. Šiuo atveju jis naudojamas pakartotinai siųsti duomenis iš pagreičio matuoklio į serverį „[z_accel]: [y_mag]: [z_mag]“pavidalu. Klientas.spaudas (skaičiai); funkcija siunčia duomenis į serverį.

tuštumos kilpa () {uždelsimas (250); if (connected) {// Tai siųs duomenis į serverį sensors_event_t accel, mag, gyro, temp; lsm.getEvent (& accel, & mag, & gyro, & temp); Styginių skaičiai; skaičiai += accel.acceleration.z; skaičiai += ":"; skaičiai += mag.magnetinis.y; skaičiai += ":"; skaičiai += mag.magnetic.z; Serial.print (skaičiai); client.print (skaičiai); Serial.println (); } else {createConnection (); }}

Kai kurioms naudingumo funkcijoms mums reikia tos, kuri užmegztų ryšį tarp plunksnos ir serverio.

void createConnection () {if (! client.connect (priegloba, prievadas)) {Serial.println ("nepavyko prisijungti"); prijungtas = klaidingas; grįžti; } else {prijungtas = tiesa; }}

Taip pat turime sukonfigūruoti jutiklį ir pateikti jam skaitomų verčių diapazoną. Pavyzdžiui, pagreitis turi 5 diapazono parinktis: 2g, 4g, 6g, 8g ir 16g.

void configureSensor (void) {// Nustatykite akselerometro diapazoną //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); // Nustatykite magnetometro jautrumą //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_2GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_4GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_8GAUSS); lsm.setupMag (lsm. LSM9DS0_MAGGAIN_12GAUSS);

// Nustatykite giroskopą

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

Serverio nustatymas:

Serveris bus „Python“failas, kuris bus paleistas kompiuterio komandinėje eilutėje. Norėdami pradėti, importuokite reikiamas klases.

importuoti lizdą importuoti iš naujo importuoti pyautogui

lizdas naudojamas tinklui. re naudojamas regex arba eilutės manipuliacijoms. pyautogui yra python biblioteka, kuri leis piešti (aptarsime vėliau).

Toliau turėtume apibrėžti kai kuriuos kintamuosius. Tai bus visuotiniai kintamieji, todėl jie bus pasiekiami naudojant kelias funkcijas. Jie bus naudojami vėliau kodu.

i = 0n = 0 eilutė = 1

data_list =

mag_data =

mag_calib_y = 0 mag_offset_y = 0

z_kalibas = 0

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

keep_offset = Netiesa

first_data = tiesa

Dabar mums reikia funkcijos, kad sukurtume serverį ir atidarytume jį gaunamiems ryšiams.

def startServer (): global i global first_data # inicializuokite serverio lizdą 149.160.251.3 "port = 12347 server_address = (priegloba, prievadas) # Atidarykite serverį ir klausykitės gaunamų ryšių spausdinimo ('Serverio paleidimas %s prievado %s' %serverio_adrese) serverocket.bind (server_address) serverocket.listen (5) # Palaukite ryšių… kol tiesa: spausdinkite („Laukiama ryšio…“) # Priimkite gaunamą ryšį (kliento lizdas, adresas) = serverocket.accept () # Pabandykite išanalizuoti gautus duomenis pabandykite: print („Ryšys užmegztas iš“, adresas)), nors tiesa: # Gaukite duomenis ir nusiųskite juos apdoroti = customersocket.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] spausdinti (accel_data) i+= 1, jei (i <51): calibData (accel_data) else: moveAcce l (accel_data [0]) processData (accel_data) first_data = Galiausiai klaidinga: # Uždarykite lizdą, kad išvengtumėte nereikalingo duomenų nutekėjimo customersocket.close ()

Dabar mums reikia funkcijų, kurios apdorotų visus duomenis. Pirmasis žingsnis, kurį reikia atlikti, ir pirmoji vadinama funkcija yra jutiklio kalibravimas skaičiavimo tikslais.

def calibData (sąrašas): 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)

Toliau sukuriame judantį pagreičio poslinkį. Dėl to programa atpažįsta, kai kas nors nustoja judinti pirštą, nes visos pagreičio vertės, siunčiamos į serverį, tuo metu turėtų būti vienodos.

def moveAccel (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): # judesyje aptiktas judesys, paleiskite iš naujo keep_offset = True n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = pertrauka, jei ne keep_offset: # stacionarus duomenyse, nustatykite naują 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 = Netiesa keep_offset = Netiesa

Toliau mes atliekame matematiką. Tai apima pagreičio duomenų pavertimą padėties duomenimis, kurie leis mums pasakyti, kuria kryptimi vartotojas juda pirštu.

def processData (sąrašas): #[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 (sąrašas [0]) - z_offset

mag_y = sąrašas [1] mag_z = sąrašas [2] kairė = klaidinga dešinė = klaidinga # Neapdorokite pagreičio, kol nesate visiškai tikri, kad jis pagreitėjo integracijos, skirtos rasti poziciją, jei (pirmasis_datas): 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): dešinė = tikras elifas (plūdė (mag_data [1]) - plūdė (mag_data [0]) <-0.03): kairė = tiesa, jei (dešinė): judėjimas (50, int (z_pos*) 1000)) elifas (kairėje): judėjimas (-50, int (z_pos*1000)) z_velo = 0 z_pos = 0

Dabar pagaliau perkeliame žymeklį! Norėdami tai padaryti, atidarėme dažų langą ir padarėme jį per visą ekraną. Pyautogui bibliotekoje yra funkcija, vadinama pyautogui.dragRel (x, y); kuriuos mes naudojame pelytės žymeklio perkėlimui iš vieno taško į kitą. Jis naudoja santykinės padėties duomenis, todėl judėjimas yra susijęs su paskutine žymeklio padėtimi.

def judėjimas (x, y): print ("juda į", x, -y) pyautogui.dragRel (x, -y)

Galiausiai turime iškviesti pagrindinę funkciją, kad net leistume paleisti visą šį kodą.

# Kviečia šią funkciją paleisti serveriustartServer ()