Accel წერა (ჯადოსნური ხელი): 4 ნაბიჯი (სურათებით)

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:20

შესავალი

ჯადოსნური ხელი საშუალებას აძლევს შეზღუდული შესაძლებლობის მქონე პირებს და საავტომობილო უნარ -ჩვევების დარღვევას ისარგებლონ ხატვისა და წერის შემოქმედებითობით იმიტირებულ გარემოში. ჯადოსნური ხელი არის ტარებადი ხელთათმანი, რომელიც გრძნობს თქვენი საჩვენებელი თითის მოძრაობას და თარგმნის მას კომპიუტერის ეკრანზე ხაზების დახატვაში.

საჭირო მასალები

LSM9DOF გარღვევის დაფა --- 24,95 $ ---

ადაფრუტის ბუმბული Wifi--$ 18.95 ---

ქალი/ქალი მავთულები --- $ 1.95 ---

ფირზე/Velcro ზოლები --- $ 3

ორი თანაბარი სიძლიერის მაგნიტი --- ფასები განსხვავებულია

Როგორ მუშაობს

აქსელერომეტრის გამოყენებით, ჩვენ შეგვიძლია შევაგროვოთ y ღერძის დაჩქარების მონაცემები, რაც დაგვეხმარება განსაზღვროს როდის მოძრაობს მომხმარებლის თითი ზემოთ და ქვემოთ. გამომდინარე იქიდან, რომ ჩვენი ამაჩქარებელი გაზომავს აჩქარებას დედამიწის ცენტრთან მიმართებაში, ჩვენ არ შეგვიძლია განვსაზღვროთ x ღერძის აჩქარება (მარცხნივ ან მარჯვნივ). საბედნიეროდ, LSM9DOF გარღვევის დაფა ასევე შეიცავს მაგნიტომეტრს, რომელიც საშუალებას გვაძლევს შეაგროვოთ მონაცემები მაგნიტურ ველებზე. ჩვენ ვათავსებთ ორ მაგნიტს 30 სმ დაშორებით და ხელთათმანი გვაქვს შუაში. თუ მაგნიტური მონაცემები დადებითად იკითხება, მაშინ ჩვენ ვიცით, რომ ხელთათმანი მოძრაობს მარჯვნივ და პირიქით. მას შემდეგ, რაც ყველა მონაცემი გროვდება აქსელერომეტრში/მაგნიტომეტრში, იგი მონაცემებს აგზავნის მავთულის მეშვეობით ბუმბულთან, რომელიც დაკავშირებულია wifi კომპიუტერთან და შემდეგ აგზავნის მონაცემებს კომპიუტერში, რომელიც ჩვენ შეგვიძლია გამოვიყენოთ ჩვენს კოდში.

ნაბიჯი 1: ფიზიკური პროტოტიპი 1

ეს პროტოტიპი იგულისხმება, რომ ხელთათმანები ერთმანეთზე ხელით იყოს შეკერილი, რათა ის ელექტრონულ მოწყობილობებზე გადაიჩეხო. შემდეგ ელექტრონული მოწყობილობა მიმაგრებული იქნება velcro- ს ქვეშ ჯავშნის ყდის ბაზაზე, ხელის ძირითად ხელთათმანთან ერთად. შემდეგ მწვანე ხელთათმანი გადაისვრის ბაზას და ელექტრონულ მოწყობილობებს….

ხელთათმანების პროტოტიპის დამზადების ნაბიჯები:

• მიიღეთ ქსოვილის ორი ნაჭერი იმდენად დიდი, რომ ხელი გამოავლინოთ
• მიაკარით ხელი ქსოვილის ორივე ნაჭერს და გაჭერით ისინი
• მოათავსეთ ორი ხელით გათიშული ნაწილი ისე, რომ ისინი იდეალურად იყოს განლაგებული
• შემდეგი, სამკერვალო მანქანის მოსამზადებლად, გაუშვით ძაფი მანქანაზე მითითებულ ლაქებზე
• როდესაც სამკერვალო მანქანა შეიქმნება, ასწიეთ ნემსი და მოათავსეთ ქსოვილის ორი ნაჭერი ნემსის ქვეშ
• დარწმუნდით, რომ ნემსი გაფორმებულია ქსოვილის კიდეზე, ჩართეთ მანქანა და შეკერეთ ქსოვილის კიდეებზე, ხოლო ორი ცალი დაუტოვეთ მაჯაზე ისე, რომ ხელი მოთავსდეს.

