#1 (2025-01-23)

כן, התחלתי את ההקלטה. אז שלום חבר'ה, לפני שאני מעביר את השרביט למרצה שלכם, למי שלא מכיר, אני שחף, אני מנהל את הקהילה של Embedded Academy.

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

טל היה פה בקורס של AI, ועשינו קורס מרתק על מה זה Machine Learning, מה זה Deep Learning, מה זה בכלל AI. שמח שהוא הצטרף איתנו לעוד קורס.

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

אור הוא גם מרצה בכיר אצלנו שמרצה במועדון המפתחים. יש לנו כל יום ראשון הרצאה בלייב חדשה שאנחנו נפגשים ולומדים על אינסוף תחומים מרתקים, כמו UART ו-IPC ו-I2C, ועשינו גם הרצאה על Yocto ו-Poky ו-FPGA ו-Board Design, עשינו עם EasyEDA, מלא דברים מעניינים, שיש לנו כבר ספריית VOD של עשרות שעות של הרצאות. כיף לראות את זה וככה לפנות את הזמן בשבוע למשהו שאוהבים, מעבר לזה שאנחנו תמיד נותנים הנחות קבועות על קורסים וכניסה חינם למפגשי קהילה ודברים כאלה.

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

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

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

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

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

בבקשה, אור.

## סבב היכרות

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

אני יכול להגיד. אני עובד בתעשייה, מתכנת בקרים מתוכנתים, מנועים, מכונות, כאלה דברים. קצת עשיתי פרויקטים עם Arduino, פרויקטים פשוטים, וקצת תכנתי ב-Java כל מיני תוכניות. זה הרקע שלי. אני לא מתכנת full-time, אני עובד בהחזקה, מתקן מכונות.

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

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

אני עבדתי עכשיו שלוש שנים בחברת אברא ב-Real-Time, Networking, בעיקר User Space. זה בגדול. הידד, אור.

ראיתי היום שמחפשים שני Real-Time חדשים, זה בגלל שעזבת?

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

לעל המיקרופון יש בעיה, אז הוא אומר: "אני כרגע אינטגרטור, בעבר תכננתי 6 שנים ב-C#". יפה, תודה טל.

אני רואה פה את מורן.

כן. אני מורן, גם מתכנת Real-Time בעברי שלוש שנים, ועוד בשנה האחרונה מתכנת בעיקר ב-Linux User Space, דברים שקשורים לראייה ממוחשבת. זהו.

באיזה חברה?

Tandem, אם מישהו מכיר מפה פרויקטים.

מוכר לי Tandem.

חברה נחמדה, מתחרים של אברא.

כן, מנסים למשוך אותנו לאברא, אבל אני כבר לא שם.

רואים אותי? אני מצטער, אני בלי וידאו. אבל אתם שומעים?

כן, שומעים.

אני מהנדס חומרה, אני עובד בחברת PetPace. אני יותר מתמחה בתחום ה-Board Design ורוצה להיכנס לעולם ה-Embedded, בעיקר כרטיסים שקשורים ל-IoT, ובעבר גם עשיתי כרטיסים בתחום המדיקל. נראה לי שאני כבר 7 שנים בתעשייה. עשיתי כל מיני תפקידים, הייתי טכנאי מעבדה עד Board Design בחברה שאני נמצא בה היום. זהו.

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

כן, אני די מתחיל בהכול. אני סוג של System כזה עם נגיעות של אבטחת מידע בפועל. והתחלתי לפני חצי שנה פרויקט של השקיה אוטומטית כזאת עם אפליקציה ו-Arduino ו-Raspberry Pi, ונכנסתי לזה פעם ראשונה, ו-Linux וזה. ומתכנת בכיף, משתדל ללמוד כמה שיותר. מאוד מתלהב להתחיל ולהיכנס לזה.

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

אז היו כבר תקריות.

כן, אבל בגדול פרויקטים מגניבים.

אני אשתף את המסך, אנחנו נתחיל. אני גם אתן את הרקע על עצמי.

## Instructor Info

ברוכים הבאים לשיעור הראשון, שיעור 0 של Embedded Linux Course.

אני אספר קצת על עצמי:

אני עם 10 שנים של ניסיון טכני, כולל בצבא ובכמה תפקידים שאינם פיתוח, ו-7 שנות פיתוח תוכנה. ב-5 השנים האחרונות אני עושה Low-Level Embedded על Linux.

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

יצא לי לעבוד על כמה סוגים של Network Stacks. הרוב אנחנו עובדים רק ב-TCP/IP, אז יצא לי גם לעבוד בעבודה שאותה אני מסיים ביום ראשון על ה-LTE stack של 4G, יצא לי לעבוד על TCP/IP בפרויקט של גילת עם אוהד (עבדנו ביחד), וגם כן TCP/IP ב-Parallels Wireless.

עוד פרויקטים שעשיתי זה תקשורת לוויינית עם כל מיני עבודות על ה-terminal ועל השרת שם. בפרויקט הזה עבדנו על Yocto, על Linux Kernel וקצת Driver Development.

את הניסיון התכנותי שלי ב-Firmware התחלתי דווקא על Microcontrollers, M3 ו-M4 של ARM, בעצם זה ARM על Silicon Labs. זה היה הוונדור. גם ל-IoT Devices, הרבה מאוד דרייברים ברמת החומרה. כל תקשורות שחשובות לנו כאן: I2C, UART, SPI, וכולל גם דרייברים יותר סטנדרטיים מבוססי RS.

לפני זה יצא לי להיות אינטגרטור ו-QA, וגם באיזשהו מקום נגעתי קצת ב-Board Design, אבל רק ברמת ה-Debug של QA.

רוב הפלטפורמות שאני עובד איתן ועבדתי איתן: אנחנו מדברים על Linux, GDB ה-debugger של GCC, FreeRTOS, U-Boot שגם נגיע, Yocto ועוד פלטפורמות מבוססות תקשורת שבהן אנחנו נוגעים כמו MQTT, DPDK ו-XDP.

## Course Philosophy and Goals

אני אשתף קצת על פילוסופיית הלמידה שאני מתכנן לנו לשיעור.

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

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

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

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

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

המטרות של הקורס:

בעצם שכל מי שיסיים את הקורס הזה, תהיה לו את האפשרות לפתח מערכות. אם בעבר פיתוח Embedded Linux היה נחשב System Programming — היום System Programming נחשב משהו אחר, אבל בעבר זה מה שהיה נחשב System Programming — זה בעצם לקחת איזושהי מערכת ולראות אותה בתצורה שונה מזוויות שונות ובעצם לפתח את המערכת.

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

אני רוצה מאוד שמי שיסיים פה יצליח לשלוט גם ב-API וגם ב-...

ה-ABIs, שזה ה-binaries של Linux, ושיהיה לו שליטה מאוד טובה ברמת האפליקציה. הקורס הזה הוא יותר ברמת האפליקציה.

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

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

## Agenda

אז מה יהיה לנו היום? זה ה-agenda שלנו. אני אעבור על זה בזריז כי אנחנו תכף נכנס לכל שקף.

נסביר איך הקורס בנוי, נדבר על ה-repository של הקורס, אני אסביר איך יהיו המטלות של הקורס.

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

נסתכל על הסביבה שלנו. נבין איך לבנות את ה-Virtual Machine, למרות שחלקכם כבר בניתם, אבל אולי יש משהו לעשות לו tweak או משהו כזה.

נדבר קצת על C ו-C++, על ה-compiler של C++, על ה-C library בכללי.

נדבר על הסביבה, נלקנפג את ה-Visual Studio Code, נגדיר SSH connection לכולם.

נתחיל לדבר על CMake, שאנחנו נעבוד עם CMake בקורס הזה, כי אנחנו לא יכולים עכשיו להתחיל ללמוד Make והכל, ה-CMake ייתן לנו את מה שאנחנו צריכים.

ונעשה מבוא קטן ל-Yocto, כי Yocto באמת תופס חלק גדול.

זה מה שאנחנו נספיק לעשות היום. בואו נמשיך.

## איך הקורס בנוי

אז איך בעצם הקורס בנוי? לפני הכל, הייתי רוצה רק לדעת, הבנתי שלחלק מכם יש את החומרה עצמה של הקורס. החומרה הולכת להיות BeagleBone Black. הבנתי שלחלקכם יש את הבורד הזה, ברמת ה-hardware?

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

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

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

אז ככה, כל המטלות והכל אנחנו נריץ או על האימולטור של ה-BeagleBone Black שאנחנו נפעיל, או על ה-Virtual Machine עצמו. ככה שאין שום בעיה. אם אנחנו נעבוד על multi-process וכאלה, אז אנחנו כנראה שנעבוד על המערכת ההפעלה עצמה, עוד שנייה אני אסביר למה. אם אנחנו נעבוד על ת'רדים ועל כל מיני דברים, אנחנו נעבוד על ה-BeagleBone, חומרה גם כן, וכן הלאה.

לפני כל שיעור תהיה הכנה שתצטרכו לעשות. בעצם אני אצור תג ב-Git של השיעור הבא, שאתם בסך הכל צריכים לעשות לו checkout וזה בעצם ההכנה שתהיה. אולי יתווסף עוד איזשהו README אם תצטרכו לעשות עוד כל מיני דברים.

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

אז ככה, אז בעצם כל שיעור הולך לתת תג. התג בעצם יהיה השם של השיעור, אני גם אשלח לכם אותו. בתג הולכות להיות הדוגמאות של השיעור, בעצם מה שאנחנו הולכים להריץ, ה-assignments שיהיו, וגם פתרונות לדוגמה ל-assignments.

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

