מן המסד עד הטפחות: הפעלה ישירה של מנוע סרבו דרך המחשב

לאון מינץ

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

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

מהו מנוע סרבו?

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

אפנון רוחב דופק (Pulse Width Modulation)

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

בשיטת PWM, לעצמת הזרם יש רק שני מצבים: I=I_max ו-I=0.
כפי שניתן לראות באיור, הגל הריבועי מתאפיין במשך זמן בו הוא מקבל את ערכו המקסימלי, ובמשך זמן שבו הוא מקבל את ערכו המינימלי, וסכומם הוא זמן המחזור של הגל.
טווח הזמנים של Imax עבור מנוע סטנדרטי הוא 920μs – 2120μs, כאשר 1250μs מציין את מצב האמצע, והזמן המומלץ עבור I=0 הוא‏ 14ms-20ms^[2].

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

חיווט

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

אזהרה: אספקת מתח הגבוה ממתח העבודה של הסרבו או החלפה רגעית של הקוטביות עלולה לשרוף את המנוע מיידית.

חיבור LPT – מוטיבציה

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

חסרונות

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

כללית, עקרון הפעולה הוא^[3]:

1. שליחה של 1-לוגי ליציאה דיגילית.
2. המתנה של מספר מילישניות.
3. שליחה של 0-לוגי ליציאה דיגיטלית.
4. המתנה של מספר מילישניות.
5. חזרה על כך כמה עשרות פעמים בשניה.

מבוא לתכן לוגי...

כל אחד מ-8 הפינים של היציאה המקבילית יכולים להיות בשני מצבים לוגיים – 1,0 – ולכן 8 הפינים מסוגלים לייצג מספר בן 8 סיביות. כמות המספרים שניתן לייצג היא אפוא 2⁸=256 ולכן טווח המספרים המתאים להפעלת 8 מנועי סרבו שונים במקביל הינו0-255.

#	ביט	דצימלי	בינארי
2	D0	1	00000001
3	D1	2	00000010
4	D2	4	00000100
5	D3	8	00001000
6	D4	16	00010000
7	D5	32	00100000
8	D6	64	01000000
9	D7	128	10000000

דוגמה: נניח כי לכל פין של היציאה המקבילית מחוברת נורת LED. על מנת להאיר את ה-LEDs ה-3,5,9, עלינו לשלוח את המספר הבא ליציאה המקבילית:

‏

‏ (2+8+128)_d=(138)_d=(10001010)_b

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

התממשקות אל היציאה המקבילית

במערכות הפעלה מיושנות (non-multitasking, 16bit) כגון MS-DOS, Win3x, ניתן להריץ קוד פשוט אשר ניגש ישירות אל היציאה המקבילית^[4].
אולם רק מערכות הפעלה של 16 ביט מאפשרות גישה ישירה ליציאות המחשב. מערכות לינוקס וחלונות NT ומעלה לא יאפשרו גישה ישירה ליציאה המקבילית. לכן יש לאפשר גישה זו עם דרייבר מתאים (giveio בחלונות והרשאת root בלינוקס).

פייתון וחבילת pyParallel

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

התקנה

1. התקינו את פייתון^[6].
2. התקינו את pyParallel.
3. התקינו את giveio^[7].
4. רוב משתמשי לינוקס יצטרכו להקליד את הפקודה הבאה על מנת לאפשר גישה ליציאה: rmmod lp

הפעלה

הכנסו לפייתון על ידי הקלדת python בשורת הפקודה.
הפעולה הראשונה היא import, בדומה ל-include המוכר משפת C. לאחר מכן נתחיל לשלוח ביטים ליציאה:

>>> import parallel
>>> p = parallel.Parallel()
>>> p.setData(1)

הדוגמה הבאה מזיזה סיבית 1 ב-4 סיביות ימינה:

>>> p.setData(1 << 4)

קוד לדוגמה

בדוגמה הבאה נגדיר פונקציה המקבלת כפרמטרים שני זמנים: אחד עבור I=0 ואחד עבור I=Imax.

#!/bin/env python

import time
import parallel

p=parallel.Parallel()
p.setData(0)

def my_sleep(sec):
c = time.clock()
while time.clock() - c <>
pass

def startInfLoop(Time1,Time0):
time1=float(Time1)
time0=float(Time0)
while(1):
p.setData(0)
my_sleep(Time0)
p.setData(1)
my_sleep(Time0)

מקביליות

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

לקריאה נוספת

• פרויקטים קהילתיים בקוד פתוח: http://www.openservo.com

סימוכין

