תפריט בקרת מהירות צעדים מונע עבור Arduino: 6 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:12

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

מגבלות: ספריית SpeedStepper מניעה רק פלט כיוון וצעד ולכן יש לחבר אותה למנהג מנוע, כגון Easy Driver, כדי להניע את מנוע הצעד בפועל. ספריית AccelStepper מספקת אפשרויות נהיגה נוספות הניתנות להעתיק לספרייה זו במידת הצורך.

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

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

ספרייה זו פועלת על Arduino Uno ו- Mega2560, אך עבור אב הטיפוס נעשה שימוש במעבד הזיכרון / המהיר יותר SparkFun Redboard Turbo.

מדריך זה זמין גם באינטרנט בספריית בקרת מהירות Stepper עבור Arduino

אספקה

כדי להריץ את הסקיצות לדוגמה יש צורך רק ב- UNO Arduino או Mega2560 וספריות התוכנה

לבדיקת ספסל של הספרייה נעשה שימוש ב- SparkFun Redboard Turbo עם דרייבר קל, 200 צעדים/סיבוב, מנוע צעד 12V 350mA ואספקת 12 DC 2A או יותר, למשל. https://www.sparkfun.com/products/14934. כבל USB A למיקרו USB ל- TTL כבל סידורי Arduino IDE V1.8.9 ומחשב להפעלה עליו. ספריית SpeedStepper pfod ספריית ה- nonBlockingInput ו- pfodBufferedStream כיתות millis ספריית עיכוב לעיכובים שאינם חוסמים

שלב 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 צעדים/sec ו- setMinSpeed (float), ברירת מחדל 0.003 צעדים/sec. ברירות מחדל אלה הן גם מגבלות המהירות המקודדות הקשות שהספרייה תקבל עבור setMaxSpeed () ו- setMinSpeed (). אם ברצונך להגדיר מהירות מרבית> 1000 צעדים/שניות, יהיה עליך לערוך את השורה הראשונה בקובץ SpeedStepper.cpp כדי לשנות את maxMaxSpeed (1000) למהירות המרבית שאתה רוצה. בפועל המהירות המרבית מוגבלת גם בזמן בין שיחות לשיטת הפעלה () של הספרייה. במשך 1000 צעדים / שניות יש לקרוא לשיטת הריצה () לפחות בכל 1 מיליוני שניות. עיין בסעיף איחורים להלן.

ניסיון להגדיר מהירות נמוכה ממהירות הדקה יגרום למנוע להיעצר. לכל אחת מההגדרות הללו יש גטר מקביל, עיין בקובץ SpeedStepper.h. עבור מהירות, getSetSpeed () מחזיר את המהירות שהגדרת באמצעות setSpeed (), בעוד getSpeed () מחזיר את מהירות המנוע הנוכחית המשתנה ככל שהיא מאיצה/מאיטה לך את המהירות שנקבעה. אם המנוע לא הולך בכיוון שאתה חושב על +ve אתה יכול להתקשר ל- invertDirectionLogic () כדי להחליף את הכיוון שהמנוע נע עבור +מהירויות ve.

getCurrentPosition () מחזיר את המיקום המוטורי הנוכחי בהשוואה ל'בית '(0). אתה יכול לעקוף את המיקום הנוכחי של המנוע setCurrentPosition (int32_t). המיקום החדש מוגבל להיות בתוך גבולות הפלוס/מינוס שנקבעו.