רק בקשה אחת: אני לא ניהלתי את ההרשאות של כל מי שמגיע ל-Git. זאת אומרת שאתם יכולים ליצור בראנצ'ים לעצמכם, ואתם יכולים לדחוף לשם דברים, רק אל תצרו לי pull requests או כאלה, כי זה לא הולך להגיע ל-main branch, בסדר? אם אתם רוצים לעבוד עם עצמכם ולכתוב, תעשו או fork, או שתצרו לעצמכם branch משלכם. אתם יכולים לקחת כל פעם את התג ב-cherry-pick. אם זה עסיסי, תגידו לי. אתם יכולים לקחת כל פעם את התג ב-cherry-pick, לעבוד עליו, ולדחוף את זה ל-branch שלכם בחזרה. או אם אתם רוצים, אפשר למצוא איזשהו פתרון.

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

- בגדול.

- אוקיי.

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

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

- הכוונה היא שלא נשמור את זה כל אחד כאילו פרטי אצלו? זה כאילו...

- אם יהיו לך קבצים שהם untracked, אוקיי? אז ברגע שתעשה checkout ל-branch אחר, אז הוא לא ייתן לך. אז מה שאני אומר זה או שתעשה stash... אתה מכיר stash?

- לא, לא מספיק מכיר.

- stash זה כמו commit שנמצא מקומית אצלך, בעצם אתה דוחף ל-stash... שכחתי את המילה בעברית. מחבוא? אני יודע, מסתור? אתה דוחף לשם...

- מחסנית.

- מחסנית? לא נראה לי...

- stash זה מחסנית, כאילו. כמו stack.

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

- אני לא הבנתי מתי אנחנו עושים את זה. נגיד אנחנו עכשיו לומדים איזה משהו, כותבים קוד של משהו, בשביל לשמור אותו?

- כן. אל תשמור אותו... אתה יכול או ליצור branch משלך, אוקיי? ואז אתה יכול לעשות commits, וכל פעם שמתחיל השיעור, אז תעשה cherry-pick. אתה מכיר cherry-pick?

- אבל למה שאני לא אשמור את זה בחשבון Git שלי קיים או משהו כזה, בפרויקט חדש או...?

- אה, הבנתי, אתה יכול לעשות fork. fork זה בעצם להעתיק את ה-repository של הקורס ל-repository שלך, ועליו אתה יכול לעבוד עכשיו.

- אה, אוקיי. אוקיי, לא הבנתי מה זה. אוקיי.

- אז זה של fork. cherry-pick אתם גם יכולים לעשות, אני לא יודע איך עובד fork אם אתה צריך להתעדכן בעדכונים שלי לשרת עצמו.

- כן, ב-merging אתה יכול להתעדכן מול השרת... מול הקוד המקורי.

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

- אחלה.

- קול.

## Repository של הקורס

אז זה ה-course repository. בעצם יהיו שמה את ה-assignments, code examples, resources ו-references. אם אנחנו... יהיה לנו reference... אני חושב שכבר יש שם איזשהו reference לדוגמה. זה ה-repository פתוח פה בצד ימין, אז יש לנו בתוך ה-README איזשהו reference לדוגמה על ה-Yocto project. סתם, הקוד לא אומר מה זה, אבל יש כאן איזשהו מידע על זה, איזשהו עוד reference שיהיו כל מיני כאלה. יכול להיות שיהיה ל-toolchain, זה מה שבעצם כנראה יהיה בשיעור הבא. אנחנו כנראה נתקין toolchain ספציפי כדי לבנות Linux. בסדר, בואו נמשיך.

זה ה-link בעצם, נראה לי שלכולכם יש אותו. זה פחות ניתן להעתקה מכאן, אבל אעביר.

## מטלות הקורס

Course assignments. המטרה של ה-assignments בגדול זה לעודד אתכם לעשות את המטלות ולעבור על דברים של השיעור.

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

## ידע מקדים נדרש

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

אז הבנה בסיסית ב-C/C++ programming, בעצם תכנות ב-C, כי רוב הקוד שאנחנו נראה הוא יהיה ב-C. הערה קטנה: אפשר לעשות את הכל ב-C++. אוקיי? כמובן שאפשר לכתוב קוד של C ב-C++ או שיש אינטגרציות של פתיחת קבצים ב-C++. אני עובד ב-C. אוקיי? C זה גם האינטגרציה הכי טובה לתוך Linux, ככה שהדוגמאות יהיו ב-C. מי שרוצה יכול לפתור את זה גם ב-C++ בעצמו.

הכרות של פקודות Git, זה משהו שחשוב. וזהו.

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

## סביבת העבודה

אז בואו נדבר על הסביבה שאנחנו נעבוד איתה. אז יהיה לנו את ה-Virtual Machine. אנחנו נעבוד ב-C ו-C++. את הקוד נכתוב ב-VS Code, לפחות אני אכתוב. אתם מוזמנים לעשות מה שבא לכם. בבקשה לא Visual Studio, אוקיי? כי אין אינטגרציה כל כך טובה. אתם יכולים לעבוד עם... איך קוראים לזה של JetBrains? שכחתי את השם שלו.

- CLion.

- CLion. אתם יכולים לעבוד גם עם CLion. יש לו גם אינטגרציה עם WSL, שזה עוד איזה מכונה וירטואלית, למרות שביקשתי מכם להתקין VM. יש לו גם אינטגרציה עם VM, גם יש לו debugger משלו. רק שאני פחות מכיר אותו, בסדר? אז אם אתם בוחרים לעבוד איתו...

- זה לגבי כאילו איפה אנחנו מריצים את C ואת C++?

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

אז Visual Studio... אנחנו נקים SSH connection לתוך ה-VS Code לתוך ה-Virtual Machine, מי שצריך.

CMake, אנחנו גם כן נעשה עכשיו כאילו... ה-repository שהורדתם הוא לא כולל את ה-CMake file של ההרצה. אנחנו נראה איך ליצור אותו, וגם אנחנו נקמפל לפחות Hello World. אני חושב שבצד ימין פה עשה לכם איזשהו ספוילר, אני אסתיר את זה, אבל אנחנו נעשה איזשהו Hello World. זה מה שנעשה היום.

נדבר על Yocto ועל החומרה של הקורס.

## מכונה וירטואלית

אוקיי, אז מכונה וירטואלית. למה בעצם אנחנו משתמשים במכונה וירטואלית?

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

משתמש במחשב Linux, נכון? אז כל הכבוד על היוזמה. אני לא חושב שזה באמת ישנה לך אם אנחנו על מכונה וירטואלית או לא. אנחנו נהיה מחוברים ב-SSH לתוך המכונה הווירטואלית, אתה פשוט יכול לפתוח VS Code במכונה עצמה.

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

די פשוט לשנות ולהזיז דברים, להוסיף CPUs, להוסיף עוד video memory כדי שזה ייראה נורמלי יותר, וגם אפשר להריץ כמה כאלה אם אנחנו רוצים. במקרה שלנו אנחנו לא נריץ כמה, אבל אפשר להריץ כמה כאלה במקביל.

מה שאנחנו כן נעשה, אנחנו נעשה קצת איזשהו nesting של Virtual Machine. אז יהיה לנו Virtual Machine של מה שנרוץ עליו, שבתוכו אנחנו נריץ את Yocto שהוא בונה באמצעות Docker שזה איזשהו Virtual Machine, ועליו ירוץ ה-QEMU שזה עוד איזשהו Virtual Machine. אז אנחנו ממש נעשה כינון של מכונות וירטואליות.

## Setting Up Your Virtual Machine

אוקיי, אז כדי להוריד, אני מניח שחלקכם כבר הספקתם לעשות את זה. אז או VirtualBox או VMware, באמת שאני לא יודע מה זה משנה. בעבר אמרתי עדיף VMware, היום חזרתי ל-VirtualBox, רק מהפשטות. אחד מהשניים.

בעצם אתם צריכים להוריד את הקובץ ISO של Ubuntu, או גרסה 20 או 22. אני כרגע... וידוי, אני כרגע עם 18, אבל המחשב הזה חוזר לבעליו ביום ראשון ויהיה מחשב חדש.

RAM: 4GB זה מספיק, 8GB זה גם סבבה. ואנחנו צריכים לפחות 65GB של Hard Drive.

למה 65GB? זה המון, אני יודע, בשביל Yocto. ל-Yocto יש הרבה metadata שרץ והרבה שימוש ב-metadata כדי לבנות מערכת הפעלה בגדול.

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

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

אז מי שישתמש ב-4 processes, יכול להיות שהוא יצליח להשתמש בפחות. מי שיותר, יכול להיות שאולי יעבור את ה-65GB. אז אם אתם מאוד לחוצים בגודל, אולי שווה לנסות לעשות adjustment של מספר ה-processes, מספר ה-CPUs במכונה הווירטואלית.

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

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

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

זה הכל. כל שאר הדברים, הגדרות Networking, אני חושב שמה שצריך להגדיר זה בגדול Adapter אחד של Bridge ואיזשהו NAT שיעשה את ההמרה מכתובות שם כביכול... כתובת של רשת לכתובת Private. אז זה מה שאנחנו צריכים.

אנחנו כן נשתמש ב-GUI רק מסיבה אחת, שאחת האפליקציות שנשתמש נקראת GParted והיא צריכה GUI.

