מנועים: מנוע זרם ישר, סרוו ומנוע צעד

מנוע זרם ישר והצורך במעגל הנעה (DC Motor)

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

מכאן שלושה כללים שילוו אותנו לאורך כל הפרק:

• מעגל הנעה (דרייבר): טרנזיסטור MOSFET, גשר H או מודול מוכן נושאים את זרם המנוע, והבקר רק נותן להם פקודה.
• מקור נפרד למנוע: המנוע צורך זרם גדול ומייצר רעש חשמלי. אילו הזנו אותו מהדק 5 V של הלוח, המתח היה צונח בהתנעה, והבקר עלול לעבור אתחול מעצמו.
• אדמה משותפת: נחבר את הקוטב השלילי של מקור המנוע להדק GND של הבקר. בלי זה אין ייחוס משותף למתח, ומעגל ההנעה אינו "מבין" את האות של הבקר.

בקרת מהירות באפנון רוחב פולס (PWM Speed Control)

ב-Arduino Uno הפונקציה analogWrite(pin, x) מפיקה אות PWM רק בהדקים 3, 5, 6, 9, 10, 11 (המסומנים ב-~). התדר לפי התיעוד של Arduino: 490 Hz (T = 2.04 ms) בהדקים 3, 9, 10, 11, ו-980 Hz (T = 1.02 ms) בהדקים 5 ו-6.

מעגל ההנעה: MOSFET ודיודת חופש:

נשתמש בטרנזיסטור MOSFET ברמה לוגית, כלומר טרנזיסטור שמוליך במלואו כבר במתח 5 V על השער, כמו IRLZ44N. הטרנזיסטור פועל כמפסק בין המנוע לאדמה; דיודת החופש מחוברת במקביל למנוע, והקתודה שלה פונה אל +V_M; הנגד 220 Ω מגביל את זרם הטעינה של השער, והנגד 10 kΩ משאיר את הטרנזיסטור בקטעון כאשר ההדק צף בזמן האתחול של הבקר. הפוטנציומטר בהדק A0 קובע את המהירות.

const int POT = A0;
const int MOTOR = 9;        // PWM pin, 490 Hz
const float VM = 6.0;       // motor supply [V]
unsigned long last = 0;

void setup() {
  pinMode(MOTOR, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int raw = analogRead(POT);
  int x = raw / 4;                  // 0..1023 -> 0..255
  analogWrite(MOTOR, x);
  if (millis() - last >= 500) {     // print twice a second
    last = millis();
    float duty = x * 100.0 / 255;
    float vavg = VM * x / 255;
    Serial.print("raw = "); Serial.print(raw);
    Serial.print("  x = "); Serial.print(x);
    Serial.print("  D = "); Serial.print(duty, 1);
    Serial.print(" %  Vavg = "); Serial.print(vavg, 2);
    Serial.println(" V");
  }
}

raw = 0  x = 0  D = 0.0 %  Vavg = 0.00 V
raw = 205  x = 51  D = 20.0 %  Vavg = 1.20 V
raw = 512  x = 128  D = 50.2 %  Vavg = 3.01 V
raw = 818  x = 204  D = 80.0 %  Vavg = 4.80 V
raw = 1023  x = 255  D = 100.0 %  Vavg = 6.00 V

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

היפוך כיוון בגשר H (H-Bridge)

אם נפתח את ארבעת המפסקים, המנוע יאט מעצמו עד שייעצר — עצירה חופשית. ואם נסגור את S₂ ו-S₄ יחד, הדקי המנוע יקוצרו והוא ייעצר מהר — בלימה.

דרייבר מוכן: L298N ו-L9110:

ברכיב L298N יש שני גשרי H. לכל מנוע שלושה הדקי בקרה: IN1 ו-IN2 קובעים את הכיוון, ו-ENA מפעיל את הגשר; אם נכניס ל-ENA אות PWM, נשלוט גם במהירות. טבלת האמת לפי גיליון הנתונים:

הלוגיקה הפנימית הופכת את המצב IN1 = IN2 לבלימה, ואינה מאפשרת את המצב האסור. הטרנזיסטורים של L298N הם דו-קוטביים, ולכן נופל עליהם מתח ניכר: למנוע מגיע מתח נמוך ממתח המקור, וההפרש הופך לחום ברכיב; לכן נבחר מקור גבוה מעט ממתח המנוע. ברכיב עצמו אין דיודות חופש, ובמודולים מוכנים רבים הדיודות מורכבות על הלוח — נבדוק זאת בשרטוט של המודול. הרכיב L9110 קטן יותר ומתאים למנועים קטנים מאוד; יש לו רק שני הדקי בקרה לכל מנוע, ואת ה-PWM נותנים לאחד מהם.

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

const int ENA = 5, IN1 = 7, IN2 = 8;    // ENA: PWM 980 Hz
const int STEP = 5, STEP_MS = 20;       // ramp: +5 every 20 ms
void setup() {
  pinMode(ENA, OUTPUT); pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT);
  Serial.begin(9600);
}

