एक्सेल राइटिंग (मैजिक हैंड): 4 स्टेप्स (चित्रों के साथ)

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:23

परिचय

मैजिक हैंड विकलांग लोगों और मोटर कौशल की कमी वाले लोगों को एक नकली वातावरण में ड्राइंग और लेखन की रचनात्मकता का आनंद लेने की अनुमति देता है। द मैजिक हैंड एक पहनने योग्य दस्ताने है जो आपकी तर्जनी की गति को महसूस करता है और कंप्यूटर स्क्रीन पर रेखाओं के चित्र में अनुवाद करता है।

सामग्री की जरूरत

LSM9DOF ब्रेकआउट बोर्ड --- $24.95 ---

Wifi के साथ Adafruit पंख --- $18.95 ---

महिला/महिला तार --- $1.95 ---

टेप/वेल्क्रो स्ट्रिप्स --- $3

समान शक्ति के दो चुम्बक --- मूल्य भिन्न होते हैं

यह काम किस प्रकार करता है

एक्सेलेरोमीटर का उपयोग करके, हम y-अक्ष के लिए त्वरण डेटा एकत्र कर सकते हैं जो हमें यह निर्धारित करने में मदद करेगा कि उपयोगकर्ता की उंगली ऊपर और नीचे कब चल रही है। इस तथ्य के कारण कि हमारा एक्सेलेरोमीटर पृथ्वी के केंद्र के संबंध में त्वरण को मापता है, हम एक्स-अक्ष (बाएं या दाएं) के त्वरण को निर्धारित नहीं कर सकते हैं। सौभाग्य से LSM9DOF ब्रेकआउट बोर्ड में एक मैग्नेटोमीटर भी होता है जो हमें चुंबकीय क्षेत्रों पर डेटा एकत्र करने की अनुमति देता है। हम दो चुम्बकों को 30 सेमी की दूरी पर रखते हैं और उनके बीच में दस्ताना लगाते हैं। यदि चुंबकीय डेटा सकारात्मक पढ़ता है तो हम जानते हैं कि दस्ताने सही चल रहा है और इसके विपरीत। एक्सेलेरोमीटर/मैग्नेटोमीटर में सभी डेटा एकत्र होने के बाद यह डेटा को तार के माध्यम से पंख को भेजता है जो कि वाईफाई के कंप्यूटर से जुड़ा होता है और फिर डेटा को कंप्यूटर को अग्रेषित करता है जिसे हम अपने कोड में उपयोग कर सकते हैं।

चरण 1: भौतिक प्रोटोटाइप 1

इस प्रोटोटाइप को इलेक्ट्रॉनिक उपकरणों पर फिसलने के लिए हाथ पर ढीले ढंग से एक साथ दस्ताने सिलने के लिए है। इलेक्ट्रॉनिक उपकरण को वेल्क्रो द्वारा हाथ पर एक मूल दस्ताने के साथ संयुक्त अंडर आर्मर स्लीव बेस से जोड़ा जाएगा। फिर हरे रंग का दस्ताना आधार और इलेक्ट्रॉनिक उपकरणों पर फिसल जाएगा…।

प्रोटोटाइप दस्ताने बनाने के चरण:

• हाथ का पता लगाने के लिए कपड़े के दो टुकड़े काफी बड़े लें
• कपड़े के दोनों टुकड़ों पर हाथ ट्रेस करें और उन्हें काट लें
• दोनों हाथों के कटे हुए हिस्सों को एक साथ रखें ताकि वे पूरी तरह से संरेखित हों
• अगला, सिलाई मशीन तैयार करने के लिए, मशीन पर संकेतित स्थानों के माध्यम से धागा चलाएं
• जब सिलाई मशीन की स्थापना की जाती है, तो सुई को उठाएं और कपड़े के दो टुकड़ों को एक साथ सुई के नीचे रखें
• सुनिश्चित करें कि सुई कपड़े के बिल्कुल किनारे पर है, मशीन शुरू करें, और कपड़े के किनारों के साथ सिलाई करें, जबकि दो टुकड़ों को कलाई पर बिना सिलना छोड़ दें ताकि एक हाथ फिट हो सके।

चरण 2: भौतिक प्रोटोटाइप 2