בבקשה, אם אתם יכולים תשתמשו בססמאות קלות, זה לא מעניין. אוקיי, עם זה אנחנו עושים adjustments. אם אתם רואים אצלי, יש 69GB בשימוש. באמצעות זה נשים את המערכת הפעלה על SD card, או נשים את המערכת הפעלה באיזושהי צורה אחרת. בעיקר SD card, כי בעצם נשתף את ה-SD. אני אראה את הכל כנגיע לזה. בסדר. שאלות על ה-VM?

- אני התקנתי את זה על המחשב שלי, לא על Virtual Machine.

- זה Linux?

- כן.

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

- או שאני אתקין את זה למחר על Virtual Machine.

- מה שבא לך, זה ישר... קו כזה.

- אני כמוך, עובד על Linux, אז...

- אני איתך באותה סירה, אני גם בלינוקס. יענו בלי Virtual Machine.

- אוקיי.

זה בסדר גמור. רוב האנשים עובדים עם Windows. בסדנה של Yocto התחבר מישהו עם macOS וגם עבד על ה-Mac שלו. בסדר.

## C/C++

## The C Library

בואו נדבר על ה-C Library. על C/C++, על C Library, בעצם השפה שאנחנו נעבוד איתה. הספרייה הבסיסית של C זה בעצם איזשהו אוסף של פונקציות, מאקרואים שאנחנו משתמשים בהם כשאנחנו כותבים ב-C. בעצם כל המילים השמורות שמרכיבות את השפה נמצאות ב-C Library.

בעצם הפונקציונליות שאנחנו מקבלים איתה זה איזשהם tasks שעושים Input/Output, Memory Management, String Manipulation, `strcat`, `strcpy`. יש לנו את `math.h` ועוד הרבה מאוד ספריות שאנחנו מקבלים.

בעצם הספרייה הבסיסית נקראת libc, היא הבסיס של כל אפליקציות Unix שקיימות. אנחנו עובדים על Linux, שהוא בעצם איזשהו sub-section של Unix. ומי שיצר אותו זה לינוס. אבל ב-Linux יש בעצם אינטגרציה מאוד חזקה עם מה שמספקת הקבוצה GNU, שאם אתם מכירים זה החיה כזאת, גנו מופסת.

יודעים מה הרפרנס, נכון?

אז GNU זה בעצם איזושהי קבוצה של מפתחים שפיתחה open source. הם אלה שמספקים ל-Linux כיום את ה-C Library שנקראת GNU C Library, ובעצם מקצרים את זה ל-glibc, ומבטאים את זה או G-lib-C או glibc. אני שמעתי עוד כל מיני דרכים לבטא את זה שכל מיני אנשים ביטאו, אז תרגישו חופשי, אין שום דבר לא נכון.

הרבה מאוד שפות תכנות שעובדים איתן היום, לדוגמה שמעתי Java ו-JavaScript יש אנשים שעובדים, אז בעצם משתמשים ב-C ברקע, וב-C Library ברקע בכלל. משתמשים באיזשהן ספריות שעוטפות פונקציונליות של C בשביל השפה שלהם.

אם אתם מכירים בפייתון יש את Cython, CPython. בעצם בפייתון אתה יכול לבחור מה הקוד שלך יומר בזמן אמת, אני חושב שיש אפשרות ל-C, יש אפשרות ל-Java שנקרא Jython, ויש עוד שפה ששכחתי. בסופו של דבר כולם הופכים להיות C. אבל יש אפשרות כזאת וזה נקרא Cython. אפשר גם לכתוב בפייתון ישירות ב-C אם צריך. לא נגיע לפייתון, זה לא הקורס שלנו.

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

C99 שזה איזשהו וריאנט מתקדם, C11, וגם סטנדרטים חדשים יותר שלוקחים פיצ'רים שפותחו ב-C++ ומתאימים ל-C.

יש לנו את קבוצת הסטנדרט של POSIX. POSIX - אנחנו גם עליהם נדבר, זו איזושהי קבוצה שיצרה סטנדרטיזציה לכל מיני פעולות כמו Threading, Memory Management, Memory Allocation. הם גם כן שגורים בתוך המערכת הפעלה, אז הרבה מאוד מהדברים אנחנו משתמשים שיהיו שלהם ואין לנו מושג. מישהו יצר פה Threading ב-C, אז pthreads, זו דוגמה אחת. POSIX shared memory, נגע בזה, ועוד דברים.

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

## The C Compiler

ה-Compiler. אז בעצם מה ה-Compiler שלנו עושה? הוא בעצם לוקח את ה-source code שלנו והופך אותו בעצם ל-executable code, ל-assembly code שרץ על המכונה.

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

עוד משהו שהקומפיילר יודע לתת זה בעצם error checking. הוא יגיד לך אם יש לך שגיאת syntax בקוד או שגיאות קצת יותר חמורות כמו שאמרתי עכשיו - דליפות זיכרון וכדומה. למה דליפות זיכרון? כי ב-C אנחנו מנהלים את הזיכרון של עצמנו.

ה-Compiler שאנחנו נעבוד איתו הוא GCC. GCC בעצם זה GNU Compiler Collection. זה לא רק הקומפיילר עצמו אלא עוד כל מיני דברים שמגיעים איתו. ואנחנו גם נתקין toolchain מבוסס GCC.

קומפיילרים מתחרים של GCC זה Clang, אם מישהו שמע עליו שהוא אחלה גבר. אני מאוד אוהב את Clang. ויש את החיה המוזרה של Windows. אם אני מלכלך יותר מדי על Windows ואתם מרגישים לא נעים עם זה, תגידו לי ואני אעצור. איך זה נקרא, MSVC? משהו כזה. באמת שרק כ שעבדתי עם זה... אבל יש את הקומפיילר של Windows.

אז GCC הוא בעצם קומפיילר שהוא חינמי, open-source, הוא נתמך על ידי ה-GNU Project, אלה של החיה המופסת. הוא תומך בהרבה מאוד שפות תכנות כמו C, C++, Ada, Fortran ועוד.

בעצם מה שהוא נותן לנו זה cross-compilation. שאני יכול לקמפל גם למכונות מבוססות x86, שזה הארכיטקטורה של Intel ו-AMD בעצם. אני יכול ל-ARM, מה שאנחנו נשתמש כאן בחומרה של הקורס ובאימולטור. יש גם אפשרות לקמפל ל-MIPS ול-PowerPC אם עדיין קיים בעולם. אני יכול להגיד שעשיתי הדרכה לא מזמן לאנשים בעבודה שלי, ואני חושב שאתה צריך להיות בגיל מסוים כדי שתעבוד עם PowerPC, כבר אין כמעט אנשים שעובדים עם זה. וזהו.

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

89, עשיתי 89, 11, אני חושב 16, 14 באמצע, ו-23. משהו, חיה חדשה מעניינת.

למה GCC? בעצם,

מאוד חזק בתעשייה, הרבה מאוד חברות משתמשות בזה. האינטגרציה של GCC לתוך toolchains של Linux היא מאוד חזקה.

יש הרבה מאוד תמיכה, ככה שכל מיני באגים שאתה קורא, כמו למשל... אני יכול לספר על... אני עשיתי המרה מ-Intel ל-AMD אצלנו בחברה,

ובעצם בשלב מסוים גילינו שיש באג ב-GCC 12, שיש איזה בעיית offseting לפעולות מבוססות וקטורים.

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

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

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

אז Yocto הוא בונה toolchain בעצמו. אולי צריך להכניס קצת הסבר מה זה toolchain, יהיה בשיעור הבא גם ככה. Yocto בונה את ה-toolchain בעצמו, כי Yocto בונה הכול. גם על זה אנחנו ניכנס.

וחלק מה-toolchain שהוא בונה הוא עם GCC, אלא אם כן אתה מגדיר לו משהו אחר, כמו Clang וכו'.

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

אז אם אתם עוקבים, אז Ctrl+Alt+T פותח לי טרמינל. אם אני רוצה להתקין רק את ה-GCC, אז `sudo apt install gcc`

או `g++`, ואם אני נותן לו את הפלאג `-y` אז הוא כבר ישר יתקין את זה. סיסמה, כי זה זה, והוא התקין. במקרה הזה זה כבר מותקן, זה הכול.

ואיך אנחנו בודקים את הגרסה? אז זה `gcc --version`. אנחנו יכולים לראות שכרגע לי מוגדר GCC 11.

אנחנו נתקין GCC 11 גם כן. אני חושב ממהגרסאות Ubuntu שלכם, יש איזה פייצ'ר נחמד שאולי נשתמש בו כבר בשיעור הבא, שיותר קל להחליף את הגרסה של ה-GCC.

הרי איפה אנחנו מגיעים עם GCC? בוא ננסה שנייה לחפש איזה גרסאות GCC יש לנו, אז בוא נסתכל: `ls -a`

`ls /bin/g...`

– זה ב-`/usr/bin` אני חושב, לא ב-`/bin`.

– `/usr/bin`.

`ls /usr/bin | grep gcc | less`

אז פה מותקן 11, מותקן 11, 7, ואני חושב שמותקן פה אפילו עוד אחד. בסדר.

אז איך אנחנו מתקינים גרסאות ספציפיות? יש לנו גם פה את זה, בסדר? אז `sudo apt install gcc-11`.

אז במקרה הזה הוא גם מותקן. אבל `g++` שזה ה-compiler של C++, אז הוא לדעתי לא מותקן פה. בוא נתקין 10 בשביל הדוגמה.

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

