תוכן עניינים:

כתיבת אקסל (יד קסומה): 4 שלבים (עם תמונות)
כתיבת אקסל (יד קסומה): 4 שלבים (עם תמונות)

וִידֵאוֹ: כתיבת אקסל (יד קסומה): 4 שלבים (עם תמונות)

וִידֵאוֹ: כתיבת אקסל (יד קסומה): 4 שלבים (עם תמונות)
וִידֵאוֹ: ככה זה כשיש לך חברה רוסיה 2024, נוֹבֶמבֶּר
Anonim
כתיבת אקסל (יד קסומה)
כתיבת אקסל (יד קסומה)
כתיבת אקסל (יד קסומה)
כתיבת אקסל (יד קסומה)
כתיבת אקסל (יד קסומה)
כתיבת אקסל (יד קסומה)

מבוא

יד הקסם מאפשרת לאנשים עם מוגבלויות ולקויות מיומנות מוטוריות ליהנות מהיצירתיות של ציור וכתיבה בסביבה מדומה. יד הקסם היא כפפה לבישה החושת את תנועת אצבע המורה שלך ומתרגמת זאת לציור קווים על מסך מחשב.

חומרים דרושים

לוח פריצת LSM9DOF --- $ 24.95 ---

נוצת Adafruit עם Wifi --- $ 18.95 ---

חוטי נקבה/נקבה --- $ 1.95 ---

רצועות קלטת/סקוטש --- $ 3

שני מגנטים בעלי חוזק שווה --- המחירים משתנים

איך זה עובד

באמצעות מד תאוצה, אנו יכולים לאסוף נתוני תאוצה לציר ה- y שיסייעו לנו לקבוע מתי האצבע של המשתמש נעה למעלה ולמטה. בשל העובדה שמד התאוצה שלנו מודד תאוצה ביחס למרכז כדור הארץ איננו יכולים לקבוע את האצת ציר ה- x (שמאל או ימין). למרבה המזל לוח הפריצה LSM9DOF מכיל גם מגנטומטר המאפשר לנו לאסוף נתונים על שדות מגנטיים. אנו ממקמים שני מגנטים במרחק של 30 ס מ זה מזה וביניהם הכפפה. אם הנתונים המגנטיים נקראים חיוביים, אנו יודעים שהכפפה נעה ימינה ולהיפך. לאחר שכל הנתונים נאספים במד התאוצה/מגנטומטר הוא שולח את הנתונים באמצעות חוט אל הנוצה המחובר למחשב של wifi ולאחר מכן מעביר את הנתונים למחשב שבו אנו יכולים להשתמש בקוד שלנו.

שלב 1: אב טיפוס פיזי 1

אב טיפוס פיזי 1
אב טיפוס פיזי 1
אב טיפוס פיזי 1
אב טיפוס פיזי 1

אב טיפוס זה נועד לתפור כפפה ביחד באופן רופף על היד על מנת שיחליק מעל המכשירים האלקטרוניים. המכשיר האלקטרוני יחובר באמצעות סקוטש לבסיס שרוול התחתון בשילוב כפפה בסיסית על היד. אז הכפפה הירוקה תחליק מעל הבסיס והמכשירים האלקטרוניים….

שלבים בייצור כפפת האב טיפוס:

  • קבל שתי פיסות בד גדולות מספיק כדי לאתר יד
  • עקבו את היד על שתי פיסות הבד וחתכו אותן
  • חבר את שני החיתוכים ביד כך שהם יהיו מיושרים לחלוטין
  • לאחר מכן, כדי להכין את מכונת התפירה, העביר את החוט דרך הנקודות המצוינות במכונה
  • כאשר מכונת התפירה מוגדרת, הרימו את המחט והניחו את שתי פיסות הבד המחוברות מתחת למחט
  • וודא שהמחט מיושרת בקצה הבד ממש, הפעל את המכונה ותפר לאורך שולי הבד, תוך השארת שני החלקים לא תפורים בשורש כף היד כך שיד יכלה להיכנס פנימה.

שלב 2: אב טיפוס פיזי 2