בתחילה המנוע נעצר במיקום 0. קריאת setSpeed (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 סקיצה → כלול ספרייה → הוסף ספריית ZIP כדי לייבא את הספרייה הורד והתקן את ספריית millisDelay גם כן

פתח את דוגמאות → SpeedStepper → speedStepperPlot סקיצה לדוגמא (הפעל מחדש את IDE במידת הצורך). סקיצה זו מוגדרת לעבודה עם סידורי, למשל. UNO ומגה וכו 'להפעלה על טורבו Redboard של SparkFun ראו להלן.

אין צורך בלוח נהג או במנוע צעד כדי להריץ דוגמה זו. דוגמאות אלה משתמשות ב- D6 ו- D7 כתפוקות. אתה יכול לשנות את סיכות הפלט לכל פלט דיגיטלי על ידי שינוי הגדרות STEP_PIN ו- DIR_PIN ליד החלק העליון של המערכון.

העלה את הסקיצה ללוח ולאחר מכן פתח את הכלים → פלוטר סידורי ב -115200 באוד כדי להציג את עלילת המהירות (אדומה) והמיקום (כחול) מגבלת הפלוס נקבעת ל- 360 מה שגורם למהירות לעלות לאפס מכ- 100 נקודות על ציר ה- x. מגבלת המינוס היא -510. המיקום עוצר ב- ~ -390 מכיוון שהמהירות נדרשה ל- 0.0. בנקודה 380 בציר ה- x, cmd goHome מונפק שמחזיר את המדרגה למיקום אפס.

סקיצה זו של speedStepperPlot משתמשת ב- millisDelays לזמן מעבר בין מהירויות ותאוצות שונות. במקרים רבים השימוש ב- SpeedStepperProfile, כמו בדוגמה הבאה, הוא פשוט יותר.

שלב 3: הפעלת דוגמת SpeedStepperProfile ללא מנוע

פתח את הדוגמאות → SpeedStepper → סקיצה לדוגמא speedStepperPlot, סקיצה זו מייצרת את העלילה לעיל באמצעות ה- Pluter Serial Arduino והיא דוגמה להפעלת פרופיל מהירות שנקבע למשל אם מפעילים משאבה.

פרופילי מהירות Stepper מורכבים ממערך 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}, // רמפה ל -200 {-200, 6000}, // החזק ב- -200 למשך 6 שניות {-50, 2000}, // רמפה ל -50 {0, 0}, // // עצור מיד {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 = sizeof (פרופיל) / sizeof (SpeedProfileStruct); // לחשב את גודל מערך הפרופיל

הפרופיל נקבע על ידי התקשרות setProfile (SpeedProfileStruct* profileArray, size_t arrayLen) למשל stepper.setProfile (פרופיל, PROFILE_LEN);

לאחר הגדרת הפרופיל, התקשר ל startProfile () כדי להתחיל להריץ אותו ממהירות המנוע הנוכחית (בדרך כלל תתחיל מעצור). בסוף הפרופיל המנוע ימשיך לפעול במהירות היעד האחרונה. ניתן לקרוא לשיטת isProfileRunning () כדי לבדוק אם הפרופיל עדיין פועל. אם ברצונך לעצור את הפרופיל מוקדם תוכל להתקשר ל- stopProfile () שיזנח את הפרופיל ויעצור את המנוע.

שלב 4: הפעלת דוגמת SpeedStepperSetup ללא מנוע

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

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

התקן את הספריות המשמשות להפעלת SpeedStepperPlot למעלה, ולאחר מכן התקן גם את ספריית pfodParser. ספריית pfodParser מספקת את שיעורי NonBlockingInput ו- pfodBufferedStream המשמשים לטיפול בקלט המשתמש ופלט התפריט עם חסימת ריצה של הלולאה ().

פתח את הדוגמאות → SpeedStepper → speedSpeedSetup דוגמה. סקיצה זו מוגדרת לעבודה עם סידורי, למשל. UNO ומגה וכו 'להפעלה על טורבו Redboard של SparkFun ראו להלן.

אין צורך בלוח נהג או במנוע צעד כדי להריץ דוגמה זו. דוגמאות אלה משתמשות ב- D6 ו- D7 כתפוקות. אתה יכול לשנות את סיכות הפלט לכל פלט דיגיטלי על ידי שינוי הגדרות STEP_PIN ו- DIR_PIN ליד החלק העליון של המערכון. העלה את הסקיצה ללוח ולאחר מכן פתח את הכלים → צג סידורי ב- 115200 כדי לראות את תפריט ההגדרות.

הגדרת pos: 0 sp: 0.00 +Lim: 500000 -גבול: -500 LATENCY: step: 492uS לולאה: 0uS p -set Home l -הגדר גבולות h -goHome r -run>