סבבה, בינתיים נמשיך. אם אני רוצה לקבוע גרסה מסוימת של GCC להיות הגרסה הסטנדרטית שאיתה אני עובד, בעצם כשאני רושם `gcc --version` זו הגרסה שתהיה, אני צריך ליצור מה שנקרא symbolic link.

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

אז אנחנו יכולים להסתכל כאן. ונגיד בוא נראה אם אני זוכר איך רואים את ה-symbolic links, אז `ls -ltrah /usr/bin/gcc`

ואנחנו נראה ש-GCC מצביע על GCC 11. בעצם זה כשעשינו `gcc --version` ראינו שהגרסה היא 11.

שאלות? והנה גם הווידוי, אני עובד עם Ubuntu 18. שאלות?

– יש בעיה אם עובדים בגרסה יותר חדשה מ-11?

– לא, כמובן זה backward compatible. אני פשוט לא רציתי להוסיף sources, אני עובד עם 11 כי הוא הכי מתקדם שהיה על ה-glibc שיש כאן, שמתאים ל-glibc שיש כאן. לא רציתי להעדכן glibc במערכת ההפעלה, כי זה סיפור.

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

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

– במערכות שלנו שהן לא עובדות על מכונה וירטואלית, כאילו גם לי וגם ראיתי עוד אחד, יש GCC 13.3.

– אין שום בעיה. בעצם מגרסה 12 באמת יש את רוב ה-features שצריך, כולל בדיקות סטטיות לקוד ותמיכה בכל מיני ארכיטקטורות.

אם שניכם, אני חושב שאתה עובד עם Ubuntu 20.04... רק דבר אחד, ה-Yocto, אני חושב שבחרתי איזושהי גרסה שהיא יציבה. אני לא זוכר את השם שלה, היא רשומה שם. אני אחזיר לכם תשובה. בחרתי איזושהי גרסה שתהיה יציבה של Yocto.

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

הלאה.

## Visual Studio Code

Visual Studio Code. ה-IDE שאני הכי אוהב להשתמש. IDE זה Integrated Development Environment, זה בעצם סביבת עבודה.

אני אוהב להשתמש בזה, זה חינמי, זה קל, זה נוח. יש את כל ה-features של השלמות קוד, ליצור לעצמנו בעצם קיצורים.

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

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

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

ה-code editing וגם ההשלמה האוטומטית, אנחנו נראה באיזה extensions אנחנו משתמשים, או אני משתמש ואני מציע לכם גם, כדי לעבוד. בעצם באמת אנחנו נהנים. באמת הוא ממש סבבה, גם ה-debugger שלו סבבה. ה-debugger שלו שמתממשק אליו זה בעצם GDB.

אני חושב שמבחינת התממשקות אוטומטית אנחנו ננסה ביחד, כי אני לא הגדרתי את ה-debugger, ואני חושב שהוא כבר מוגדר דרך ה-CMake שיצרתי.

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

אז ככה, יש לנו את ה-editor עצמו, שבבעצם את ה-file explorer ששם עוברים על כל הקבצים שנמצאים. ברגע ש...

מה יש לי פה את הדבר הזה של הזום תקוע, אני לא יודע איך אני מזיז אותו.

– אנחנו לא נראה לי רואים את זה.

– כן, אתם לא רואים אותו, אבל אני לא רואה מה קורה מאחוריו. טוב, בסדר.

בעצם ברגע שפותחים איזושהי תיקייה, ואני כרגע נמצא בתוך ה-virtual machine, אנחנו נראה איך משתמשים בזה. אז ברגע שפותחים איזושהי תיקייה, היא נפתחת כאן, יש לנו את כל הקבצים. יש לנו את הקבצי metadata של ה-VS Code.

שזה סך הכול מוגדר איזה קובץ, איזה סיומת של קובץ, במקרה הזה איזה סיומת של קובץ תהיה באיזה שפה. השפה היא BitBake, למרות שזה לא בדיוק שפה, אבל בסדר.

ייצרתי לנו תיקיית binaries, ששם יהיה כל ה-binaries שאנחנו נריץ במכונה הווירטואלית. build ל-CMake, שגם פה יש את כל ה-metadata שמשתמש בו ה-CMake.

לכל שיעור יהיה לנו lesson, והיום אנחנו ניצור ביחד כדי שנראה מה יש שם. שני התיקיות האלה הם של ה-Yocto, וגם ה-Yocto build, זה עוד תיקייה שבה יהיה ה-Yocto.

את ה-`.gitignore`, בעצם זה כל הקבצים שאנחנו לא נרצה לדחוף לתוך ה-repository, הם נמצאים פה. submodules, אנחנו משתמשים בפרויקט של Yocto כ-submodule, זאת אומרת שזה עוד איזשהו פרויקט Git.

ושאנחנו משתמשים בו, ואנחנו לא נרצה להעתיק אותו אוטומטית, אז יש אפשרות להשתמש ב-submodules. זה איזשהו סקריפט ממש פשוט כדי שיהיה אפשר להתחיל לעבוד בלי להסביר למה. ה-license עצמו של ה-repository, שזה open source, כולם יכולים להשתמש בו.

ואת ה-README שחלקכם כבר עברתם עליו, בסדר? חיפוש, בעצם ברגע שאנחנו מחפשים אנחנו מחפשים בהכול. תקראו, קצת תשחקו. יש מישהו שלא עבד פה עם VS Code?

– שומעים? אני לא עשיתי.

– לא עבדת עם VS Code? Visual Studio Code.

– אני עבדתי.

– אוקיי, אני רואה שגם טל... פספסתי את הדיבור, אני רואה שגם אצלך GCC 13, סבבה לגמרי.

בסדר, אז אם עבדתם כולכם, אז אני מדלג על ה-features כי זה לא מעניין כל כך, ובוא נגיע ל-extensions.

אז ה-extensions שאנחנו משתמשים בהם לפי המצגת, ואני אחזיר את המצגת, אז זה C/C++, C/C++ עצמו. מה שזה נותן לנו זה בעצם השלמת קוד ו-highlight של ה-syntax.

הוא גם האינטגרציה עם ה-debugger של GNU, היא גם קורת ב-extension הזה.

אנחנו גם משתמשים ב-CMake, אז גם ההרחבה של CMake עצמו. גם אנחנו חלק ממנה. אתם צריכים לינקים או שאתם מסתדרים עם זה? או מישהו רוצה איתי?

– אני מתקין בליב.

– והעבודה הבאה, Remote - SSH.

אז באמצעות זה אנחנו נתחבר ל-SSH עצמו, למכונה הווירטואלית, וככה זה נראה. אלה המכונות שלי עבודה, אבל פה יש לנו עוד כל מיני... אלה המכונות שאני עובד איתם. המכונה הזאת ספציפית זה BeagleBone Black, ומנגד זה ה-virtual machine.

בסדר?

– יש לי שאלה. אם ה-CMake וה-C/C++ צריך לקנפג משהו גם חוץ מהתקנה או פשוט להתקין?

– לא, אנחנו עושים הכול משם.

– אה, אוקיי.

ויש את ה-Yocto Project... איפה הוא נמצא פה למטה, אני לא זוכר, את ה-Yocto Project BitBake. מומלץ מאוד.

## SSH Connection

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

יש לנו בעצם encryption, אז בעצם הדאטה שעובר ביניהם הוא מוצפן ואנחנו לא דואגים. נותן לנו את ה-feature של port forwarding שזה בעצם איזשהו, הוא מסתיר את ה-port שבו אנחנו משתמשים ואז אנחנו יכולים להשתמש בו בלי שיראו אותנו מאחורי ה-firewall. ו-file transfer, אז דיברנו על זה לפני רגע.

איך אנחנו מגדירים את ה-SSH connection? אז אנחנו נעשה את זה בלייב.

יש לי שאלה, VSCode מותקן על ה-virtual machine או לא?

VSCode מותקן על המכונה עצמה, ואנחנו מתחברים אליה ב-SSH.

אה, VSCode מותקן כאילו על המחשב שלי ואני מתחבר ל-virtual machine עם ה-SSH.

נכון. כן, כן. זה מאוד נוח. אני חושב שאוהד טוען שככה מתקמפל יותר מהר ה... כאילו נבנה יותר מהר ה-Yocto.

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

אז איך אנחנו בעצם מגדירים SSH? אז אנחנו... דבר ראשון אנחנו מתקינים את ה-OpenSSH server, אז `sudo`... קודם כל עושים את ה-`sudo apt update`, אני מניח שעשיתם את זה כמה פעמים היום. לאחר מכן אנחנו נעשה `sudo apt`...

`apt install`...

`apt install open`...

מציע לי או לא משלים? טוב, בואו נלחץ מקש ה-Tab. `open-ssh`...

`-server`...

`server -y`. אתם רואים זה כבר מותקן, תגידו לי אם אצלכם זה מותקן. לאחר מכן, אנחנו בעצם נריץ את שני אלה. אני לא אריץ אותם כדי שלא ייפול לי הזה, אבל `sudo systemctl enable ssh` ו-`start` או `restart ssh` לעבוד גם כן.

לאחר מכן אנחנו נרצה לקחת את הכתובת IP של המכונה עצמה, או שיש לנו עוד אפשרות לעבוד עם hostname של המערכת. אני אראה איך זה נראה. ה-hostname של המערכת עצמה אצלי הוא נקרא `or-VirtualBox`, וה-username הוא `or`. אז השם של המכונה הוא `or-VirtualBox`, אז בעצם ברגע שאני אעשה כאן SSH, אני יכול לתת את ה-username שזה `or`, ואני אתן את השם של המחשב עצמו שהוא `or`... אני לא יודע מי בחר את השם הזה, אני חושב שזה הגיע אוטומטית, אבל אפשר גם להגדיר אותו. `or-VirtualBox`.