[1] וקס, שלמה, בקרת תהליכים באמצעות מחשב, מהדורה ניסויית, הטכניון, 1988.

[2] Fred G. Martin, Robotic Exploration - A Hands-On Introduction to Engineering, Prantice-Hall, 2001
[3] http://www.societyofrobots.com/actuators_servos.shtml
[4] http://www.epanorama.net/circuits/parallel_output.html
[5] http://pyserial.sourceforge.net/pyparallel.html
[6] http://www.python.org/
[7] http://sourceforge.net/project/showfiles.php?group_id=46487&package_id=77441&release_id=150767

המשך...

קוד פתוח נגד זיהום האוויר

לאון מינץ

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

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

החלטתי לשים את היד על הדופק ולעקוב באופן רציף אחר קריאות המנטרים. הייתי אופטימי כשציפיתי שאיגוד ערים חיפה יתן לי את זה ב-RSS. מה שקורה בפועל הוא שיש שני קבצי PNG במסווה של דפי PHP:

• http://www.net4u.co.il/envihaifa/map.php
• http://www.net4u.co.il/envihaifa/Proopin.php

הרעיון הוא לקרוא את המספרים באמצעות OCR. ובכן, שלבי הפעולה הם:

1. הורדת התמונות למחשב עם wget.
2. לאחר מכן יש לבצע cropping עבור המלבנים המעניינים אותנו.
3. לבסוף יש להמיר עם OCR. לצורך כך נשתמש ב-gocr.

אז הנה קוד הפייתון שעושה את כל זה:

import os # for executing wget, gocr
import Image
import ImageFilter as Filter
import ImageEnhance as Enhance

url1='http://www.net4u.co.il/envihaifa/map.php'

url2='http://www.net4u.co.il/envihaifa/Proopin.php'
command1='wget ' + url1 + ' -O map1.png'
command2='wget ' + url2 + ' -O map2.png'

print '===================='
print 'Retrieving map1...'
print '===================='
os.system(command1)
print '===================='

print 'Retrieving map2...'
print '===================='
os.system(command2)

rect={}

rect['Shuk_Talpiot']=[164,132,195,144]
rect['Kiryat_Shprintzak']=[47,102,76,114]
rect['Carmelia']=[62,208,92,220]
rect['Ahuza']=[122,225,153,238]

rect['Einstein']=[153,289,183,300]
rect['Neve_Shaanan']=[237,237,267,249]
rect['Krayot_tunnel']=[256,197,285,208]
rect['Nesher']=[318,307,348,318]
rect['Igud_Arim']=[348,236,377,247]
rect['Kfar_Hasidim']=[449,330,478,342]
rect['Kiryat_Tivon']=[509,429,539,441]
rect['Kiryat_Binyamin']=[480,231,510,244]
rect['Kiryat_Ata']=[499,209,528,221]

rect['Kiryat_Bialik']=[493,87,523,99]
rect['Kiryat_Motzkin']=[488,35,517,46]
rect['Kiryat_Haim']=[379,69,408,80]
rect['Kiryat_Yam']=[444,3,474,16]
rect['DATE']=[13,3,88,18]
rect['TIME']=[97,4,138,17]


rect2={}


rect2['Romema']=[78,21,107,32]
rect2['Israelia']=[182,91,212,103]
rect2['Sapir']=[89,111,119,122]

EXT='.png'
Air_quality={}

print 'Processing map1...'
# Load, convert to Grayscale and Invert colors:
im = Image.open('map1.png').convert('L').point(lambda i: 255 -i)

for obj in rect:
# Crop rectangle and Sharpen:
cropped=im.crop(rect[obj]).filter(Filter.SHARPEN)
if ((rect[obj] == rect['DATE']) or (rect[obj] == rect['TIME'])):
# Date and Time are on different background...
cropped=cropped.point(lambda i: 255 -i)

# Increase contrast:
cropped=Enhance.Contrast(cropped).enhance(2)
cropped.save(obj + EXT)
# Run OCR and store:
Air_quality[obj]=os.popen('gocr -i ' + obj + EXT).read()

print 'Processing map2...'

im = Image.open('map2.png').convert('L').point(lambda i: 255 -i)
for obj in rect2:
cropped=im.crop(rect2[obj]).filter(Filter.SHARPEN)
cropped=Enhance.Contrast(cropped).enhance(2)
cropped.save(obj + EXT)
Air_quality[obj]=os.popen('gocr -i ' + obj + EXT).read()


for obj in Air_quality:
print obj+': ', Air_quality[obj]

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

הכתבה פורסמה גם בלינמגזין

המשך...