כאשר המערכון פועל, המיקום הנוכחי של המדרגה נלקח כמיקום 'בית' (0). אם עליך למקם מחדש את המדרגה למיקום ה'בית 'האמיתי שלה, הזן את הפקודה p כדי להציג את תפריט SET HOME

SET HOME pos: 0 sp: 0.00 + Lim: 1073741808 -גבול: -1073741808 LATENCY: stepper: 752uS loop: 3852uS x -setHome here and exit + -Forward - -Reverse s -swap Forward/Reverse -hardStop >

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

השתמש ב- cmd + כדי להתחיל להזיז את המדרגה קדימה, אם אתה מוצא שהיא נעה בכיוון הלא נכון הזן פקודה שאינה פקודה או רק שורה ריקה כדי לעצור אותה ולאחר מכן השתמש בפקודה כדי להחליף את הכיוון קדימה. עליך לעדכן את הסקיצה כך שתכלול קריאה ל- invertDirectionLogic () בהגדרה כדי לתקן זאת לקראת הריצה הבאה.

השתמש ב- + / - cmds כדי למקם את המדרגה למיקום האפס הנכון. המנוע מתחיל לאט ואז מצטבר מהירות ככל שהוא מתקדם, פשוט השתמש בקו הריק כדי לעצור אותו. המהירות המקסימלית לכך ותפריט המגבלות נקבעים על ידי MAX_SETUP_SPEED בחלק העליון של setupMenus.cpp.

לאחר שהמנוע ממוקם במיקום ה'בית 'שלו, השתמש ב- x cmd כדי להגדיר מחדש את המיקום הנוכחי כ- 0 וחזור לתפריט SETUP.

אם עליך להגדיר את הגבולות, בדרך כלל רק בהגדרה הראשונית, השתמש ב- cmd כדי להיכנס לתפריט SET LIMITS

SET LIMITS pos: 0 sp: 0.00 + Lim: 1073741808 -גבול: -1073741808 LATENCY: step: 944uS לולאה: 5796uS l -setLimit כאן + -קדימה - -הפוך h -goHome x -יציאה -hardStop>

השתמש ב- cmd + כדי להתקדם יותר אל מגבלת הפלוס ולאחר מכן השתמש ב- cmd כדי להגדיר אותו כמגבלת הפלוס. לאחר מכן ניתן להשתמש בפקודה h כדי לחזור ל- 0 ולהשתמש ב- cmd כדי לזוז אם חוזר למיקום המנוע בגבול המינוס. שוב השתמש ב- cmd כדי להגדיר את מגבלת המינוס. שים לב למיקומי מגבלות הפלוס והמינוס ועדכן את הצהרות setPlusLimit ו- setMinusLimit של שיטת setup () עם ערכים אלה.

כאשר נקבעו המגבלות השתמשו ב- x cmd כדי לחזור לתפריט SETUP ולאחר מכן תוכלו להשתמש ב- r cmd כדי לפתוח את תפריט RUN

תפריט RUN pos: 0 sp: 3.31 + Lim: 500000 -גבול: -500 LATENCY: stepper: 944uS לולאה: 5796uS + -מהירות - -מהירות למטה h -goHome. -hardStop-מהירות הקפאה> +pos: 4 sp: 9.49 +Lim: 500000-גבול: -500 LATENCY: stepper: 792uS לולאה: 5664uS pos: 42 sp: 29.15 +Lim: 500000-גבול: -500 LATENCY: stepper: לולאה 792uS: 5664uS pos: 120 sp: 49.09 +Lim: 500000 -גבול: -500 LATENCY: stepper: 792uS loop: 5664uS pos: 238 sp: 69.06 +Lim: 500000 -Limens: -500 LATENCY: stepper: 792uS loop: 5664uS

ה- cmd + מתחיל להאיץ בכיוון קדימה ומדפיס את המיקום והמהירות כל 2 שניות. כאשר המנוע מגיע למהירות הרצויה תוכל לעצור את ההאצה בעזרת כל מקש אחר (או קלט ריק). אתה יכול להפחית את המהירות באמצעות - cmd למטה כדי לעצור. אם עוצרים - cmd יואץ לאחור.

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

שלב 5: איחורים