ואז אני לוחץ Enter. אני לוחץ על ה... זה עצמו. אני לא יודע אם יווצר לי עוד אחד נוסף. רגע, סליחה. אני הולך למסך של ה-SSH, אני עושה עדכון, ו... בוא נראה אם נוצר לי עוד אחד. לא נוצר, אבל בעצם אמור להיווצר הדבר הזה. בסדר? ברגע שזה נוצר, אני פשוט יכול ללחוץ כאן והוא יכניס אותי לתוך המכונה הווירטואלית עצמה.

אם אני רוצה לראות איפה אני נמצא או אם אני רוצה לפתוח טרמינל, אז אני עושה Ctrl + Tilde (`~`). Tilde זה הגל הזה לפני 1. ואז אני נמצא בתוך המכונה הווירטואלית עצמה. בסדר? אצלי הדברים נמצאים... אני יכול ניגש ל-Desktop אגב, אני יכול ניגש ל-Downloads, אני יכול ניגש לאן שאני רוצה. אצלי הדברים נמצאים בתוך תיקיית `src` (source, תלוי איך אתם רוצים לבטא את זה), `embedded_linux_course`, ולשם אני נכנס. זו הפקודה: `cd` (זה change directory) לתוך התיקייה עצמה. אז אם אני אעשה `ls` אני אראה כאן את הכל. שימו לב שעכשיו לא מופיע שום דבר ב-folder עצמו, כי בעצם אני לא נמצא כאן, אז אני אלחץ על Open Folder. שוב, `src`, `embedded_linux_course`. והוא יחזיר אותי לכאן. אוקיי? עכשיו אני נמצא פה. הטרמינל שלי משוחזר, אבל אם לא אז פשוט Ctrl + Tilde, יתן לי את הכל. תתעלמו ממה שקורה כאן כרגע. בסדר?

במקרה ואני לא יודע את השם של המחשב שלי, או שאני רוצה לעבוד עם כתובת IP, אז `ip a` יתן לי את כל ה-interfaces שמחוברים. לרוב זה יהיה ה-interface שנמצא על `enp0s3` או משהו שנראה דומה, והכתובת עצמה היא הכתובת הזאתי. בסדר? משמה אנחנו ניגשים.

איך אני מגדיר את ה-SSH להיות ללא סיסמה? שמתם לב שלא הכנסתי סיסמה. אז בואו נסביר גם לכם, כי זה משהו שהוא מאוד נחמד. אז ככה, בתוך המכונה החיצונית או מכונת Windows במקרה שלי, אני הולך ובודק אם יש שם מפתח SSH. אז בואו נעשה פה `clear`. אז איך אני בודק? אני בודק אם יש בתוך `~/.ssh`. ה-Tilde וה-slash בעצם מוביל אותי לתוך ה-home directory, למקום שממנו אני רץ. אנחנו נסביר את הכל, אם זה לא ברור זה בסדר, רק לא היום. `~/.ssh`. ראיתם שהוא השלים לבד ל-`C:\Users\or_sulimani`? או `or_sulimani` כמו שקוראים לי בעבודה הזאתי. ואז בעצם נוצרו לי... ובעצם אני רואה את כל התיקיות שנמצאות. אם נמצא לי `id_rsa` ו-`id_rsa.pub`, זאת אומרת שיש לי מפתח RSA מה-Windows. בסדר? אם אין לי, אני צריך לעשות `ssh-keygen`. אני אראה לכם איך עושים, `ssh-keygen`. זה בעצם ייצר לי מפתח SSH. אני לא אצור אחד כזה, בסדר? כי כבר יש לי אחד. אבל אותו המפתח יגיע לתוך `id_rsa` ו-`id_rsa.pub`.

בתוך המכונה הווירטואלית, ואני ממליץ לעשות את זה מכאן, בתוך המכונה הווירטואלית אני עושה... אני אפתח טרמינל חדש. אותו דבר: `ls ~/.ssh`. רואה שיש לי את ה-`id_rsa.pub`. ואני צריך ליצור קובץ חדש שנקרא `authorized_keys`. אז איך אני יוצר את הקובץ הזה? `nano authorized_keys`. `nano`... פשוט רשום פה את הפקודה, אם אתם צריכים שאני אשלח לכם את זה אז תגידו לי. `nano ~/.ssh/authorized_keys`.

ופה אני מדביק את המפתח SSH שיש לי כאן. אז מכאן אני לוקח אותו, אני לוקח אותו מה-Windows machine, עושה לו `cat` (cat בעצם מציג לי את התוכן של הקובץ). `cat ~/.ssh/id_rsa.pub`. אוקיי, אני לוקח מכאן, מעתיק את זה. ב-Windows מעתיקים עם כפתור ימני, נכון? כן. ואני מגיע לכאן ואני עושה Shift + Insert. Shift + Insert זה ה-Ctrl + C של הטרמינל, ה-Ctrl + V של הטרמינל, סליחה. בסדר, עושה Shift + Insert, בוא נעשה פה עוד אחד כדי שזה... והוא מדביק לי אותו. עכשיו אני אמחק אותו כדי שלא יהיה לי פעמיים.

איך יוצאים מ-nano? nano זה הכתבן של Linux. הוא לא מגיע בכל המכונות כמו vi, אבל יתרון נוח לעומת vi זה שאפשר לצאת ממנו. מי שאי פעם נשאר כלוא בתוך vi... אז מ-nano אפשר לצאת, לא מסובך. אז Ctrl + S זה שומר לי, Ctrl + X אני יוצא. ולאחר מכן אני פשוט יכול להתחבר בלי שום בעיה. אז בוא נעצור את זה כאן, ובלי להכניס סיסמה, סליחה. נסגור את זה מכאן ונמשיך הלאה.

## CMake

CMake. בעצם מה זה CMake? CMake זה בעצם איזשהו קונפיגורטור, הוא בעצם יכול לקנפג לי `Makefile`. מה זה `Makefile`? `Makefile` זה בעצם איזושהי חיה שיצרו כדי שיהיה אפשר לקחת את כל הפקודות קימפול ולחבר אותם ביחד, כדי שאני לא אצטרך להכניס אותם אחת לתוך השנייה. אז זה בעצם איזשהו... אפשר להגיד, לקרוא לזה סקריפט קימפול. אבל זה אפילו יותר מזה, וזה גם נהיה אפילו יותר גדול מזה. אז יצרו... הבעיה היחידה עם `Makefile` זה שה-syntax שלו הוא מאוד קשה, והרבה פעמים אתה קורא `Makefile` ואתה אומר "מה הולך מאיפה ולאן? אני לא מבין מי שכתב את זה מה עשו", או מי שכתב את זה צריך לשבור לו את הידיים ואת הרגליים בשפה אחרת. אז בשביל זה באו גוגל, אגב זה נוצר על ידי גוגל, באו גוגל ויצרו את CMake. זה פרויקט open-source שהוא גם כן cross-platform, זאת אומרת שאני יכול להשתמש בו ב-Windows, אני יכול להשתמש פה ב-Linux, אני יכול להשתמש באותו קובץ כדי ליצור את שניהם, כדי ליצור בינארים לשניהם.

אז בעצם על ידי 10 פקודות מאוד פשוטות אני יכול לייצר לעצמי `Makefile`, ואנחנו גם נראה איך עושים את זה עכשיו, וזה מה שאנחנו נעשה עוד רגע. הסיבה שעשו אותו זה בעצם כדי לעשות את הבנייה הרבה יותר פשוטה, או ליצור איזשהו סטנדרט. אני לא יודע אם יצא לחלקכם לעבוד עם מכונות של... עם IDE-ים של Eclipse, אני חושב שהרבה פעמים עובדים איתם. אז Eclipse מייצר לך ברקע `Makefile`, אבל זה איזשהו משהו שהוא חיה לא מובנת, הסט חוקים הוא של Eclipse, משהו כזה, ומאוד קשה בעצם לתחזק את זה ולהוסיף משהו, אתה צריך להתחיל לחפש בכל מיני מקומות, כל מיני הגדרות וכל מיני מסכים. CMake בא גם לפתור את זה.

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

אז לפני כל שיעור תיווצר תיקייה של lesson או יותר דברים, תלוי במה שיהיה בתוך התג. בתוך ה-lesson יהיה לנו את ה-assignments, אוקיי? את ה-assignments עצמם. ואם נרצה לבנות אותם בתוך המכונה, או אם נרצה לתת ל-Yocto לקחת אותם, אנחנו נצטרך ליצור איזשהו קובץ CMake, או לבנות מכאן, או לקשר ל-Yocto, או גם וגם. אפשר גם להעביר flags דרך Yocto. אז זה ממש נחמד. אפילו רשמתי את זה פה כבר.

איך אנחנו מגדירים את ה-CMake, אוקיי? אני קצת אקטין. אז F1 בתוך ה-VSCode, הוא פותח לי את ה-command palette. אם אתם רוצים לעשות בצורה אחרת, אני חושב ש-Shift... לא, Ctrl + P ואז את ה-`<`, או Ctrl + Shift + P, אחד מהם. ברגע שאני מתקין את ה-extension, אז אני יכול לעשות `CMake` ואז `Build`. ואם זה הפעם הראשונה, אז הוא בעצם ייסרוק את כל ה-toolchains ויציע לי toolchain. יובל, אתה עוקב? הוא הציע לך?