ნაბიჯი 2: ფიზიკური პროტოტიპი 2

ჩვენი საბოლოო პროტოტიპი არის ჩვეულებრივი ხელთათმანი Velcro სამაჯურთან ერთად, რომელიც მორგებულია ნებისმიერ მაჯაზე. ხელთათმანი და სამაჯური ერთმანეთზეა შეკერილი, ხოლო ელექტრონული მოწყობილობები მიმაგრებულია ხელთათმანზე Velcro– ს საშუალებით.

ხელთათმანების მე -2 პროტოტიპის დამზადების ნაბიჯები:

1. შეიძინეთ ხელთათმანი, ხელთათმანის მასალას არ აქვს მნიშვნელობა.
2. შეიძინეთ Velcro მაჯის სამაჯური
3. შეიძინეთ პორტატული ბატარეა
4. შეიძინეთ წებოვანი Velcro
5. სამკერვალო ნემსით, მიამაგრეთ velcro მაჯის სამაჯური ხელთათმანის ძირზე
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…

შესავალი:

აქსელერომეტრიდან მონაცემების დამუშავების მიზნით, უნდა დამყარდეს ურთიერთობა კლიენტს/სერვერს ადაფრუტის ბუმბულსა და სერვერს შორის, რომელიც ამუშავებს მონაცემებს (მუშაობს ლეპტოპზე/სამუშაო მაგიდაზე). ორი კოდის ფაილის შექმნაა საჭირო: ერთი კლიენტისთვის (ადაფრუტის ბუმბული), ხოლო მეორე სერვერისთვის (ამ შემთხვევაში, ჯაროდის ლეპტოპი). კლიენტი დაწერილია C ++ - ით, ხოლო სერვერი - პითონში. კლიენტისთვის გამოყენებული ენა მნიშვნელოვანია, რადგან არდუინო ძირითადად C ++ ენაა და მისი შეცვლა სხვა ენის გამოყენებით რთულია. სერვერი შეიძლება დაიწეროს ნებისმიერ ენაზე, რამდენადაც მას აქვს ქსელის ფუნქციები.

კლიენტის დაყენება:

პირველი, ჩვენ დავაყენებთ კლიენტის კოდს. WiFi კავშირის კოდის უმეტესობა ადვილად ხელმისაწვდომია ადაფრუტის ბიბლიოთეკების საშუალებით. ჩვენ ვიწყებთ შესაბამისი კლასების ჩართვით.

#ჩართეთ #ჩართეთ #ჩართეთ #ჩართეთ #ჩართეთ

დააყენეთ რამდენიმე ცვლადი, რაც გამოყენებული იქნება მთელ კოდში.

// ქსელთან დაკავშირება const char* ssid = "MMS სერვერი"; const char* პაროლი = "MMS სერვერი-პაროლი"; // სერვერის IP და პორტი, რომელიც მიიღებს მონაცემებს const char* host = "149.160.251.3"; const int პორტი = 12347; bool დაკავშირებული = ყალბი;

// მოძრაობის დეტექტორის ინიციალიზაცია

Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0 (1000);

WiFiClient კლიენტი;

შექმენით setup () ფუნქცია, რომელიც გაშვებული იქნება ბუმბულის დაწყებისთანავე.

// WiFi კავშირის დაყენება და დაკავშირება servervoid setup () {Serial.begin (9600); დაგვიანება (100);

Serial.println ();

Serial.println (); Serial.print ("დაკავშირება"); Serial.println (ssid); // WiFi WiFi.begin– ის დაწყება (ssid, პაროლი); // დაკავშირება… while (WiFi.status ()! = WL_CONNECTED) {დაგვიანებით (500); Serial.print ("."); } // წარმატებით უკავშირდება WiFi Serial.println (""); Serial.println ("WiFi დაკავშირებულია"); Serial.println ("IP მისამართი:"); Serial.println (WiFi.localIP ());

#ifndef ESP8266

ხოლო (! სერიული); #ენდიფი 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 ("კავშირი ვერ მოხერხდა"); დაკავშირებული = ყალბი; დაბრუნების; } else {დაკავშირებული = ჭეშმარიტი; }

// დააყენეთ სენსორის მომატება და ინტეგრაციის დრო

configureSensor (); }