हमारा अंतिम प्रोटोटाइप वेल्क्रो स्ट्रैप के साथ संयुक्त एक नियमित दस्ताने है जो किसी भी कलाई के लिए समायोज्य है। दस्ताने और पट्टा एक साथ सिल दिए जाते हैं, और इलेक्ट्रॉनिक उपकरण वेल्क्रो के माध्यम से दस्ताने से जुड़े होते हैं।

दस्तानों का दूसरा प्रोटोटाइप बनाने के चरण:

1. एक दस्ताने खरीदें, दस्ताने की सामग्री कोई फर्क नहीं पड़ता।
2. एक वेल्क्रो कलाई का पट्टा खरीदें
3. पोर्टेबल बैटरी खरीदें
4. स्टिकी वेल्क्रो खरीदें
5. एक सिलाई सुई के साथ, दस्ताने के आधार पर वेल्क्रो कलाई का पट्टा संलग्न करें
6. कलाई का पट्टा विभिन्न कलाई आकारों में समायोजित करने में सक्षम होना चाहिए।
7. चिपचिपा टेप को एक्सेलेरोमीटर के आधार पर संलग्न करें और इसे दस्ताने की तर्जनी से जोड़ दें
8. पंख के लिए चिपचिपा टेप संलग्न करें और इसे दस्ताने के शीर्ष पर संलग्न करें।
9. तारों का उपयोग करके पंख में 3V3 पिन को एक्सेलेरोमीटर में VIN पिन से कनेक्ट करें
10. तारों का उपयोग करके पंख में GND पिन को एक्सेलेरोमीटर को GND पिन से कनेक्ट करें।
11. तारों का उपयोग करते हुए एससीएल पिन को पंख में एससीएल पिन को एक्सेलेरोमीटर से कनेक्ट करें।
12. तारों का उपयोग करते हुए एसडीए पिन को पंख में एसडीए पिन को एक्सेलेरोमीटर से कनेक्ट करें।
13. शक्ति प्रदान करने के लिए यूएसबी के माध्यम से कम से कम 5 वोल्ट की बैटरी को पंख से कनेक्ट करें।

चरण 3: चुंबक

चरण 1: समान शक्ति वाले दो चुम्बकों को एक दूसरे के आर-पार रखें।

चरण 2: दो चुम्बकों के बीच 30 सेमी का अंतर मापें

चरण 3: मैग्नेटोमीटर को दो चुम्बकों के ठीक बीच में रखें। बीच में रहते हुए आपको लगभग 0 डेटा प्राप्त करना चाहिए। यदि आपको शून्य की रीडिंग मिलती है तो चरण 5 पर जाएं।

चरण 4: यदि रीडिंग शून्य नहीं है या शून्य के करीब है तो आपको चुम्बकों की दूरी को समायोजित करना होगा। यदि पठन ऋणात्मक है तो बाएँ चुम्बक को एक सेमी या 2 बाईं ओर या जब तक पठन शून्य न हो जाए तब तक घुमाएँ। यदि यह सकारात्मक है तो सही चुंबक को छोड़कर वही काम करें।

चरण 5: वह कोड लिखें जो मैग्नेटोमीटर से डेटा को स्वीकार करता है और पढ़ता है कि क्या यह सकारात्मक या नकारात्मक है। यदि धनात्मक है तो कोड को दाईं ओर एक रेखा खींचना है और यदि ऋणात्मक है तो बाईं ओर एक रेखा खींचना है।

चरण 4: कोड

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

परिचय:

एक्सेलेरोमीटर से डेटा प्रोसेस करने के लिए, एडफ्रूट फेदर और डेटा को प्रोसेस करने वाले सर्वर (लैपटॉप/डेस्कटॉप पर चलने वाले) के बीच क्लाइंट/सर्वर संबंध स्थापित होना चाहिए। दो कोड फाइलें बनाने की आवश्यकता होगी: एक क्लाइंट के लिए (एडफ्रूट फेदर), और दूसरा सर्वर के लिए (इस मामले में, जारोड का लैपटॉप)। क्लाइंट सी ++ में लिखा गया है, और सर्वर पायथन में लिखा गया है। क्लाइंट के लिए उपयोग की जाने वाली भाषा Arduino के रूप में मुख्य रूप से एक C++ भाषा है, और इसे एक अलग भाषा का उपयोग करने के लिए बदलना मुश्किल है। सर्वर को किसी भी भाषा में लिखा जा सकता है, जब तक उसमें नेटवर्क सुविधाएँ हों।

क्लाइंट की स्थापना:

सबसे पहले, हम क्लाइंट कोड सेटअप करेंगे। अधिकांश वाईफाई कनेक्शन कोड एडफ्रूट पुस्तकालयों के माध्यम से आसानी से उपलब्ध है। हम प्रासंगिक वर्गों को शामिल करके शुरू करते हैं।

#शामिल करें #शामिल करें #शामिल करें #शामिल करें

कुछ चर सेट करें जो पूरे कोड में उपयोग किए जाएंगे।

// एक नेटवर्क से कनेक्ट करें const char* ssid = "MMServer"; कॉन्स्ट चार * पासवर्ड = "एमएमसर्वर-पासवर्ड"; // आईपी और सर्वर का पोर्ट जो डेटा प्राप्त करेगा const char* host = "149.160.251.3"; कॉन्स्ट इंट पोर्ट = १२३४७; बूल जुड़ा = झूठा;

// मोशन डिटेक्टर को इनिशियलाइज़ करें

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0 (1000);

वाईफाई क्लाइंट क्लाइंट;

एक सेटअप () फ़ंक्शन बनाएं जो पंख शुरू होते ही चलाया जाएगा।

// सेटअप वाईफाई कनेक्शन, और सर्वरवॉइड सेटअप से कनेक्ट करें () {Serial.begin (९६००); देरी (100);

सीरियल.प्रिंट्लन ();

सीरियल.प्रिंट्लन (); Serial.print ("कनेक्ट कर रहा है"); सीरियल.प्रिंट्लन (एसएसआईडी); // वाईफाई वाईफाई शुरू करें। शुरू करें (एसएसआईडी, पासवर्ड); // कनेक्ट हो रहा है … जबकि (वाईफाई.स्टेटस ()! = WL_CONNECTED) {देरी (500); सीरियल.प्रिंट ("।"); } // WiFi Serial.println(""); से सफलतापूर्वक कनेक्ट हो गया है; Serial.println ("वाईफाई कनेक्टेड"); Serial.println ("आईपी पता:"); Serial.println (वाईफाई.लोकलआईपी ());

#ifndef ESP8266

जबकि (! सीरियल); #endif Serial.begin(9600); Serial.println ("सेंसर टेस्ट");

// सेंसर को इनिशियलाइज़ करें

if(!lsm.begin()) {// LSM9DS0 Serial.print(F("Ooops, no LSM9DS0 पता चला … अपनी वायरिंग या I2C ADDR की जांच करें!")); जबकि(1); } Serial.println(F("LSM9DS0 9DOF मिला")); // सर्वर से कनेक्ट करना शुरू करें Serial.print("कनेक्ट कर रहा है"); सीरियल.प्रिंट्लन (होस्ट);

// सफल कनेक्शन के लिए जाँच करें। विफल रहे तो निरस्त करें

अगर (! क्लाइंट। कनेक्ट (होस्ट, पोर्ट)) {Serial.println ("कनेक्शन विफल"); जुड़ा = झूठा; वापसी; } और {जुड़ा = सच; }

// सेंसर लाभ और एकीकरण समय सेट करें

कॉन्फ़िगर सेंसर (); }

फिर हमें एक लूप फ़ंक्शन की आवश्यकता होती है जो बार-बार लूप करेगा। इस मामले में, इसका उपयोग एक्सेलेरोमीटर से सर्वर को "[z_accel]: [y_mag]: [z_mag]" के रूप में बार-बार डेटा भेजने के लिए किया जाता है। क्लाइंट.प्रिंट (संख्या); फ़ंक्शन वह है जो सर्वर को डेटा भेजता है।

शून्य लूप () {देरी (250); if(connected){// यह सर्वर sensor_event_t accel, mag, gyro, temp को डेटा भेजेगा; lsm.getEvent(&accel, &mag, &gyro, &temp); स्ट्रिंग नंबर; संख्याएँ + = accel.acceleration.z; नंबर + = ":"; संख्याएँ += mag.चुंबकीय.y; नंबर + = ":"; संख्याएँ += mag.magnetic.z; सीरियल.प्रिंट (संख्या); क्लाइंट.प्रिंट (संख्या); सीरियल.प्रिंट्लन (); } और {स्थापना कनेक्शन (); } }

कुछ उपयोगिता कार्यों के लिए, हमें पंख और सर्वर के बीच संबंध स्थापित करने के लिए एक की आवश्यकता होती है।

शून्य स्थापना कनेक्शन () { अगर (! क्लाइंट। कनेक्ट (होस्ट, पोर्ट)) {Serial.println ("कनेक्शन विफल"); जुड़ा = झूठा; वापसी; } और {जुड़ा = सच; } }

हमें सेंसर को कॉन्फ़िगर करने और इसे पढ़ने वाले मूल्यों की सीमा देने की भी आवश्यकता है। उदाहरण के लिए, त्वरण में श्रेणी के लिए 5 विकल्प हैं: 2g, 4g, 6g, 8g और 16g।

शून्य कॉन्फ़िगर सेंसर (शून्य) {// एक्सेलेरोमीटर रेंज सेट करें //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); // मैग्नेटोमीटर संवेदनशीलता सेट करें //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_2GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_4GAUSS); //lsm.setupMag(lsm. LSM9DS0_MAGGAIN_8GAUSS); lsm.setupMag(lsm. LSM9DS0_MAGGAIN_12GAUSS);

// जाइरोस्कोप सेटअप करें

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

सर्वर की स्थापना:

सर्वर एक पायथन फाइल होगी जो कंप्यूटर की कमांड लाइन पर चलेगी। शुरू करने के लिए, आवश्यक कक्षाएं आयात करें।

आयात सॉकेटआयात पुनः आयात pyautogui

सॉकेट का उपयोग नेटवर्किंग के लिए किया जाता है। रे रेगेक्स, या स्ट्रिंग मैनिप्लेशंस के लिए उपयोग किया जाता है। pyautogui एक अजगर पुस्तकालय है जो ड्राइंग को होने देगा (बाद में चर्चा की गई)।

इसके बाद, हमें कुछ चरों को परिभाषित करना चाहिए। ये वैश्विक चर होंगे, इसलिए इन्हें कई कार्यों में एक्सेस किया जाएगा। इनका उपयोग बाद में कोड में किया जाएगा।

मैं = 0n = 0 पंक्ति = 1

डेटा_लिस्ट =

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 = गलत

first_data = सच

अब हमें सर्वर बनाने और आने वाले कनेक्शन के लिए इसे खोलने के लिए एक फ़ंक्शन की आवश्यकता है।

def startServer (): वैश्विक i वैश्विक first_data # सर्वर सॉकेट सर्वर सॉकेट = सॉकेट.सॉकेट (सॉकेट। AF_INET, सॉकेट. SOCK_STREAM) सर्वरसॉकेट। 149.160.251.3" पोर्ट = 12347 सर्वर_एड्रेस = (होस्ट, पोर्ट) # सर्वर खोलें और आने वाले कनेक्शनों को सुनें प्रिंट ('%s पोर्ट%s'% सर्वर_एड्रेस पर सर्वर शुरू करना) serversocket.bind(server_address) serversocket.listen(5) # कनेक्शन के लिए प्रतीक्षा करें … जबकि सही: प्रिंट ('कनेक्शन की प्रतीक्षा कर रहा है …') # आने वाले कनेक्शन को स्वीकार करें (क्लाइंटसॉकेट, पता) = सर्वर सॉकेट। स्वीकार () # प्राप्त डेटा को पार्स करने का प्रयास करें: प्रिंट ('कनेक्शन स्थापित', पता) जबकि सही: # डेटा प्राप्त करें और इसे डेटा प्रोसेसिंग के लिए भेजें = 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] प्रिंट(accel_data) i+=1 अगर (i <51): calibData(accel_data) अन्य: मूविंगएक्स l(accel_data[0]) processData(accel_data) first_data = False अंत में: # अनावश्यक डेटा रिसाव को रोकने के लिए सॉकेट बंद करें क्लाइंट सॉकेट.क्लोज़ ()

अब हमें उन कार्यों की आवश्यकता है जो सभी डेटा को संसाधित करेंगे। पहला कदम उठाना है, और पहला फ़ंक्शन जिसे कहा जाता है, गणना उद्देश्यों के लिए सेंसर का अंशांकन है।

def calibData (सूची): वैश्विक z_calib वैश्विक z_offset वैश्विक mag_data वैश्विक mag_calib_y वैश्विक mag_offset_y z_calib + = फ्लोट (सूची [0]) mag_calib_y + = फ्लोट (सूची [1]) अगर (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)

अगला, हम एक गतिमान त्वरण ऑफ़सेट बनाते हैं। यह ऐसा इसलिए करता है जब कोई अपनी उंगली हिलाना बंद कर देता है तो प्रोग्राम पहचानता है क्योंकि उस समय सर्वर पर भेजे जाने वाले त्वरण के सभी मान समान होने चाहिए।

डीईएफ़ मूविंगएक्सेल (संख्या): वैश्विक z_calib वैश्विक z_diff वैश्विक z_moving_offset वैश्विक z_offset वैश्विक डेटा_सूची वैश्विक n वैश्विक Keep_offset अगर (n 0.2 या z_diff <-0.2): # डेटा के भीतर गति का पता चला, Keep_offset को पुनरारंभ करें = सही n = 0 z_calib = 0 z_moving_offset = 0 z_diff = ० data_list = अगर रख नहीं तो तोड़ें_ऑफ़सेट: # डेटा में स्थिर, नया सेट करें z_offset z_offset = z_moving_offset प्रिंट ("नया z_offset:") प्रिंट (z_offset) n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = Keep_offset = गलत Keep_offset = False

अगला, हम गणित का खामियाजा उठाते हैं। इसमें त्वरण डेटा को स्थिति डेटा में अनुवाद करना शामिल है जो हमें यह बताने की अनुमति देगा कि उपयोगकर्ता अपनी उंगली को किस दिशा में ले जाता है।

डीईएफ़ प्रक्रियाडेटा (सूची): #[accel.z, mag.y] वैश्विक z_offset वैश्विक z_real वैश्विक z_velo वैश्विक z_pos वैश्विक प्रथम_डेटा वैश्विक mag_data

z_real = फ्लोट (सूची [0]) - z_offset

mag_y = सूची [1] mag_z = सूची [2] बायां = झूठा दायां = झूठा # त्वरण की प्रक्रिया तब तक न करें जब तक कि यह पूरी तरह से तेज न हो जाए # यांत्रिक शोर को स्थिति में योगदान करने से रोकता है अगर (z_real -0.20): z_real = 0 # शुरुआत स्थिति खोजने के लिए एकीकरण अगर(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) अन्य: 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])> ०.०३: दाएँ = ट्रू एलिफ़ (फ्लोट (मैग_डेटा [१]) - फ्लोट (मैग_डेटा [०]) <-०.०३: लेफ्ट = ट्रू अगर (राइट): मूवमेंट (५०, इंट (z_pos *) 1000)) एलिफ(बाएं): आंदोलन(-50, int(z_pos*1000)) z_velo = 0 z_pos = 0

अब, अंत में, हम कर्सर ले जाते हैं! ऐसा करने के लिए, हमने एक पेंट विंडो खोली और इसे पूर्ण स्क्रीन बना दिया। pyautogui पुस्तकालय में pyautogui.dragRel(x, y); जिसका उपयोग हम माउस कर्सर को एक बिंदु से दूसरे बिंदु तक खींचने के लिए करते हैं। यह सापेक्ष स्थिति डेटा का उपयोग करता है इसलिए गति कर्सर की अंतिम स्थिति के सापेक्ष होती है।

डीईएफ़ मूवमेंट (एक्स, वाई): प्रिंट ("मूविंग टू", एक्स, -वाई) pyautogui.dragRel(x, -y)

अंत में, हमें इस सभी कोड को चलाने की अनुमति देने के लिए मुख्य फ़ंक्शन को कॉल करने की आवश्यकता है।

# सर्वरस्टार्ट सर्वर शुरू करने के लिए फ़ंक्शन को कॉल करें ()