השליטה במנוע הצעד תלויה בתוכנה המפקדת על כל שלב. כדי לשמור על המהירות שנקבעה, הסקיצה שלך צריכה לקרוא לשיטת stepper.run () לעתים קרובות מספיק כדי לירות את השלב הבא בזמן הנכון עבור המהירות הנוכחית. לשליטה באמצעות חיישנים עליך להיות מסוגל לעבד מדידות חדשות באופן מיידי. הדפסת המיקום/המהירות כוללת שתי מדידות LATENCY כדי לאפשר לך לבדוק שהשרטוט שלך מהיר מספיק.

איחורי צעד (pfodBufferedStream)

חביון stepper מודד את העיכוב המרבי בין שיחות רצופות לשיטת stepper.run (). על מנת להפעיל את מנוע הצעד ב -1000 צעדים לשנייה, זמן ההשהיה של הצעדים צריך להיות פחות מ- 1000uS (1mS). לגרסה הראשונה של מערכון זה הייתה חביון של אלפיות השנייה רבות. כדי להתגבר על שיחות נוספות אלה לשיטת runStepper () (אשר קוראת stepper.run ()) כאשר היא נוספה באמצעות הקוד. זה לא פתר את הבעיה לחלוטין מכיוון שהצהרות התפריט וההדפסה של הפלט חסמו את הסקיצה לאחר שמאגר ה- Tx הסידורי הקטן מלא. כדי להימנע מחסימה זו, pfodBufferedStream מספריית pfodParser שימש להוספת מאגר הדפסה של פלט 360 בתים שאליו הצהרות ההדפסה יכלו לכתוב במהירות. ואז pfodBufferedStream משחרר את הבייטים בקצב השידור שצוין 115200 במקרה זה. ל- pfodBufferedStream יש אפשרות לחסום כאשר המאגר מלא או פשוט להפיל את תווי הצף. כאן הוא אמור להוריד תווים נוספים כאשר המאגר מלא, כך שהסקיצה לא תיחסם בהמתנה לסדרה שתשלח תווים.

Latency Loopcy (NonBlockingInput)

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

העיכובים עקב הצהרות ההדפסה הוסרו באמצעות pfodBufferedStream לעיל, אך כדי לעבד את קלט המשתמש עליך לקחת את הסמן הראשון רק של הקלט ולהתעלם משאר השורה. מחלקת NonBlockingInput בספריית pfodParer משמשת להחזרת תו לא אפס כאשר יש קלט, באמצעות readInput (), ולמחוק ולמחוק את התווים הבאים, באמצעות clearInput (), עד שלא יתקבלו תווים במשך 10mS מבלי לחסום את הלולאה ()

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

שלב 6: הפעלת SpeedStepperSetup עם מנוע צעד ו- SparkFun Redboard Turbo

כדי להריץ את סקיצת SpeedStepperSetup באמת תצטרך מנוע צעד, נהג ואספקת חשמל ובדוגמה זו SparkFun Redboard Turbo.

תרשים החיווט למעלה (גירסת pdf) מציג את החיבורים. במערכון SpeedStepperSetup שנה את ההגדרה SERIAL ל- #define SERIAL Serial1

מנוע צעד, ספק כוח, נהג והגנה

ישנם סוגים וגדלים רבים של מנועי צעד. כאן משמש מנוע צעד בעל שני סלילים של 12V 350mA לבדיקה. כדי להפעיל את המדרגה הזו אתה צריך ספק כוח של 12V או יותר וגדול מ -350mA.

ספרייה זו מספקת רק כיוון ופלט צעד כך שאתה צריך מנהל התקן כדי להתממשק עם מנוע הצעדים. הנהג הקל והנהג הגדול קל לשלוט בזרם לסלילי המנוע כך שתוכל להשתמש באספקת מתח גבוה יותר בבטחה, למשל באמצעות אספקת 6V עבור מנוע 3.3V. מנהל ההתקן הקל יכול לספק בין 150mA/סליל ל- 700mA/סליל. עבור זרמים גבוהים יותר, הנהג Big Easy יכול לספק עד 2A לכל סליל. קרא את השאלות הנפוצות בתחתית דף ה- Easy Drive.