შემდეგ ჩვენ გვჭირდება მარყუჟის ფუნქცია, რომელიც განმეორებით მარყუჟდება. ამ შემთხვევაში, იგი გამოიყენება არაერთხელ გაგზავნის მონაცემებს ამაჩქარებელიდან სერვერზე "[z_accel]: [y_mag]: [z_mag]". კლიენტი. ბეჭდვა (რიცხვები); ფუნქცია არის ის, რაც აგზავნის მონაცემებს სერვერზე.

void loop () {დაგვიანებით (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 {installConnection (); }}

ზოგიერთი სასარგებლო ფუნქციისთვის, ჩვენ გვჭირდება ერთი, რათა დავამყაროთ კავშირი ბუმბულსა და სერვერს შორის.

void installConnection () {if (! client.connect (მასპინძელი, პორტი)) {Serial.println ("კავშირი ვერ მოხერხდა"); დაკავშირებული = ყალბი; დაბრუნების; } else {დაკავშირებული = ჭეშმარიტი; }}

ჩვენ ასევე გვჭირდება სენსორის კონფიგურაცია და მივცეთ მას მნიშვნელობების დიაპაზონი, რომელსაც წაიკითხავს. მაგალითად, აჩქარებას აქვს 5 ვარიანტი დიაპაზონისთვის: 2 გ, 4 გ, 6 გ, 8 გ და 16 გ.

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 ხელახალი იმპორტი pyautogui

სოკეტი გამოიყენება ქსელში. re გამოიყენება regex, ან სიმებიანი მანიპულაციებისთვის. pyautogui არის პითონის ბიბლიოთეკა, რომელიც საშუალებას მისცემს ნახაზი მოხდეს (განხილული მოგვიანებით).

შემდეგი, ჩვენ უნდა განვსაზღვროთ რამდენიმე ცვლადი. ეს იქნება გლობალური ცვლადები, ამიტომ მათ წვდომა ექნება მრავალ ფუნქციაში. ისინი მოგვიანებით გამოყენებული იქნება კოდში.

i = 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 (): global i global first_data # ინიციალიზაცია სერვერზე socket serversocket = 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) # დაელოდეთ კავშირებს… სანამ მართალია: ბეჭდვა ('ელოდება კავშირს …') # მიიღეთ შემომავალი კავშირი (კლიენტის ჯიბე, მისამართი) = serversocket.accept () # შეეცადეთ გაანალიზოთ მიღებული მონაცემები try: print ('კავშირი დამყარებულია', მისამართი) სანამ მართალია: # მიიღეთ მონაცემები და გაგზავნეთ მონაცემების დასამუშავებლად = clientsocket.recv (25) accel_data = re.split ('[:]', str (მონაცემები)) 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) სხვა: მოძრავი Acce l (accel_data [0]) processData (accel_data) first_data = ყალბი საბოლოოდ: # დახურეთ სოკეტი, რომ არ მოხდეს მონაცემთა არასაჭირო გაჟონვა clientocket.close ()

ჩვენ ახლა გვჭირდება ფუნქციები, რომლებიც დაამუშავებს ყველა მონაცემს. პირველი ნაბიჯი, რომელიც გადადგმულია და პირველი ფუნქციაა, არის სენსორის დაკალიბრება გაანგარიშების მიზნით.

def calib მონაცემები (სია): გლობალური 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 moveAccel (num): global z_calib global z_diff global z_moving_offset global z_offset global data_list global global global z_diff = 0 data_list = შესვენება თუ არა keep_offset: # სტაციონარული მონაცემებში, დააყენეთ ახალი z_offset z_offset = z_moving_offset print ("ახალი 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 (სია): #[accel.z, mag.y] გლობალური z_offset გლობალური z_real გლობალური z_velo გლობალური z_pos გლობალური first_data გლობალური mag_data

z_real = float (სია [0]) - z_offset

mag_y = სია [1] mag_z = სია [2] მარცხენა = ცრუ მარჯვნივ = ყალბი # ნუ ამუშავებთ აჩქარებას მანამ, სანამ აბსოლუტურად არ დაჩქარდება # აფერხებს მექანიკური ხმაურის პოზიციის წვლილს, თუ (z_real -0.20): z_real = 0 # დასაწყისი ინტეგრაცია პოზიციის საპოვნელად თუ (პირველი_დანაწერი): 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.move გადაადგილება (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): მარჯვნივ = ჭეშმარიტი elif (float (mag_data [1]) - float (mag_data [0]) <-0.03): left = ჭეშმარიტი თუ (მარჯვნივ): მოძრაობა (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- ის დასაწყებად ()