Digilog_Bike POV ჩვენება: 14 ნაბიჯი

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

დიგილოგი

ციფრული + ანალოგი

ციფრული ხვდება ანალოგს

POV

ვიზუალური გამძლეობა

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

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

ნაბიჯი 1: იდეის კონცეფცია

POV ხორციელდება ველოსიპედის ბორბალზე LED სამაჯურის მიმაგრებით.

ნაბიჯი 2: მასალების სია

გამოთვლა და I/O

1. Arduino Mega 2560 [arduino] x3

2. ჰოლის სენსორის მოდული V2 [YwRobot] x3

3. WS2812-5050 მოქნილი ნეოპიქსელი [ადაფრუტი] x3

4. მაგნიტური (დიამეტრი 15 მმ, სისქე 50 მმ) x3

5. Arduino Mega Case x3

ელექტროგადამცემი ხაზი

5. 5000mAh/3.7V ლითიუმის ბატარეა [TheHan] x3

6. AVR 5V მარეგულირებელი და დატენვა და PCM მოდული: JBATT-U5-LC [Jcnet] x3

7. 4 ჯუმბერის მავთულის ნაკრები 65PCS/SET [OR0012] x3

ნაბიჯი 3: ინსტრუმენტები

არც ისე ბევრი ინსტრუმენტია საჭირო, მაგრამ დაგჭირდებათ:

1. შედუღების მანქანა

2. შედუღების რკინა

3. წებო იარაღი

4. ნიპერი

ნაბიჯი 4: ჩარჩოს შექმნა

ველოსიპედის მოჭრა და ბაზის მიმაგრება

საფქვავი გამოიყენებოდა ველოსიპედის ბორბლებიდან, ხოლო შედუღებული ფოლადის ფირფიტები ბორბლების უზრუნველსაყოფად.

ნაბიჯი 5: საბოლოო სურათებისა და კონცეფციების შედგენა

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

ნაბიჯი 6: გააკეთეთ მოძრავი სურათის მოჭრა

გამოსახულება გაყავით სამ ნაწილად, რომელიც მოთავსდება თითოეულ ველოსიპედზე და გაყავით ჯამში 12 სურათი ფერისა და მოძრაობის მიხედვით.

ნაბიჯი 7: პროგრამული უზრუნველყოფის მომზადება

ქვე ნაწილი 1. დააინსტალირეთ Arduino

Arduino ჩამოტვირთვა:

(დააინსტალირეთ თქვენი OS ვერსიისა და სისტემის შესატყვისად.)

-

ქვე ნაწილი 2. დააინსტალირეთ ბიბლიოთეკა

