მართეთ სტეპერიანი ძრავა AVR მიკროპროცესორით: 8 ნაბიჯი

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

გაქვთ ზოგიერთი scavenged სტეპერი ძრავები საწყისი პრინტერები/დისკზე/etc ცრუობს გარშემო?

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

ნაბიჯი 1: გაიცანით სტეპერები

ძირითადად, თქვენ უნდა გაარკვიოთ, სად მიდის ყველა პატარა მავთული.

პირველი ნაბიჯი არის იმის გარკვევა, არის თუ არა ეს ერთპოლარული ან ბიპოლარული ძრავა. შეხედეთ ჯონსს სტეპერსზე უფრო ღრმა ფონისთვის, შემდეგ იან ჰარის საიტს უცნობი ძრავის გასარკვევად მარტივი მეთოდისთვის. ცოტა წაიკითხეთ, შემდეგ შემომიერთდით ამ ძრავის საფეხურზე, რომელიც იაფად შევიძინე. (ისინი ახლა იყიდება 0,99 დოლარად. ისინი პატარაა, შედარებით მსუბუქი, მაგრამ არ აქვთ დიდი ბრუნვის მომენტი. ჯერ არ ვიცი რა იქნება კარგი.)

ნაბიჯი 2: იპოვნეთ საერთო საფუძველი

ასე რომ თქვენ გაქვთ ხუთი (ან ოთხი, ან ექვსი) მავთული. თქვენს ძრავას ექნება ორი ნახევარი, და თქვენ ალბათ გეცოდინებათ მხოლოდ იმის მიხედვით, თუ რომელ მხარეს ეკუთვნის თითოეული მავთული.

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

ნაბიჯი 3: გამოთვალეთ საფეხურების რიგი

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

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

ნაბიჯი 4: საავტომობილო ტესტის გადაყვანა

თუ თქვენ ჯერ კიდევ არ ხართ გადატვირთული მიკროპროცესორული პროგრამირებისთვის, შეგიძლიათ უარესი გააკეთოთ, ვიდრე Ghetto Development Kit ან რომელიმე სხვა PIC პროგრამისტი. მიამაგრეთ მავთულები პირდაპირ თქვენს მიკროპროკში და დაწვით იგი შემდეგი კოდით:

/* თამაში პატარა სტეპერიანი ძრავების მართვით. */

/ * ჩართეთ შეფერხების ფუნქცია */ #განსაზღვრეთ F_CPU 1000000UL #მოიცავს/ * Pin defs for ATTiny2313 *// * საათის ისრის მიმართულებით */ #definine BLUE _BV (PB0) #define BLACK _BV (PB1) #define RED _BV (PB2) #define YELLOW _BV (PB3) #განსაზღვრეთ DELAY 200 / * მილიწამები ნაბიჯებს შორის * / int მთავარი (ბათილია) {DDRB = 0xff; / * ჩართეთ გამომავალი ყველა B ქინძისთავზე */ PORTB = 0x00; / * დააყენეთ ყველა 0v */ ხოლო (1) {/ * მთავარი მარყუჟი აქ */ PORTB = BLUE; _ დაგვიანებით_ms (DELAY); PORTB = შავი; _ დაგვიანებით_ms (DELAY); PORTB = წითელი; _ დაგვიანებით_ms (DELAY); პორტი = ყვითელი; _ დაგვიანებით_ms (DELAY); }} რამდენად მარტივია ეს კოდი? მართლაც მარტივი. ყველაფერი რაც მას აკეთებს არის ლამაზი განმარტებების გაკეთება, ასე რომ მე შემიძლია მავთულხლართებს მივუთითო ფერით და არა მათი სახელებით და შემდეგ გადართოს ისინი თანმიმდევრობით, მათ შორის რეგულირებადი შეფერხებით. დასაწყისისთვის, მე შევარჩიე ნაბიჯებს შორის ნახევარი წამიანი დაყოვნება. იხილეთ მოკლე ვიდეო შედეგებისთვის. თუ თქვენ ნამდვილად თამაშობთ, დაითვალეთ ნაბიჯების რაოდენობა თითო ციკლზე, რომ გაარკვიოთ ძრავის ერთი საფეხურიანი კუთხის გარჩევადობა. (ოჰ ჰო. PS. მართავს 3.6 ვ -ზე დატვირთვის გარეშე მარტივად. იხილეთ ბატარეა ვიდეოში.)

ნაბიჯი 5: გადაატრიალეთ უკან და წინ

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

int main (void) {const uint8_t დაგვიანებით = 50; const uint8_t საათის ისრის მიმართულებით = {ცისფერი, შავი, წითელი, ყვითელი}; uint8_t მე; DDRB = 0xff; / * ჩართეთ გამომავალი ყველა B ქინძისთავზე */ PORTB = 0x00; / * დააყენეთ ყველა 0v */ სანამ (1) {/ * მთავარი მარყუჟი აქ */ for (i = 0; i <= 3; i ++) {/ * გადააბიჯეთ ფერებში საათის ისრის მიმართულებით */ PORTB = საათის ისრის ისრის მიმართულებით ; _ დაგვიანებით_ms (დაგვიანება); } for (i = 3; i> = 0; i-) { / * ფერები ccw * / PORTB = საათის ისრის მიმართულებით ; _ დაგვიანებით_ms (დაგვიანება); }}} იხილეთ არაჩვეულებრივი ვიდეო უკან და გამაგრებისთვის.

ნაბიჯი 6: მე არასოდეს ვდგამ ნახევარ ნაბიჯს, იმიტომ რომ მე არ ვარ ნახევარ ნაბიჯზე…