דוגמאות אלה משתמשות ב- D6 ו- D7 כפלט ה- Step and Direction. אתה יכול לשנות את סיכות הפלט לכל פלט דיגיטלי על ידי שינוי הגדרות STEP_PIN ו- DIR_PIN ליד החלק העליון של המערכון.

תכנות הטורבו Sparkfun Redboard

התכנות של ה- Redboard Turbo היא בעייתית.אם הוא לא מצליח לתכנת, תחילה לחץ פעם אחת על לחצן האיפוס ובחר מחדש את יציאת ה- COM בתפריט Arduino Tools ונסה שוב. אם זה לא עובד, לחץ פעמיים על לחצן האיפוס ונסה שוב.

חיבור הנהג הקל

שני מנועי צעד סליל בעלי 4 חוטים. השתמש במולטימטר כדי למצוא את הזוגות המתחברים לכל סליל ולאחר מכן לחבר סליל אחד למסופי Easy Driver A ואת הסליל השני למסוף B. זה לא משנה באיזה כיוון אתה חוט אותם כי אתה יכול להשתמש ב- cmd בתפריט ההתקנה כדי להחליף את כיוון התנועה.

ספק הכוח המוטורי מחובר ל- M+ ו- GNDS הגדר את רמת הלוגיקה של הלוח עם הקישור 3/5V. קצר את הקישור יחד ליציאות מעבד של 3.3V, כמו טורבו SparkFun Redboard (אם אתה משאיר אותו פתוח הוא מתאים לאותות דיגיטליים של 5V, למשל UNO, מגה) חבר את סיכות ה- GND, STEP, DIR אל המעבדה GND ולשלב ו אין צורך בחיבורים אחרים כדי להניע את המנוע.

כבל סידורי מסוג USB ל TTL

בעת העברת סקיצת SpeedStepperSetup מה- Uno/Mega ל- Turbo Redboard, ייתכן שנאיבי פשוט תחליף את #define SERIAL Serial ב- #define SERIALUSB כך שיתאים לחיבור הסדרתי של ה- Redboard Turbo usb, אולם תגלה שההשהיה של הצעד המתקבל היא בערך 10 ms. זה איטי פי 10 אז ל- UNO. זאת בשל האופן שבו מעבד ה- Redboard מטפל בחיבור ה- USB. כדי להתגבר על זה, חבר USB לכבל סידורי TTL ל- D0/D1 והגדר#הגדר סדרה 1 כדי להשתמש בחיבור הטורי של החומרה כדי לשלוט במנוע הצעד. שימוש ב- Serial1 נותן LATENCY: stepper: 345uS לולאה: 2016uS המהירה פי 3 מה- UNO עבור חביון צעדים ולולאה

תוכנית מסוף

הצג הסידורי של Arduino קצת יותר קשה לשליטה על מנוע הצעד שכן עליך להזין את התו בשורת cmd ולאחר מכן הקש Enter כדי לשלוח אותו. אמצעי מהיר יותר להגיב יותר הוא פתיחת חלון מסוף, TeraTerm למחשב (או CoolTerm Mac), המחובר ליציאת COM לכבל USB ל- TTL. ואז בחלון זה לחיצה על מקש cmd שולחת אותו מייד. לחיצה על Enter פשוט שלח שורה ריקה.

הגדרת טווח מהירות המנוע

כפי שחובר למעלה, הכונן הקל מוגדר לצעדים 1/8, כך ש- 1000 צעדים/שניות יסובבו את המנוע במהירות 1000/8/200/מהפכה = 0.625 סיבובים לשנייה או 37.5 סל"ד לכל היותר. על ידי שינוי הכניסות ל- MS1/MS2 ניתן לעבור בין 1/8, ¼, ½ ושלבים מלאים. עבור שלבים מלאים חבר את MS1 ו- MS2 ל- GND. זה יאפשר מהירות של עד 300 סל"ד. בחירת ההגדרות המתאימות MS1/MS2 מאפשרת לך להתאים את יחס ההילוכים המותקן בין המנוע לחלק המונע.

הגנה על חומרה

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

הגדרת מגבלת זרם המנוע

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

סיכום

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