*(თუ გსურთ Github– ის საშუალებით დაინსტალირება, გთხოვთ ეწვიოთ Github Arduino ბიბლიოთეკის ზემოთ მოცემულ ბმულს:

1. გაუშვით Arduino პროგრამა

2. ბმულის დაშვება ზედა მენიუ - ესკიზი - მოიცავს ბიბლიოთეკას - დაამატეთ. Zip ბიბლიოთეკა

3. თქვენ უნდა აირჩიოთ. Zip ფაილი, რომელიც უკვე დაინსტალირებულია github library4

*(თუ გსურთ გამოიყენოთ Arduino პროგრამის სერვისები)

1. გაუშვით Arduino პროგრამები

2. ბმულის დაშვება ზედა მენიუ - ესკიზი - მოიცავს ბიბლიოთეკას - მენეჯმენტის ბიბლიოთეკას - ეძებს "Adafruit neopixel" - შეგიძლიათ ნახოთ "Adafruit Neopixel by Adafruit"

3. დააინსტალირეთ და განაახლეთ ბიბლიოთეკა

-

ქვე ნაწილი 3. დააინსტალირეთ კონვერტორი პროგრამა

1. დააინსტალირეთ როტაციის წრის პროგრამა (R. C. P):

2. თქვენ უნდა წაიკითხოთ README ფაილი

ნაბიჯი 8: აპარატურის ელექტრომომარაგების დამზადება

*ასე ხდება Arduino 5V ძაბვის მიწოდება ბატარეის საშუალებით. გთხოვთ მიყევით ქვემოთ მოცემულ ნაბიჯებს.

1. შეაერთეთ ლითიუმის ბატარეა და JBATT დატენვის მოდული. (ცნობისთვის, JBATT მოდულს აქვს ჩაშენებული დენის გადამრთველი.)

2. შეაერთეთ JBATT– ის გამომავალი ტერმინალი Arduino– ს Vin ტერმინალთან და Ground ტერმინალთან.

3. შეაერთეთ Micro 5pin USB პორტი დატენვის პორტთან, რათა შეამოწმოთ პროდუქტი მუშაობს თუ არა სწორად.

4. შემდეგი, ჩართეთ ჩაშენებული გადამრთველი ON.

5. თუ წითელი led ანათებს და მწვანე led ანათებს Arduino– ში, პროდუქტის სიმძლავრის ეტაპის კონფიგურაცია ნორმალურად სრულდება.

ნაბიჯი 9: აპარატურის I/O დამზადება და შემოწმება OUTPUT (NeoPixel მუშაობს)

*ეს ნაწილი შედგება სენსორისა და გამომავალი ეტაპისგან

1. შეაერთეთ Arduino და Hall სენსორები. მონაცემთა პინი უკავშირდება Arduino პინ 2 -ს.

2. როდესაც არდუინო იკვებება და მაგნიტი მჭიდრო კონტაქტშია ჰოლის სენსორთან, წითელი ლედ ანათებს.

3. შეაერთეთ არდუინო და ნეოპიქსელი. გამოიყენება მხოლოდ 30 ნეოპიქსელი.

4. დააკავშირეთ მონაცემთა პინი Arduino პინ 6 -თან.

5. შეაერთეთ Arduino და გადმოწერეთ კაბელი თქვენი კომპიუტერის USB პორტში და გაუშვით Arduino თქვენს კომპიუტერზე.

6. არდუინოს პროგრამის ზედა მენიუდან შეარჩიეთ Tool - board - “Arduino / Genuino Mega or Mega 2560”.

7. შეამოწმეთ არის თუ არა პროდუქტების ჩამონათვალი, რომელთა პირდაპირ დაკავშირება შესაძლებელია პორტთან. თუ ის არ არის შემოწმებული, დააწკაპუნეთ მის ასარჩევად.

8. ჩასვით კოდი ქვემოთ და დააწკაპუნეთ ატვირთვაზე მარცხნივ. (ამის შემდეგ, პროგრამის ყველა ატვირთვა მიჰყვება ნაბიჯებს 5-8.)

9. კონფიგურაცია დასრულებულია, როდესაც ჩართულია 30 ნეოლირებული პიქსელი.

#1 სათაურის ფაილის და წინასწარი დამუშავების ჩათვლით

პირველ რიგში ჩვენ უნდა მივიტანოთ ბიბლიოთეკა Adafruit_NeoPixel, რომელსაც შეუძლია ნეოპიქსელების მოქმედება.

ბიბლიოთეკა შეიძლება გამოყენებულ იქნას ობიექტების გამოცხადებით.

Adafruit_NeoPixel კლასს შეუძლია საჯაროდ შეიყვანოს 3 პარამეტრი.

პირველი პარამეტრი არის LED- ების რაოდენობა.

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

მესამე პარამეტრი არის პარამეტრების შეყვანა პროდუქტის მახასიათებლების შესაბამისად. სამი ფერის WS2812b პროდუქტი იყენებს 'NEO_GRB' შეყვანას

#ჩართეთ

#განსაზღვრეთ PIN 6 Adafruit_NeoPixel ზოლები = Adafruit_Neopixel (30, PIN, NEO_GRB+NEO_KHZ800);

#2 აწყობა

დაყენების ნაწილში ინიციალიზაცია გაუკეთეთ ობიექტს და მოამზადეთ გამოსაყენებლად.

'Adafruit_Neopixle_Object.begin ()' ადგენს ყველა LED- ის გამორთვას.

'Adafruit_Neopixle_Object.show ()' გამოდის LED- ში მითითებული სიკაშკატით.

void setup () {

ზოლები. დაწყება (); ზოლები. ჩვენება (); }

#3 მთავარი მარყუჟი

ძირითადი მარყუჟის მოქმედება იყენებს for მარყუჟს, რომ LED- ები თანმიმდევრულად გამოვიდეს (0.1 წამი) თეთრად

ბათილი მარყუჟი () {

for (uint16_t i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, 255, 255, 255); ზოლები. ჩვენება (); დაგვიანება (100); }}

