משרד החינוך והתרבות מחוז דרום אוניברסיטת בן גוריון בנגב אגף החינוך עיריית ב "ש לשכת הרקטור המחלקה למחוננים ירושלים מעו"ף-למצויינות מרכז לעידוד ולטיפוח למצויינות מרכז יומי למחוננים, מעוף מס' טל': 6415305 08 מס' פקס: 7415812 08 עקרונות בסיסים ברובוטיקה חוברת עזר נכתב ע"י אילן זוהר בהנחית דר' חפצי זוהר מנהלת התוכנית 1
1. המדריך מדריך זה נועד לספק לתלמיד את כל חומר הרקע הנדרש ע"מ לאפשר לו לבנות ולתכנן רובטים בצורה עצמאית על בסיס ערכת.LEGO MINDSTORMS כמון כן מתאר המדריך את כל כלי התקנה הנדרשים כולל כלים גרפים לשמירת הפרויקט. מדריך זה נערך ע"י אילן זוהר ניתן לפנות בשאלות/הערות ל- ilanzoh@bgu.ac.il 2. מבוא חברת Lego משווקת ערכת Mindstorms בערכה זו כ- 700 חלקים של לגו וכן מחשב מרכזי אשר נקרא RCX,מחשב זה מכיל מעבד קטן (H8/300.(Hitachi ערכת ה- Mindstorms מאפשרת ללמוד רובוטיקה על ידי בניית רובוטים פשוטים. כמה אנשי מדע ותעשיה, הבולט שבהם-,Dave Baum ראו ב Mindstorms שילוב מעניין של פלטפורמה מכאנית גמישה ומעבד פשוט וזול השולט בה. עם השנים, פותחו בידי אנשים אילו, סביבות עבודה טובות יותר מאשר הממשק המקורי המסופק ע"י חברת.Lego הסביבה המוכרת שבהם הייתה NQC אשר נכתבה ע"י Dave Baum ואפשרה את תכנות ה- RCX בשפה דמוית C בעלת מגבלות רבות. באוקטובר 1988 נכתבה ע"י Markus.L Noga הגרסה הראשונה של סביבת העבודה.(gcc) Unix סטנדרטי של ++C או C, המאפשרת כתיבה בשפה עילית LegOS המשותף לסביבות עבודה אילו הוא היותם Open source וניתנות להורדה מהאינטרנט ללא תשלום. בשונה מהתנהגותה של חברת Lego במקרים בהם בוצעה העתקה של מוצריה, בחרה Lego "לחבק" את כותבי ומפיצי סביבות העבודה האלטרנטיביות ולתמוך בפועלם, כך שכיום יכול כל משתמש אשר רכש ערכת, Mindstorms להתקין סביבת עבודה אלטרנטיבית ולהשתמש בה כחוק. The mindstorms box: The RCX: 3. אופן הפעולת הערכה המקורית של LEGO לבנת RCX קוראת ומעבדת נתונים משלושה חיישנים (שיכולים להיות חיישן מגע, גלאי אור, מד זווית, מד טמפרטורה, מד לחץ ועוד...) המחוברים לכניסות 1,2,3, ושולטת על שלושה מנועים המחוברים ליציאות.C,B,A התוכנה לבקרת הרובוט נבנית בתוכנה ידידותית בעלת GUI עשיר המסופקת בערכה. התוכנה נטענת ב- RCX באמצאות משדר (Tower) אינפרא אדום שמחובר ליציאת ה- Serial או ל- USB של המחשב. 2
4. מערכת הפעלה אלטרנטיבית הדגש במערכת הפעלה המקורית הוא על קלות התכנות. עם זאת, ישנן מגבלות: אפשר להשתמש בלא יותר מ- 32 משתנים, הקוד מבוצע ע''י Interpreter ולכן הביצוע איתי, קשה "לכתוב" תוכנות מורכבות בסביבה המקורית. יתרונות העיקריים של LegOS הם: הקוד נכתב ב- C או ++C..Interpreter ולא-,Compiler אין מגבלה על מספר המשתנים. תוכניות עד 32K. תמיכה בריבוי חוטים, תמיכה במנגנון עדיפויות. מערכת הפעלה זו תשמש אותנו להקנות את היכולת לבצע מספר פעולות מוגדרות מראש בבנית הרובטים בקורס זה. 3
5. התקנת LegOS במספר שלבים. לרשותך עומד CD ובו כל הקבצים שתצטרכו במהלך ההתקנה אם אתה עובד ב- Windows.Administrator אז בשלבים מסוימים של ההתקנה תצטרך הרשאת ה- NT או,XP,2000.5.1 התקנת Mindstorms tower driver הדרייבר נמצא ב- CD בספריה ב-\ tower diskdrive:\usb שם נדרש להריץ את הקובץ.ReinstallUsbTower בצע BOOT לאחר ההתקנה וחבר את משדר אינפרא אדום. התקנת סביבות משלימות התקן את ה- SDK של לגו ע"י הרצת הקובץ.LEGOMindstormsSDK25.exe הרץ את התקנה של סביבת המעטפת ע"י הרצת.BricxCCSetupCygwin.exe הרץ את השלמה של התקנה ע"י הרצת.BricxCCbrickOSleJOS.exe התקנת מעטפת BRICKCC IDE הרץ את הקובץ bricxcc_setup_33710.exe ועקוב אחר ההוראות לחץ Next על הכול, ניתן להוריד את הגרסא העדכנית מהקישור הבא: latest version של BRICKCC התקנת WinLNP.5.2.5.3.5.4 תוכנה WinLNP מאפשרת תקשורת בין תוכנות Windows וקוביות RCX באמצאות משדר אינפרה אדום של,LEGO או בין RCX ל- RCX. את ארכיון קבצי WinLNP ניתן להוריד מ- http://www.geocities.com/winlnp/ ה- CD שברשותך מכיל שתי גרסאות של :WinLNP אחת ל- USB Tower ושניה ל-.Serial Tower גרסתה- USB לא קיימת באינטרנט בינתיים. בהתאם למשדר שיש לך חלץ את הגרסה המתאימה של הארכיון לספריה.C:\cygwin\lejos\ קימפול של :WinLNP הפעל ++C Microsoft Visual ופתח את הקובץ winlnp.dsw שנמצא בספריה C:\cygwin\lejos\winlnp_serial\src (דוגמא ל- serial ). בתפריט Build בחר בפקודה.Build WinLNP.exe אם הקומפילציה הסתיימה עם 2 שגיאות סימן שצריך להתקין.Service Pack 4 for Visual Studio כעת, אם התקנת גרסת,USB הפעל את הקובץ בספריה,WinLNP USB לצורך עידכון ה-.Registry WinLNPUSB.reg זהו! התקנת את כל התוכנות הדרושות להפעלת המערכת. שנמצה ב- CD 4
6. עבודה עם LegOS שפת C/C++.6.1 הורדת Kernel ל- RCX Kernel של LegOS מחליף את ה- Kernel המקורי של,LEGO לכן בהפעלה ראשונה של RCX יש להוריד אל ה- RCX את ה- Kernel החדש. הרץ את BRICKCC בחר ב- standard ויציאת התקשורת המתאימה: לחץ.OK פתח את TOOLS בחר download firmware בחר את קובץ ה- brickos.srec מדיסק, שים לב ה- RCX צריך להיות דולק הורד את הקובץ. לבסוף תקבל הודעת שגיאה, זה בסדר פשוט הקשר של RCX עם התוכנה אבד. שים לב בטעינת ה- firmware בהתחלה אתה טוען את מערכת ההפעלה ה- standard אחרי שהורדת את ה- SREC צריך לסגור את התוכנה ולהפעילה מחדש ואז לטעון את Legos ולא standard (בגלל זה נוצרת הודעת השגיאה). 5
כתיבת תוכנית עבור RCX כותבים תוכנית בשפת C או ++C תחת תוכנת המעטפת או במעבד תמלילים כלשהו. נניח שכתבת תוכנית helloworld.c שנמצאת בספרית ה- C:\cygwin\brickos\demo טען תוכנית זו לתוכנת המעטפת,BrickCC ע"י בחירה של File/Open קימפול התוכנית.6.2.6.3 נדרש ללחוץ על הצלמית 6
6.4. הורדת התוכנית ל- RCX תהליך הורדת התוכנית לוקח כמה שניות, בזמן הורדת התכנית יודפס סימן המאשר עצם העברת מידע בין המחשב ל RCX בצידו השמאלי של מסך ה.RCX לחץ על הצלמית ע"מ להוריד את תוכנית ל- RCX. שים לב ניתן להוריד לאחת מתוך 5 התוכניות האפשריות כעת ניתן להריץ את התוכנית ע''י לחיצה על כפתור ירוק (run) על גבי,RCX כאשר הורדו מספר תכניות, ניתן לבחור את התכנית הרצויה להרצה עי לחיצות על הכפתור האפור.(program) 7
7. התקנת תוכנת גרפיקה יש להעתיק את שני הקבצים הבאים: הראשית ldraw027.exe ו- complete.exe לספריה. c:\ יש לצאת לחלון (start/run) COMMAND תחת הספריה הראשית ולהריץ את הקבצים בצורה הבאה:,C:\>ldraw027/y o,c:\>complete/y o פרוס את ספרית ה- mlcad300.zip לספריה הראשית \:c לאחר הפריסה תוצר ספריה בשם C:\MLCad_V3.00 כנס לספריה זו והרץ את הקובץ C:\MLCad_V3.00 יופיע המסך הבא שנה את Base Path ע"פ המסך הבא ולחץ OK תשאל שאלה לחצ/י על Y. זה הכול ניתן ליצור קיצור דרך ולהעתיקו ל- Desktop 8. דוגמאות את כל הדוגמאות שמובאות להלן תוכל למצוא בספרית מוכנות לקימפול והרצה על.RCX ה- demo אשר ב- CD כל הדוגמאות 8.1. דוגמת שימוש ב- LCD של RCX 8
דוגמה זו נמצאת בקובץ.lcd.c קמפל אותה, הורד ל- RCX והרץ ע''י כפתור.RUN תוכנית זו מדפיסה מילה TEST על גבי המסך של RCX ולאחר מכן מספרים רצים מ- 1 עד 20. שים לב לפונקציה להדפסת מחרוזת ופונקציה להדפסת מספר הן לא אותו דבר. #include <conio.h> #include <unistd.h> int counter=0; int main() lcd_clear(); /* clears LCD screen (including special characters)*/ cputs("test "); /* prints string on LCD */ sleep(1); /* 1 second pause */ while (counter<=20) lcd_int(counter); /* use this function to print integers on LCD */ msleep(250); /* pause 250 milliseconds */ counter++; דוגמת שימוש בחיישן מגע קובץ: touch.c תוכנית זו בודקת כל הזמן את מצב של חישן מגע המחובר לכניסה מספר 1 של,RCX ומדפיסה על LCD את מצב החיישן (לחוץ או משוחרר). #include <conio.h> #include <unistd.h> #include <dsensor.h> int main() while(1) /* checks the state of touch sensor attached to port 1 */ /* prints the appropriate string on LCD */ if (TOUCH_1==0) cputs("unprs"); /* if not pressed */ if (TOUCH_1==1) cputs("press"); /* if pressed */.8.2 9
8.3. דוגמת שימוש במנועים קובץ: moto.c תוכנית זו מפעילה את המנועים שמחוברים ליציאות C,A קדימה 4 שניות ואחורה 2 שניות. שים לב שיש פונקציה שקובעת את כיוון הסיבוב, ויש פונקציה שמפעילה את המנוע במהירות הרצויה (100 בדוגמה זו). טווח המהירות הינו מ- 0 עד 250. #include <conio.h> #include <unistd.h> #include <dmotor.h> int main(void) motor_a_dir(fwd); /* sets the motor A direction forward */ motor_c_dir(fwd); /* sets the motor B direction forward */ motor_a_speed(100); /* runs the motor A at speed of 100 */ motor_c_speed(100); /* runs the motor B at speed of 100 */ sleep(4); /* sleep 4 seconds */ motor_a_dir(rev); /* sets the motor A direction reverse */ motor_c_dir(rev); /* sets the motor B direction reverse */ /* pay attention that motor continue to run at the same speed */ sleep(2); motor_a_speed(off); /* turns off motor A */ motor_c_speed(off); /* turns off motor B */ 8.4. דוגמת שימוש במד זווית 10 קובץ: rotation.c חבר מד זווית לכניסה מס' 1. תוכנית זו מדפיסה עת הערך שמוחזר ממד זווית. נסה לסובב את החיישן לכיוונים שונים. ערך התחלתי משתנה כל 1/16 סיבוב. מד זווית זקוק למתח אספקה, לכן נדרש לעשות Activate ע''י פונקציה.ds_active #include <conio.h> #include <unistd.h> #include <dsensor.h> int main() ds_active(&sensor_3); /* activates sensor on port 3 */ ds_rotation_on(&sensor_3); /* activates rotation sensor on port 3 */ ds_rotation_set(3,10); /* sets initial value that sensor returns */ while(1) lcd_clear(); /* clears LCD screen (including special characters)*/ lcd_int(rotation_3); /* prints the the value returned from rotation sensor on LCD */ msleep(100); /* pause 100 milliseconds, to prevent LCD blinking */
דוגמת שימוש בחיישן אור קובץ: light.c חבר חיישן אור לכניסה מס' 2. תוכנית זו מדפיסה עת הערך שמוחזר מהחיישן. נסה לכוון את החיישן לאזורים כהים ובהירים..8.5 #include <conio.h> #include <unistd.h> #include <dsensor.h> int main() ds_active(&sensor_2); /* turns the light sensor into active mode (turns on the red light) */ while(1) lcd_clear(); /* clears LCD screen (including special characters)*/ lcd_int(light_2); /* prints the the value returned from lightsensor on LCD */ msleep(100); /* pause 100 milliseconds, to prevent LCD blinking */ 8.6. דוגמה ל- Multitasking 3 קובץ: multitasking.c תוכנית זו מריצה את שני המנועים קדימה. כל לחיצות של חיישן מגע המועים נוסעים אחורה במשך 3 שניות. תוכנית זו מריצה 2 תהליכים: האחד לספירת מספר לחיצות והשני לבקרת מנוע. כל פעם שתהליך המנוע רואה שמספר לחיצות הגיע ל- 3 #include <conio.h> #include <unistd.h> #include <dsensor.h> #include <dmotor.h> #include <sys/tm.h> #include <rom/system.h> pid_t pid1, pid2; // pid_t is a special variable type int touch_counter=0; הוא מפעיל את המנועים אחורה. void touch_sensor() // this thread counts touch sensor clicks while(1) if(touch_1!=0) //if sensor has been touched touch_counter++; cputs(" "); // clear screen lcd_int(touch_counter); // show counter value on LCD msleep(250); // this pause needed to prevent 11
cputs(" "); //triggering counter several times void motor_driver() //this thread drives the motors forward and //checks the number of touch sensor clicks //then drives the motors reverse every 3 clicks. motor_a_speed(100); //drives motors at speed 100 motor_c_speed(100); while(1) motor_a_dir(fwd); // sets the motors direction to forward motor_c_dir(fwd); if (touch_counter>=3) motor_a_dir(rev); motor_c_dir(rev); touch_counter=0; sleep(3); int main() pid1=execi(&motor_driver, 0, NULL, 2, DEFAULT_STACK_SIZE); //start motor thread pid2=execi(&touch_sensor, 0, NULL, 2, DEFAULT_STACK_SIZE); //start touch thread sleep(30); // the program will run 30 seconds. motor_a_speed(off); motor_c_speed(off); kill(pid1); //kill motor thread kill(pid2); //kill touch thread return 0; 8.7. דוגמה לשימוש בסמפורים קובץ: sem.c תוכנית זו מרימה שני חוטים במקביל שממלאים מערך buffer באורך 10. חוט ראשוןמנסה לכתוב "1" למערך, ובמקביל חוט שני מנסה לכתוב "2" לאותו מערך. כמו כן, חוט שני רץ לאט, כי הוא ישן 20 מילישניות במהלך הביצוע. לכן אם מריצים את התוכנית בלי סמפורים אז את רוב המקומות במערך תופסים אחדים והוא נראה כך: 1211121112. נשתמש במנגנון הסמפורים כדי להגן על קטעים קריטיים בתוכנית ולגרום מספר שווה של "1" ו-" 2 " במערך. אז המערך ייראה 12
כך: 1212121212. בסוף התוכנית משדרת את המערך למחשב. כדי לראות את התוצאה במחשב יש #include <conio.h> #include <unistd.h> #include <lnp.h> #include <lnp-logical.h> #include <sys/tm.h> #include <rom/system.h> #include <semaphore.h> 13 להפעיל את TestLNP כפי שמוסבר בפרק "תקשורת בין מחשב ל- RCX ובחזרה". pid_t pid1, pid2; // pid_t is a special variable type sem_t MySemaphore; // variable of semaphore type char buffer[10]; int i=0; void write_to_buffer(int data) if (i<=10) // writes first 10 numbers to the buffer buffer[i]=data; i++; void write1() while(1) sem_wait(&mysemaphore); //wait write_to_buffer(1); // writes 1 to buffer sem_post(&mysemaphore); //signal msleep(1); void write2() while(1) sem_wait(&mysemaphore); //wait msleep(20); //sleep 20 milisecinds write_to_buffer(2); // write 2 to buffer sem_post(&mysemaphore); //signal msleep(1); int main() sem_init(&mysemaphore,0,1); //initialize new semaphore
lnp_logical_range(1); // sets the transitter mode to the long range pid1=execi(&write1, 0, NULL, 2, DEFAULT_STACK_SIZE); // start write1 thread pid2=execi(&write2, 0, NULL, 2, DEFAULT_STACK_SIZE); // start wirte2 thread msleep(1000); // the program will 1 second kill(pid1); //kill write1 thread kill(pid2); //kill write2 thread sem_destroy(&mysemaphore); //destroy semaphore lnp_addressing_write(buffer,10,0x21,1); // sends the buffer to computer return 0; 14
9. תקשורת בין הרובוטים: אפשרויות ומגבלות פרוטוקול תקשורת (LegOS Network Protocol) LNP מובנה במערכת הפעלה.LegOS ערכנו מספר ניסויים כדי לגלות מה היכולת של.LNP להלן הממצאים: כל RCX יכול לשלוח ולקבל הודעות מ- RCX אחר או מהמחשב. כתובת היעד מורכבת ממספר Host ומספר פורט Port. למשל, כתובת 0x01 משמעותה Host מספר 0, פורט מספר 1; כתובת 0x23 משמעותה Host מספר 2, פורט מספר 3. אבל למעשה אין צורך להשתמש במספר :Host כברירת מחדל בתקשורת בין הרובוטים הוא 0, ואז מספיק לרשום רק מספר הפורט, למשל 2, במקום לרשום את כל הכתובת 0x02. אורך תוכן ההודעה מקסימאלי הוא 250. bytes שליחת הודעה באורך מקסימאלי לוקחת בערך שנייה אחת. לכל RCX ניתן לקבוע מספר פורט ייחודי, לו הוא מאזין, הוא יגיב לכל הודעה שנשלחה על הפורט שלו (יגיב הכוונה שייכנס ל-,handler שגרת טיפול בהודעה). ניתן לקבוע ש- RCX אחד יאזין למספר פורטים. ניתן לקבוע שכל הרובוטים יאזינו לאותו פורט. אז ברגע שאחד ששולח הודעה על פורט משותף כולם יכולים לקבל אותה. בנוסף לפורט היעד ולתוכן, ההודעה מכילה מספר ID המזהה של השולח. המזהה הוא מספר בין 1 ל- 15, וזה יכול להיות מספר פורט אליו השולח מאזין או סתם מספר. למשל, אם יש לך הרבה רובוטים שכולם מאזינים לאותו פורט וכולם שולחים על אותו פורט, אתה יכול לתת לכל אחד מספר ID ייחודי לו וכך הרובוטים יוכלו לדעת מי שלח הודעה. השליחה מובטחת, כלומר אם מספר רובוטים רוצים לשדר בו זמנית, הם מצליחים, ע''י כך שמחכים עד שהאוויר יהיה נקי משידורים אחרים. הרובוט תקוע בתהליך שליחה עד שהוא מצליח לשדר. הקבלה של הודעה אינה מובטחת, כלומר אין פה Acknowledge אוטומטי. רובוט ששלח הודעה על פורט מסוים לא יודע האם היעד קיבל אותה. כמובן, ניתן לתכנת acc בקלות ע''י שליחת הודעת אישור מרובוט היעד, רובוט השולח מנסה לשלוח עוד ועוד, עד שמקבל אישור מהיעד. כמובן, לרובוט היעד להחזיר אישור. צריך לעשות הפסקות בין שידורים חוזרים כדי לתת הזדמנות 15
תיאור הפונקציות לשליחה וקבלת הודעות: (נכון להיום פונקציות אילו לא מתועדות בצורה ברורה במקורות אחרים).9.1 הפונקציה לשליחת ההודעה היא: lnp_addressing_write(buffer, length, port, ID) כאשר: buffer מערך של chars לשליחה, באורך עד 250 buffer אורך ה- length port מספר פורט היעד ID מס' מזהה של השולח (ראה הסבר לעיל) o o קבלת הודעות: lnp_addressing_set_handler(my_port, MyPortHandler) כאשר את הפונקציה נ''ל רושמים ב-,main my_port מס' פורט אליו אני מאזין, o MyPortHandler שגרת טיפול שאליה התוכנית קופצת ברגע שמתקבלת הודעה על הפורט שלי. שגרה זו צריכה להיראות ככה: void MyPortHandler(const unsigned char* data, unsigned char length, unsigned char src) כאשר data מערך של chars בגודל length שהתקבל בהודעה מרובוט (או מחשב) עם ID (מזהה של שולח).src שים לב! אסור לבלות יותר מדי זמן ב-.handler מקסימום שאפשר להספיק לעשות ב- handler זה להעתיק את הנתונים שהתקבלו בהודעה למשתנים שלכם ולצאת, אחרת RCX נתקע ודופק את ה-,kernel ואז צריך להוציא בטריות כדי לכבותו, להכניס מחדש, ולהוריד את ה- kernel ואת התוכנית מחדש. כל מה שנאמר פה תקף גם לגבי תקשורת בין הרובוטים למחשב, למעט הכתובת של המחשב, שהיא 0x21 (ראה הסבר בעמודים הבאים). 16
9.2. דוגמת תקשורת מספר 1 lnp_receiver.c קבצים: lnp_transmitter.c מקבל. עבור רובוט משדר, עבור רובוט דוגמה זאת מדגימה תקשורת בין 3 רובוטים: אחד שולח ושני מקבלים, תוך שימוש בפורטים שונים עבור המקבלים. רובוט ראשון שולח הודעה 2 HI על פורט מספר 2, ולאחר 5 שניות שולח הודעה 3 HI על פורט מספר 3. הורד תוכנית lnp_transmitter שלהלן לרובוט הראשון. #include <conio.h> #include <unistd.h> #include <lnp.h> #include <lnp-logical.h> char first_buffer[4]='h','i',' ','2'; // buffer for data to be transmitted char second_buffer[4]='h','i',' ','3'; // buffer for data to be transmitted int main() lnp_logical_range(1); // sets the transmitter mode to the long range lnp_addressing_write(first_buffer,4,2,1); // sends buffer to port number 2 cputs("sent2"); sleep(5); lnp_addressing_write(second_buffer,4,3,1); // sends buffer to port number 3 cputs("sent3"); sleep(5); return 0; שני רובוטים נוספים ממתינים להודעה, ברגע שהם מקבלים הודעה מדפיסים אותה על.LCD רובוט שני מאזין לפורט 2. הורד תוכנית lnp_receiver שלהלן לרובוט שני. #include <conio.h> #include <unistd.h> #include <lnp.h> void MyPortHandler(const unsigned char* data, unsigned char length, unsigned char src) //this is the handler. If someone sends data over port 2 - this //handler will be activated. cputs(data); // prints the received buffer int main() cputs("wait "); 17
lnp_addressing_set_handler(2, MyPortHandler); //sets the handler for listening to the port 2 //change this number to 3 for the third robot sleep(200); return 0; כעת שנה את מספר הפורט האזנה ל- 3, קמפל והורד לרובוט שלישי. הפעל את שני הרובוטים המקבלים. מילה WAIT מופיעה על המסך. הפעל רובוט- שולח ותראה הודעות שמודפסות על LCD של מקבלים. 9.3. דוגמת תקשורת מספר 2 3 קובץ: robot.c דוגמה זו מדגימה תקשורת בין רובוטים שמשדרים ומאזינים לאותו פורט. כל רובוט בעל מזהה ייחודי: הראשון 11, השני 12, והשלישי 13. לכל רובוט יש שני מנועים וחיישן מגע. כל רובוט נוסע קדימה, ברגע שנתקע במכשול (חיישן מגע נלחץ) הוא משדר על פורט 1 "סע אחורה" וכל הרובוטים מתחילים לנסוע אחורה במשך 2 שניות. רובוטים שקיבלו פקודה כותבים על LCD את ID של רובוט ששלח פקודה. הורד את התוכנית שלהלן לרובוט ראשון (המזהה שלו יהיה 11): #include <conio.h> #include <unistd.h> #include <lnp.h> #include <lnp-logical.h> #include <dmotor.h> #include <dsensor.h> char buf[1]; // buffer for data to be transmitted int flag=0; void MyPortHandler(const unsigned char* data, unsigned char length, unsigned char src) lcd_int(src); // prints the ID of the sender flag=1; // to prevent spending too much time in the handler, // I only update the flag that means "go reverse" void reverse() motor_a_dir(rev); // sets the motor A direction reverse motor_c_dir(rev); // sets the motor B direction reverse sleep(2); void send() 18
lnp_addressing_write(buf,1,1,11); // sends rev order to to port 1 cputs("sent "); int main() lnp_logical_range(1); // sets the transitter mode to the long range lnp_addressing_set_handler(1, MyPortHandler); // set message handler motor_a_dir(fwd); // sets the motor A direction forward motor_c_dir(fwd); // sets the motor B direction forward motor_a_speed(100); // runs the motor A at speed of 100 motor_c_speed(100); // runs the motor B at speed of 100 while(1) if (flag==1) // this flag updated in the handler reverse(); flag=0; if (TOUCH_1==1) send(); // call for function that sends a message reverse(); msleep(250); motor_a_dir(fwd); motor_c_dir(fwd); return 0; שנה את מספר ID בפונקציה send ל- 12 והורד לרובוט שני. שנה את מספר ID בפונקציה send ל- 13 והורד לרובוט שלישי. הפעל את שלושת הרובוטים ושחק עם הלחצנים. 19
9.4. תקשורת בין מחשב ל- RCX ובחזרה תוכנת WinLNP מאפשרת תקשורת בין תוכנות Windows לרובוטים. כדי להדגים את התקשורת אנו צריכים תוכנה שמשתמשת בשירותים של.WinLNP אם התקנת כפי שמוסבר בהוראות התקנה בתחילת המדריך אז נמצאת ברשותך WinLNP התוכנה הדרושה: TestLNP בספריה.C:\LegOS\WinLNP\test תוכנית זו כתובה ב- Visual Basic ומריצה את WinLNP ברקע. לדוגמה נרצה להעביר מחרוזת של מספרים 2,4,6,8,10 מהמחשב לרובוט באמצעות.RCX winlnp_to_rcx.c TestLNP ולקבל אותם בחזרה. תחילה יש להוריד את התוכנית ל- תוכנית זו מחכה לשידור, ברגע שמשהו מגיע לפורט 1 היא מדפיסה את עשרת התווים הראשונים של ההודעה על LCD בזה אחר זה במרווח של חצי שנייה, לאחר מכן שולחת את 10 התווים הראשונים של המחרוזת שהיא קיבלה בחזרה למחשב, ומחכה לשידור נוסף: #include <conio.h> #include <unistd.h> #include <lnp.h> int i=0; int flag=0; char *string; void MyPortHandler(const unsigned char* data, unsigned char length, unsigned char src) string=data; //copy the data received from TestLNP to srting array flag=1; int main() cputs("wait "); // waits for transmittion from TstLNP lnp_addressing_set_handler(1, MyPortHandler); //sets the handler to port 1 while (1) if (flag==1) while (i<11) //this loop will print the first 10 numbers // on LCD one after another, from the //string that came from TestLNP. // If the string was less than 10 numbers then the rest of // numbers will be garbge. lcd_int(*(string+i)); msleep(500); i++; 20
return 0; lnp_addressing_write(string,10,0x21,1); //sends the first 10 numbers of the received string back to //the computer. Pay attention to the computer address: 0x21 //That's because computer is on Host 2, Port 1. flag=0; i=0; הפעל את התוכנית ב- RCX והפעל את.TestLNP בחלון שנפתח וודא שמספר פורט הוא 1 ולחץ על.Connect כמו כן ניתן לראות שמספר Host של המחשב הוא 2, ומספר פורט 1, מספר ה- Host אינו 0, לכן בשליחה למחשב יש להשתמש בכתובת המלאה של המחשב, שהיא 0x21. תוכנת TestLNP מבינה רק מספרים הקסאדצימליים, לכן אם נרצה לשלוח 2,4,6,8,10 אז נכתוב בשורת הקלט: 0x2, 0x4, 0x6, 0x8, 0xA ונלחץ על.Send אם הרובוט היה במצב המתנה לשידור אז תיראה מספרים 2,4,6,8,10 רצים על ה-.LCD לאחר מכן תראה בחלון של TestLNP את המספרים ש- RCX שלח בחזרה למחשב. 21
9.5. כתיבת תוכנית לתקשורת בין מחשב ל- RCX בדוגמה הבאה תראה איך משתמשים בשירותים של WinLNP לצורך כתיבת תוכנית לתקשורת עם רובוטים. WinLNP הוא אובייקט COM 3 שמכיל.LNPManager, LNPSession, LNPPort ניתן להשתמש בהם מתוך קומפוננטות: Visual.Studio ההסבר המלא לגבי הקומפוננטות, אופן השימוש בהן וכן צורת הגישה מתוך ++C Visual תמצא באתר של WinLNP (כתובתו מופיעה בסוף החוברת). כאן יודגם השימוש מתוך.Visual Basic פתח פרויקט חדש ב-.Visual Basic תחילה יש לחבר את השירותים של.WinLNP בתפריט.References בחר Project חפש ברשימה את,WinLNP 1.0 Type Library סמן אותה ב- V. אם זה לא מופיע ברשימה אז לחץ על Browse ותצביע אל WinLNP.exe שנמצא ב-.C:\LegOS\WinLNP\Release כעת היכנס לקוד של הטופס (בתפריט View בחר (Code וכתוב את הקוד הבא (תוכל למצוא דוגמה זו בקובץ VBsample.frm בספרית Code ב- ): CD Private MyWinLNP As LNPManager Private MySession As LNPSession Private WithEvents gport As LNPPort Private Sub Form_Load() Set MyWinLNP = New LNPManager Set MySession = MyWinLNP.CreateNewSession() Set gport = MySession.OpenPort(0, 1) 'sets the destination port Call gport.setdataformat(bstr_formatedstring) Call gport.send("0x1, 0x2, 0x3, 0x4, 0x5") 'sends the string to RCX End Sub Private Sub gport_datahandler(byval vdata As Variant) MsgBox (vdata) 'prints the received data on the screen End Sub הורד ל- RCX את winlnp_to_rcx.c (מהדוגמה הקודמת) והפעל אותה, לאחר מכן הפעל את התוכנית שכתבת ב-.Visual Basic תוכנית זו שולחת לרובוט סדרת מספרים על פורט מספר אחד ולאחר מכן מקבלת אותם מ- RCX בחזרה ומדפיסה אותם על המסך. 22
9.6. ניהול הזיכרון הזיכרון ב RCX משותף למערכת ההפעלה ולתכניות המשתמש. אין הגנות מפני גלישה או כתיבה למקום אסור (לדוגמא כתיבה לאינדקס שלילי במערך). אין ספק שחופש פעולה זה פותח בפני המשתמש אפשרויות רבות, (לדוגמא תכנית משתמש המשנה קוד בתכנית משתמש אחרת, התערבות בפעולת מערכת ההפעלה ועוד) אך מצד שני, קל לטעות ולכתוב במקום אסור, ליצור בעיות בזמן ריצה, שקשה מאוד לאתר. סממנים: לאחר כתיבה על מערכת ההפעלה, אלמנטים במערכת ההפעלה יצאו מכלל פעולה (אם לא כל המערכת תקרוס), למשל יתכן מצב שתכן מסך ה RCX ישתנה, RCX יתחיל לצפצף או גם הפרעות שקשה לזהות אך הן פוגעות בריצתה התקינה של התכנית. במצב זה, טעינתה מחדש של התכנית (אם תתאפשר) לא תעזור מפני אין בכך לתקן את פונקציות מערכת ההפעלה הפגועות. יש לטעון את מערכת ההפעלה מחדש ל RCX כפי שתואר בחוברת זו, זאת לאחר ניתוק ה RCX ממקור מתח (הוצאה מהתקע או הוצאת בטריות), וחיבורו מחדש. 23
בבילוגרפיה קישורים באינטרנט http://legos.sourceforge.net/ אתר LegOS המקיף ביותר, מכיל קישורים לכל הספרות הקיימת, מכיל את רוב הקבצים הדרושים להתקנת המערכת. מומלץ מאד להוריד משם את הספר LegOS.Luis Villa מאת Howto http://www.noga.de/legos/ אתר ה- LegOS מאת יוצר המערכת. http://news.lugnet.com/robotics/rcx/legos/ פורום משתמשי.LegOS http://www.geocities.com/winlnp/ אתר WinLNP מאת יוצר התוכנה. מכיל קבצים להורדה והוראות שימוש. חומר רקע ע"י מקסים פלדמן. ספרות.LegOS HOWTO by Luis Villa ניתן להורדה מ- http://legos.sourceforge.net/howto/howto.ps Extreme MINDSTORMS an advanced guide to LEGO Mindstorms by Dave Baum, Michael Gasperi, Ralph Hempel, Luis Villa. קיים במעבדה. G.Martin. Robotic Explorations by Fred קיים במעבדה. 24
LegOS Commands Reference: נספח - 1 Much of this command reference is taken from the LegOS Commands Reference 1.0-0.2.4 written by Dave Chen. Thanks go to him. button input Data Log LCD display LNP, IR networking Math Memory management, allocation Miscellaneous stuff that doesn't fit anywhere else Motor control Semaphores Sensors Sound Strings Task / Thread management 26 27 30 32 34 35 36 37 38 39 40 44 45 25
Button input #include <dkey.h> #include <dbutton.h> Think of your RCX as a computer with a 4-key keyboard. You are also only allowed access to two of the keys, because LegOS reserves use of the other two for itself. With that said, there are only a few things we can think of that you could and would want to do with the keys, so here they are. #define KEY_ONOFF 0x01 //!< the on/off key is pressed #define KEY_RUN 0x02 //!< the run key is pressed #define KEY_VIEW 0x04 //!< the view key is pressed #define KEY_PRGM 0x08 //!< the program key is pressed #define KEY_ANY 0x0f //!< any of the keys char getchar ( ); returns: one of the following KEY types: KEY_ONOFF, KEY_PRGRM, KEY_RUN, KEY_VIEW the input keys are debounced in this routine wakeup_t dkey_pressed ( wakeup_t data ); returns when a key is pressed wakeup_t dkey_released ( wakeup_t data ); returns when a key is released 26
Data Log #include <log.h> The data log is useful for tracking data when your robot is not in range of an IR tower. This was built so as to minimize impact on the rest of the kernel, so it has several bugs that may cause legos to crash. If used as prescribed, however, the data log can be a very useful tool. To use the data log, your program must first allocate space by issuing the command init_log. This command must be issued by your main program thread. If not, legos will probably crash. After your program is finished, the very first thing you should do is retrieve the datalog using the PC-side tools. If you execute a program which does not use the datalog, do not try to download the log, as this may cause legos to crash. int init_log ( size_t size ); Initializes the log, allocating size bytes for it. If a log had already been allocated, the old log is destroyed before the new one is allocated. Returns 1 on success, 0 on failure. int lprintf ( const char *fmt ); Writes a printf-style-formatted string to the log. Returns the number bytes written to the log. void destroy_log ( ); Frees the space allocated for the log int log_size ( ); Returns the log size in bytes int dump_log ( unsigned char addr ); Dumps the log to the specified LNP address 27
Display #include <conio.h> #includ <dlcd.h> This section is a reference for all commands related to controlling the LCD panel. Display positions Digit display positions are denumerated from right to left, starting with 0 for the digit to the right of the running man. Digit 5 is only partially present on the RCXs display. Native segment masks In these bitmasks, bit 0 toggles the middle segment. Bit 1 toggles the top right segment, and the remaining segments are denumerated counterclockwise. The dot isn't encoded. void cls ( ); Clear the user portion of screen void cputs ( char * s ); Display an ASCIIZ string, only the first 5 characters will be displayed. if there are less than 5 characters, the remaining display positions will be cleared Parameters: s - the string to be displayed void cputw ( unsigned word ); Display a hexword, position 0 not used Parameters: word - the word the be displayed void cputc_hex_x ( unsigned nibble c ); Displays a hex value in position X Parameters: c - the value to be displayed void lcd_int ( int i ); Displays an integer on the LCD screen. Position 0 not used. Parameters: i - the integer to be displayed void lcd_unsigned ( unsigned int u ); Displays an unsigned integer value in decimal. Parameters: i - the unsigned integer to be displayed void lcd_digit ( int i ); displays a digit at position 0 Parameters: i - the digit to be displayed void lcd_clock ( int i ); Parameters: i - will be displayed with the format XX:XX void number ( int i, lcd_number_style n, lcd_comma_style c ); fancy number display Number Style: digit, sign, unsign Comma Style: e0, e_1, e_2, e_3 i - the integer to be shown Parameters: n the number style c the comma style void lcd_hide ( char mask ); void lcd_show ( char mask ); 28
hide and show the specified LCD segments Parameters: mask, see below - LCD mask definitions LCD_0_BOT, LCD_0_BOTL, LCD_0_BOTR, LCD_0_MID, LCD_0_TOP, LCD_0_TOPL, LCD_0_TOPR LCD_1_BOT, LCD_1_BOTL, LCD_1_BOTR, LCD_1_MID, LCD_1_TOP, LCD_1_TOPL, LCD_1_TOPR LCD_2_BOT, LCD_2_BOTL, LCD_2_BOTR, LCD_2_MID, LCD_2_TOP, LCD_2_TOPL, LCD_2_TOPR LCD_3_BOT, LCD_3_BOTL, LCD_3_BOTR, LCD_3_MID, LCD_3_TOP, LCD_3_TOPL, LCD_3_TOPR LCD_4_BOT, LCD_4_BOTL, LCD_4_BOTR, LCD_4_MID, LCD_4_TOP, LCD_4_TOPL, LCD_4_TOPR LCD_5_MID LCD_2_DOT, LCD_3_DOT, LCD_4_DOT LCD_A_LEFT, LCD_A_RIGHT, LCD_A_SELECT LCD_B_LEFT, LCD_B_RIGHT, LCD_B_SELECT LCD_C_LEFT, LCD_C_RIGHT, LCD_C_SELECT LCD_CIRCLE_0, LCD_CIRCLE_1, LCD_CIRCLE_2, LCD_CIRCLE_3 LCD_BATTERY_X LCD_ARMS, LCD_1LEG, LCD_2LEGS, LCD_BODY LCD_DOT_0, LCD_DOT_1, LCD_DOT_2, LCD_DOT_3, LCD_DOT_4, LCD_IR_LOWER, LCD_IR_UPPER LCD_EMPTY_1, LCD_EMPTY_2 29
IR networking Assume that none of the LNP commands are thread-safe. The following declarations are used typedef void (*lnp_addressing_handler_t) (const unsigned char *, unsigned char, unsigned char); LNP logical layer commands #include <lnp/lnp-logical.h> void lnp_logical_range ( int i ); Sets the IR range mode. 0 = Short range (~3 ft) 1 = Long Range (>15 ft) void lnp_logical_range_is_far ( ); returns the IR Range setting void lnp_logical_write ( const void *buf, size_t len ); len byte block of memory starting at buf is written to the IR port. You typically will want to use lnp_addressing_write or lnp_reliable_write instead of this, as this provides no addressing functionality. A call to this function waits for the write to complete / fail. returns 0 on success. Any other value signifies a probable collision. void lnp_logical_fflush ( ); flushes the input buffer LNP addressing layer commands #include <lnp/lnp.h> void lnp_addressing_set_handler ( unsigned char port, lnp_addressing_handler_t handler ); sets the handler for incoming data received on port port. Whenever a message is received on the specified port, a call to handler will be made, with the message as a parameter. Parameters: port - the port to set an addressing handler for handler - a function pointer to the function that will handle incoming data on port port int lnp_addressing_write ( const void *data, unsigned char length, unsigned char dest, unsigned char srcport ); Transmits length bytes of a chunk of memory starting at data to dest, with an originating port of srcport. A call to this function will block until the entire message has been transmitted or until failure. Parameters: data - a pointer to the block of memory to be sent length - the number of bytes to send dest - The address to broadcast to. This should be a full address, with both host address and destination port 30
srcport - This is used to tell the recipient which port to send replies to. returns: 0 on success, -1 on failure int lnp_get_hostaddr ( ); returns: the address of the current machine void lnp_set_hostaddr ( unsigned char new_hostaddr ); changes the host address to new_hostaddr. Does not affect existing port handlers. Does not affect reliable connections, but any existing reliable conection should be re-initialized anyway. LNP reliable layer commands #include <lnp/lnp-reliable.h> void lnp_reliable_init ( char dest, int port ); intializes LNP reliable communications with dest. This needs to be called by both sides of the connection before data can be sent. Both sides need to be using the same port number. int lnp_reliable_write ( const void * data, int real_length ); sends a real_length byte chunk of data starting from data across the network. A call to this function will block until either the message has been acknowledged or until a timeout occurs (currently 2.5 seconds) returns: 0 on success, -1 on failure int lnp_reliable_read ( void * data, unsigned char *src ); fills data with whatever has been received from the reliable connection. If src is non-null, then the originating address and port are stored in src. A call to this function will block until data is successfully read. Parameters: data - The buffer to write to src - the place to store the source address. Make this NULL if you don't want it filled in returns: the number of bytes read int lnp_reliable_printf ( const char * fmt,... ); wrapper around lnp_reliable_write for more convenient writing of data across the reliable connection. uses printf style formatting returns: number of bytes written 31
Math floating point math is no longer an issue with LegOS. It used to be, but is not anymore. Use a double the way you normally would, but keep in mind that it's often much slower than integer math. keep in mind that integers in LegOS are only 16-bits. This means that the maximum values an integer and an unsigned integer can have are 32767 and 65535, respectively. So don't do something like "int big_number=100000;" Advanced math routines are available for use in LegOS. Unfortunately, we haven't been able to get them to work under Windows yet. If you want to use any of the following functions (available on Solaris), speak to a TA #include <math.h> double atan2 ( double y, double x ); double sin ( double x ); double cos ( double x ); double tan ( double x ); many others... 32
Memory management #include <stdlib.h> void free ( void *ptr ); Frees the block of memory pointed to by ptr void * calloc ( size_t nmemb, size_t size ); Allocates adjacent blocks of memory, nmemb number of blocks of size individual block size Parameters: nmemb - the number of blocks to allocate size the size of each block returns: a pointer on success, NULL on failure void * malloc ( size_t size ); Allocate a block of memory Parameters: size - the size of the requested block of memory, in bytes. returns: a pointer on success, NULL on failure 33
Miscellaneous int sleep ( int sec ); #include <unistd.h> pauses the current task for sec seconds returns: zero int msleep ( int msec ); #include <unistd.h> pauses the current task for msec milliseconds returns: zero void power_off ( ); #include <rom/system.h> Initiates Software Standby/Low Power mode. On/Off button will reactivate void reset ( ); #include <rom/system.h> Returns control to ROM, ie. Cold Boot int random ( ); #include <stdlib.h> returns: a random integer void srandom ( int seed ); #include <stdlib.h> Seeds the random number generator with value seed long int sys_time #include <time.h> macro that evaluates to the current system time (time up from last firmware d/l) in msec. This is a 32 bit value which will overflow after 49.7 days of continuous operation. 34
Motors #include <dmotor.h> void motor_a_dir ( enum MotorDir ); void motor_b_dir ( enum MotorDir ); void motor_c_dir ( enum MotorDir ); Sets the direction of the specified motor Parameters: MotorDir - one of the following: off, fwd, rev, brake void motor_a_speed ( int speed ); void motor_b_speed ( int speed ); void motor_c_speed ( int speed ); Sets the speed of the specified motor Parameters: speed - an integer value between MAX_SPEED and MIN_SPEED MAX_SPEED is defined to be the upper limit of motor speed MIN_SPEED is defined to be the lower limit of motor speed 35
Semaphores #include <semaphore.h> Semaphores are used to synchronize different threads of control. This course does not place an emphasize on the finer points of synchronization, so don't be surprised or dissappointed if you don't understand any of this. If you have questions, feel free to approach a TA on hours. Semaphores in LegOS are POSIX 1003.b compliant. They must be declared, then initialized, before they can be used. int sem_init ( sem_t *sem, int pshared, unsigned int value ); Initializes a semaphore, giving it starting value of value. Parameters: sem - a pointer to the semaphore being initialized pshared not used by LegOS, usually set to indicate whether the semaphore is shared between processes or not. Just leave it at 0 value The initial value that you want to give the semaphore returns: 0 int sem_wait ( sem_t *sem ); suspends the calling thread until the semaphore pointed to by sem has nonzero count. It then atomically decreases the semaphore count. returns: 0 int sem_trywait ( sem_t *sem ); sem_trywait is a non-blocking variant of sem_wait. If the semaphore pointed to by sem has non-zero count, the count is atomically decreased and sem_trywait immediately returns 0. If the semaphore count is zero, sem_trywait immediately returns with error EAGAIN. returns: a non-zero value if sem was successfully decremented, 0 otherwise int sem_post ( sem_t *sem ); atomically increases the count of the semaphore pointed to by sem. This function never blocks and can safely be used in asynchronous signal handlers. Parameters: sem - the semaphore to post returns: 0 int sem_getvalue ( sem_t *sem, int *sval ); get the semaphore value Parameters: sem - the semaphore sval the integer to store the value of the semaphore into returns: 0 int sem_destroy ( sem_t *sem ); destroys a semaphore object, freeing the resources it might hold. No threads should be waiting on the semaphore at the time sem_destroy is called. Parameters: sem - the semaphore returns: 0 36
Sensors #include <dsensor.h> light sensors may be put into active mode if desired (probably) rotation sensors must be in active mode for proper readings rotation sensors must also be activated with ds_rotation_on touch sensors must be in passive mode for proper readings These constants are defined: LIGHT_RAW_BLACK LIGHT_RAW_WHITE LIGHT_MAX DS_ALL_ACTIVE a macro to set all sensors as active DS_ALL_PASSIVE a macro to set all sensors as passive void ds_active ( SENSOR ); void ds_passive ( SENSOR ); set an individual sensor mode Parameters: SENSOR - must be one of the following &SENSOR_1 &SENSOR_2 &SENSOR_3 void ds_rotation_on ( SENSOR ); void ds_rotation_off ( SENSOR ); sets a sensor into rotation sensor mode Parameters: SENSOR - must be one of the following &SENSOR_1 &SENSOR_2 &SENSOR_3 returns: void ds_rotation_set ( SENSOR, int i ); sets the value of a rotation sensor. Use this to initialize and calibrate your rotation sensors when your program begins. Parameters: SENSOR - see above - i The value to set the rotation sensor to returns: int TOUCH_X macro for touch sensor X. evaluates to zero if touch sensor connected to input port X is released, and non-zero if the touch sensor is pressed. int LIGHT_X macro for light sensor X. evaluates to an integer between LIGHT_MIN and LIGHT_MAX int ROTATION_X 37
macro for rotation sensor X. evaluates to how many 16ths of a revolution the rotation sensor has spun. int SENSOR_X macro for sensor X. evaluates to the raw, unprocessed value returned by the sensor connected to input port X. int get_battery_mv ( ); returns: the battery voltage, in millivolts int BATTERY macro for the raw battery voltage level. use get_battery_mv instead 38
Sound #include <dsound.h> Notes in LegOS are represented by the note_t struct, which is defined as follows: typedef struct unsigned char pitch; unsigned char length; note_t; Normally, you should declare a note_t * and then fill it in. For example: note_t nbc[] = PITCH_C, EIGHTH, PITCH_A, EIGHTH, PITCH_F, EIGHTH, PITCH_END, EIGHTH ; when dsound_play() is called, it will play each note in succession and for the specified duration until it reaches a PITCH_END note, when it will stop. The following pitches have been defined #define PITCH_A0 0 #define PITCH_Am0 1 #define PITCH_H0 2 #define PITCH_C1 3 #define PITCH_Cm1 4 #define PITCH_D1 5 #define PITCH_Dm1 6 #define PITCH_E1 7 #define PITCH_F1 8 #define PITCH_Fm1 9 #define PITCH_G1 10 #define PITCH_Gm1 11 #define PITCH_A1 12 #define PITCH_Am1 13 #define PITCH_H1 14 #define PITCH_C2 15 #define PITCH_Cm2 16 #define PITCH_D2 17 #define PITCH_Dm2 18 #define PITCH_E2 19 #define PITCH_F2 20 #define PITCH_Fm2 21 #define PITCH_G2 22 #define PITCH_Gm2 23 #define PITCH_A2 24 #define PITCH_Am2 25 #define PITCH_H2 26 #define PITCH_C3 27 #define PITCH_Cm3 28 #define PITCH_D3 29 #define PITCH_Dm3 30 #define PITCH_E3 31 #define PITCH_F3 32 #define PITCH_Fm3 33 #define PITCH_G3 34 #define PITCH_Gm3 35 39
#define PITCH_A3 36 #define PITCH_Am3 37 #define PITCH_H3 38 #define PITCH_C4 39 #define PITCH_Cm4 40 #define PITCH_D4 41 #define PITCH_Dm4 42 #define PITCH_E4 43 #define PITCH_F4 44 #define PITCH_Fm4 45 #define PITCH_G4 46 #define PITCH_Gm4 47 #define PITCH_A4 48 #define PITCH_Am4 49 #define PITCH_H4 50 #define PITCH_C5 51 #define PITCH_Cm5 52 #define PITCH_D5 53 #define PITCH_Dm5 54 #define PITCH_E5 55 #define PITCH_F5 56 #define PITCH_Fm5 57 #define PITCH_G5 58 #define PITCH_Gm5 59 #define PITCH_A5 60 #define PITCH_Am5 61 #define PITCH_H5 62 #define PITCH_C6 63 #define PITCH_Cm6 64 #define PITCH_D6 65 #define PITCH_Dm6 66 #define PITCH_E6 67 #define PITCH_F6 68 #define PITCH_Fm6 69 #define PITCH_G6 70 #define PITCH_Gm6 71 #define PITCH_A6 72 #define PITCH_Am6 73 #define PITCH_H6 74 #define PITCH_C7 75 #define PITCH_Cm7 76 #define PITCH_D7 77 #define PITCH_Dm7 78 #define PITCH_E7 79 #define PITCH_F7 80 #define PITCH_Fm7 81 #define PITCH_G7 82 #define PITCH_Gm7 83 #define PITCH_A7 84 #define PITCH_Am7 85 #define PITCH_H7 86 #define PITCH_C8 87 #define PITCH_Cm8 88 #define PITCH_D8 89 #define PITCH_Dm8 90 #define PITCH_E8 91 #define PITCH_F8 92 #define PITCH_Fm8 93 #define PITCH_G8 94 #define PITCH_Gm8 95 #define PITCH_A8 96 #define PITCH_PAUSE 97 40
#define PITCH_MAX 98 #define PITCH_END 255 The following note lengths have been defined #define WHOLE 16 #define HALF 8 #define QUARTER 4 #define EIGHTH 2 void dsound_system ( SOUND ); plays pre-defined system sound SOUND. Currently, only DSOUND_BEEP is a defined system sound. There are no others. wakeup_t dsound_finished ( wakeup_t data ); wakeup function that wakes up the calling thread when the RCX has finished playing any sounds that it is supposed to. int dsound_playing ( ); returns: non-zero if the system is playing a sound, zero if not void dsound_stop ( ); stops any sound playing that is in progress void dsound_play ( const note_t *notes ); Plays an array of notes, as explained above. This is a non-blocking call, so a call to this function will simply set the sound player in motion, it will not wait for it to finish. Parameters: notes - a pointer to the first note to play. The array must end with a note having pitch PITCH_END, otherwise bad things may happen More advanced sound commands are available, but we won't cover them here. Poke through dsound.h if you're interested 41
String functions #include <string.h> A small subset of the standard C string.h has been implemented in LegOS void * memcpy ( void *dest, const void *src, size_t size ); copies a memory block from src to dest of size size bytes returns: dest void * memset ( void *dest, int c, size_t n ); Fills a memory block of size n bytes at dest with byte value c returns: dest int strcmp ( const char *s1, const char *s2 ); performs a lexicographic comparison of two NULL-terminated strings s1 and s2 returns: < 0 if s1 < s2 > 0 if s1 > s2 zero if s1 == s2 char * strcpy ( char *dest, char *src ); copy a null terminated string src into memory block starting at dest returns: dest int strlen ( const char *s ); returns: length of null terminated string s 42
Task/Thread Management Multitasking is going to be crucial to building a robust robot. Make sure you know how to use these commands with at least some ease. It is often said that one of the best ways to learn code is to read through examples and to play with them. See the sample code section for examples on how to use tasks and events. Download some samples and experiment with them, making sure you understand how everything works. pid_t execi ( int (*code_start) (int, char **), int argc, char **argv, priority_t priority, size_t stack_size ); Starts a new thread of control. The new thread begins execution by calling the function pointed to by code_start argc and argv are used for passing parameters to the function code_start, but you most likely will not need them, so just leave them both as 0 for now. Parameters: code_start - a function pointer for where the thread should begin execution priority the priority of the new thread. Should be in between PRIO_LOWEST and PRIO_HIGHEST. Typically, set this value to PRIO_NORMAL plus or minus one or two. stack_size unless you are an elite h4x0r, leave this as DEFAULT_STACK_SIZE returns: the pid of the new thread void exit ( int code ); causes the current task to halt execution and terminate, returning code. This will also free any memory allocated by the task. void kill ( pid_t pid ); Kill task associated with pid as assigned when it was started by execi() void killall ( priority_t prio ); Kills all tasks with priority less than prio wakeup_t wait_event ( wakeup_t (*wakeup) (wakeup_t), wakeup_t data ); Suspends the current task until a call to the wakeup function wakeup returns a non-null value. This is confusing if you are not familiar with function pointers, so see the example on how to use it. void yield ( ); Yields the rest of the current task's timeslice. void systime_set_timeslice ( unsigned char slice ); #include <sys/time.h> Sets the multitasking timeslice in ms. Minimum value of 5 ms. The default value is 20 ms. 43
44
נספח 2 חלקי : LEGO מטרתו של נספח זה הנה לזהות ע"י תמונה את החלקים הבסיסיים של LEGO עליהם דובר בחלקי החוברת השונים. פריט LEGO Robotics Invention System 2.0 תמונה RCX Serial tower 45
Light sensor Rotation sensor Toch sensor Temperature sensor 46
Fast motor (gray) Gear motor (gray) Mini motor (red) סכימת החיבורים: 47
: 3 נספח הנחיות להגשת פרוייקט ברובטיקה עריכת חוברת הפרוייקט הנחיות הגשת הקוד הכנת מצגת הפרוייקט - - - מטרה מטרת המסמך הינה לתת לתלמיד המבצע פרוייקט במסגרת המעבדה ואינו מכיר את נוהלי הגשת הפרוייקט את הרקע וההנחיות הדרושות לביצוע מיטבי של הפרוייקט. עקרונות על הפרויירקט להיות מוגש בצורה העונה בצורה טובה ככל הניתן על הציפיות הבאות : סטנדרטיזציה צורת הגשה אחידה ובהירה שמירת ידע יש לשאוף לצמצום מרבי של הזמן שיידרש למי שיקרא את ספרות הפרוייקט על מנת לרכוש את הידע שנצבר בפרוייקט. זאת הן לגבי טעויות והן לגבי ההישגים. תוצאה זו תנבע מפירוט מרבי של הידע שנרכש, תוך סידורו ומבניות אשר יקלו על הקורא להגיע למידע הרלוואנטי. הדגמת תוצאות על ידי מצגות לרבות בפורמט פאוור-פוינט. חוברת הפרוייקט החוברת חייבת לכלול : דף שער לפי דוגמה מצורפת תמצית הכוללת בין השאר את הנושא, הבעיה, המצב לפני הפרוייקט וההתקדמות שהושגה בפרוייקט תוכן עניינים הצגת הבעיה שהפרוייקט בא לנסות ולפתור הכיוון והדרכים לפתרון שייושמו בפרוייקט ניסויים ושלבי התקדמות תוצאות ומסקנות לגבי כל שלב דיון בתוצאות הכולל: הישגים, כשלונות, כיוונים להמשך ביבליוגרפיה קוד מצגות 48
אופן הגשה ספר הפרוייקט יוגש בשני פורמטים : בצורה מודפסת בצורה אלקטרונית מצגות בסיום הפרוייקט, יחד עם ספרות הפרוייקט יש להציג מצגת אשר מטרתה להדגים את תוצאת הפרוייקט ולהסבירה ברמה מעשית. הפורמט יהיה PowerPoint בתוספת שמוש מירבי במולטימדיה ככל שידרש. על המצגת להיות מוגשת בפורמט נוסף המותאם לרשת בפורמט HTML הקוד הקוד חייב להיות קריא, מובן ולכלול תיעוד מלא ככל האפשר. 49