אב טיפוס פיזי 2
אב טיפוס פיזי 2
אב טיפוס פיזי 2
אב טיפוס פיזי 2

אב הטיפוס האחרון שלנו הוא כפפה רגילה בשילוב רצועת סקוטש המתכווננת לכל פרק כף היד. הכפפה והרצועה נתפרים יחד, והמכשירים האלקטרוניים מחוברים לכפפה באמצעות סקוטש.

שלבים בייצור אב הטיפוס השני של הכפפה:

  1. רכשו כפפה, החומר של הכפפה לא משנה.
  2. רכשו רצועת פרק כף היד
  3. רכשו סוללה ניידת
  4. לרכוש סקוטש דביק
  5. בעזרת מחט תפירה, חבר את רצועת פרק כף היד לבסיס הכפפה
  6. רצועת היד צריכה להיות מסוגלת להתאים את עצמה לגדלי פרק כף היד השונים.
  7. חבר את הקלטת הדביקה לבסיס מד התאוצה והצמד אותה לאצבע המורה של הכפפה
  8. הצמד סרט דביק אל הנוצה והצמד אותו לראש הכפפה.
  9. באמצעות חוטים חבר את סיכת 3V3 בנוצה לסיכת VIN במד התאוצה
  10. באמצעות חוטים חבר את סיכת ה- GND בנוצה לסיכה ה- GND את מד התאוצה.
  11. באמצעות חוטים חבר את סיכת SCL בנוצה לסיכת SCL מד התאוצה.
  12. באמצעות חוטים חבר את סיכת ה- SDA שבנוצה לסיכת ה- SDA את מד התאוצה.
  13. חבר לפחות סוללת 5 וולט דרך ה- usb לנוצה כדי לספק כוח.

שלב 3: מגנטים

מגנטים
מגנטים

שלב 1: הניחו את שני המגנטים של חוזק שווה זה מזה.

שלב 2: מדוד פער של 30 ס מ בין שני המגנטים

שלב 3: הנח את המגנומטר בדיוק באמצע שני המגנטים. אתה אמור לקבל נתונים בסביבות 0 כשהוא באמצע. אם אתה מקבל קריאה של אפס דלג לשלב 5.

שלב 4: אם הקריאה אינה אפסית או קרובה לאפס, עליך להתאים את מרחק המגנטים. אם הקריאה שלילית הזז את המגנט השמאלי ס מ או 2 שמאלה או עד שהקריאה היא אפס. אם זה חיובי עשה את אותו הדבר למעט בעזרת המגנט הנכון.

שלב 5: כתוב קוד שמקבל את הנתונים מהמגנטומטר וקורא אם הוא חיובי או שלילי. אם לחיוב יש את הקוד צייר קו ימינה ואם שלילי צייר קו שמאלה.

שלב 4: קוד

קוד
קוד

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

מבוא:

על מנת לעבד נתונים ממד התאוצה, יש ליצור קשר בין לקוח/שרת בין הנוצה של Adafruit לבין השרת המעבד את הנתונים (פועל במחשב נייד/שולחן עבודה). יהיה צורך ליצור שני קבצי קוד: אחד עבור הלקוח (נוצה Adafruit), והשני עבור השרת (במקרה זה, הלפטופ של Jarod). הלקוח כתוב ב- C ++, והשרת כתוב בפייתון. השפה המשמשת את הלקוח חשובה מכיוון שארדואינו היא בעיקר שפת C ++, וקשה לשנות אותה לשימוש בשפה אחרת. ניתן לכתוב את השרת בכל שפה, כל עוד יש לו תכונות רשת.

הגדרת הלקוח:

ראשית, נתקין את קוד הלקוח. רוב קוד חיבור ה- WiFi זמין בקלות דרך ספריות Adafruit. אנו מתחילים בהכללת שיעורים רלוונטיים.

#include #include #include #include #include

הגדר כמה משתנים מה ישמש לאורך כל הקוד.

// התחבר לרשת const char* ssid = "MMServer"; const char* password = "MMS-server-Password"; // IP ויציאת השרת שיקבל נתונים const char* host = "149.160.251.3"; const int port = 12347; בול מחובר = שקר;

// אתחל גלאי תנועה

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0 (1000);