void ramp(int from, int to) {
  int s = (to > from) ? STEP : -STEP;
  for (int x = from; x != to; x += s) { analogWrite(ENA, x); delay(STEP_MS); }
  analogWrite(ENA, to);
}

void run(int a, int b, const char *name) {
  digitalWrite(IN1, a); digitalWrite(IN2, b);
  Serial.println(name);
  ramp(0, 255); delay(2000); ramp(255, 0);
}

void loop() {
  run(HIGH, LOW, "FWD");
  digitalWrite(IN1, LOW); digitalWrite(IN2, LOW);          // IN1 = IN2
  analogWrite(ENA, 255); Serial.println("BRAKE"); delay(1000);
  run(LOW, HIGH, "REV");
  analogWrite(ENA, 0); Serial.println("FREE"); delay(1000); // EN = 0
}

FWD
BRAKE
REV
FREE
FWD

מנוע סרוו (Servo Motor)

את הזווית קובעים באות של פולסים: פולס אחד כל 20 ms (תדר 50 Hz), ורוחב הפולס הוא שקובע את הזווית. הערכים האופייניים: 1 ms לזווית 0°, 1.5 ms לאמצע ו-2 ms לזווית 180°; אבל מנועים רבים צריכים תחום רחב יותר, מ-0.5 ms עד כ-2.5 ms. נבדוק בגיליון הנתונים של כל מנוע.

ב-Arduino נשתמש בספרייה Servo: הפונקציה attach(pin, min, max) מקשרת את המנוע להדק וקובעת את רוחב הפולס ב-0° וב-180° במיקרו-שניות, והפונקציה write(angle) ממירה את הזווית לרוחב פולס בעזרת הפונקציה map(). בלי שני הערכים האלה הספרייה משתמשת ב-544 µs וב-2400 µs. כאן ניקח את התחום הבטוח 1000–2000 µs, ונרחיב אותו בזהירות לפי המנוע.

#include <Servo.h>

const int POT = A0;
const int SERVO_PIN = 9;
Servo servo;
unsigned long last = 0;

void setup() {
  servo.attach(SERVO_PIN, 1000, 2000);   // pulse at 0 and 180 deg [us]
  Serial.begin(9600);
}

void loop() {
  int raw = analogRead(POT);
  int angle = map(raw, 0, 1023, 0, 180);
  servo.write(angle);
  if (millis() - last >= 500) {
    last = millis();
    Serial.print("raw = "); Serial.print(raw);
    Serial.print("  angle = "); Serial.print(angle);
    Serial.print("  pulse = "); Serial.print(servo.readMicroseconds());
    Serial.println(" us");
  }
}

raw = 0  angle = 0  pulse = 1000 us
raw = 256  angle = 45  pulse = 1250 us
raw = 512  angle = 90  pulse = 1500 us
raw = 700  angle = 123  pulse = 1683 us
raw = 1023  angle = 180  pulse = 2000 us

חוג סגור בתוך הסרוו:

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

מנוע צעד (Stepper Motor)

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

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

28BYJ-48 עם ULN2003:

מנוע הצעד הקטן הנפוץ במעבדה הוא 28BYJ-48 (למתח 5 V), ויש בו גלגלי שיניים פנימיים. בצעד מלא ציר המוצא צריך 2048 צעדים לסיבוב שלם, ובחצי צעד 4096 (ערך אופייני לפי גיליון הנתונים). ההתנגדות של כל סליל היא כ-50 Ω (ערך אופייני לפי גיליון הנתונים), ולכן עובר בסליל 100 mA — הרבה יותר ממה שההדק מספק. לכן נניע את הסלילים ברכיב ULN2003: שבעה מפסקי טרנזיסטור, כל אחד מהם עומד בזרם של עד 500 mA, ודיודות החופש נמצאות בתוכו.

