სტეპერ სიჩქარის კონტროლის მენიუ მართულია Arduino– სთვის: 6 ნაბიჯი

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

ეს SpeedStepper ბიბლიოთეკა არის AccelStepper ბიბლიოთეკის გადაწერა, რათა შესაძლებელი გახდეს სტეპერიანი ძრავის სიჩქარის კონტროლი. SpeedStepper ბიბლიოთეკა გაძლევთ საშუალებას შეცვალოთ მითითებული ძრავის სიჩქარე და შემდეგ აჩქაროთ/შეანელოთ ახალ დადგენილ სიჩქარეზე იგივე ალგორითმის გამოყენებით, როგორც AccelStepper ბიბლიოთეკა. SpeedStepper ბიბლიოთეკა ასევე გაძლევთ საშუალებას დააყენოთ პლუს და მინუს ლიმიტი და "სახლის" პოზიცია. არსებობს ბრძანება goHome, რომ დაუბრუნდეთ საწყის პოზიციას.

შეზღუდვები: SpeedStepper ბიბლიოთეკა მართავს მხოლოდ მიმართულებით და ნაბიჯების შედეგებს და ამიტომ უნდა იყოს დაკავშირებული ძრავის დრაივერთან, მაგალითად Easy Driver, რომ რეალურად მართოს სტეპერიანი ძრავა. AccelStepper ბიბლიოთეკა გთავაზობთ მართვის უფრო მეტ ვარიანტს, რომელიც საჭიროების შემთხვევაში შეიძლება კოპირდეს ამ ბიბლიოთეკაში.

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

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

ეს ბიბლიოთეკა მუშაობს Arduino Uno და Mega2560– ზე, მაგრამ პროტოტიპისთვის გამოყენებული იყო უფრო დიდი მეხსიერება / უფრო სწრაფი პროცესორი SparkFun Redboard Turbo.

ეს ინსტრუქცია ასევე შესაძლებელია ონლაინ რეჟიმში სტეპერ სიჩქარის კონტროლის ბიბლიოთეკაში Arduino– სთვის

მარაგები

მაგალითის ჩასატარებლად საჭიროა მხოლოდ Arduino UNO ან Mega2560 და პროგრამული ბიბლიოთეკები

ბიბლიოთეკის სკამის შესამოწმებლად SparkFun Redboard Turbo გამოიყენეს მარტივი დრაივერით, 200 საფეხურით/ბრუნვით, 12V 350mA სტეპერიანი ძრავით და 12 DC მიწოდებით 2A ან უფრო დიდი, მაგ. https://www.sparkfun.com/products/14934. USB A to Micro cableUSB to TTL Serial Cable Arduino IDE V1.8.9 and computer to run it.

ნაბიჯი 1: ბიბლიოთეკის ფუნქციები

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

სტეპერის პოზიციას თვალყურს ადევნებს ნაბიჯების (პულსის) რაოდენობის დათვლით. ბიბლიოთეკა ზღუდავს პოზიციას შორის იყოს setPlusLimit (int32_t) და setMinusLimit (int32_t) პოზიციებს შორის. პლიუს ლიმიტი არის ყოველთვის> = 0 და მინუს ლიმიტი ყოველთვის <= 0. გაშვებისას ძრავის პოზიცია არის 0 (მთავარი) და ლიმიტები დადგენილია ძალიან დიდი +/- რიცხვებისთვის (დაახლოებით +/- 1e9 ნაბიჯი). setAcceleration (float) ადგენს რამდენად სწრაფად ცვლის ძრავა სიჩქარეს მაღლა ან ქვევით. როდესაც ძრავა უახლოვდება პლიუს ან მინუს ლიმიტს, ის შენელდება ამ სიჩქარით, სანამ არ გაჩერდება ლიმიტზე. გაშვებისას აჩქარება არის 1.0 საფეხური/წმ/წმ. აჩქარების პარამეტრი ყოველთვის არის +ve რიცხვი. მითითებული setSpeed (float) პარამეტრი ადგენს ძრავის მოძრაობის მიმართულებას.