לא, לא ראיתי משהו. פספסתי נראה לי מה עשית. כתבת `CMake` שם?

עשיתי F1, `CMake: Build`.

אה, `CMake: Build`.

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

כתבת פשוט `CMake` רווח `Build`, זהו?

כן. `CMake`. אתה רואה זה הפקודה הראשונה.

הוא מציע לי Online Help.

מותקן לך ה-extension של CMake?

אמור להיות כן.

הייתי רוצה גם להתקין את ה-extension של זה. אני חושב שזו הסיבה, אבל CMake Tools, בסדר?

אצלי כבר התקנתי אותה, בסדר?

‏**משתתף:** אוקיי, אה CMake Tools, לא.

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

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

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

```bash

cmake ..

```

הוא בעצם יעשה את השלב של הקנפוג, ואני עושה:

```bash

make

```

והוא בונה את מה שעשינו כאן. אלו השלבים, ו-make clean מוחק את הכל.

## יצירת קובצי הבינארי וניקוי הפרויקט

כאן, אז פה יוצא הקובץ הבינארי. בוא נעשה את זה גם ביחד.

אז שימו לב שאין לנו כרגע בינארי, יש לנו רק את הקובץ gitkeep, כדי שתסומן ותישאר התקייה הזאתי ב-Git.

אז `cmake ..` מקנפג משהו. אני אפילו אמחק את כל השאר כדי שתראו שהוא גם עושה את זה. רגע, חוץ מה-gitkeep.

מהתחלה: `cmake ..`

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

ברגע שאני מעדכן, נוצר לנו Makefile. זה בעצם ה-Makefile שיוצר לנו ה-CMake. כמו שאתם רואים, הרוב לא מובן, אבל אפשר לראות שה-shell שאנחנו משתמשים הוא `/bin/sh`. זה לא קריטי לנו כאן, זה ה-directory. אם אנחנו אי פעם צריכים לדעת איזשהו סימבול בשביל, ואנחנו גם נראה את הסימבולים שאנחנו משתמשים בהם כדי לבנות, אז פה הם מוגדרים.

אצלנו ה-CMAKE_SOURCE_DIR מוגדר כ-`/home/or/embedded_linux_course`, והבינאריים הולכים... לא לתוך ה-build, או שזה משתנה per תקייה, בוא נסתכל שנייה. כן, את הבינאריים הגדרתי אותם שיצאו... טוב, זה כנראה לא קרה, או שלא הגדרתי את זה. לא אמבלבל אתכם יותר מדי.

פה כל הפקודות של ה-make שמשתמשים בהן: make all זה מה שהוא יוצר לנו, clean כמו שעשיתי, ו-make רק ל-hello_world, שזה מה שאנחנו נבנה ביחד.

עכשיו, בעצם אם הייתי רוצה רק ליצור את ה-hello_world, אז אני אעשה make clean כדי שיימחק. אם אני רוצה ליצור את ה-hello_world, אז:

```bash

make hello_world

```

אם זה לא ברור זה בסדר. בעצם יצרתי את ה-hello_world והוא יופיע פה בבינאריים. וברגע שאני עושה make clean, זו הפקודה שמוחקת את הבינאריים ואת המטא-דאטה של ה-Make, לא של ה-CMake, אז נעלם לי ה-hello_world. ואם אני אעשה שוב make, אז הוא יעשה make לכלום. במקרה שלנו זה רק אחד, וזה ה-hello_world.

אנחנו לא נריץ אותו כרגע כי זה לא התכנון.

## עבודה מול ה-Repository

יובל, אני יודע שאתה רץ. חוץ מיובל, עוד אנשים רצים איתי תוך כדי?

‏**יובל:** לא אמור להיות אצלנו את ה-hello_world, נכון?

לא, אנחנו ניצור אותו עכשיו.

‏**יובל:** משהו פה לא עובד לי עם ה-CMake. עדיין אין לי את... אני עושה לו cmake build... אתה יכול רגע לעשות את זה שוב? לראות רגע מה זה נתן לך שם?

בוא נעשה כזה דבר. יש לך את התקייה של ה-build, היא מופיעה?

‏**יובל:** לא, אני עדיין לא משכתי בכלל את ה-repository. אין לי פה את ה-repository.

אה, לא עשית קלון?

‏**יובל:** לא עשיתי עדיין קלון.

אה, אוקיי, בסדר גמור.

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

```bash

cmake ..

```

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

אם אתה רוצה למחוק את כל המטא-דאטה ולהתחיל מחדש, אתה יכול למחוק מכאן, או פשוט בפקודה:

```bash

rm -rf *

```

שימו לב שאתם לא עושים `rm -rf /*`, כי אז אתם תמחקו את כל מערכת הקבצים.

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

```bash

rm -rf build/*

```

את כל מה שבתוך build, אוקיי?

תמיד עדיף לראות לפני שמוחקים, אז בעצם אם אני אעשה ls לכל זה, אז הוא ייתן לי את כולם, ואז אני יכול פשוט להחליף את ה-ls ל-`rm -rf`. ועכשיו אני אעשה כאן ותראו שיימחק פה הכל חוץ מה-gitkeep שהוא קובץ מוסתר.

אותו דבר גם לתקיית bin. ותקיית bin אנחנו צריכים גם שיהיה מסודר יותר וגם בשביל ה-Yocto. וזה נכנס גם כן לכאן, אוקיי?

## הגדרת קיצורי מקלדת ב-VSCode

אז ככה, בואו נגדיר shortcuts כדי שאם אני אומר משהו אז זה יהיה ברור גם לכם. בשביל להגדיר את השורטקאטס הזה, אנחנו נעשה F1.

נרשום Shortcuts. אצלי עשיתי את זה בצורה קצת מכוערת מקודם, אז בוא נסדר איך יפה לעשות את זה: Open Keyboard Shortcuts.

נשים אותו כאן. אני שנייה ארחיב את המסך.

ואת זה נפתח ככה, ונשים פה עוד shortcut כדי שנוכל להעתיק מה-shortcut שלי. אז נפתח את ה-keybindings שנמצאים כאן.

וה-shortcuts שאנחנו מחפשים זה ל-clean ול-make, ו-F7 אוטומטית מגדיר לנו ה-extension.

אז אם אנחנו נלך לכאן, נלחץ על Enter, כאן הוא בעצם יגיד לי "תכניס לי איזושהי קומבינציה של קיצור כדי שאני אוכל ליצור". אז אם אני אלחץ Ctrl+F7, הוא יבקש להכניס. אבל אם אני ארצה להפוך את זה למשהו, סליחה.

איך אני בעצם עושה? אני אלך ומחפש: `cmake: configure`

`CMake: Configure`

כבר מופיע keybinding, אבל אני אראה לכם איך עושים את זה לבד. דאבל קליק, Ctrl+F7, זהו, ו-Enter. ואז אנחנו עושים את ה-configure.

אותו דבר גם ל-`cmake: clean`

`CMake: Clean`

אם אני דורס למישהו מכם את ההגדרות, אתם יכולים להגדיר משהו אחר. רק שימו לב שכשאני אומר Ctrl+F8 או make clean ואני לוחץ Ctrl+F8, תעשו לעצמכם את ה-symbolic link ותעשו את זה איך שאתם רוצים.

אז Ctrl+F8 זה יהיה Clean, אז לחצתי דאבל קליק ועשיתי Enter.

אם אני רוצה את ה-build עצמו, הוא כבר מוגדר ב-F7. זה מגיע מה-extension עצמו.

סבבה? זה היה ברור?

יופי.

## מבנה הקובץ CMakeLists.txt

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

מה שאנחנו עושים ב-CMake, אנחנו צריכים להגיד איזה גרסאות אנחנו תומכים. זה לא משנה, אני עשיתי מגרסה 3.1 עד 3.27, ואפשר אגב סתם לעשות את הגרסה שיש על המערכת. אני עשיתי את זה כדי שאם לכם יש גרסה שונה, תוכלו להריץ.

אבל בוא נסתכל באמת איזה גרסה יש לנו על המערכת:

```bash

cmake --version

```

אצלי יש 3.10, מה שמופיע כאן. הגדרתי את השם של הפרויקט. השם של הפרויקט הוא `embedded-linux-class`.

בעצם הוספתי איזשהו פלאג שמי שיצא לו להריץ פקודות של GCC, אז `-g` בעצם נותן לי את האפשרות לעשות export לכל הסימבולים שבמערכת, כדי שהדיבאגר יידע מה אני מריץ בזמן שאני מריץ. זה הרבה יותר איטי, אבל אפשר לדבג באמצעות זה, ואני אראה לכם עוד רגע איך. אני חושב שהאינטגרציה עובדת out of the box, ואם לא אז בלחיצה אחת אנחנו נעשה את זה בשורה אחת.

הגדרתי את ה-output directory. אם אתם זוכרים שמקודם ראינו בתוך הקובץ build, בתוך ה-Make, איפה זה מוגדר, מה זה ה-CMAKE_BINARY_DIR, שזו התקייה אליה ייווצרו כל התוצרים שלנו.

אז בואו נעשה את זה שוב:

```bash

cd build

```

ו-cmake. בואו לא נעשה `cmake ..`, נשתמש בקיצורים: Ctrl+F7. אז בעצם את כל התוצאה הוא נותן לי לתוך המסך. אם אני עושה Ctrl+~ הוא חוזר. ותראו כשאני עושה ls אז יהיה לי פה את הכל. עוד משהו נחמד ב-VSCode, אם אני לוחץ Ctrl ועל הקובץ עצמו, הוא יפתח לי אותו. נחמד, נכון? אין על VSCode.