ნაბიჯი 10: შეკრება და მიმაგრება ბორბალზე

1. შეაერთეთ ნეოპიქსელები. (ყურადღება მიაქციეთ პინის ნომრის შემოწმებას)

2. შეაერთეთ დარბაზის სენსორი. (იხილეთ ნაბიჯი 9)

3. მიამაგრეთ ჩარჩო არდუინოს ველოსიპედებს შორის. (მიამაგრეთ არდუინოს ქეისი ველოსიპედის ჩარჩოს პარალელურად).

4. ჩადეთ არდოინო, რომელიც დაკავშირებულია ნეოპიქსელთან. (ფრთხილად იყავით, რადგან წებოს იარაღი ცხელია).

5. ჩადეთ დაკავშირებული ჰოლის სენსორი არდუინოში, (მიამაგრეთ საკაბელო ჰალსტუხი ისე, რომ დარბაზის სენსორი არ ჩამოვარდეს).

6. შედუღება ბატარეის დასაკავშირებლად. (ფრთხილად იყავით შედუღების დროს).

7. შეასწორეთ იგი წებოს იარაღით. (მიამაგრეთ დატენვის მოდული ბატარეაზე სივრცის უზრუნველსაყოფად).

8. ჩართეთ თითოეული ხაზი არდუინოსთან დაკავშირებამდე, 9. შეაერთეთ თითოეული პინის ნომრის მიხედვით. (შეაერთეთ გადასასვლელი ხაზები დატენვის მოდულისთვის მათი დაბნევის გარეშე).

10. დაასრულეთ წებოს იარაღით ერთხელ, (გთხოვთ ფრთხილად იყოთ რომ არ დაეცეს).

ნაბიჯი 11: შემოწმება INPUT (HALL სენსორის მონაცემები)

*შეამოწმეთ პროგრამული უზრუნველყოფის კოდი, რომ ნახოთ მუშაობს თუ არა სენსორი.

1. ჩასვით და ატვირთეთ კოდი ქვემოთ.

2. დააწკაპუნეთ სერიული მონიტორის ღილაკზე Arduino– ს ზედა მარჯვენა კუთხეში.

3. როდესაც მაგნიტი ჰოლის სენსორთან კონტაქტშია 1 წამზე მეტხანს, კონფიგურაცია სრულდება, როდესაც სერიულ მონიტორზე გამოჩნდება სიტყვა „კონტაქტური მაგნიტური“.

------------------------------------------------------ ------------------------------------------------------ ------------------------------------------------------ #1 განსაზღვრეთ პინის ნომერი და დააყენეთ

პირველი კონფიგურაციის პინ ნომერი, რომელიც გამოიყენებს ჰოლის სენსორს და დააყენებს პინის ნომერს, როგორც მხოლოდ შეყვანის პორტს.

დააყენეთ კომუნიკაცია, რათა შეამოწმოთ Hall სენსორის მონაცემები სერიულ მონიტორზე.

#განსაზღვრეთ დარბაზი 2

void setup () {pinMode (HALL, INPUT); სერიული.დაწყება (9600); }

#2 მთავარი მარყუჟი

შეამოწმეთ ჰოლის სენსორის მონაცემები 0.1 წამის ინტერვალით.

თუ მაგნიტი იგრძნობა და მონაცემები შეიცვლება, "კონტაქტური მაგნიტური" გამოდის სერიულ მონიტორზე.