setSpeed (float) ადგენს ძრავის დაჩქარების / შენელების სიჩქარეს მისი ამჟამინდელი სიჩქარედან. სიჩქარე, რომლის დაყენებაც შესაძლებელია setSpeed (float) საშუალებით, შეზღუდულია აბსოლუტურ მნიშვნელობაში, პარამეტრებით, setMaxSpeed (float), ნაგულისხმევი 1000 ნაბიჯი/წმ და setMinSpeed (float), ნაგულისხმევი 0.003 საფეხური/წმ. ეს ნაგულისხმევები ასევე არის აბსოლუტურად მყარი კოდირებული სიჩქარის შეზღუდვები, რომელიც ბიბლიოთეკას მიიღებს setMaxSpeed () და setMinSpeed (). თუ გსურთ დააყენოთ მაქსიმალური სიჩქარე> 1000 ნაბიჯი/წმ, თქვენ უნდა შეცვალოთ პირველი ხაზი SpeedStepper.cpp ფაილში, რომ შეცვალოთ maxMaxSpeed (1000) თქვენთვის სასურველ მაქსიმალურ სიჩქარეზე. პრაქტიკაში მაქსიმალური სიჩქარე ასევე შეზღუდულია ბიბლიოთეკის გაშვების () მეთოდის ზარებს შორის დროით. 1000 ნაბიჯის / წამის განმავლობაში run () მეთოდი უნდა იყოს გამოძახებული მინიმუმ ყოველ 1mS. იხილეთ ლატენტურობის განყოფილება ქვემოთ.

მცდელობა დადგინდეს სიჩქარეზე ნაკლები სიჩქარე გამოიწვევს ძრავის გაჩერებას. თითოეულ მათგანს აქვს შესაბამისი მიმღები, იხილეთ SpeedStepper.h ფაილი. სიჩქარისთვის, getSetSpeed () აბრუნებს თქვენს მიერ დაყენებულ სიჩქარეს setSpeed () საშუალებით, ხოლო getSpeed () აბრუნებს ძრავის ამჟამინდელ სიჩქარეს, რომელიც იცვლება როგორც აჩქარებს/შენელდება თქვენ მიერ მითითებული სიჩქარე. თუ ძრავა არ მიდის იმ მიმართულებით, რომელზეც ფიქრობთ +ve შეგიძლიათ დარეკოთ invertDirectionLogic (), რომ შეცვალოს ის მიმართულება, რომელიც ძრავა მოძრაობს +ve სიჩქარით.

getCurrentPosition () აბრუნებს ძრავის ამჟამინდელ მდგომარეობას "სახლთან" შედარებით (0). თქვენ შეგიძლიათ გააუქმოთ ძრავის ამჟამინდელი პოზიციის setCurrentPosition (int32_t). ახალი პოზიცია შეზღუდულია იყოს მითითებული პლუს/მინუს ფარგლებში.

თავდაპირველად ძრავა ჩერდება 0. პოზიციაზე დარეკვა setpeed (50.0) გამოიწვევს აჩქარების დაწყებას +ve მიმართულებით მაქსიმალური სიჩქარით 50 ნაბიჯი/წთ. HardStop () - ით დარეკვა დაუყოვნებლივ გააჩერებს ძრავას იქ, სადაც არის. მეორეს მხრივ, გაჩერების () მეთოდის გამოძახება ადგენს სიჩქარეს ნულს და შეანელებს ძრავას გაჩერებამდე. StopAndSetHome () გამოძახებით დაუყოვნებლივ გააჩერებს ძრავას და დააყენებს მის პოზიციას 0. პლუს/მინუს ლიმიტების მნიშვნელობები არ იცვლება, მაგრამ ახლა მითითებულია ამ 0 (სახლის) ახალ პოზიციაზე. დარეკვა goHome () დააბრუნებს სტეპერს ამ 0 (სახლის) პოზიციაზე და გაჩერდება. SetSpeed () დარეკვა გააუქმებს სახლში წასვლას.

ბიბლიოთეკა SpeedStepper ასევე უზრუნველყოფს სიჩქარის პროფილის კონტროლს setProfile (SpeedProfileStruct* profileArray, size_t arrayLen), startProfile (), stopProfile (), გაშვებული პროფილის შეწყვეტისთვის და isProfileRunning (). იხილეთ speedStepperProfile მაგალითის ესკიზი.

ნაბიჯი 2: გაუშვით SpeedStepperPlot მაგალითი ძრავის გარეშე

დააინსტალირეთ Arduino IDE V1.8.9 ჩამოტვირთეთ და დააინსტალირეთ SpeedStepper ბიბლიოთეკა შეინახეთ SpeedStepper.zip და შემდეგ გამოიყენეთ Arduino IDE მენიუს პუნქტი Sketch → Include Library → ბიბლიოთეკის იმპორტისთვის დაამატეთ. ZIP ბიბლიოთეკა ჩამოტვირთეთ და დააინსტალირეთ millisDelay ბიბლიოთეკა ასევე

გახსენით მაგალითები → SpeedStepper → speedStepperPlot მაგალითის ესკიზი (საჭიროების შემთხვევაში გადატვირთეთ IDE). ეს ესკიზი კონფიგურირებულია სერიალთან მუშაობისთვის, მაგ. UNO და მეგა და ა.შ. SparkFun Redboard Turbo– ზე გასაშვებად იხილეთ ქვემოთ.

ამ მაგალითის გასაშვებად არ არის საჭირო მძღოლის დაფა ან სტეპერიანი ძრავა. ეს მაგალითები იყენებენ D6 და D7 როგორც შედეგებს. თქვენ შეგიძლიათ შეცვალოთ გამომავალი ქინძისთავები ნებისმიერ ციფრულ გამომავალზე ესკიზის ზედა ნაწილთან STEP_PIN და DIR_PIN პარამეტრების შეცვლით.

ატვირთეთ ესკიზი დაფაზე და შემდეგ გახსენით Tools → Serial Plotter 115200 baud, რათა ნახოთ სიჩქარის (RED) და პოზიციის (BLUE) ნაკვეთი. პლიუს ლიმიტი არის 360, რაც იწვევს სიჩქარის ნულამდე ნულამდე დაახლოებით 100 წერტილიდან x ღერძზე. მინუს ლიმიტი არის -510. პოზიცია ჩერდება 3 -390-ზე, რადგან სიჩქარე მოთხოვნილია 0.0-მდე. X ღერძის 380 წერტილში goHome cmd გაიცემა, რომელიც სტეპერს უბრუნებს ნულის პოზიციას.

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

ნაბიჯი 3: გაუშვით SpeedStepperProfile მაგალითი ძრავის გარეშე

გახსენით მაგალითები → SpeedStepper → speedStepperPlot მაგალითი ესკიზი, ეს ესკიზი აწარმოებს ზემოხსენებულ ნაკვეთს Arduino სერიული Plotter გამოყენებით და არის მაგალითი გაშვებული სიჩქარის პროფილის მაგალითად, თუ მუშაობს ტუმბო.

Stepper Speed პროფილები შედგება SpeedProfileStruct– ის მასივისგან, რომელიც განსაზღვრულია SpeedStepper.h ფაილში.