const int IN_PIN[4] = {8, 9, 10, 11};       // ULN2003 IN1..IN4
const byte SEQ[4] = {0b1100, 0b0110, 0b0011, 0b1001};
const long STEPS_REV = 2048, STEP_MS = 3;   // full step, output shaft
int phase = 0;
void coils(byte p) {
  for (int i = 0; i < 4; i++) digitalWrite(IN_PIN[i], bitRead(p, 3 - i));
}
void turn(long steps, int dir) {            // dir = +1 or -1
  Serial.print(dir > 0 ? "CW  steps = " : "CCW steps = "); Serial.println(steps);
  for (long n = 0; n < steps; n++) {
    phase = (phase + dir + 4) % 4;          // next row of SEQ
    coils(SEQ[phase]); delay(STEP_MS);
  }
  coils(0);                                 // coils off: no heating
}

void setup() {
  for (int i = 0; i < 4; i++) pinMode(IN_PIN[i], OUTPUT);
  Serial.begin(9600);
  Serial.print("t_rev = "); Serial.print(STEPS_REV * STEP_MS / 1000.0, 2);
  Serial.println(" s");                     // time of one revolution
}

void loop() {
  turn(STEPS_REV, +1);     delay(1000);     // one revolution
  turn(STEPS_REV / 4, -1); delay(1000);     // quarter back
}

t_rev = 6.14 s
CW  steps = 2048
CCW steps = 512
CW  steps = 2048

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

מנוע צעד דו-קוטבי ודרייבר STEP/DIR:

המנועים החזקים יותר, כמו המנועים של מדפסת תלת-ממד, הם מנועי צעד דו-קוטביים: יש בהם רק שני סלילים, והזרם בכל סליל צריך להתהפך — כלומר כל סליל צריך גשר H. זווית הצעד ברבים מהם 1.8°, כלומר 200 צעדים בסיבוב (ערך אופייני). מודולי ההנעה A4988 ו-DRV8825 מכילים שני גשרי H ולוגיקה מלאה, ולבקר מספיקים שני הדקים: פולס ב-STEP = צעד אחד, והרמה ב-DIR = הכיוון. המודולים מחלקים כל צעד למיקרו-צעדים: עד 1/16 ב-A4988 ועד 1/32 ב-DRV8825, לפי הדקי MS. הם גם מגבילים בעצמם את הזרם בסלילים; את הגבול נכוון בפוטנציומטר הקטן שעל הלוח, לפי הוראות היצרן.

const int STEP_PIN = 3, DIR_PIN = 4;
const long STEPS_REV = 200L * 8;        // 1.8 deg motor, 1/8 microstep
const float RPM = 60.0;
unsigned long periodUs;
int dir = HIGH;

void setup() {
  pinMode(STEP_PIN, OUTPUT); pinMode(DIR_PIN, OUTPUT);
  Serial.begin(9600);
  periodUs = 60000000.0 / (STEPS_REV * RPM);
  Serial.print("steps/rev = "); Serial.println(STEPS_REV);
  Serial.print("period = "); Serial.print(periodUs); Serial.println(" us");
}

void loop() {
  digitalWrite(DIR_PIN, dir);
  Serial.print("DIR = "); Serial.println(dir);
  for (long n = 0; n < STEPS_REV; n++) {     // one revolution
    digitalWrite(STEP_PIN, HIGH); delayMicroseconds(10);
    digitalWrite(STEP_PIN, LOW);  delayMicroseconds(periodUs - 10);
  }
  dir = !dir;                                // reverse next time
  delay(500);
}

steps/rev = 1600
period = 625 us
DIR = 1
DIR = 0
DIR = 1

בחלוקה 1/8 הסיבוב הוא 200 · 8 = 1600 צעדים. הסקיצה מחשבת בעצמה את הזמן בין שני פולסים מן המהירות הרצויה RPM, ולכן כדי לשנות את המהירות משנים רק את הקבוע הזה.

השוואה ובחירת מנוע (Choosing a Motor)

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

סיכום נוסחאות הפרק:

מילון מונחים:

שאלות לתרגול: