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

 

ובכל זאת: נתחיל מההתחלה - מה זה מנוע צעד?

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

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

בנוסף, רוב המנועים שנפגוש יהיו בעלי אחד משני מבנה סלילים – חד קוטבי (Unipolar) או דו קוטבי (Bipolar). יש הרבה מה לומר על זה, אבל ההבדלים העיקריים הם:

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

ראוי לציין שניתן להפעיל מנועים חד-קוטביים כמנועים דו קוטביים על ידי התעלמות מחוט מספר 2 וחוט מספר 5 (בעיקרון הסדר תמיד עקבי). לקריאה נוספת בעניין, כאן.

במנועי NEMA הפופולאריים, בדרך כלל מדובר על 200 צעדים לסיבוב, 1.8 מעלות לכל צעד, רמת דיוק הנדרשת במכונות מדויקות כמו מדפסות תלת מימד ומכונות cnc שונות. 

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

במנוע צעד של 200 צעדים, על הסטטור 48 שיניים ועל הרוטור 50 שיניים. הרווח ממקם, בכל רגע נתון, את חלק משיני סלילי הסטטור במצב מיושרים לשיני הרוטור, חלק אחר במצב מנוגד לשיני הסטטור וחלק נוסף במצב חלקי. כאשר זרם זורם בסלילים בצורה מסונכרנת, חלק מהסלילים דוחים את השיניים וחלק מהסלילים מושכים אותם. 

חלק ממנועי הצעד, ובפרט מנועי הצעד ההיברידיים מסוג NEMA, יכולים לפעול גם בחצאי צעדים, רבעי צעדים, שמניות צעדים ו1/16 מכל צעד. מצבי הפעלה אלו מאפשרים למנועים להגיע לרזולוציה של עד 0.11 מעלות, אך למצבי הפעלה בצעדים הקטנים מצעד מלא של 1.8 מעלות יש מספר חסרונות: מומנט סיבוב מופחת, שנוצר מהעובדה שהשדה המגנטי אינו מיושר במלואו בכל מיקום של הרוטור, כך שהיכולת של המנוע לעשות עבודה יורדת; מורכבות גבוהה בשליטה במנוע, שלרוב דורשת מעגלי שליטה יקרים ומורכבים יותר ולכן גם יקרים יותר; ועד אובדן יעילות, רעד בהפעלה, ויצירת חום עודף (כיוון שביותר סלילים זורם זרם באותו הזמן, כדי לאפשר את הצעדים החלקיים).

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

מנוע צעד צריך דרייבר (במקרה הזה A4988)

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

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

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

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

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

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

ולמי שמעוניין ללמוד עוד על בקר השליטה A4988 אפשר להעמיק כאן באתר של אחד היצרנים.

 

מנוע צעד NEMA 17 עם בקר שליטה A4988 - על לוח HCMODU0068

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

בסרטון אפשר לראות מנוע צעד בודד, מחובר דרך בקר שליטה A4988 על הלוח HCMODU0068, אל בקר ES88266. כמו שאפשר לראות בקוד, המנוע מסתובב 200 צעדים, סיבוב שלם, ממתין שניה וחצי עם התנגדות, ואז הENABLE עובר לHIGH וההתנגדות נעלמת, אז מחכה שוב שניה וחצי עם התנגדות, ומסתובב שוב. בהמשך אני משחק ידנית עם חלקי הצעדים ואפשר לראות שהמנוע מאט.

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

#define ENABLE 15 
#define DIRECTION 0 
#define STEP 16 

#define FORWARD HIGH
#define REVERSE LOW

#define SPEED 4

void setup() {
  pinMode(ENABLE, OUTPUT);
  pinMode(DIRECTION, OUTPUT);
  pinMode(STEP, OUTPUT);
  digitalWrite(ENABLE, LOW);
}


void loop() {
  /* The the rotational direction to the forward direction */
  digitalWrite(DIRECTION, FORWARD);
  /* Keep stepping the motor in an infinite loop */
  cycle();
  delay(1500);
  digitalWrite(ENABLE, HIGH);
  delay(2500);
  digitalWrite(ENABLE, LOW);
  delay(1500);
}

float cycle() {
    for (int x = 0; x < 200; x++) {
    digitalWrite(STEP, HIGH);   
    delay(SPEED);              
    digitalWrite(STEP, LOW);
    delay(SPEED);  
  }
  return 1;
} 

 

שלושה מנועי צעד עם esp8266 אחד ועדיין להשאר עם 6 (!) יציאות פנויות... זה אפשרי?

על זה שברתי קצת את הראש. להפעיל שלושה סטפרים בשני מהירויות ובשני כיוונים עם מינימום של יציאות כדי להשאיר לפחות 5 יציאות פנויות. הצלחתי לבסוף להגיע לשש, למרות שכל מנוע דורש 3 יציאות, ויש רק 11 יציאות פנויות במקסימום.

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

החוכמה ניבטת מסכמת החיבורים שלמטה.

יציאה D8 בעיקרון צריכה להשאר LOW (“להמשך למטה”, Pulled Down) בגלל שבזמן ההפעלה מחדש הboot נכשל אם היציאה בHIGH. ההתחכמות היא לחבר את כל שלושת היציאות ENABLE מבקר השליטה – זה כמובן בהנחה שאתם רוצים שהמנוע יעבוד כל הזמן, גם כשהוא לא זז. בנוסף הD (כיוון, Direction) של מנוע אחד (בסכמה הוא מנוע C)  צריך להיות LOW כדי להסתובב הפוך מהשניים האחרים וגם הוא חובר לאותה יציאה. חסכתי 3 יציאות כך.

על אותו הדבר חזרתי עם הכיוון של שני המנועים הנוספים שחייב להיות HIGH לd3 שמפריע לboot אם הוא בLOW, מה שהפך את כיוון הסיבוב של שני האחרים (A+B) לכיוון המנוגד למנוע C, במחיר של יציאה אחת בודדת, ואת הצעדים של מנועים B ו-C שצריכים לנוע מסוכרנים גם חיברתי לאותה היציאה (TX) שהפכה לGPIO רגיל, ביחד עם הRX, באמצעות ההצהרה הזו:

//********** CHANGE PIN FUNCTION TO GPIO **********
   //GPIO 1 (TX) swap the pin to a GPIO.
   pinMode(1, FUNCTION_3); 
   //GPIO 3 (RX) swap the pin to a GPIO.
   pinMode(3, FUNCTION_3); 
 //**************************************************

כך נשארו לי היציאות d1(5), d2(4), d5(14), d6(12), d7(13), rx(3) שכולן GPIO רגילות – פנויות להמשך העבודה.

להלן הקוד המלא בו השתמשתי לצורך ההפעלה המודגמת בסרטון העוקב:

//   free pins to pull up or down: *d0(16), d1(5), d2(4), d5(14), d6(12), d7(13),  rx(3), *tx(1)
//   pins need to be pulled down: *d8(15)
//   pins need to be pulled up: *d3(0), d4(2)

#define ENABLE 15 //all steppers = d8 
#define DIRECTION 0 // Direction forward - stepper A + B
#define STEP 16 // stepper A

#define DIRECTIONTWO 15 // Direction reverese - stepper C
#define STEPTWO 1 // Stepper B + C

#define FORWARD HIGH
#define REVERSE LOW

/* Change this values to alter the clock speed */
#define SPEED 4


void setup() {
  //********** CHANGE PIN FUNCTION TO GPIO **********
    //GPIO 1 (TX) swap the pin to a GPIO.
    pinMode(1, FUNCTION_3); 
    //GPIO 3 (RX) swap the pin to a GPIO.
    pinMode(3, FUNCTION_3); 
  //**************************************************
  pinMode(ENABLE, OUTPUT);
  pinMode(DIRECTION, OUTPUT);
  pinMode(STEP, OUTPUT);
  pinMode(DIRECTIONTWO, OUTPUT);
  pinMode(STEPTWO, OUTPUT);
  digitalWrite(ENABLE, LOW);
}

void loop() {
  /* The the rotational direction to the forward direction */
  digitalWrite(DIRECTION, FORWARD);
  digitalWrite(DIRECTIONTWO, REVERSE);
  /* Keep stepping the motor in an infinite loop */
  cycle();
  delay(1500);
}

float cycle() {
  for (int x = 0; x < 199; x++) {
    digitalWrite(STEPTWO, HIGH);   
    delay(SPEED/4);              
    digitalWrite(STEPTWO, LOW);    
    delay(SPEED/4);  
  }
    for (int x = 0; x < 3200; x++) {
    digitalWrite(STEP, HIGH);   
    delay(SPEED);              
    digitalWrite(STEP, LOW);
    delay(SPEED);  
  }
  return 1;
} 

 

מקורות חשובים נוספים

הסבר מפורט מאוד, אבל בדיוק לעניין שלנו, שווה לקרוא את הכל –
https://howtomechatronics.com/tutorials/arduino/stepper-motors-and-arduino-the-ultimate-guide/

מאמר ארוך (וישן אבל מקיף) באתר של אוניברסיטת איווה על מנועי צעד –
https://homepage.cs.uiowa.edu/~dwjones/step

עוד מבוא למנועי צעד –
https://www.globalspec.com/learnmore/motion_controls/controls_drives/stepper_motor_drives

עוד הסבר על מנועי צעד, הפעם קצת יותר מעשי –
https://electricdiylab.com/how-stepper-motor-works/

הסבר מפורט על בקר השליטה A4988 באתר של אחד היצרנים –
https://www.pololu.com/product/1182

גיליון מפרט (Specsheet) של השבב A4988 שמהווה את לב בקר השליטה
https://www.pololu.com/file/0J450/A4988.pdf