אם אני מחפש עכשיו, בוא נלך לכאן ונחפש את זה, הוא יגיד לי איך מוגדר הסימבול הזה. Ctrl+F זה החיפוש. הוא אומר לי שזה נמצא בתקיית ה-HOME directory שלי, לתוך ה-user, לתוך `src`, `embedded_linux_course`, ו-`build`. אז הסימן הזה אומר תקייה אחת אחורה. אני חוזר תקייה אחת אחורה בעצם לתיקייה הזאתי, כי התיקייה הזאתי היא build.

יכולתי גם האמת לבחור את התקייה הזאתי ככה ישר.

אבל בואו לא נשנה סדרי עולם תוך כדי התצוגה כדי שלא יהיו שום דברים.

פה אני מגדיר לאן ייווצרו הבינאריים, בעצם לאן ייווצרו כל הקבצים שאני בונה. כאן אני מגדיר קומפיילר, אני חושב שזה מגדיר אוטומטית. אני העתקתי את זה מאיזשהו CMake שלי שאני עובד איתו גם עם Clang וגם עם GCC ל-g++, אבל במקרה שלנו אנחנו צריכים רק GCC.

`find_package`: יש אפשרות, במקום שעכשיו אני אצטרך לחפש את ה-`-l` וכל מיני דברים, אני פשוט אומר לו איזה package. זו החבילה של threads שנותנת לנו pthread, וככה אנחנו מקמפלים עם זה. אין לנו צורך בזה כרגע, אבל לשם הדוגמה הכנסתי את זה לכאן.

ובעצם איך שעובד ה-CMake, אני יכול לתת לו `add_subdirectory`, שזה כמו include, למרות שיש include שזה משהו אחר, אבל זה בעצם אני אומר לו "אני רוצה גם שתנסה לקמפל עם מה שנמצא בתוך תקייה". אז לכם אין את התקייה הזאתי, lesson_1, אוקיי? אז אני אבקש מכם ליצור אותה. איך אנחנו יוצרים תקייה ב-Linux?

אנחנו חוזרים ל-path, למיקום של ה-repository, בעצם מה שנקרא repository level. בתוכה אנחנו עושים:

```bash

mkdir lesson_1

```

אנחנו ניצור את זה היום ביחד, בדרך כלל יהיה לכם את זה כבר. אז lesson_0, שזו הראשונה. אתם רואים אם הוא קיים לנו.

אז בתוך התיקייה עצמה, אני אראה לכם מה נמצא: `ls lesson_0`. נמצאים כמה דברים, איזשהו משהו שאני רציתי שיהיה סטנדרטי, אבל אני לא חושב שזה יהיה נוח עם Yocto.

בגדול איך שאני עובד כשאני לומד דברים, יש לי קובץ CMakeLists.txt שהוא יודע לעבור על כל הקבצים שנמצאים באיזשהו sub-directory ומקמפל אותם לתוך זה. אנחנו לא משתמשים בו. אם מישהו רוצה את ה-CMakeLists.txt הזה, שיגיד לי.

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

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

ואני צריך לתת את כל ה-sources. בעצם ה-sources שנתתי זה כל ה-sources שנמצאים בתוך תיקיית hello_world, שאתם צריכים ליצור אותה בעצמכם. אז שוב, כבר הבנו איך יוצרים, אנחנו ניכנס לתוך lesson_0 וניצור תיקייה חדשה שנקראת hello_world. נרשום `mkdir hello_world`. יש גמישות פה תמיד, שזה נחמד.

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

## יצירת קובץ C ו-Hello World

יש כמה אפשרויות ליצור קובץ. בואו אני אראה שתי אפשרויות. יש לנו `touch`, שהוא פשוט מייצר את הקובץ. נפתח קובץ `hello.c`, ואם נעשה `ls` אז הוא ייצר לנו כאן. ואם אני רוצה לפתוח אותו בטרמינל, אז אני צריך למצוא אותו ואז ליצור אותו. זו דרך אחת שתמיד תעבוד בכל תצורה.

הדרך הנוספת היא להשתמש ב-VSCode. נרשום `code hello.c`. מה שהוא יעשה, הוא יפתח אותו וכבר ייתן לנו את זה, וברגע שאני אעשה Ctrl+S הוא יוצר לי את הקובץ.

עכשיו בואו נעשה איזושהי תוכנית פשוטה של Hello World:

`#include <stdio.h>` – זה בעצם Standard Input and Output.

ניצור `main`. ראיתם את ההשלמה האוטומטית, זה מה שנותן לנו ה-extension שאנחנו משתמשים בו.

נעשה `printf` – זה print formatted, בעצם איזושהי אפשרות לעשות פורמט. נהיה קצת קרינג'יים ונרשום לא רק Hello World, נרשום Hello בשם של הקורס: Embedded Linux Class.

נעשה `\n`. מה קורה בעצם כשאנחנו עושים `\n` ולמה אנחנו צריכים לעשות את זה? ברגע שאנחנו עושים `\n`, ה-Standard Output יודע שהוא צריך לעשות flush למסך. מה זה flush ומה זה מסך אנחנו נדבר על זה, אבל בעצם כשהקורא קורא את התו הזה, הוא יודע שהוא זורק את כל מה שקרה עד עכשיו לתוך המסך. נקודה פסיק, ואנחנו מחזירים 0, זה אומר שרצנו בלי שגיאה.

## קומפילציה והרצה באמצעות CMake ו-VSCode

עכשיו אנחנו נבנה את זה. איך אנחנו בונים את זה? יש לנו שתי אפשרויות. אפשרות אחת זה איך שהראיתי מקודם. אפשרות שנייה היא פשוט לעשות F7. אם אנחנו בתוך הטרמינל ולא עובד לנו מה שרצינו, אפשר בלחיצה על Alt+F7 והוא יריץ לנו את זה ככה.

אם הייתי רוצה לקנפג מחדש, למשל אם הוספתי קובץ חדש, אז צריך לעשות Ctrl+F7. במקרה הזה לא באמת צריך לקנפג מחדש כי אלה אותם קבצים, אז זה לא שינה לו. אז Ctrl+F7 ו-F7. אם אני רוצה למחוק את זה, Ctrl+F8, ואז לא יהיה לי פה תוצר. ואז שוב רק F7, כי הקינפוג עצמו בנוי, ונוצר לי הקובץ.

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

מקש Ctrl+~ יקח אותי בחזרה אל הטרמינל. אני אלך למקום שבו נמצא ה-bin: שתי תיקיות אחורה לוקח אותי ל-embedded_linux_course, ומפה אני הולך לתוך ה-bin. ברגע שאני כאן, יש לי את hello_world.

אם מסתכלים עם `ls -la` (עוד לא למדנו על זה), זה ייתן לי את הרשאות הריצה, הכתיבה והקריאה שלו. נסתכל ויש לכולם x, זה אומר שאני יכול להריץ את זה. אז נריץ `./hello_world`, ובירכנו לשלום על ידי התוכנית הזאת! כל הכבוד לנו, מה שנקרא שלום לכיתה א'.

## דיבאגינג עם VSCode ו-GDB

זה מה שרצינו לעשות. זרקתי לכם פה שהדיבאגר עובד out of the box. אני שם פה breakpoint ואני פשוט מריץ את הדיבאגר. הוא מזהה את ה-compiler ואנחנו רצים איתו.

אוטומטית אני אעצור כאן. הוא כבר מדבג ישר, אני יכול לראות את ה-argc ואת ה-argv. אנחנו נלמד מה זה argc ו-argv, אבל בגדול argc זו הכמות של ה-arguments שמועברים לתוכנית, ו-argv אלו ה-arguments עצמם. ברגע שלא שולחים שום דבר לתוכנית, אז ה-argument היחיד הוא השם של התוכנית עצמה.

יש לנו פה עוד אינטגרציה לראות מה יש בזיכרון, לא רלוונטי לנו כרגע. לגבי ה-breakpoint והקיצורים של הדיבאגר: F10 עובר לשורה הבאה, F11 זה step into (נכנס פנימה), Shift+F11 זה step out (יוצא החוצה), ו-F5 זה להמשיך לרוץ.

F11 לא באמת ייתן לי להיכנס לתוך `printf` כי זו פונקציה סטנדרטית, אבל אם הייתי כותב פונקציה משלי, הוא היה נותן להיכנס תוכה. F10 עובר הלאה, ו-Shift+F11 יוצא החוצה.

## שימוש ב-GDB בטרמינל

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

נפתח בטרמינל: `gdb hello_world`. הוא מכניס אותי לתוך הדיבאגר. אם אני רוצה לעצור איפשהו, אני כותב `b hello.c:5` (breakpoint בשורה 5 ב-hello.c) ואז אני מריץ עם `r`.

הגעתי לשורה 5. ברגע שאני עושה `n` זה next, אז אני ממשיך לשורה הבאה. `s` זה step into (נכנס לתוך פונקציה), ו-`fin` מסיים את הריצה של הפונקציה הנוכחית.

נעשה next ונמשיך הלאה. הודפס לנו למסך: `Hello Embedded Linux Class`. אם אני רוצה לצאת, מקלידים `q`.