struct SpeedProfileStruct {

მცურავი სიჩქარე; // სამიზნე სიჩქარე ამ ნაბიჯის ბოლოს ხელმოუწერელი გრძელი deltaTms; // მიმდინარე სიჩქარედან (ამ ნაბიჯის დასაწყისში) მიზნობრივ სიჩქარეზე აჩქარების დრო};

განსაზღვრეთ SpeedProfileStruct– ის მასივი, რომელიც შეიცავს სამიზნე სიჩქარეს თითოეული ნაბიჯისათვის და დროს, deltaTms, mS– ში, რათა მიაღწიოს ამ მიზნობრივ სიჩქარეს წინა სამიზნე სიჩქარედან. თუ deltaTms არის ნულოვანი ან ძალიან მცირე, მაშინ სიჩქარე მაშინვე გადავა ახალ სამიზნე სიჩქარეზე. წინააღმდეგ შემთხვევაში, საჭირო აჩქარება გამოითვლება setAcceleration () გამოიძახება, რასაც მოჰყვება ზარი setSpeed () ახალი სამიზნე სიჩქარისთვის. ყველა შემთხვევაში პროფილი შემოიფარგლება არსებული პლიუს და მინუს პოზიციის ლიმიტებით და მაქსიმალური/წთ სიჩქარის პარამეტრებით. თუ გსურთ შეინარჩუნოთ სიჩქარე, უბრალოდ გაიმეორეთ წინა სიჩქარე იმ დროით, რამდენიც გსურთ რომ ის გამართული იყოს. ვინაიდან ახალი სამიზნე სიჩქარე იგივეა, რაც ამჟამინდელი სიჩქარე, გამოთვლილი აჩქარება იქნება ნული და არ შეიცვლება სიჩქარე.

ამ SpeedProfileStruct მასივმა წარმოადგინა ზემოთ ნაკვეთი

const SpeedProfileStruct პროფილი = {{0, 0}, // მაშინვე გაჩერდით, თუ უკვე არ გაჩერებულხართ {0, 1000}, // დაიჭირეთ ნული 1 წამით {-50, 0}, // გადახტომა -50 {-200, 2000}. {0, 1500}, // დაიჭირეთ ნული 1.5 წამის განმავლობაში {50, 0}, // გადახტომა 50 -ზე {200, 2000}, // ჩასასვლელი 200 -მდე {200, 6000}, // გამართვა 200 6 წამის განმავლობაში {50, 2000}, // ჩასასვლელი 50 -მდე {0, 0}, // // შეჩერდით დროულად {0, 1000} // დაიჭირეთ ნული // გამომავალი გამოსახვისთვის}; const size_t PROFILE_LEN = ზომა (პროფილი) / ზომა (SpeedProfileStruct); // გამოთვალეთ პროფილის მასივის ზომა

პროფილის დაყენება ხდება setProfile (SpeedProfileStruct* profileArray, size_t arrayLen) გამოძახებით. stepper.setProfile (პროფილი, PROFILE_LEN);

პროფილის დაყენებისთანავე დარეკეთ startProfile (), რომ დაიწყოთ მისი გაშვება ძრავის ამჟამინდელი სიჩქარით (ჩვეულებრივ თქვენ დაიწყებთ გაჩერებულიდან). პროფილის ბოლოს, ძრავა უბრალოდ გააგრძელებს მუშაობას ბოლო სამიზნე სიჩქარით. IsProfileRunning () მეთოდის გამოძახება შესაძლებელია იმის დასადგენად, თუ პროფილი ჯერ კიდევ მუშაობს. თუ გსურთ პროფილის ადრე გაჩერება შეგიძლიათ დარეკოთ stopProfile () რომელიც დატოვებს პროფილს და გააჩერებს ძრავას.

ნაბიჯი 4: გაუშვით SpeedStepperSetup მაგალითი ძრავის გარეშე

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

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

დააინსტალირეთ ბიბლიოთეკები, რომლებიც გამოიყენება SpeedStepperPlot– ის ზემოთ, და ასევე დააინსტალირეთ pfodParser ბიბლიოთეკა. PfodParser ბიბლიოთეკა აწვდის NonBlockingInput და pfodBufferedStream კლასებს, რომლებიც გამოიყენება მომხმარებლის შეყვანისა და მენიუს გამომავალი მარყუჟის () გაშვების დაბლოკვით.

გახსენით მაგალითები → SpeedStepper → speedSpeedSetup მაგალითი. ეს ესკიზი კონფიგურირებულია სერიალთან მუშაობისთვის, მაგ. UNO და მეგა და ა.შ. SparkFun Redboard Turbo– ზე გასაშვებად იხილეთ ქვემოთ.

მძღოლის დაფა ან სტეპერიანი ძრავა არ არის საჭირო ამ მაგალითის გასაშვებად. ეს მაგალითები იყენებენ D6 და D7 როგორც შედეგებს. თქვენ შეგიძლიათ შეცვალოთ გამომავალი ქინძისთავები ნებისმიერ ციფრულ გამომავალზე ესკიზის ზედა ნაწილთან STEP_PIN და DIR_PIN პარამეტრების შეცვლით. ატვირთეთ ესკიზი დაფაზე და შემდეგ გახსენით Tools → Serial Monitor 115200 ნომერზე SETUP მენიუს სანახავად.

SETUP pos: 0 sp: 0.00 +Lim: 500000 -Lim: -500 LATENCY: stepper: 492uS loop: 0uS p -set home l -set limit h -goHome r -run>

როდესაც ესკიზი გადის, სტეპერის ამჟამინდელი პოზიცია მიიღება როგორც "სახლის" (0) პოზიციაზე. თუ თქვენ გჭირდებათ სტეპერის ხელახლა დაყენება მის ნამდვილ "სახლის" პოზიციაზე, შეიყვანეთ p ბრძანება SET HOME მენიუს საჩვენებლად

SET HOME pos: 0 sp: 0.00 + Lim: 1073741808 -Lim: -1073741808 LATENCY: stepper: 752uS loop: 3852uS x -set სახლში აქ და გასვლა + -წინ - -უკუ s -გაცვლა წინ/უკან -hardStop >>

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

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

გამოიყენეთ + / - cmds სტეპერის პოზიციონირებისთვის ნულოვან პოზიციაში. ძრავა ნელ -ნელა იწყებს მუშაობას და შემდგომ აძლიერებს სიჩქარეს, უბრალოდ გამოიყენეთ და ცარიელი ხაზი მის შესაჩერებლად. ამის მაქსიმალური სიჩქარე და ლიმიტების მენიუ დადგენილია MAX_SETUP_SPEED მიერ setupMenus.cpp ზედა.

მას შემდეგ, რაც ძრავა განთავსდება "სახლის" პოზიციაზე, გამოიყენეთ x cmd, რომ გადააკეთოთ მიმდინარე პოზიცია 0 და დაუბრუნდეთ SETUP მენიუს.

თუ თქვენ გჭირდებათ ლიმიტების დაყენება, ჩვეულებრივ მხოლოდ საწყის პარამეტრებში, გამოიყენეთ l cmd SET LIMITS მენიუში შესასვლელად

SET LIMITS pos: 0 sp: 0.00 + Lim: 1073741808 -Lim: -1073741808 LATENCY: stepper: 944uS loop: 5796uS l -setLimit here + -Forward - -Reverse h -goHome x -exit -hardStop>

გამოიყენეთ + cmd, რომ უფრო წინ გადახვიდეთ პლიუს ლიმიტზე და შემდეგ გამოიყენეთ l cmd, რომ დაადგინოთ ის პლიუს ლიმიტად. H ბრძანება შეიძლება გამოყენებულ იქნას 0 – ზე დასაბრუნებლად და - cmd გადაადგილებისთვის, თუკი იგი მხარს უჭერს ძრავის პოზიციას მინუს ლიმიტზე. კვლავ გამოიყენეთ l cmd მინუს ლიმიტის დასადგენად. შენიშნეთ პლიუს და მინუს ლიმიტების პოზიციები და განაახლოთ setup () მეთოდის setPlusLimit და setMinusLimit განცხადებები ამ მნიშვნელობებით.

ლიმიტების დადგენისას გამოიყენეთ x cmd დასაბრუნებლად მენიუში და შემდეგ შეგიძლიათ გამოიყენოთ r cmd RUN მენიუს გასახსნელად

RUN MENU pos: 0 sp: 3.31 + Lim: 500000 -Lim: -500 LATENCY: stepper: 944uS loop: 5796uS + -დააჩქარეთ - -დააჩქარეთ h -goHome -hardStop-გაყინვის სიჩქარე> +pos: 4 sp: 9.49 +Lim: 500000-ლიმი: -500 ლატენტურობა: სტეპერი: 792uS მარყუჟი: 5664uS pos: 42 sp: 29.15 +Lim: 500000-ლიმიტი: -500 ლატენტურობა: სტეპერი: 792uS მარყუჟი: 5664uS pos: 120 sp: 49.09 +Lim: 500000 -ლიმი: -500 ლატენტურობა: სტეპერი: 792uS მარყუჟი: 5664uS pos: 238 sp: 69.06 +Lim: 500000 -ლიმიტი: -500 ლატენტურობა: სტეპერი: 792uS მარყუჟი: 5664uS

+ Cmd იწყებს აჩქარებას წინსვლის მიმართულებით და ამობეჭდავს პოზიციას და სიჩქარეს ყოველ 2 წამში. როდესაც ძრავა აღწევს თქვენთვის სასურველ სიჩქარეს, შეგიძლიათ შეაჩეროთ აჩქარება ნებისმიერი სხვა გასაღებით (ან ცარიელი შეყვანის საშუალებით). თქვენ შეგიძლიათ შეამციროთ სიჩქარე - cmd ქვემოთ შესაჩერებლად. გაჩერების შემთხვევაში - cmd აჩქარდება საპირისპიროდ.

ეს RUN მენიუ უზრუნველყოფს თქვენი პროექტის ხელით კონტროლს. ავტომატური კონტროლისთვის დაგჭირდებათ სხვა სენსორების დამატება.

ნაბიჯი 5: ლატენტურობა

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

სტეპერ ლატენტობა (pfodBufferedStream)

სტეპერ ლატენტურობა ზომავს მაქსიმალურ შეფერხებას შემდგომ ზარებს შორის სტეპერ.რუნის () მეთოდით. სტეპერიანი ძრავა წამში 1000 საფეხურით რომ გაუშვას, სტეპერის დაგვიანება უნდა იყოს 1000uS- ზე ნაკლები (1mS). ამ ესკიზის პირველ ვერსიას მრავალი მილიწამიანი შეყოვნება ჰქონდა. ამ ზედმეტი ზარების დასაძლევად runStepper () მეთოდით (რომელიც მოუწოდებს stepper.run ()), სადაც დამატებულია კოდის საშუალებით. ამან პრობლემა ბოლომდე ვერ გადაჭრა, რადგან მენიუ და გამომავალი ბეჭდური განცხადებები ბლოკავს ესკიზს მას შემდეგ, რაც მცირე სერიული Tx ბუფერი სავსე იყო. ამ დაბლოკვის თავიდან ასაცილებლად, pfodBufferedStream pfodParser ბიბლიოთეკიდან გამოიყენა 360 ბაიტიანი გამომავალი ბეჭდვის ბუფერის დასამატებლად, რომელსაც ბეჭდური განცხადებები სწრაფად ჩაწერდა. შემდეგ pfodBufferedStream ავრცელებს ბაიტებს ამ შემთხვევაში 115200 განსაზღვრული ბადის სიჩქარით. pfodBufferedStream– ს აქვს შესაძლებლობა დაბლოკოს, როდესაც ბუფერი სავსეა, ან უბრალოდ ჩამოაგდეს გადავსების სიმბოლოები. აქ დაყენებულია ნებისმიერი დამატებითი სიმბოლო, როდესაც ბუფერი სავსეა ისე, რომ ესკიზი არ იყოს დაბლოკილი და ელოდება სერიალს სიმბოლოების გაგზავნას.

Loop Latency (NonBlockingInput)

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

დაბეჭდილი განცხადებების გამო შეფერხებები ამოღებულ იქნა ზემოთ pfodBufferedStream– ის გამოყენებით, მაგრამ მომხმარებლის შეყვანის დასამუშავებლად თქვენ უნდა აიღოთ შეყვანის მხოლოდ პირველი სიმბოლო და იგნორირება გაუკეთოთ ხაზის დანარჩენ ნაწილს. PFodParer ბიბლიოთეკაში NonBlockingInput კლასი გამოიყენება არა ნულოვანი ნახშირის დასაბრუნებლად, როდესაც არის შეყვანა, readInput () გამოყენებით და შემდეგი სიმბოლოების გასასუფთავებლად და გასაგდებლად, clearInput () გამოყენებით, სანამ სიმბოლოები არ მიიღება 10mS მარყუჟის დაბლოკვის გარეშე ()

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

ნაბიჯი 6: გაუშვით SpeedStepperSetup სტეპერიანი ძრავით და SparkFun Redboard Turbo

SpeedStepperSetup ესკიზის რეალურად გასაშვებად დაგჭირდებათ სტეპერიანი ძრავა, დრაივერი და კვების ბლოკი და ამ მაგალითში SparkFun Redboard Turbo.

გაყვანილობის დიაგრამა ზემოთ (pdf ვერსია) გვიჩვენებს კავშირებს. SpeedStepperSetup ესკიზში SERIAL- ის შეცვლა #განსაზღვრეთ SERIAL Serial1

სტეპერიანი ძრავა, კვების ბლოკი, მძღოლი და დაცვა

სტეპერ ძრავების მრავალი ტიპი და ზომა არსებობს. აქ ორი კოჭის 12V 350mA სტეპერიანი ძრავა გამოიყენება შესამოწმებლად. ამ სტეპერის გასაძლიერებლად გჭირდებათ კვების წყარო 12 ვ ან მეტი და მეტი 350mA.

ეს ბიბლიოთეკა მხოლოდ მიმართულებისა და საფეხურის გამომუშავებას იძლევა, ასე რომ თქვენ გჭირდებათ დრაივერი სტეპერ ძრავასთან დასაკავშირებლად. Easy Driver და Big Easy Driver აკონტროლებენ დენს ძრავის ხვეულებში, ასე რომ თქვენ შეგიძლიათ უსაფრთხოდ გამოიყენოთ მაღალი ძაბვის კვების წყარო, მაგალითად, 6V კვების წყარო 3.3V ძრავისთვის. Easy Driver– ს შეუძლია მიაწოდოს 150mA/coil და 700mA/coil. უფრო მაღალი დენებისთვის, Big Easy Driver– ს შეუძლია მიაწოდოს 2A– მდე თითო გრაგნილი. წაიკითხეთ ხშირად დასმული კითხვები Easy Drive გვერდის ბოლოში.

ეს მაგალითები იყენებენ D6 და D7 როგორც ნაბიჯი და მიმართულება. თქვენ შეგიძლიათ შეცვალოთ გამომავალი ქინძისთავები ნებისმიერ ციფრულ გამომავალზე ესკიზის ზედა ნაწილთან STEP_PIN და DIR_PIN პარამეტრების შეცვლით.

Sparkfun Redboard Turbo პროგრამირება

Redboard Turbo პროგრამირება პრობლემურია.თუ პროგრამა ვერ მოხერხდა, ჯერ დააჭირეთ გადატვირთვის ღილაკს ერთხელ და ხელახლა შეარჩიეთ COM პორტი Arduino Tools მენიუში და ხელახლა სცადეთ. თუ ეს არ მუშაობს, ორჯერ დააჭირეთ გადატვირთვის ღილაკს და სცადეთ ხელახლა.

მარტივი მძღოლის გაყვანილობა

ორ სპირალურ სტეპერ ძრავას აქვს 4 მავთული. გამოიყენეთ მულტიმეტრი, რათა იპოვოთ წყვილი, რომელიც აკავშირებს თითოეულ კოჭას და შემდეგ ერთი გრაგნილი მიაბით Easy Driver A ტერმინალებს და მეორე კოჭა B ტერმინალს. არ აქვს მნიშვნელობა რა მიმართულებით უნდა დააკავშიროთ ისინი, რადგან თქვენ შეგიძლიათ გამოიყენოთ s cmd დაყენების მენიუში მოძრაობის მიმართულების შესაცვლელად.

საავტომობილო დენის წყაროს უკავშირდება M+ და GND დაყენება დაფის ლოგიკური დონე 3/5V ბმულით. მოკლე კავშირი 3.3V მიკროპროცესორული გამოსავლისთვის, მაგალითად SparkFun Redboard Turbo (თუ გახსნით მას, ის შესაფერისია 5V ციფრული სიგნალისთვის, მაგ. UNO, მეგა) დააკავშირეთ GND, STEP, DIR ქინძისთავები მიკროპროცესორულ GND– ს და საფეხურს და dir გამომავალი ქინძისთავები. სხვა კავშირები არ არის საჭირო ძრავის მართვისთვის.

USB to TTL სერიული კაბელი

SpeedStepperSetup ესკიზის Uno/Mega– დან Redboard Turbo– ზე გადატანისას თქვენ შეიძლება გულუბრყვილოდ შეცვალოთ #განსაზღვრეთ სერიული სერიალი #განსაზღვრული სერიული USB– ით, რათა მოერგოს Redboard Turbo usb სერიულ კავშირს, თუმცა აღმოაჩენთ, რომ შედეგად მიღებული სტეპერული შეყოვნება დაახლოებით 10 წმ. ეს გაეროსთვის 10 ჯერ ნელია. ეს იმის გამო ხდება, თუ როგორ ამუშავებს Redboard CPU USB კავშირს. ამის გადასაჭრელად, დაუკავშირეთ USB TTL სერიულ კაბელს D0/D1 და დააყენეთ#განსაზღვრეთ სერიული სერია 1, რათა გამოიყენოთ ტექნიკური სერიული კავშირი სტეპერ ძრავის გასაკონტროლებლად. Serial1– ის გამოყენება იძლევა LATENCY: stepper: 345uS loop: 2016uS რომელიც 3 -ჯერ უფრო სწრაფია ვიდრე UNO სტეპერისა და მარყუჟის შეყოვნებისთვის

ტერმინალური პროგრამა

Arduino სერიული მონიტორის გამოყენება ცოტა ძნელია სტეპერი ძრავის გასაკონტროლებლად, რადგან თქვენ უნდა შეიყვანოთ char cmd ხაზში და შემდეგ დააჭირეთ Enter მის გასაგზავნად. უფრო სწრაფი რეაგირების საშუალება არის ტერმინალის ფანჯრის გახსნა, TeraTerm კომპიუტერისთვის (ან CoolTerm Mac), რომელიც დაკავშირებულია USB– თან TTL კაბელის COM პორტთან. შემდეგ ამ ფანჯარაში cmd ღილაკის დაჭერით იგი დაუყოვნებლივ იგზავნება. Enter- ზე დაჭერით უბრალოდ გაგზავნეთ ცარიელი ხაზი.

ძრავის სიჩქარის დიაპაზონის დაყენება

როგორც ზემოთ არის გაყვანილი, Easy Drive არის კონფიგურირებული 1/8 საფეხურისთვის, ასე რომ 1000 ნაბიჯი/წამი ძრავას ატრიალებს 1000/8/200 საფეხურზე/რევოლუციაზე = 0.625 ბრუნვა წამში ან 37.5 rpm მაქსიმალური. MS1/MS2– ში შეყვანის შეცვლით შეგიძლიათ გადახვიდეთ 1/8, ¼, ½ და სრულ ნაბიჯებს შორის. სრული ნაბიჯებისთვის დააკავშირეთ MS1 და MS2 GND– თან. ეს საშუალებას მისცემს 300 rpm– მდე სიჩქარეს. MS1/MS2 შესაბამისი პარამეტრების არჩევა საშუალებას გაძლევთ დაარეგულიროთ დაყენებული სიჩქარის თანაფარდობა ძრავასა და ამოძრავებულ ნაწილს შორის.

აპარატურის დაცვა

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

ძრავის დენის ლიმიტის დაყენება

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

დასკვნა

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