ბათილი მარყუჟი () {

if (digitalRead (HALL)) {Serial.println ("კონტაქტური მაგნიტური"); } დაყოვნება (100); }

ნაბიჯი 12: კოდირების ალგორითმი

*შექმენით ლოგიკა და კოდირება სენსორის მნიშვნელობებზე დაყრდნობით ნეოპიქსელების გასაკონტროლებლად.

1. ჩასვით და ატვირთეთ კოდი ქვემოთ.

2. ნორმალურია, რომ გამოსახულება სწორად არ იყოს ნაჩვენები, რადგან ჩარჩო არ არის წარმოებული. მაგრამ თქვენ ხედავთ, რომ ის უხეშად მუშაობს.

3. სწრაფად შეეხეთ და გაუშვით ჰოლის სენსორი და მაგნიტი 1 წამში. გაიმეორეთ ეს ოპერაცია დაახლოებით 10 -ჯერ.

4. კონფიგურაცია სრულდება, როდესაც ნეოპიქსელების ფერები რეგულარულად იცვლება.

#1 სათაურის ფაილების ჩათვლით და წინასწარი დამუშავება

პირველ რიგში, ჩვენ უნდა გვესმოდეს, რომ არდუინო მეგას მეხსიერება არ არის საკმარისად დიდი, რომ შეინახოს გამოსახულების ფაილი.

ამიტომ, 'avr/pgmspace' სათაურის ფაილი გამოიყენება სხვადასხვა მეხსიერების სივრცის გამოსაყენებლად.

ნეოპიქსელების გამოსაყენებლად თქვენ აცხადებთ ობიექტს და კონფიგურაციას I/O პინ ნომერს.

სურათის მასივი ძალიან დიდია კოდირებისთვის, ამიტომ გადმოწერეთ და ჩასვით თანდართული ფაილები.

#ჩართეთ

#მოიცავს #განსაზღვრა PIN 6 #განსაზღვრეთ NUMPIXELS 30 #განსაზღვრეთ HALL 2 Adafruit_NeoPixel ზოლები = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_RGB + NEO_KHZ800); // ჩასვით მასივი 'image_array_1.txt' // "'image_array_2.txt' //" 'image_array_3.txt' // "'image_array_4.txt'

#2 გლობალური ცვლადი და კონფიგურაცია

დააყენეთ გლობალური ცვლადი.

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

int რაოდენობა = 0;

ორმაგი v = 0; ორმაგი last_v = 0; ორმაგი ქრონომეტრი = მიკრო (); ორმაგი ex_timer = მიკრო (); ორმაგი last_timer = მიკრო (); int deg = 36; int pix = 35; int rgb = 3; ორმაგი q_arr [2] = {0, 0}; int HALL_COUNT = 0; ორმაგი VELO; ორმაგი დამუშავების_ტაიმერი = მიკრო (); void setup () {strip.setBrightness (255); ზოლები. დაწყება (); ზოლები. ჩვენება (); Serial.begin (230400); }

#3 მთავარი მარყუჟი - გამოსახულების გამოხატვის გამომავალი ნაწილი

ეს კოდი არის პირობითი განცხადება იმის შესახებ, თუ როგორ გამოვა დრო, როდესაც ბორბალი ტრიალებს რეზოლუციით.

ეს ნაწილი იყენებს ველოსიპედის ბორბლის ერთხელ გადაბრუნების ციკლს, როგორც ძალიან მნიშვნელოვან პარამეტრს.

ასევე, მნიშვნელოვანია მეხსიერების სურათის მასივის მონაცემების წაკითხვა.