הדיבאגר שאנחנו נרוץ איתו מתוך האימולטור נקרא GDB. GDB זה דיבאגר ש-GNU יצרו, מוצר משלים ל-GCC. כלי מאוד חזק ומשתמשים בו להרבה דברים. הוא לא הכי טוב ל-multithreading, אבל הוא כן טוב ל-multiprocessing.

## מבוא ל-Yocto

אנחנו הולכים לעבוד גם עם Yocto. בעצם Yocto זה פרויקט open-source שנוצר על ידי ה-Linux Foundation (הארגון שמפתח את Linux). מה שנותן לנו Yocto זו אפשרות ליצור מערכת הפעלה מבוססת Linux המותאמת אישית למה שאנחנו צריכים. אנחנו לוקחים איזשהו בסיס שנקרא Poky או אפשרות אחרת.

הוא חינמי לחלוטין. הרבה מאוד חברות בתעשייה לקחו אותו, בנו עליו והוסיפו כל מיני פיצ'רים. ל-AMD (שקנו את Xilinx) יש אחד שעובדים איתו, ל-Intel יש אחד שלהם, וכמובן גם ל-Canonical (חברת האם של Ubuntu) יש את Ubuntu Core, שזה Yocto מותאם לאובונטו.

אתה יכול ב-build אחד לתמוך בהרבה מאוד ארכיטקטורות: x86, ARM, MIPS, או PowerPC. הוא תומך בהרבה מאוד פלטפורמות out of the box.

בשיעור הבא ניכנס ל-QEMU ונבנה Linux. אנחנו נריץ ב-QEMU ונגיע לזה שנשתמש באימולטור עצמו.

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

יש תמיכה בהרבה מאוד דיבייסים, והאימולטור QEMU תומך בהרבה מאוד בורדים: Raspberry Pi, BeagleBone Black, ואפילו Linux מבוסס Yocto על STM32 למיניהם (כמו STM32F4).

עוד יתרון ש-Yocto נותן זה builds שניתן לשחזר אותם באופן רפרודוסיבי. זה לא שהצלחת לבנות פעם אחת משהו ואתה לא זוכר איך לעשות את זה שוב. כל פעם מחדש שנבנה, ה-build שלנו יהיה אותו דבר וישתחזר. זה מונע את התופעה שאצל מפתח אחד זה עובד ואצל מפתח אחר לא, כי יש virtual machine שרץ ברקע ובונה את כל התהליכים, ככה שלכולם נבנית אותה מערכת.

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

## BeagleBone Black

הנה עוד שקף שלא הגעתי אליו, נכון?

החומרה שאנחנו נרוץ עליה זה BeagleBone Black. או נרוץ עליה, או שנדמה, זה BeagleBone Black. אני מאוד אוהב את הבורד הזה. תמיד אני חותר להשתמש בו.

מה זה BeagleBone Black? זה בעצם איזשהו open source hardware שפיתחו Texas Instruments. הוא די זול ובעצם הרבה מאוד בתעשייה, הרבה מאוד בקהילה של BeagleBone תומכים בו. יש בו הרבה מאוד דברים. הוא בעצם להוביסטים, לאנשים שאוהבים תחביבים, אבל גם הרבה מאוד חברות בתעשייה משתמשות בו, או משתמשות בבורדים דומים.

- הוא מיקרוקונטרולר?

הוא לא מיקרוקונטרולר, הוא בעצם System on Chip. הוא בעצם מחשב קטן. הוא בעצם איזשהו שלב אחד מעל מיקרוקונטרולר. בעצם יש לו פרוססור שהוא אמיתי, ויש לו פונקציונליות שאין במיקרוקונטרולרים. אני מניח ש... אני אנסה לחשוב עכשיו על משהו שאין, אבל נגיד DDR... איך זה נקרא? DDR Controller. בעצם הקונטרולר של הזיכרון, של ה-RAM.

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

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

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

המעבד שיש לו זה בעצם מעבד ARM Cortex-A8, שזה בעצם מהמעבדים היותר רציניים של ARM. אם סיפרתי לכם על עצמי, אני עבדתי עם ARM Cortex-M3 שזה מיקרוקונטרולרים, ו-M4, שיש להם פיצ'רים מסוימים. ל-A8 יש כבר פיצ'רים הרבה יותר רציניים.

יש לו 512MB של RAM בתכנולוגיית DDR3, אני חושב שהיום יש כבר 5, נכון? או 5X אפילו.

יש לו 4GB של MultiMediaCard, בעצם כרטיס SD אבל baked-in לתוך המערכת.

מגיע איתו גם חיבור Ethernet לרשת ואיזשהו NIC, ו-USB, כולל גם HDMI.

מבחינת Input/Output Capabilities, בעצם יש לו 69 GPIOs. מה זה GPIO? זה General Purpose Input Output. בעצם איזשהו פין שיש לו פעולות שהם גנריות. שזה פעולות של input או output מהפין עצמו. בעצם אני יכול לקחת את הפין ולשים אותו במצב של 1 או 0, או שאני יכול אפילו לשים עליו כל מיני peripheral functions, כמו PWM, שזה בעצם גל בתדר קבוע. יש לו גם Analog to Digital Converter וגם Digital to Analog.

UART, שבאמצעותו אנחנו מתחברים ומדבגים וקוראים את ה-logs שלו. יש לנו גם SPI, שזאת שיטת תקשורת פריפריאלית שאנחנו נדבר עליה גם כן. I2C ועוד.

ויש לו עוד איזשהו פיצ'ר נחמד שזה coprocessor, בעצם עוד פרוססור ייעודי לפעולות real-time. Linux היא לא מערכת הפעלה שהיא real-time-ית, אבל כן משתמשים בה הרבה בשביל real-time כי יש לה את התמיכה בפרוססורים שהם coprocessor, בעצם עוד פרוססור נוסף, או co-controller, עוד קונטרולר נוסף שהוא real-time. שאתה יכול לעשות פה processing של real-time ואתה לא בעצם תלוי במה שקורה בתוך ה-Linux.

עוד דבר נוסף שיש ב-BeagleBone Black: הרבה מאוד תמיכה ב-expansion boards. אתה יכול לקבל expansion board לתקשורות נוספות, אתה יכול לקבל עוד פינים, אתה יכול לקבל מוקסינג. אני חושב שבאחד הפרויקטים ראינו שאתה יכול לקבל מסך שמתחבר ישירות לפינים של ה-BeagleBone עצמו.

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

זה ה-BeagleBone עצמו. כמו שאתם רואים, זה ה-Ethernet שיש לו, זה ה-CPU שנמצא כאן, אני לא יודע אם אתם מצליחים לראות, CPU. פה למטה זה ה-RAM, ה-RAM chip שלו. חזרתי? בי? הנה, זאת קיימת.

ועוד כל מיני פיצ'רים. מה שמחובר אליו כאן, שכרגע ניתקתי, זה המתאם UART ל-USB. אם יש לכם את הבורד אולי יש לכם את זה ואתם משתמשים. אנחנו נשתמש בזה כדי לראות את תהליך העלייה של Linux. אוקיי? תהליך העלייה של המערכת הפעלה, אנחנו נראה איך אנחנו משתמשים בו כאן.

זה הבורד עצמו. יש פה כניסה ל-SD card, USB, זה בעצם ה-GPIOs שיוצאים מהבורד עצמו, מה שנקרא פריפריאלים, הפינים שאליהם אנחנו יכולים להתחבר ולהשתמש בהם. בסדר?

## הרצת Yocto ומטלת הבית

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

אז כמו שאני מניח שגם אתם, יצא לכם להיכנס לכאן. אז אני אעשה את התהליך שוב כדי שיהיה ברור. אז אני חוזר ל-repository base level, אוקיי? ואני עושה `ls`, אני כותב `source . init-yocto`. אוקיי? הוא בעצם יאתחל את הסביבה ויצור לי את התיקייה הזאתי, שאצלכם היא נמצאת כאן, אוקיי? את התיקייה yocto-build, בסדר?

כמובן שצריך לעשות את הסאב-מודולינג בעצם להוריד את Yocto עצמו. וברגע שאני אעשה `bitbake core-image-minimal`, שזה ה-image עצמו, אז הוא יתחיל את התהליך של ליצור מכונה וירטואלית, להתחבר אליה ולהריץ אותה. אז אני אראה איך זה נראה כאן.

כמו שאתם יכולים לראות, ה-machine שאנחנו בונים אליו הוא beaglebone-yocto. בתהליך הזה ירוצו 3000 ומשהו פרוססים, שהם רצים במקביל. זה נראה בערך ככה. זה לוקח זמן, אוקיי? זה לוקח זמן, הוא בונה file system, הוא בונה גם את המערכת הפעלה עצמה, הוא בונה קרנל. תריצו את זה ואת הכל.

בוא נדבר על assignments. ה-assignment מבחינתכם, זה... אני עכשיו אדחוף את זה לכאן. זה יהיה בלי ה-`add_subdirectory` של כאן, ככה. ה-assignment שלכם היום זה להריץ את ה-Yocto כמו שצריך, ליצור את תיקיית Hello World... ליצור את תיקיית lesson_0.

אני איצור לכם את תיקיית lesson_0, פה יופיע לכם קובץ חדש נקרא assignment.txt.

והשאלה שלנו כאן זה:

`create CMakeLists.txt file within lesson_0 directory`

`create Hello World directory and file`

`configure and build Hello World and execute it from bin`

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

אז זה היה השיעור הראשון שלנו. אני אעצור את ההקלטה. אני אפסיק את השיתוף. לא עצרתי את ההקלטה, שנייה.