მოუსმინეთ ლირიკას, თქვენი ძრავის ნახევარი ნაბიჯით არის იქ, სადაც არის. თქვენ მიიღებთ უფრო პიკურ დენს, უფრო მომენტალურ ბრუნვას და ორჯერ კუთხოვან გარჩევადობას. ნახევრად ნაბიჯ-ნაბიჯ: ლურჯი, შავი, წითელი, ყვითელი ნაცვლად, თქვენ მართავთ ძრავას ლურჯი, ლურჯი+შავი, შავი, შავი+წითელი, წითელი, წითელი+ყვითელი, ყვითელი, ყვითელი+ლურჯი. შედეგი ის არის, რომ ნახევარი დრო თქვენ ერთდროულად ჩართავთ ორივე მაგნიტს. და იმ დროს, როდესაც ორივე კომპლექტი ჩართულია, საავტომობილო მოძრაობა ორს შორის შუაშია, ამცირებს კუთხეს "ნაბიჯებს" შორის და ძრავას უფრო შეუფერხებლად ბრუნავს. შეგიძლია ამიხსნა ვიდეოდან? დარწმუნებული არ ვარ … ახლა კოდის ნაწილი, რომელიც აკეთებს ნახევარ ნაბიჯს, ასე გამოიყურება:

ბათილად ნახევარი ნაბიჯი (uint16_t შეფერხება, uint8_t მიმართულება ) {uint8_t i; for (i = 0; i <= 3; i ++) {PORTB = მიმართულება ; / * ერთი გრაგნილი ნაწილი */ _ დაგვიანებით_ms (დაგვიანებით); პორტი | = მიმართულება [i+1]; / * დაამატეთ ნახევარ ნაბიჯში */ _delay_ms (დაგვიანებით); }} პირველი PORTB ბრძანება ადგენს ერთ პოლუსს დადებითს და ყველა დანარჩენს უარყოფითს. შემდეგ ის ელოდება. შემდეგ მეორე PORTB ბრძანება ადგენს მეორე ბოძს (მეორე გრაგნილზე) დადებითზე, ორივე გრაგნილის ჩართვას 1.4x ბრუნვის მომენტზე (და 2x დენზე). ქვემოთ მოცემულია პროგრამის სრული ჩამონათვალი. ორი მასივი არის განსაზღვრული (საათის ისრის მიმართულებით, საათის ისრის ისრის საწინააღმდეგოდ) და ორივეს აქვს 5 ელემენტი, რაც i+1 შესვლის საშუალებას აძლევს halfStepping ფუნქციას.

ნაბიჯი 7: დაამატეთ საავტომობილო დრაივერი

ჯერჯერობით კარგად.

ერთადერთი პრობლემა ისაა, რომ ძრავას არ გააჩნია იმდენი ბრუნვის მომენტი, რაც შეიძლება გამოწვეული იყოს იმით, რომ მიკროპროცესორი მხოლოდ პინზე გამოიტანს m 50mA. აშკარა მომდევნო ნაბიჯი იქნება ძრავის მძღოლთან მიერთება, რათა მას მეტი წვენი მიაწოდოს. მაგრამ შემდეგ ცოტა ვიფიქრე: მე ვმოძრაობ მას მხოლოდ 5 ვ-ით, ხოლო გრაგნილი-გრაგნილი წინააღმდეგობა ~ 125 ოჰ. რაც იმას ნიშნავს, რომ ძრავა მხოლოდ 40mA ხატავს პინზე და ის კარგად უნდა იყოს მართული (ძროხის!) AVR ჩიპით. ასე რომ, ძრავის მეტი ძაბვის მისაღებად, მე მას SN754410 H- ხიდის ჩიპთან მივედი. წრე საკმაოდ მარტივია. AVR– დან თითოეული პინი მიდის შეყვანისკენ და შესაბამისი გამომავალი ქინძისთავები მიდის ძრავზე. ჩიპს სჭირდება 5 ვ ლოგიკური განყოფილებისთვის და შეუძლია გაცილებით მეტი ძაბვა მიიღოს ძრავის განყოფილებაში. მისი გაშვება 11.25 ვ (სამი 3.6 ვ ბატარეა) ცოტათი დაეხმარა. შესამჩნევად მეტი ბრუნვის მომენტი ჩემს თითზე, მაგრამ ის მაინც არ არის ძლევამოსილი. ცუდი არ არის ძრავისთვის, რომელიც უფრო მცირეა ვიდრე ნიკელი. ახლა კი წრე გახდა ზოგადი დანიშნულების ბიპოლარული სტეპერიანი ძრავის მძღოლი. დაემატა 29 ნოემბერს: დაძრა ძრავა წუხელ 12 ვ -ზე ცოტა ხნით და დაიწყო ცხელება. მე არ ვარ დარწმუნებული, იყო თუ არა ეს რეზონანსული სიხშირის პრობლემა, თუ ის უბრალოდ ზედმეტად მიმდინარე იყო გრაგნილებისთვის. ნებისმიერ შემთხვევაში, ფრთხილად იყავით, თუ ამ პატარა ძრავას უფრო დიდი ძაბვით მართავთ.

ნაბიჯი 8: დასასრული

მაშ რა ვისწავლე? სტეპერიანი ძრავის მართვა AVR (და H- ხიდიანი ჩიპი) საკმაოდ ადვილია, თუნდაც "ლამაზი" ნახევრად ნაბიჯების რეჟიმში.

თუმცა ჯერ არ ვიცი რას გავაკეთებ პატარა სტეპერმოტორებთან. Რაიმე რჩევა?