ბათილი მარყუჟი () {

თუ ((დათვლა (ექს_ტაიმერი / 120.0) - (მიკრო () - დამუშავების დრო))) {ქრონომეტრი = მიკრო (); if (VELO> 360000) {for (int i = 0+5; i <pix; i ++) {strip.setPixelColor (i - 5, strip. Color (pgm_read_byte (& (image_1 [დათვლა] [1])), pgm_read_byte (& (image_1 [რაოდენობა] [2])), pgm_read_byte (& (image_1 [რაოდენობა] [0])))); } strip.show (); } else if (VELO 264000) {for (int i = 0+5; i <pix; i ++) {strip.setPixelColor (i - 5, strip. Color (pgm_read_byte (& (image_2 [რაოდენობა] [1])), pgm_read_byte (& (image_2 [count] [2])), pgm_read_byte (& (image_2 [count] [0])))); } strip.show (); } else if (VELO 204000) {for (int i = 0+5; i <pix; i ++) {strip.setPixelColor (i - 5, strip. Color (pgm_read_byte (& (image_3 [რაოდენობა] [1])), pgm_read_byte (& (image_3 [რაოდენობა] [2])), pgm_read_byte (& (image_3 [რაოდენობა] [0])))); } strip.show (); } else if (VELO <= 204000) {for (int i = 0 + 5; i = 120)) {for (int i = 0 + 5; i <pix; i ++) {strip.setPixelColor (i - 5, ზოლები.ფერი (0, 0, 0)); } strip.show (); }

#4 მთავარი მარყუჟი - დამუშავება და ციკლის დროის შემოწმება და შეგრძნება

ეს არის მთელი სისტემის ყველაზე მნიშვნელოვანი ნაწილი.

პირველი, შეამოწმეთ მთელი კოდის შესასრულებლად საჭირო დრო და დაარეგულირეთ LED გამომავალი დრო ციკლზე.

ბორბლის ბრუნვის დროს შეგრძნებული დრო პროგნოზირებს მომდევნო ციკლის დროს.

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

სისტემა ითვლის დამუშავების დროსა და აჩქარებას იმის გამოსათვლელად, რამდენ ხანს ჩართავს LED- ები განუწყვეტლივ.

დამუშავების_ტაიმერი = მიკრო ();

if ((digitalRead (HALL) == HIGH) && (HALL_COUNT == 1)) {VELO = v; v = micros () - last_timer; ex_timer = q_arr [0] - q_arr [1] + v; last_timer = მიკრო (); q_arr [0] = q_arr [1]; q_arr [1] = v; დათვლა = 0; HALL_COUNT = 0; } else if (digitalRead (HALL) == LOW) {HALL_COUNT = 1; }}

ნაბიჯი 13: პროგრამული უზრუნველყოფის გამოყენება

*გამოიყენეთ პროგრამული უზრუნველყოფა სურათის შესაცვლელად და პროცესის მონაცემების კოდში ჩასასმელად

1. ჩადეთ სურათი ზემოთ საფეხურიდან გამოსახულების საქაღალდეში მომზადების საფეხურზე დაყენებული R. C. P საქაღალდეში.

- როგორ უნდა დადოთ სურათი შემდეგია.- გადაარქვით პროდუქტის # 1 ანიმაციურ სურათს 1.png, 2.png, 3-p.webp

2. გაუშვით Ver.5.exe ფაილი.

3. დარწმუნდით, რომ 12 ფაილი pro_1_code_1.txt to pro_3_code_4.txt შექმნილია R. C. P საქაღალდეში.

4. თუ ის არ არის შექმნილი, შეცვალეთ config.txt შინაარსი, როგორც შემდეგი კონფიგურაციის ფაილი.

5. ფაილის შექმნის შემდეგ დააკოპირეთ მთელი შინაარსი ფაილიდან pro_1_code_1.txt და ჩასვით ქვემოთ მოცემულ კოდში ნაჩვენებ ნაწილში.

6. დაამატეთ pro_1_code_2.txt, pro_1_code_3.txt და pro_1_code_4.txt შინაარსი აღნიშნულ ნაწილს მე –5 რიგით.

7. მე -5 და მე -6 პუნქტების მითითებით, pro_2_code…, pro_3_code ავსებს კოდს ერთნაირად.

ნაბიჯი 14: დაასრულეთ

დასრულდა POV– ის წარმოება, რომელიც ქმნის ერთ სურათს სამი ბორბლით.