לקוח WiFiClient;

צור פונקציית setup () שתופעל ברגע שהנוצה מתחילה.

// הגדר חיבור WiFi, והתחבר להגדרת השרת () {Serial.begin (9600); עיכוב (100);

Serial.println ();

Serial.println (); Serial.print ("מתחבר אל"); Serial.println (ssid); // הפעל WiFi WiFi.begin (ssid, סיסמא); // מתחבר… בעוד (WiFi.status ()! = WL_CONNECTED) {עיכוב (500); Serial.print ("."); } // מחובר בהצלחה ל- WiFi Serial.println (""); Serial.println ("WiFi מחובר"); Serial.println ("כתובת IP:"); Serial.println (WiFi.localIP ());

#ifndef ESP8266

בעוד (! סדרתי); #endif Serial.begin (9600); Serial.println ("בדיקת חיישן");

// אתחל את החיישן

if (! lsm.begin ()) {// הייתה בעיה בזיהוי LSM9DS0 Serial.print (F ("אופס, לא זוהה LSM9DS0 … בדוק את החיווט או את ה- I2C ADDR!")); בעוד (1); } Serial.println (F ("נמצא LSM9DS0 9DOF")); // התחל להתחבר לשרת Serial.print ("מתחבר אל"); Serial.println (מארח);

// בדוק אם קיים חיבור מוצלח. אם נכשל אז הפסק

if (! client.connect (מארח, יציאה)) {Serial.println ("החיבור נכשל"); מחובר = שקר; לַחֲזוֹר; } אחר {מחובר = נכון; }

// הגדר את רווח החיישן וזמן האינטגרציה

configureSensor (); }

לאחר מכן אנו זקוקים לפונקציית לולאה שתחזור שוב ושוב. במקרה זה, הוא משמש לשלוח שוב ושוב נתונים ממד התאוצה לשרת בצורה של "[z_accel]: [y_mag]: [z_mag]". Client.print (מספרים); פונקציה היא מה ששולח נתונים לשרת.

לולאת חלל () {עיכוב (250); אם (מחובר) {// זה ישלח נתונים לשרת sensors_event_t accel, mag, gyro, temp; lsm.getEvent (& accel, & mag, & gyro, & temp); מספרי מחרוזת; מספרים += accel.acceleration.z; מספרים += ":"; מספרים += mag.magnetic.y; מספרים += ":"; מספרים += mag.magnetic.z; Serial.print (מספרים); client.print (מספרים); Serial.println (); } else {etablConnection (); }}

עבור כמה פונקציות שירות, אנו זקוקים לאחת כדי ליצור את הקשר בין הנוצה לשרת.

void etablConnection () {if (! client.connect (host, port)) {Serial.println ("החיבור נכשל"); מחובר = שקר; לַחֲזוֹר; } אחר {מחובר = נכון; }}

עלינו גם להגדיר את החיישן ולתת לו את טווח הערכים שהוא יקרא. לדוגמה, להאצה יש 5 אפשרויות לטווח: 2g, 4g, 6g, 8g ו- 16g.

void configureSensor (void) {// הגדר את טווח מד התאוצה //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); }

הגדרת השרת:

השרת יהיה קובץ פייתון שיופעל בשורת הפקודה של מחשב. כדי להתחיל, ייבא את המחלקות הנדרשות.

ייבוא socketimport re יבוא pyautogui

שקע משמש לרשת. re משמש לניצול רגלי או מניפולציות של מחרוזות. pyautogui היא ספריית פייתון שתאפשר את הציור לקרות (נדון בהמשך).

לאחר מכן, עלינו להגדיר כמה משתנים. אלה יהיו משתנים גלובליים, כך שניתן יהיה לגשת אליהם במספר פונקציות. הם ישמשו אותם בהמשך הקוד.

i = 0n = 0 שורה = 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 = שקר

first_data = נכון

כעת אנו זקוקים לפונקציה כדי ליצור שרת ולפתוח אותו לחיבורים נכנסים.

def startServer (): global i global first_data # לאתחל שרת שרת שקע שקע = socket.socket (socket. AF_INET, socket. SOCK_STREAM) serversocket.setsockopt (socket. SOL_SOCKET, socket. SO_REUSEADDR, 1) # כתובת IP של שרת ומארח יציאות = " 149.160.251.3 "יציאה = 12347 server_address = (מארח, יציאה) # פתח את השרת והקשב לחיבורים נכנסים הדפס ('הפעלת שרת ב- %s יציאת %s' %server_address) serversocket.bind (server_address) serversocket.listen (5) # המתן לחיבורים … בעוד נכון: הדפס ('ממתין לחיבור …') # קבל חיבור נכנס (clientsocket, כתובת) = serversocket.accept () # נסה לנתח נתונים שהתקבלו נסה: הדפס ('חיבור נוצר מ', כתובת) בעוד נכון: # קבל את הנתונים ושלח אותם לעיבוד נתונים = 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 if (i <51): calibData (accel_data) else: movingAcce l (accel_data [0]) processData (accel_data) first_data = שגוי לבסוף: # סגור את השקע כדי למנוע דליפת נתונים מיותרת clientsocket.close ()

כעת אנו דורשים את הפונקציות שיעבדו את כל הנתונים. הצעד הראשון שצריך לבצע, והפונקציה הראשונה הנקראת, היא כיול החיישן לצורכי החישוב.

def calibData (רשימה): z_calib גלובלי z_offset גלובלי mag_data גלובלי mag_calib_y mag_offset_y z_calib += float (רשימה [0]) mag_calib_y += float (רשימה [1]) אם (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)

לאחר מכן, אנו יוצרים קיזוז האצה נע. זה גורם לכך שהתוכנית מזהה כאשר מישהו מפסיק להזיז את האצבע מכיוון שכל ערכי ההאצה שנשלחים לשרת צריכים להיות זהים באותו זמן.

def movingAccel (num): global z_calib גלובלי z_diff גלובלי z_moving_offset גלובלי z_offset גלובלי data_list global n global keep_offset אם (n 0.2 או z_diff <-0.2): # תנועה זוהתה בתוך הנתונים, הפעל מחדש keep_offset = True n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = הפסקה אם לא keep_offset: # נייח בנתונים, הגדר z_offset חדש z_offset = z_moving_offset הדפסה ("new z_offset:") print (z_offset) n = 0 z_calib = 0 z_moving_offset = 0 z_diff = 0 data_list = keep_offset = שקר keep_offset = שקר

לאחר מכן, אנו מבצעים את עיקר המתמטיקה. זה כרוך בתרגום נתוני ההאצה לנתוני מיקום שיאפשרו לנו להגיד את הכיוון שהמשתמש מניע את אצבעו.

def processData (list): #[accel.z, mag.y] גלובלי z_offset גלובלי z_real גלובלי z_velo גלובלי z_pos גלובל first_data גלובלי mag_data

z_real = float (רשימה [0]) - z_offset

mag_y = list [1] mag_z = list [2] left = False right = False # אל תעבד תאוצה עד שוודאי שהאיץ אותו # מונע מרעש מכני לתרום למיקום אם (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])> 0.03): right = elif true (float (mag_data [1]) - float (mag_data [0]) <-0.03): left = True if (מימין): תנועה (50, int (z_pos* 1000)) elif (משמאל): תנועה (-50, int (z_pos*1000)) z_velo = 0 z_pos = 0

עכשיו, סוף סוף, אנו מזיזים את הסמן! לשם כך פתחנו חלון צבע והפכנו אותו למסך מלא. ספריית pyautogui מכילה פונקציה הנקראת pyautogui.dragRel (x, y); שבו אנו משתמשים כדי לגרור את סמן העכבר מנקודה אחת לאחרת. הוא משתמש בנתוני מיקום יחסי כך שהתנועה היא יחסית למיקום האחרון של הסמן.

תנועת def (x, y): הדפס ("מעבר ל-", x, -y) pyautogui.dragRel (x, -y)

לבסוף, עלינו להתקשר לפונקציה הראשית כדי לאפשר לכל קוד זה לפעול.

# קורא לפונקציה כדי להתחיל את serverstartServer ()

מוּמלָץ: