#1 (2025-08-06)
טוען נגן…
תמלול
## סקירת נושאי השיעור והקורס
אני אעבור על האג'נדה כדי שמי ששומע את זה יוכל להבין. אחרי שהצגנו את עצמנו ואת המטרות שלנו ואת מה נעשה, אנחנו נדבר על מה נעשה בשיעור הזה. נעשה recap לשיעור הקודם, נעשה setup של המערכת, כולל התקנה של Git. ולעומת קורסים אחרים, הפעם אנחנו ניצור את ה-Git ב... בעצם אני אראה לכם איך אני דוחף את הקוד ואיך אתם לוקחים אותו.
נזכיר מה זו מערכת הפעלה, מה ה-services ומה הדברים שכלולים ושאנחנו מקבלים ממערכת הפעלה. מה זה אפליקציית real-time, נעשה השוואה בין real-time system ל-general-purpose system, זאת אומרת מערכות זמן אמת מול מערכות כלליות.
נדבר על task-ים, מה זה task scheduler, מה הוא context שאותו אנחנו מחליפים בין task-ים ומה זה ה-stack שאיתו אנחנו עובדים.
ונסיים עם multitasking, מה זה multitasking, ונדבר ספציפית כבר על מערכת ההפעלה עצמה, על FreeRTOS.
איתן, יש לך שאלה? פספסתי משהו?
– לא, תודה.
## הגדרת סביבת העבודה וציוד חומרה
אז בואו נתחיל לעשות setup לסביבה. הסביבה שלנו תהיה STM32CubeIDE, שזה ה-IDE – Integrated Development Environment, שזו סביבת פיתוח בעברית. אנחנו עוד רגע נוריד STM32. אם יש לכם STM32 ישן, שימו לב שצריך להוריד עדכון או לגרסה 1.18.3 או ל-1.19. אז כבר אנחנו נעשה את זה.
נסביר קצת על הבסיס של איך אנחנו מפתחים ואיך אנחנו יוצרים פרויקטים ל-STM, ובשיעור הבא כבר אנחנו נראה איך אנחנו עושים אינטגרציה ל-FreeRTOS לתוך הפרויקטים שלנו.
נדבר על Git Bash, שזה ה-Command Line Interface, מה שנקרא טרמינל ל-Windows, שאיתו אפשר לעבוד ב-Git. אם אתם שולטים ב-VS Code ואתם יודעים לעבוד עם ה-Git של VS Code, מעולה.
ואנחנו נדבר קצת על ה-board-ים שאנחנו נשתמש בהם. אנחנו הולכים להשתמש בשני board-ים או לפחות board אחד. ה-board הראשי זה ה-STM32 Discovery, שזה עם ה-MCU שאני אוהב, F411E. אז זה ה-MCU שאיתו אנחנו משתמשים. אני חושב שאחד מכם הראה לי board Nucleo עם ה-MCU הזה.
– כן, זה אני.
– כן, אז שלך זה Nucleo, שזה כזה דבר. וזה בגדול, זה ה-Discovery kit. ההבדל אני חושב זה עוד כמה LED-ים וחיבור ל-Arduino.
– אפשר להשתמש ב...
– אפשר להשתמש, אפשר להשתמש בכל MCU של ST.
– רגע, אתה יכול שנייה רק להזכיר מה זה MCU? שמעתי את זה פעם אבל...
– MCU זה Microcontroller Unit.
– זה בעצם ה-CPU של הכרטיס?
– MCU זה Microcontroller Unit, אפשר לחשוב על זה כעל System on Chip. MCU מכיל core של ARM (או core של כל manufacturer), ומכיל פריפריאלים. מה זה פריפריאלים? זה רכיבים שהם נמצאים בתוך הצ'יפ אבל הם בעצם הפריפריות של המעבד, שזה לדוגמה תקשורות on-board כמו I2C, SPI, GPIO-ים (פינים שאנחנו יכולים לשלוט עליהם, input ו-output, General Purpose Input and Output), USB controller יכול להיות בפנים, וגם BLE – Bluetooth Low Energy יכול להיות חלק מהצ'יפ. יש כיום צ'יפים שאפשר לממש בתוכם BLE, בעיקר של חברת Silicon Labs (אנחנו לא עובדים איתם בקורס).
– ומה ה-board השני שאמרת?
– אמרתי שיש את ה-Discovery board, ואני בודק בשביל הפרויקט על board שכולל כבר Bluetooth, אז אני אעדכן אתכם. אריה עזר לי לבחור. אם אתם צריכים עזרה בבחירה של board-ים, תדברו עם אריה.
– אנחנו צריכים בעצם שני board-ים לפרויקט?
– אנחנו לא צריכים, אין שום עדיפות. אמרתי שאפשר לעשות את הפרויקט ואפשר לעשות את הקורס עם כל אחד מהם.
## השוואה בין STM32 לבין Arduino ו-ESP32
– אתה יכול בצורה תמציתית להסביר מה ההבדלים בין ה-STM32 לבין המשפחות של Arduino או ה-ESP32?
– זו שאלה טובה. בגדול, רמות מתחים. Arduino עובד על 5V, רוב שאר ה-MCU-ים עובדים באזורים של בין 1.8V ל-3.3V.
– כאילו אלה צרכני אנרגיה נמוכים יותר?
– לא, זה רמות מתח. אנרגיה היא פונקציה של מתח וזרם, אז רק המתח שונה.
בעוד דברים – מעבדים יותר חזקים, ותמיכה ל-MCU-ים. שוב, זה תלוי ב... אני לא ככל כך מכיר Arduino, למען האמת.
– כי ה-ESP32 מגיע עם FreeRTOS, אז אני תוהה אם אני יכול להשתמש בו.
– אני חושב שאתה יכול, אני לא יודע אם אני אוכל לתמוך בך יותר מדי.
Arduino ו-ESP הם בעצם board-ים שנועדו כדי לעזור לאנשים לפתח embedded, וכותבים שמה בשפה שהיא בעצם C עם כל מיני ספריות שעוטפות את הכל. זה לא לגמרי כמו מה שאנחנו עושים. גם היום ל-STM32 יש לנו ספריות של HAL – Hardware Abstraction Layer, שגם הספריות האלה, לעומת עבודה bare-metal מול ה-register-ים ישירות, עוטפות לנו הרבה דברים.
אז לדוגמה מבחינת יציאות, פה יש לנו... אמת אף פעם לא ספרתי, אני חושב שזה 100 פינים שמציצים החוצה. יש לנו הרבה יותר אינטראפטים שאנחנו יכולים לעבוד איתם. יש לנו interrupt controller, שזה ה-NVIC – Nested Vector Interrupt Controller, שזה ה-interrupt controller של ARM. הוא חלק מה-MCU שלנו, הוא מה שעושה לנו את האינטראפטים. נסביר על הכל גם בהמשך.
עוד דברים שיש: כמה טיימרים, ובגדול הרבה יותר יכולות שאנחנו מקבלים בתוך ה-MCU-ים האלה. אפשרות לעבוד ב-low power בחלק מה-MCU-ים (בסדרת L אנחנו יכולים לעבוד הרבה יותר ב-low power), ואם אני לא טועה, יותר זיכרון.
– מהניסיון שלי, ב-STM יש לך הרבה יותר מבחר שונה של צ'יפים. אז אם אתה מחפש משהו עם יותר זיכרון או clock ב-300–400 MHz, ב-Arduino למשל אתה בערך ב-4 MHz אם אני זוכר נכון, 4 או 8, שזה הרבה יותר איטי. מצד שני הם חוסכים לך הרבה מאוד מהעבודה, הספריות שלהם מאוד פשוטות, אבל יש לך הרבה פחות שליטה bare-metal-ית אם אתה רוצה לעשות דברים יותר ידניים.
– הבנתי. זאת אומרת ש-Arduino הוא הרבה יותר עטוף, user-friendly.
– כן, Arduino זה יותר אם אתה רוצה לעשות פרויקט לכיף מהיר או אם אתה רוצה ללמד ילדי תיכון למשל. אז היית מתחיל עם Arduino, ובהמשך עובר למשהו יותר כמו ESP, ואם מישהו מאוד מתעניין בזה אז ממשיך ל-STM או דברים בסגנון.
– מסכים. תודה אורן.
## סביבות פיתוח ואינטגרציה עם FreeRTOS
סביבת הפיתוח שאנחנו הולכים לעבוד איתה זו סביבת הפיתוח של STM. זו סביבה מבוססת Eclipse (ש-Eclipse זה open source של סביבת פיתוח), ועם ה-add-on-ים של STM נוצר לנו STM32CubeIDE או STM32Cube.
למה אנחנו משתמשים בו? מסיבה פשוטה שהוא מאוד מותאם לכל ה-board-ים ולכל ה-MCU-ים של ST. אנחנו לא צריכים עכשיו לעשות התאמות, בעצם הכל נמצא לנו: כל קבצי ה-startup כבר נמצאים (שאנחנו אפילו לא צריכים לדעת מה הם), ה-linker script של מה שמוריד לנו את המידע לתוך ה-MCU גם קיים שם, וגם יש לנו עבודה עם ה-debugger של STM, עם ה-ST-Link. גם זה נמצא בתוך סביבת הפיתוח.
ככה שאנחנו לא צריכים עכשיו להתחיל לקנפג יותר מדי דברים, זה עובד out of the box. אם נספיק היום אנחנו נראה, אם לא – בשיעור הבא.
בנוסף לזה יש גם אינטגרציה עם FreeRTOS. כפי שאמרת שה-STM שלך בא עם FreeRTOS, אז גם פה אנחנו פשוט לוחצים על כמה כפתורים ויש לנו את הספריות של FreeRTOS שנוכל להשתמש בהן. וגם אנחנו נראה איך אנחנו עושים את זה בצורה ידנית, ככה שאנחנו לא מגבילים את עצמנו ל-STM.
מעבר לזה, לכל manufacturer יש איזושהי סביבת פיתוח דומה. כמו לדוגמה ל-Silicon Labs יש לנו את Simplicity Studio (אני חושב שעכשיו יצא Simplicity Studio 6), שזו באמת אחלה של סביבה. יניק, תתקן אותי אם אני טועה, ל-TI גם יש סביבה כזאת?
– Code Composer Studio. ל-Analog Devices יש CrossCore. וכולם מבוססי Eclipse. פעם ל-TI היה משהו משלהם, לדעתי היום הם זנחו את זה והכל מבוסס Eclipse.
– אז זהו, בעצם זה ש-Eclipse נתמך על ידי קהילת open source מאוד גדולה, קל להשתמש בו, ועם כמה add-on-ים עושים את השינויים.
דיברנו על Git Bash. ב-Git Bash אנחנו נשתמש כדי שתוכלו לעקוב אחרי הקורס. זאת אומרת, לפני כל שיעור (אני גם אראה איך עושים את זה) אנחנו בעצם מושכים את הקוד שאני דחפתי כדי שכולם יוכלו לעבוד באותו הזמן ולכולם יהיה קוד מעודכן.
וה-sources של FreeRTOS – בעצם אנחנו מורידים את מערכת ההפעלה מהאתר. FreeRTOS היא מערכת הפעלה שהיא open source שאנחנו יכולים להשתמש בה בחינם, היא לא סתם נקראת FreeRTOS. ל-STM יש port ספציפי ל-FreeRTOS למעבדי Cortex-M. וגם אנחנו נעשה BLE stack integration כדי שנוכל לעבוד עם תקשורת wireless.
– עוד שתי שאלות. אחת, מה הכוונה שיש port שמיועד ל-FreeRTOS?
– ל-STM יש בעצם אינטגרציה ויש להם את האפשרות פשוט להתקין מערכת מותאמת כבר. אנחנו לא צריכים להתאים אותה בעצמנו.
– זה לא קוד שאתה מקמפל על המחשב ואז טוען?
– זה קוד שאתה מקמפל, אבל אתה צריך גם לקנפג.
– הבנתי. ועוד שאלה, אמרת קודם על debugging, אין פה צורך בחומרה חיצונית?
– אם תסתכל על ה-board שלך, ה-board מחולק לשני חלקים. החלק העליון זו חומרת ה-debugging. פה למעלה יש לנו את הרכיב של ST-Link, שזה ה-debugger של ST.
– כן, אני רואה את ה-פינים של ST-Link.
– ברגע שאנחנו נחבר אותו עם mini USB (או מה שיש על ה-board שלך), זה הקונקטור.
– אני צריך למצוא כבל כזה.
– נכון, הייתי צריך להגיד לכם שצריך להשיג גם כבל כזה. אם יש לכם מצלמות בבית, הרבה פעמים זה מגיע משם, כבל מצלמה מה שנקרא.
מה עוד? הייתה שאלה? פספסתי משהו?
– לא.
הנה תמלול מוקפד ונקי של הקטע המוקלט:
## Git Bash for Windows & Basic Git Commands
למעבד, כן?
סורי איתן, אתה פשוט מתחיל מהאמצע. על מה אתה מדבר, איזה כבל צריך?
כבל כדי להתחבר ל-ST, כן.
סבבה.
אז שימו לב שיש פה שני חיבורים, אוקיי? אם אתם משתמשים בבורד הזה, אז החיבור של ה-USB, מיקרו USB, הוא בדרך כלל חיבור פריפריאלי. הוא לא מתחבר ישירות ל-debugger, אם אנחנו רוצים לדבג. אז אם יש לנו חיבור של mini, אוקיי, mini-USB, שזה הדבר הטרפזי הזה, טרפז, נכון? הטרפזי הזה, אז אנחנו יכולים...
זה הדור 2 של ה-USB, אחרי הגדולים ממש, זה הבא בתור.
נכון. כן, יש...
זה כבר עבר מן העולם החיבור הזה.
נכון. אז ה-boards, עכשיו האמת שאני עכשיו רואה שזה כבר עם USB micro בשני הצדדים. יש גם כאלה היום שמגיעים עם Type-C.
Type-C בצד של הזה. מבחינתנו זה לא משנה, נפתח COM port וה-IDE יודע לעשות את זה.
אוקיי, אז בואו נדבר על איך אנחנו מורידים Git Bash למחשב. אז יש פה את ה...
אתה רוצה לעשות את זה כבר עכשיו?
אם אתם רוצים לעקוב איתי, תעשו את זה, בטח. אם לא, אז...
רגע, את ה-IDE לא להוריד עדיין?
את ה-IDE גם אתה יכול להוריד. אני פשוט עושה את זה בשקופית הבאה, אבל אפשר כבר להוריד.
אור, יש לי שאלה. אני כרגע עם Ubuntu פה על המחשב. השאלה אם ה-IDE...
אם אתה עם Ubuntu אתה לא צריך Git, אתה יכול להוריד את ה-IDE... אתה יכול להוריד קובץ deb ובאמצעותו להתקין.
להוריד את ה-Click here to download, את ה-latest 2.41?
כן, זה רק ל-Windows. אם אתה, שוב, אם אתה עם Ubuntu אז יש לך Git.
כן, לא, אני יודע שיש לי Git, אבל תהיתי על ה-IDE הזה, אם הוא נתמך ב-Ubuntu.
בטח.
אוקיי, אז התקנה אני אעבור. אני מקווה שאני לא אעשה... אוקיי, אז הוא מסיר לי את הקודם, אז אנחנו כבר נעשה התקנה במלואה.
מציע פה מה להתקין, את ה-Components.
עוד רגע גם שלי יסיים לנקות ונכבר נעשה את כל ההתקנה.
אני אסביר קצת על למה אנחנו מורידים את זה ומאיפה אנחנו צריכים. אנחנו צריכים בגדול terminal שתומך ב-Git. ב-Windows אני חושב שזה לא בא out of the box, צריך להתקין. אלא אם כן Windows החליט להתעדכן בשנים האחרונות ואני לא מודע לזה, ואולי ב-PowerShell כבר יש.
סליחה אור, מה שוב, מה...
לא לא, אני רוצה לעשות איתכם את ההתקנה ביחד, אז אני שנייה מנסה.
כן, זה הקובץ.
כן. אז אוקיי, הנה ההתקנה ביחד.
אז בואו נעשה את ההתקנה ביחד. אז אנחנו נראה את ה-installer, תלוי במערכת ההפעלה שלנו. רובנו עם 64-bit, אלא אם כן יש לנו פה מישהו שעובד עם Linux 32, אז תורידו כל אחד מה שצריך.
אנחנו נעשה את ה-installer ביחד ונתקין את ה-Git Bash. בהפסקה שאנחנו נעשה לקראת אחת וחצי, אנחנו גם נעשה את ה-restart למחשב כדי שנוכל לעלות שוב.
אז מה זה הטרמינל הזה? הטרמינל הזה אנחנו משתמשים בו כדי שנוכל להשתמש ב-Unix-like terminal ל-Windows. למה Unix-based? כי Git פותח על ידי Linus, אותו בן אדם שפיתח לנו את Linux, והוא פיתח אותו למען terminal מבוסס Unix. אז כדי שנוכל להשתמש בו ב-Windows, שזו מערכת הפעלה מבוססת DOS, אנחנו צריכים להוריד terminal.
אז הטרמינל אנחנו נרצה Windows Explorer integration. אז Git Bash זה הכרחי. Git GUI – אם אתם רוצים ללמוד להשתמש בו, אתם יכולים, אני לא יודע לדוגמה.
Git LFS – זה ל-Large File System, תעשו את זה, כי אם יהיו לנו קבצים גדולים שלא יהיו לנו בעיות עם ה-Git.
קבצים שהם git. בסוף אנחנו נרצה, וקבצי sh, מה שנקרא קבצי Bash, אנחנו נרצה להריץ אותם עם Bash מתוך הטרמינל.
דבר נוסף שגם אנחנו נרצה – אם אתם מכירים את Windows Terminal, אז אנחנו מוסיפים תמיכה ל-Git Bash ב-Windows Terminal. והאחרון – אני לא יודע מה זה, אני לא מתקין את זה. Scalar, אני חושב שזה שפה, לא?
לא, Scala זה שפה.
Scala זה שפה? Scalar מעבר לזה שזה מספר... לא יודע, אני לא מתקין.
אוקיי, אז הוא בעצם... אוקיי, הוא אומר חבל. עכשיו, מבחינת הכתבן שאפשר להשתמש בו, אפשר להשתמש ב-Notepad++. שימו לב ש-Notepad++...
אתה יכול לחזור חזרה לחלון הקודם? להגדיל אותו שנייה? סליחה.
בכיף. אני יכול אפילו להגדיל את זה. זה מה שסימנו.
מה אתה משתמש ב-editor?
זה באתי להגיד עוד כמה מילים.
ה-editor זה משהו שהוא מוריד? כלומר אם אני בוחר Notepad++ הוא מוריד גם את Notepad++?
לא.
ה-editor זה משהו שהוא בוחר. אם אני לא טועה, תמיד השתמשתי ב-editors שהיו לי, הוא לא מוריד אותם. Notepad++ הוא אחלה של editor. הבעיה היחידה שאם אנחנו עושים ירידת שורה ב-Notepad++, אז הוא עושה ירידת שורה של Windows, מה שיכול ליצור בעיה בחלק מהקומפילציות. ירידת שורה של Windows אני חושב שהיא לא...
זה הצ'ופצ'יק M הזה...
כן. אז אני חושב שזה CRLF, backslash n backslash r.
כן.
וב-Linux זה רק backslash n. אז יכול להיות שזה יעשה בעיות בכל מיני repositories, אז אני לא הייתי משתמש ב-Notepad++. הייתי משתמש או ב-nano או ב-Visual Studio Code, שזה ה-IDE שאני משתמש בו ב-default, אז אני בוחר ב-Visual Studio Code.
אם אין לי את זה, זה משהו שאפשר לקנפג אחר כך?
הייתי משתמש ב-nano.
nano זה שלו כאילו?
nano מגיע בתוך הטרמינל.
זה כן מגיע עם ההתקנה.
nano זה כמו VI כזה, לא?
nano זה כמו VI, רק שאפשר לצאת ממנו. סליחה על הבדיחה.
לא, VI אני מסתדר איתו.
לא, VI תמיד צוחקים על זה שקשה לצאת מ-VI, כי צריך לעשות Esc, נקודתיים, q, סימן קריאה. Esc, נקודתיים, q, סימן קריאה. אז זו הבדיחה. nano פשוט עושים Ctrl+X.
סימן קריאה אתה צריך רק אם עשית שינויים ואתם מנסה לעשות את זה לא בכוח.
אז אתה מבין כמה אני לא אוהב VI.
אור, מה ה-Name of initial branch in new repositories?
אוקיי, אז אני אסביר גם על זה. כיוון שהעולם שלנו הפך להיות מאוד woke, אנחנו כבר לא קוראים ל...
Master / Slave?
Master / Slave, אנחנו קוראים לו Main ו... אז רק שתדעו שזה כבר נכנס default בכל branch שתצרו ב-GitHub, אז גם פה.
אה, בגלל זה! אוקיי. אתה יודע איזה שגעון זה? אני יצרתי master באיזה repository שלי.
זו הסיבה, זו הסיבה. לפני כמה שנים היו הודעות שמתקנות שאם אנחנו רוצים לעבור יפה, וכבר בשלב מסוים הפסיקו את זה.
וואו.
אז מה לסמן? מה לעשות?
אני עשיתי Main. זה לא משנה אם אתם יוצרים branch חדש.
בגלל זה גם SPI עבר מ-MISO / MOSI ל-PICO / POCI? במקום Master In / Slave Out?
האמת שלא שמעתי על זה. כנראה שכן. לא שמעתי על זה.
לבחור כאן ולעשות Main. השלב הבא אנחנו נרצה להשתמש ב-Command line and 3rd party software.
לי אין את העמוד הזה. לי ישירות זה עובר ל-SSH עכשיו.
בסדר גמור, אז החליטו בשבילך.
Bundled OpenSSH?
כן, Bundled OpenSSH. זה כדי שיהיה אפשר לעשות SSH, לא שאנחנו עושים.
SSL library – אני הייתי משתמש ב-native של Windows.
מה זה הדברים האלה, SSL?
SSL זו ספרייה של certificates, של הצפנות. אם אנחנו רוצים לפתוח socket להצפנה, אנחנו לא הולכים לעשות את זה.
אנחנו משתמשים ב-SSH למשוך את ה-Git, לא?
אנחנו משתמשים ב-SSH, לא ב-SSL.
אה, כן.
הנה, המסך הבא זה מה שאמרת.
נכון. אז אני לא הייתי... אני הייתי עושה Checkout as-is, או אם אתם ממש דואגים, עושים Checkout as-is. בכל מקרה לא לעשות Checkout Windows, אלא אם כן אתם מפתחים לשפות של Windows כמו C# ואולי...
אז האופציה השלישית?
כן, האופציה שמסומנת אצלי, Checkout as-is, Commit as-is.
בסוף, אנחנו לא נבחר ב-MinTTY, אנחנו נבחר ב-Windows default console, כי אין לנו צורך ב...
לא ב-MinTTY?
אין לנו צורך בזה. זה בעצם... אני אסביר, אנחנו לא הולכים להתקין את זה גם ככה. בדרך כלל שמקמפלים C ל-Windows, אז משתמשים ב-MinGW. MinGW זה הקומפיילר של C ל-Windows. ול-MinGW יש אינטגרציה עם MSYS2, שזה עוד טרמינל שתומך בזה. אנחנו לא הולכים לעשות את זה, אנחנו הולכים להשתמש בקומפיילר שבא עם ה-IDE.
סבבה, אז Default – merging, Fast-forward or merge. אתם יכולים לבחור גם Rebase, לי זה לא משנה, כי אתם לא הולכים לעשות...
מה זה הדברים האלה? סליחה, אני מכיר...
בגדול הוא שואל מה לעשות default כאשר אנחנו עושים git pull, או כאשר אנחנו מושכים מה-Main את המידע אלינו. אז יש לנו כמה אפשרויות. אפשרות לעשות merge, אוקיי? פשוט לקחת את המידע ולדחוף אותו לבפנים. זה יכול ליצור לנו merge commit אם יש לנו מידע שהוא לא מעודכן. יש לנו rebase.
מה זאת אומרת, משיכת קבצים מה-repository למחשב שלי?
כן.
אוקיי.
אם יש לך מידע שהוא לא מסונכרן עם המידע שקיבלת, אתה יכול ליצור merge commit. מה זאת אומרת? זה commit ש... אתם גם ככה לא יכולים לדחוף קוד, אז אני אראה לכם מה אתם יכולים לעשות באמצעים כאלה, בסדר?
זה לא כזה משנה, כי מה יהיה ה-default, תמיד אפשר גם כאילו לתת לו את ה-flags...
נכון, תמיד אפשר לעשות בצורה מפורשת (explicitly) את הבקשה, אם לעשות fetch, rebase, או fast-forward.
אז מה לסמן, הראשונה?
הייתי משאיר את הראשונה, זה באמת לא משנה.
Git credential manager – אני הייתי משאיר את זה או שלא נוגע בכלל, לא רלוונטי.
File system caching – כן. Symbolic links – אנחנו נרצה תמיכה ב-symbolic links, ו-Install.
אוקיי? בינתיים זה מתקין.
מה זה symbolic link?
Symbolic link זה מה שנקרא soft link. זה בעצם שאנחנו משתמשים בקובץ שמצביע על קובץ אחר.
כמו פוינטר של קבצים.
מקביל לקיצור דרך ב-Windows, או משהו כזה.
אני לא יודע איך המימוש של קיצור דרך ב-Windows.
לא, בסדר, אבל כאילו מבחינת ה... איך חושבים על זה.
אני אפילו חושב שאנחנו לא צריכים לעשות restart, אז אנחנו יכולים ישר ללחוץ על Launch Git Bash.
ואנחנו נראה אותו כבר...
שלי שואל: How do you want to open this file?
Git Bash? אתה צריך לבחור ב-Windows Terminal או ב-PowerShell. או ב-CMD.
לא, לחצתי על Release Notes אז...
אה, תסגור את זה פשוט.
בסדר.
אוקיי, אז כאן אנחנו יכולים לראות שבעצם זה נפתח לנו. שימו לב שזה מתוך הטרמינל. אז יש לנו פה את האפשרות לפתוח עוד סוגים של טרמינלים ו-Git Bash. עכשיו אנחנו נסגור אותו.
רגע, למה אצלי זה הטרמינל הרגיל של Windows?
כן, כן, כן, גם אצלי. עוד פעם, אני אראה, טרמינל...
לא ראיתי פשוט את התפריט, את ה-drop down שהראית.
הוא נמצא פה בחץ. לא, הוא נמצא פה בחץ, ואז אפשר ללחוץ עליו ואז הוא פותח את ה...
איך... לא... אצלי זה לא...
אם זה לא, אז עוד רגע אני אראה איזו דרך יש לפתוח את זה ותגיד לי אם גם אז לא.
ואז אנחנו צריכים לעשות git clone, אוקיי? איך אנחנו עושים git clone? אני אראה. אנחנו הולכים בגדול לאזור שבו אנחנו רוצים לעשות... לאזור שממנו אליו אנחנו נרצה לעשות את ה-clone ל-repository של הקורס. אנחנו נעשה פה ימני. אם אתם ב-Windows 11, אז אתם צריכים ללחוץ עוד פעם על Show more options, ואז יש לנו את האפשרות לבחור Terminal, Git Bash, או Git GUI. אם יש לכם את האפשרות לבחור Git Bash אוטומטית, אז זה יפתח לכם את זה ככה.
אוקיי, ואז אנחנו רואים שאנחנו נמצאים במיקום הנכון. אנחנו נמצאים במקרה שלי ב-C ו-source.
אוקיי? מפה אתם יכולים לעשות... אתם צריכים לעשות שני דברים. דבר ראשון, אתם צריכים לעשות SSH key. האמת שכיסיתי את זה במצגת, אז אולי אני פשוט...
רגע אור, אתה רץ מתקדם מהר ואני לא הכנתי שום... את הספריות, אז...
הכל בסדר, אתה יכול לשים את זה איפה שאתה רוצה, איפה שיש לך מקום. איפה ששמרת את הדברים של הקורס.
כן, לא, איפה... אז אני צריך... אז ברגע שיש לי... מה עשית, נגיד C:\source?
## יצירת מפתח SSH וחיבור ל-GitHub
כן. אז מה לעשות עם התיקייה הזאת?
עכשיו אנחנו נרצה ליצור SSH key, מפתח SSH כדי שנוכל למשוך מ-Git. אם יש לכם כבר מפתח אז אל תצרו.
לא, אין לי מפתח.
אז אני אראה איך עושים.
פשוט שלב אחורה, אתה יכול לחזור? נגיד אם אני מצביע על הספרייה, Open Git Bash Here?
כן.
אוקיי. נפתח, זה נראה ככה?
כן, מעולה. עשיתי ספרייה אחרת, אבל בסדר.
בסדר, זה אותו דבר. שים את זה איפה שאתה רוצה, גם ככה אנחנו נעשה clone. אז...
מה זה אומר clone?
אנחנו בעצם נעשה שכפול של ה-repository אלינו. אנחנו בעצם... אני גם אראה קצת פקודות, אנחנו נעשה את זה.
ה-repository עצמו, האמת שהוא לא נמצא כאן, הוא נמצא טיפה יותר למטה. כאן ב-Misc. אני גם אשים את זה בצ'אט כדי שיהיה לכם נגיש. ה-repository עצמו הוא נמצא תחת ה-repository שלי. אתם תראו repository ריק, זה בסדר, אנחנו עושים את הכל היום ביחד.
מאיפה אנחנו נכנסים? מכאן, אתם יכולים ללחוץ על ה-link.
שלחת בצ'אט? אני לא רואה את זה.
רגע רגע, סליחה. שלחתי בצ'אט של הזה, אני אשלח גם פה.
זה ה-git clone, על מה ללחוץ?
על GitHub, orsuliman1, freertos-microcontrollers.
מה זה Repo Name?
האמת שזה פספוס שלי, פה היה אמור להיות לי הקישור, הדבר הזה. יכולים לעשות גם את זה: `git clone`. אבל לפני שעושים את זה, אנחנו צריכים ליצור מפתח SSH.
אוקיי, מה זה מפתח SSH? זה מפתח כדי ש-GitHub יכיר אותנו וידע שאנחנו מאומתים. אז איך אנחנו עושים את זה? תסתכלו איתי ביחד, אני יכול להגדיל קצת את ה-tab. אז `ssh-keygen`, אז SSH key generate, אוקיי?
ברגע שאני אלחץ Enter, סליחה, אז הוא ישאל אותנו generating key, enter which file you want to save it. אל תלחצו על כלום, פשוט תלחצו על Enter. ואם יש לכם מפתח, אז אתם יכולים פשוט ללחוץ על N. אם אין לכם, תלחצו על Y, אוקיי?
רגע, עשיתי Create Directory... Enter passphrase.
אז שנייה, אז אנחנו נעשה Yes, ואז Enter passphrase. אנחנו לא צריכים ליצור passphrase, אז נעשה עוד פעם Enter, ועוד פעם Enter.
ואז הוא יוצר מפתח, אוקיי? המפתח מחולק לשניים: הוא מחולק ל-public key ו-private key. ה-private key הוא שלנו, וה-public key אנחנו נעשה `cat`, אנחנו נעתיק את המקום שבו הוא רשם שהוא שומר את ה-public key, ואנחנו נלחץ Enter, ומפה הוא ידפיס לנו את המפתח עצמו.
שוב, אז ללחוץ `cat`?
`cat` ואז המקום שבו הוא רשם. זה כנראה `C:/Users/<username>/.ssh` וה-ID. הוא רשם את זה למעלה, את המיקום.
עם ה-slash הראשון?
כן.
איך אני עושה copy-paste פה?
אתה פשוט מסמן וזה ידפיס לך... וזה יעתיק לך, זה Linux/Unix.
זה לא כזה עובד לי, שנייה.
אז ימני על החלק המסומן, עכשיו אני אראה איך...
יש מצב לעזרה על זה?
כן, דברו אליי.
אני יצרתי ב-ssh-keygen.exe ואז הוא שואל אותי enter file in which to save.
אמרתי, פשוט לעשות Enter.
סבבה, ואז enter passphrase?
תעשה עוד פעם Enter, ואז הוא מבקש עוד פעם, עוד פעם Enter.
סבבה, ואז להעתיק את מה בדיוק?
ואז הוא רשם Your public key has been saved in...
תודה.
ברגע שאתה מסמן את זה, אז ברגע שאתה לוחץ על העכבר הימני הוא כבר יעשה הדפסה. את המפתח הזה אנחנו צריכים להכניס לתוך GitHub. GitHub זה המקום שבו נשמר ה-repository או הקוד, זה ה-codebase.
אם אין לכם user אז תצרו user, ותכניסו אליו את זה. תנסו ליצור ככה מהר, אולי בהפסקה שנעשה עוד רגע תצרו את זה, ואם לא אז אם יש לכם כבר אני אראה גם איך...
איפה לעשות login?
תכנסו ל-repository, נתתי את ה-link. ה-link נמצא גם ב-WhatsApp וגם פה.
אה, זה ה-GitHub... אתה רוצה את ה-username שלנו ב-GitHub?
אני לא צריך את ה-username שלכם. לי יש user, אתם יכולים לעשות Sign Up ולהירשם, אני צריך פשוט להתחבר ל-user שלי.
ואז יש פה את כל ה-repositories שלי.
ואז להיכנס ל-Your repositories?
לא, אתם צריכים להיכנס... לכם יש ב-URL זה כבר מכוון אתכם ל-freertos-microcontrollers, שזה ה-repository של הקורס.
אה סבבה, אז איפה להכניס את ה-SSH?
את ה-SSH אנחנו נלחץ על ה-logo, על התמונה שלי, Settings. בתוך Settings יש לנו את התפריט השני של Access, SSH and GPG keys. New SSH key, גם אני צריך להכניס אחד חדש. תקראו לו לפי השם של המכשיר או whatever.
שאני שנייה צריך למחוק את הקודם...
אני יצרתי חדש, אז אני אקרא לו בשם של המחשב, ו-Control+V או Shift+Insert ידביק לכם את המפתח, Add SSH key, ואתם מסונכרנים.
אורן, אני יצאתי, באת אותך לצערי... אני עכשיו יצרתי user ב-GitHub. מה אני עושה עכשיו?
עכשיו אתה לוחץ על ה-logo שלך, Settings. מ-Settings אתה לוחץ על SSH and GPG keys.
[לא ברור] הוא לא נכנס לי עכשיו... Incorrect username or password.
אז בואו נעשה הפסקה, אנחנו גם לקראת זמן ההפסקה. קחו לכם את זה שנייה לעשות user אם אתם צריכים ולהתחבר, ואז אני אשאיר את זה ככה שתוכלו להסתכל. ובגדול אנחנו צריכים את ה-Settings ו-SSH and GPG keys, ומפה אנחנו מכניסים מפתח.
סבבה, אז אנחנו נחזור עוד חמש דקות, 8:32, בסדר?
יש מצב לשאלה קטנה רק?
כן, בטח.
כאילו בגדול אני קיבלתי The key fingerprint is... אז אני מעתיק את הכל? מה-SHA256 עד הסוף, נכון? או לא כולל ה-SHA256?
המפתח, ברגע שאתה עושה `cat`... `cat` זה בגדול מראה לך...
`cat` זה הדבר... הבנתי אותך, לא, את זה פספסתי, סבבה.
אוקיי, ואז הוא מראה לך את ה-public key שלך.
טוב. הוא אומר לי שזה לא קיים, מה...
מה לא קיים?
אני אחפש.
שים לב שהוא רשם לך פה איפה הוא יצר לך את זה.
כן כן, פשוט אני אעתיק את זה, אני אמצא את זה.
מעולה.
אז ב-8:32 אנחנו נחזור. בינתיים זה נשאר פתוח.
רגע אורן, אז עכשיו נכנסתי ל-GitHub עם ה-user, אז אני לוחץ על הסמל, Settings...
כן.
ואז SSH and GPG keys, New SSH key... תקרא לו באיזה שם שאתה רוצה, ופה אתה מדביק את החלק הזה.
מה השם שצריך לתת לו? ומאיפה אני לוקח את זה?
זה נמצא פה, רשום `Users/<name>`...
אבל זה המקום של ה-public key, זה לא ה-public key.
ה-public key ואז אתה מעתיק אותו ומדביק אותו כאן.
אה, זה משהו שהוא יצר, הבנתי.
ופה אתה יכול לקרוא לו בכל שם.
Key type: Authentication key?
כן.
בסדר. ואתה יכול לעשות clone בינתיים, זה יקח בדיוק שנייה...
איך אני עושה clone?
אז רגע, בוא נעשה את זה אחרי ההפסקה.
## הפסקה ודיון בנושא ניהול גרסאות
Git זה בעצם Source Control, נכון?
סוג של, זה כמו...
אני מכיר את SVN.
אני הייתי ב-Perforce בעבודה.
Perforce? משהו ממש ישן, עד לפני ארבע שנים לפחות... זה היה בעבודה הקודמת.
מה שאמרת מאוד מוכר, השם Perforce.
זה פשוט מה שהשתמשו בו ל-version control. אבל בסופו של דבר זה הכל תיקיות ו-merging. כשכמה אנשים עובדים על אותו הקוד, אז אתה יודע, אתה לא פשוט דורס, אתה אומר היי, אני עובד על זה.
מה ששמתי לב שב-Git הוא הרבה יותר מורכב, יש שם אפשרויות יותר מורכבות מסתם merge, commit ו...
כן, יש לך branches כאלה, שכאילו אתה עושה copy-paste, שם אותם בצד ואז עובד עליהם במקום להשפיע על כולם. ואז אתה יכול לחזור למרכזי או לשלב ביניהם, כל מיני. אם השינוי שעשית כן עבד אז אתה יכול לדחוף אותו ל-main, או שאתה יכול לעזוב אותו כניסיון.
אני אף פעם לא הסתדרתי כל כך עם Git.
חשוב לי להתעדכן.
יצא לך לעבוד עם STM בעבר?
לי? לא, פעם ראשונה.
## Git Bash for Windows & Basic Git Commands
כן, סורי על האיחור.
אז בואו נראה בעצם איך אנחנו עושים clone. אני מקווה שכולכם איתי. אז רגע, אני כבר עשיתי. אני כבר עשיתי את זה, אל תעשו.
- תגיד מתי להיכנס.
- ה-repository ריק או?
- ה-repository ריק, נכון.
- אה, אוקיי. אמרתי אולי עשיתי משהו לא טוב.
- לא, לא, ה-repository אכן ריק. אני רק...
אופס, אני כנראה מחקתי את ה-repo הלא נכון, לא נורא. בשביל זה יש לנו Git.
אוקיי, אז git clone... git clone, אנחנו מעתיקים את ה-repository URL, ואנחנו עושים Shift+Insert, נותן לנו... נותן לנו להדביק לתוך ה...
- אתה יכול רק להראות את הלינק בצ'אט?
- הוא בצ'אט.
- תודה, סליחה.
- ו-github.com, בסוף microcontrollers?
- כן, נכון. ואז אתם יכולים לקרוא לתיקייה בשם אחר או enter, והוא יצור אותה בשם הנוכחי.
- כתוב פה... אני מקבל כאילו אם אני מעתיק מהמצגת: Copying and pasting content...
- כן, כן, אפשר להעתיק כל דבר, כן.
אוקיי, ואז מפה אנחנו נכנסים לתוך התיקייה של ה-repository. שימו לב שאתם לא בתוך התיקייה כרגע, כי אנחנו נמצאים בתוך C ו-source, או מה שזה אצלכם. אז cd - change directory, אם אנחנו עושים double tab הוא ייתן לנו את כל האפשרויות. וזה free-rtos-microcontrollers.
- אה, זה... אה, זה לייצר חדש?
- מה, מה...
- cd זה לעבור אליו.
- cd זה change directory.
- כן, אבל אין לי את ה... אין לי את מה שאמרת, free rtos.
- עשית git clone? הצליח?
- אה, לא לא לא לא, סליחה, רגע. לא עשיתי git clone. רק שנייה.
- אתה יכול אולי לזרוק לנו את ה-bashrc שלך שכותב ככה יפה את ה... את ה-branch שאני נמצא? או שזה... אה, זה נמצא... זה פשוט... כי אני ב-Ubuntu, זה לא רושם לי יפה את ה-main ואת ה...
- נכון, אני חושב שאתה יכול לשנות את זה אם אתה רוצה.
- אה, יש לי... כן, אני מבין מה צריך לעשות עם זה, בסדר.
בסדר, ובסוף נעשה ls לראות את התוכן.
- הוא לא נותן לי את ה-git clone.
- למה הוא לא נותן לך את ה-git clone?
- הוא לא נותן לי לעשות copy-paste.
- Shift ואז הכפתור Insert.
- Shift+Insert?
- כן, זה ככה עושים הדבקה, או מקש ימני. כפתור ימני גם עובד.
- לא. מוזר.
- הוא לא... עשית לא העתקת כאילו. תלך תעשה copy ואז תעשה Shift+Insert בטרמינל.
- לא, עשיתי copy מהמצגת... אה, עשיתי את זה מפה, שנייה שנייה שנייה. רגע, רק שנייה, סליחה. או, עכשיו עשיתי. עכשיו הוא עושה cloning.
- כן, ואחר כך אתה צריך לעשות change directory לתוך ה-directory של free rtos.
- freertos-microcontrollers?
- בדיוק.
- אוקיי, כן, הגעתי.
- מעולה, ברגע שאתה בתוך התיקייה אז יופיע לך main, אלא אם כן אתה ב-Linux, ואז אתה יכול להוריד לך טרמינל אחר אם אתה רוצה.
ועכשיו אני אראה בעצם איך אני דוחף, נעשה דוגמה איך אני דוחף קוד, ואתם תמשכו אותו, כדי שתכלו להבין מה לעשות לפני כל שיעור, אוקיי?
אז כרגע אני עושה את זה בלבד. אני פותח nano כדי שאני אוכל לערוך README.md, שזה ה-MD file. ופה אני מכניס שינוי של new code for you to fetch. Control+S ו-Control+X, זה שומר ומאפשר לצאת מ-nano.
עכשיו, שוב, זה גם רק אני עושה. אז git add, ואני מוסיף את ה-README. אוקיי, ו-git status יראה לי עכשיו איזה קבצים השתנו. אז הקובץ שעשיתי לו staging זה ה-README.md. ועכשיו אני עושה commit, בעצם אני מה שנקרא מתחייב על הקוד הזה. אז git commit -m למסג', new class changes for class example. ואני סוגר את זה. וברגע שאני אעשה git push, אתם תוכלו למשוך את זה.
אז איך אתם מושכים? אני אראה לכם... הייתי יכול להראות לכם גם איך למשוך, אבל זה פשוט. נעשה כזה דבר: אז git pull, ואז יהיה לכם את כל המידע המעודכן. לכן אתם תראו צבעים בירוק ואדום של פלוס ומינוס, ואז אתם תראו שיש לכם גם את העדכונים של ה-repository. בסדר?
- git pull פעמיים?
- לא, git pull פעם אחת. אם תעשה שוב הוא ירשום לך שזה already up to date.
- אה, אוקיי, בסדר.
- אז עכשיו הוא שינה את הקובץ README.md?
- נכון. איך אנחנו נראה שהוא שינה את הקובץ README? אז cat README, רק בשביל זה. אז הנה, new code for you to fetch.
אוקיי, אני אגיד את האמת, אני עדיין מתלבט אם ליצור branch לכל שיעור. אולי זה באמת מה שאני אעשה כדי שיהיה לכם יותר קל למשוך. ואז אם אני יוצר branch לכל שיעור, אז התהליך נראה ככה:
git fetch --all --prune
זה גם ימשוך את כל ה-branches שנוצרים, וגם ינקה metadata שלא צריך, אוקיי? אז זו הפקודה. ואחר כך אני אתן לכם את ה-branch החדש. בואו נתרגל גם את זה. אני אצור branch: git checkout -b, זה יצירה של branch חדש.
- כל הפקודות האלה נגיד cat ו-cd זה פקודות Unix, נכון?
- נכון, כן.
- פשוט ה-Git משתמש בזה...
- לא, הפקודות Unix שאני משתמש זה פשוט פקודות של הטרמינל, ופקודות ה-Git שאני משתמש זה חלק מ-Git.
- אוקיי. אבל נגיד עשית cat README.md, זה כמו להדפיס קובץ?
- כן, כן. זה פשוט שנוכל לקרוא מה יש בפנים.
- אם הפקודה מתחילה ב-git, אז זו פקודה של Git, ומה שנתת לו אחר כך. ואם זו סתם פקודה, cat, ls, whatever, אז...
- זה כאילו דברים של Linux, Unix וכאלה.
- כן, כן.
אוקיי, ועכשיו אני יוצר branch חדש גם שתכלו למשוך אותו. אז git checkout -b...
- תראה, אני תקוע באותנטיקציה, אני מצטער. לא יודע אם זה רלוונטי להגיד, אבל...
- זה בסדר גמור. אם אתה לא מסתדר, אז אני יכול להראות לך אחר כך או שתשלח לי בצ'אט וננסה לעשות את זה מרחוק. זה בסדר גמור.
- אני איתכם, סבבה.
- אוקיי, וגם תמיד אפשר לחזור למצגת... להקלטה.
git checkout -b נותן לנו branch חדש, אז אני יוצר אותו. ואז אתם רואים שה-branch name משתנה פה בסוגריים. ואם אני עושה git push... אז אני יכול לדחוף את ה-branch החדש, ואתם תוכלו למשוך אותו. איך אתם מושכים אותו? אז כמו שאמרתי:
git fetch --all --prune
- רגע, אז זה אומר שאנחנו מושכים branch חדש על אותו מקום או...
- מאותו repository. זה ה-repository, אתם עשיתם clone, ואז כשתעשו את זה הוא ייתן לכם את ה-branch, ואתם עושים: git checkout לשם של ה-branch, אז class0, והוא ישלים לכם.
- רגע, אנחנו צריכים לעשות fetch או checkout?
- fetch, fetch ואז checkout. fetch זה כדי למשוך. בואו נעשה switch, יותר נכון. checkout יכול ליצור בעיות. switch.
- רגע, לעשות git fetch --all --prune?
- כן. ו-git switch עם השם של ה-branch. שזה class0.
- אצלי זה עדיין נשאר main.
- כשתעשה git switch ככה, git switch class0...
מישהו יודע להגיד למה switch ולא checkout כדי לעבור שם של branch?
- אני לא מכיר את ה-switch הזה.
- אז עד לפני כמה גרסאות ב-Git, הייתה לנו אפשרות לעבור בין branches עם checkout. אמה מה, git checkout אפשר גם לעשות לקבצים. אם אני עושה git checkout לקובץ, אז הוא בעצם מבטל את השינויים על הקובץ. ואז אם אנחנו עושים גם קובץ וגם branch באותו שם, יש לנו קונפליקט. אז יצרו פקודה שנקראת git switch.
- אה, זה חדש?
- יחסית. מה שהיה לפני זה רק checkout.
- ואז אתה חייב לדאוג שהשמות יהיו שונים? של שם של...
- או להגדיר את זה ש-checkout הוא קודם כל branch ואז קובץ, או הפוך. כנראה branch...
- מישהו פה מכיר SVN חוץ ממני?
- SVN? אני יצא לי לעבוד עם זה, אבל זה יצא... ירד מהעולם.
- תגיד, אפשר שאלה קטנה?
- כן.
- אז עשיתי clone והכל. כאילו מה עשית אחרי ה-clone? fetch all?
- אחרי ה-clone, אם עשית עכשיו clone, אז זאת אומרת שיש לך את המידע מעודכן. אוקיי? אבל אם לא היה לך את המידע מעודכן, היית צריך לעשות git pull, אוקיי? git pull מעדכן לך את ה-branch הנוכחי.
- אבל אני לא צריך.
- אם אתה רוצה לקחת את כל ה-branches החדשים ואת השינויים בהם, אתה תעשה git fetch. git fetch --all --prune.
- אה, אתה אומר כאילו בגלל בהמשך, אבל עכשיו אני...
- עכשיו אתה מיושר. אתה צריך לעשות git switch כדי לעבור ל-class0.
- ל-class0?
- כן, זה השם של ה-branch. ב-Git יש לנו מושג של branches, שאנחנו יכולים לקחת את ה-repository בנקודת זמן מסוימת ולעשות לו branch, לצאת לענף משלנו. אנחנו יכולים לשנות את הענף ואז בעתיד לדחוף אותו בחזרה אל ה-main. אז זה ה-branch, ואני יצרתי branch חדש ל-class הנוכחי כדי שנוכל לעשות אותו.
- switch לא עבד.
- git switch, ואתה צריך גם לעשות את השם של ה-branch.
- class-0.
- בלי המקף.
- אוקיי.
- אתה יכול אגב להשלים עם Tab או עם Double Tab. ככה, git switch, אתם רואים Tab משלים אותי, ו-c, אתה יכול לעשות c ולהגיד לו Double Tab והוא משלים אותך. זה הכל פה.
זה הכל מבחינת ה-Git.
## FreeRTOS Setup and Overview
- אז כרגע על המחשב שלנו תהיה את ה-FreeRTOS microcontrollers עם קובץ README.md שהוא ממופה ל-branch מסוג שנקרא class0?
- הוא נמצא בשני ה-branches. למה? כי אחרי שיצרתי אותו עשיתי branching במקום אחר.
- נכון, אז אני אומר, אז אחרי שעשינו git switch אז הוא כן עבר ל-class0. כלומר מה שאני מסתכל עליו עכשיו על המחשב זה מה שיש ב-class0.
- אוקיי, אני רואה שזה... לא, לא, הכל בסדר. מה שאתה רואה נמצא ב-class0, והוא נמצא גם ב-main. כרגע הם מעודכנים. אם אני אכתוב עוד קוד אז ה-class0 יתקדם מעבר ל-main. אם אני אעשה לו commit אז יהיה לי commit לפני ה-main. אל דאגה, אני אשלח מדריך Git שכתבתי לפני כמה זמן, ככה שתוכלו להשתמש.
- השימוש שלנו ב-Git הולך להיות בעיקר למשוך ממך את השיעור הקרוב, זאת אומרת אין פה איזה עניין של...
- נכון. אם תרצו להגיש מטלות, אני... האמת שעוד לא בדקתי איך אפשר לעשות את זה, אבל אני חושב שאתם יכולים לעשות fork ולפתוח pull request לעצמכם ואז לשלוח לי כדי שאני אוכל לעבור על זה. סבבה? אני אסביר מה זה fork. fork זה בעצם לקחת...
את ה-repository ולהפוך אותו שיהיה instance שלו אצלנו, ב-user שלנו. זאת אומרת שהוא כבר לא יהיה שייך ל-user שנקרא Orsulimani, הוא יהיה שייך לכל אחד מה-users שלכם, ואז אתם יכולים ממש משם לכתוב מה שבא לכם לבד. יש אפשרות לסנכרן forking, זאת אומרת ממש למשוך את ה-fork מה-repository הבסיסי. לא עשיתי את זה, צריך לבדוק.
מה ההבדל בין ה-fork ו-branch, אז?
Fork זה repository, זה העתק לגמרי של כל ה-repository, של כל מה שאנחנו רואים פה.
זאת אומרת, אני אראה את ה-repository ששמו FreeRTOS Microcontrollers תחת אודי, כאילו?
נכון. הוא נמצא כאן, אוקיי? אני גם יכול לראות את ה-forks. ואני אראה כאן ש... אתה תראה כאילו שעשו לך fork.
רגע, אור, איך אני בעצם... אה, אם אני הולך ל-Home, איפה אני רואה נגיד את הפעולה שעשיתי ב-GitHub? אני לא רואה את זה.
מה הכוונה איך אתה רואה? אתה יכול לראות את ה-commits שאני עשיתי.
כן, איך אני יכול לראות את זה?
אתה הולך ל-repository עצמו, אתה יכול לראות commit, אתה יכול גם לעשות `git status`.
זהו, איך אני ל-repository? זה בקישור ש...
זה ה-repository שלי. הקישור הזה הוא יופיע גם ב... אה, אני רואה ששחר כבר הכניס אותו ל-description. הוא מופיע ב-description של ה-WhatsApp, Repo הקורס. ואני רואה שתי branches: main ו-class0.
Repo הקורס כאן.
סבבה, אוקיי, בואו נמשיך.
## התקנת STM32CubeIDE
איך אנחנו מורידים את ה-STM32Cube? אם יש לכם, מעולה. אם לא, אז יש פה לינק. אנחנו נפתח את האתר של ST, ניכנס אליו, Control+C ונדביק אותו. נביא אותו לפה, Control+V, ואנחנו ניכנס לתוך האתר. בתוך האתר אנחנו צריכים להירשם, שוב, מה לעשות, צריך להירשם. אני כבר רשום.
יש את הלינק בצ'אט?
הוא נמצא במצגת.
לא הספקתי להוריד אותה.
היא נמצאת בתוך Google Slides. מתוך המייל, מופיע ב-description של ה-WhatsApp.
אני אשלח. אין בעיה, אני אנסה לתת לכם לפני, אבל בגדול אנחנו מקימים סביבה פעם אחת, אז בשיעור הבא פשוט לא תצטרכו לעשות כלום. שלחתי גם את ה-ST.
מפה, אנחנו נרשמים, לוחצים על Get Software. אז מי אמר שהוא עם Debian? אז יש לנו פה Debian, נכון, אודי?
שלחתי ב-WhatsApp. תודה.
יש לנו את ה-Debian, יש גם ל-Mac, מי שעובד עם Mac, ו-Windows. באיזה מספר סלייד זה הלינקים? בסלייד 8.
גרסה - אז אתם יכולים לבחור... אל תבחרו ב-1.18, כי ב-1.18 יש להם איזושהי פרצת אבטחה. תבחרו ב-Get latest, 1.19. אחר כך הוא יגיד... אני חושב שגם אני צריך לעדכן על הדרך, אז אחר כך הוא יגיד לנו בוא תוריד, והוא יוריד לנו את ה-installer.
ל-Debian, אני חושב שאתה צריך להשתמש ב-package manager, אני שכחתי את הפקודה.
זה `sudo apt install` משהו.
ל-Windows לא להוריד latest?
להוריד latest, בטח.
לוקח לו המון זמן לטעון את האתר הזה. האתר של ST לפעמים עושה דברים. לפעמים פשוט לא קיים לך הכפתור Install או Download.
ברגע שזה יסתיים, אנחנו פשוט נעשה את ההתקנה. בינתיים בואו נמשיך. אנחנו משתמשים בו כי זה בעצם סביבת הפיתוח הכי נוחה, יש לה את האינטגרציה הכי טובה, ויש לה גם FreeRTOS כחלק מה-project configuration, שזה מה שאנחנו נעשה בשיעור הבא.
## חזרה על נושאי הקורסים הקודמים
בינתיים, בזמן שזה מוריד, אני אדבר קצת על הקורסים הקודמים. מכולכם אני חושב שרק אריה היחידי ששרד, אז בעצם יש לנו... דיברנו על גישה ישירה ל-registers, דיברנו על אבסטרקציה של operating system.
בינתיים זה נפתח. תעשו לזה extract. Extract all, Extract all. הוא ייתן לנו תיקייה, ואז אנחנו לוחצים על ה-installer. את זה אפשר לסגור. אתם רוצים שאני אחכה שכולכם תגיעו לשלב הזה?
אז עוד דברים שעברנו בקורסים הקודמים: דיברנו על ארכיטקטורה של זיכרון, stack management, על memory-mapped I/O, בעצם איך אנחנו ניגשים לתוך ה-buses של הזיכרון, ואנחנו כותבים לתוכם את מה שאנחנו רוצים מה-registers; שיטות אופטימיזציה ב-C לקומפיילר שאנחנו עובדים איתו; דיברנו על bus interfaces, איך אנחנו משתמשים ב-buses כדי לקבל גישה לפריפריאלים.
אני יודע שזה מדאיג קצת כי לא דיברנו על זה, אבל אנחנו לא צריכים. בקורס הזה אנחנו נעבוד עם ה-HAL-ים, אוקיי? עם הספריות Hardware Abstraction Layer של STM, ככה שכל זה זה רק פלוס, זה מידע שהוא פלוס. אם תרצו בעתיד לעשות את הקורסים האלה, אז כשהם ייפתחו תוכלו ליצור קשר עם שחר.
עוד דברים שדיברנו עליהם, וגם אנחנו נדבר עליהם קצת בקורס הזה: על ה-core שלנו. אנחנו משתמשים בארכיטקטורה של ARM, ARM Cortex-M וכל הסדרה: F0, 3, 4, 5, 33, 7, ותסלחו לי אם פספסתי אחד. אלה הגרסאות core של Cortex-ARM שאנחנו יכולים להשתמש בהם. מה הן נותנות? הן נותנות register usage, privilege level שאנחנו יכולים לעבוד, ו-operational modes כדי לעבוד מתוך interrupt ולא; טיפול ב-exceptions, איך אנחנו עובדים עם vector table, fault management, ו-Nested Vectored Interrupt Controller, ואיך אנחנו מקנפגים את ה-interrupts.
בקורס דרייברים שנגמר בשבוע הבא, דיברנו על איך אנחנו מפתחים דרייברים לחומרה עצמה: GPIO, I2C, SPI, ו-UART, כל אימפלמנטציות גם ב-Bare-metal, גם עם HAL-ים, וגם ב-LL, שזה Low-Level, שזה שלושת הדרייברים שאנחנו יכולים להשתמש בהם: או ל-Bare-metal, ככה אנחנו עושים גישה ידנית, או ספריות שה-manufacturer מג'נרט לנו.
איך נקרא הקורס הקודם?
הקורס הקודם Driver Development, ולפניו Bare-Metal Programming ל-STM32.
וזה לא תנאי קדם לקורס הזה?
זה לא. בגדול עשיתי אותם... כל אחד מהם נוגע בסגמנט אחר, כל אחד מהם יכול לעמוד בפני עצמו, ויש דברים שקצת חופפים, אבל זה לא תנאי הכרחי.
ו-Real-Time Constraints, שאנחנו הולכים לעשות גם בקורס הזה: הבנה של timing requirement ו-deterministic behavior, איך אנחנו מנהלים זמן ואיך אנחנו דואגים לעשות פעולות בזמן, שזה real-time.
אני יכול להמשיך עם ה-installer?
אני עוד לא שם, עכשיו חילצתי.
אני חושב שה-installer שלך הוא שונה, אתה פשוט עושה `apt-get install`. שלי zip, אז אני צריך לפתוח את ה-zip.
אני חושב ש-Eclipse בבסיס שלו הוא 500 megabyte, 500 או 100 megabyte. ואם מעניין אתכם, אז Eclipse כתוב ב-Java.
הגעתי ל-Choose Install Locations.
אנחנו בעבודה עובדים עם Eclipse.
אני למזלי לא עובד עם Eclipse, כי זה לא הכי נוח, אני חייב להודות.
אז אני אסביר למה אנחנו משתמשים ב-Eclipse. Eclipse מייצר לנו את ה-Makefile לבד. מה זאת אומרת? זאת אומרת שאנחנו משנים הגדרות, מוסיפים קבצים, והוא לבד מייצר לנו Makefile, ככה שכשאנחנו מקמפלים, הכל כבר מסונכרן. זאת אומרת שאני לא צריך להוסיף flags ספציפיים לקומפילציה, אני לא צריך לקמפל קובץ-קובץ ובסוף להלנקט אותם ביחד, אני מקבל את הכל במכה אחת. אז זאת הסיבה שמשתמשים ב-Eclipse, כי זה יותר נוח לזה. נכון שזה לא אידיאלי, אבל זה מה שנוח ב-Eclipse.
ברגע שלוחצים על המסך, זה החלון הראשון. אנחנו נעשה Next. License Agreement, נעשה I Agree. ה-Destination Folder, אתם יכולים לבחור מה שבא לכם, ה-default זה זה. שימו לב שאתם צריכים 3.6 gigabyte פנוי. אחר כך אנחנו נצטרך לבחור את ה-Segger J-Link drivers, זה בשביל ה-ST-LINK, וה-ST-LINK driver, שזה גם בשביל ה-ST-LINK. וההתקנה תתחיל.
קודם אמרנו לסמן את שניהם? J-Link drivers ו-ST-LINK?
כן.
## מהי מערכת הפעלה (Operating System)?
בואו נדבר קצת על מה זה בעצם מערכת הפעלה.
מערכת הפעלה זה בעצם מערכת שמנהלת את החומרה ואת התוכנה, את ה-resources של החומרה ושל התוכנה בתוך ה-board או המחשב שאנחנו משתמשים בו, אוקיי? בגדול, גם board זה הקור של המחשב, או מכונה, יותר נכון.
המערכת הפעלה גם מספקת לנו כמה services, שהם ה-services למערכת. מה ה-functionality שאנחנו מקבלים במערכת הפעלה? אנחנו מקבלים process management. אל דאגה, אני אסביר מה זה process. זה האפשרות ליצור, לתזמן, להשמיד, וליצור tasks.
ניהול זיכרון - או דינמי או סטטי. מערכת הפעלה יכולה להחליט אם הניהול הזיכרון שלנו דינמי, זאת אומרת שיש לנו memory allocator, מה שעושה לנו אאלוקציה של memory כמו `malloc`, או שיש לנו זיכרון סטטי, זאת אומרת שלכל task או process יש לו את הזיכרון שלו, שזה העולם שבו הוא חי. מעבר לזה, הוא כנראה קורס. וזה זיכרון סטטי, זאת אומרת שהוא מוגדר בצורה קשה ולא דינמית.
File system management - ניהול של כל ה-storage, לאו דווקא קבצים כמו שאנחנו מכירים אותם, גם יכולים להיות קבצים בתוך הזיכרון.
Device management - ניהול וסנכרון של החומרה.
User interface - חלק ממערכות ההפעלה מגיעות גם...
user interface, נותנת לנו אפשרות לאינטראקציה בין ה-user לבין המערכת. user interface מבחינה של embedded יכול להיות כפתור, אוקיי? או LED, לתת אינדיקציה ל-user שקורה משהו. ו-security, הגנה מ- הגנה של ה-user, בקיצור חסימת גישה ל-user ל-resource data. ה-user לא תמיד צריך להיות חשוף, ולרוב לא, צריך להיות חשוף לכל הדאטה, וזה בעצם אחד מהפ'יצ'רים של מערכות הפעלה.
## OS as an Abstraction Layer
מערכת הפעלה בעצם זו איזושהי שכבה אבסטרקטית, זאת שכבה שנותנת לנו בעצם, שמסתירה לנו את מה שקורה מאחורה. היא נותנת לנו אבסטרקציה לחומרה, בעצם מסתירה מאיתנו את כל העבודה המסובכת מול חומרה, הנגיעה ברגיסטרים, ההמתנות, סנכרונים, אינטראפטים, אז זה גם מערכת הפעלה ממסכת לנו ונותנת לנו את זה כמשהו מוכן.
למה אנחנו צריכים דבר כזה? גם להגן על ה-user מפני שימוש לא נכון בתוכנה, בחומרה, וגם כמפתחים, מה שזה מעניין אותנו והאבסטרקציה הזאת, זה כדי שלא כל פעם נצטרך ללמוד מחדש את כל החומרה, אז מערכת הפעלה עושה לנו אבסטרקציה. אנחנו משתמשים רק בסט פעולות, ב-API קבוע, והמערכת הפעלה עצמה מאחורה, ב-background, עושה את מה שאנחנו צריכים.
אנחנו רואים את זה הרבה במערכות הפעלה מבוססות Unix, כמו לדוגמה Linux, שבהם הכל בעצם זה קבצים, וכל הפעולה, כל האינטראקציה מול מערכת הפעלה נעשית בתור קבצים. אז בעצם ברגע שאני פותח קובץ, אז אני בעצם משתמש בחלק ממערכת הפעלה. לדוגמה, אם אני פותח קובץ אז אני משתמש בזיכרון, בדיסק שלי. הדיסק שלי הוא גם נראה כמו קובץ. אז זה האבסטרקציה.
חלקים נוספים שאנחנו מקבלים באבסטרקציה: resource virtualization, בעצם הדוגמה הזאת היא גם רלוונטית יותר ל-Windows ו-Linux, למערכות שהן יותר general purpose, אז בעצם אנחנו אם כל מיני מניפולציות ב-background, אנחנו יכולים לקבל זיכרון לדוגמה שהוא רציף. נגיד אם יש לי... יכולים לקבל דוגמה של זיכרון שהוא וירטואלית רציף. לדוגמה ב-Linux יש לנו רכיב שעושה לנו את ההמרה מזיכרון פיזי לא רציף, זאת אומרת כמה חורים של זיכרון פנויים, לזיכרון שנראה רציף. אז זה עוד וירטואליזציה שנעשית.
וסטנדרטיזציה, בעצם עבודה עם API קונסיסטנטי, לדוגמה קבצים או API של POSIX, נדבר גם על זה. אז עם API של POSIX אנחנו יכולים לעבוד והכל נראה לנו אותו דבר ואנחנו יכולים לעשות החלפה בין מערכות הפעלה.
הפרדה, בעצם אנחנו יכולים באמצעות ההפרדה עצמה להשתמש באפליקציות בלי שהן יפריעו אחת לשנייה. זאת אומרת שיש לנו כמה task-ים וכל אחד מהם הוא מופרד מהשני עד כדי סנכרון שאנחנו נעשה באמצעות מערכות סנכרון.
ו-portability, אז אם אנחנו עם API קונסיסטנטי, אז יותר קל לנו להחליף מערכות hardware. אז יש לנו את אותו API ובעצם המערכת הפעלה ברקע עושה דברים אחרים. זאת שכבת האבסטרקציה שאנחנו מקבלים עם מערכת ההפעלה.
שאלות על זה?
בינתיים ה-installer סיים. סורי שזה קופץ, בדרך כלל השיעורים הם יותר ליניאריים. ה-installer סיים, אנחנו יכולים לפתוח את ה-STM32CubeIDE וכך לא זה רגע, אבל אנחנו נמשיך.
אז... לפתוח את זה?
כן, בינתיים נראה לי שזה נפתח. שומר כנסייה ישנה, מעניין.
STM32Cube, נותן לו עוד שנייה, הוא יפתח. לא יודע אם נספיק לעשות את זה היום, למרות שסך הכל אנחנו בסדר.
קצת תקוע לי המסך, אוקיי. הוא מבקש workspace.
אז אוקיי, ה-workspace שאנחנו הולכים להשתמש בו, אז אני שנייה באמת נוצר איזשהו directory בשביל השיעור הראשון, ואז תמשיכו אותה.
אז `mkdir`... רק אני עושה את זה, `class8`.
`git add class8`
`git commit -m "class8 lesson"`
ואז חשוב לעשות git push... git fetch...
אם אנחנו על אותו branch, אנחנו כבר נעשה `git pull`. `class8 lesson example`, עוד דוגמה בשבילנו, ואני אעשה `git push`.
שנייה, אני עדיין עושה את זה, חכו.
אוקיי, עכשיו אתם באמת יכולים למשוך. `git pull` מהצד שלכם. ואז בעצם נוכל לעשות browse למה שאנחנו צריכים, אוקיי?
אז ברגע שמשכתם, אנחנו נעשה browse, ניקח את המקום... המקום שאני שמתי זה src, freertos-microcontrollers, ו-class8. בהמשך יהיו לנו פה גם תיקיית docs שאנחנו צריכים ועוד תיקיות שאנחנו משתמשים בהם. ובסוף אנחנו עושים Launch והוא יפתח לנו את ה-IDE.
אז לשים את התיקייה microcontrollers class8 תחת workspace?
מה, מה עוד פעם?
כשאני פותח את ה-Launch...
כן, כן.
לא הבנתי, עשיתי כאילו pull, checkout ל-class8 lesson example, נכון? זה זה?
חכה שנייה, רק אצלי זה עוד פעם כנראה הראה את הדבר הזה. אוקיי, מהתחלה.
מה זה? אתה יכול להתחיל מהתחלה?
אני לא שומע אותך.
תעשה git pull.
אה כן, עשיתי git pull ו-class8 lesson example, זה כאילו אני עליו.
כן, זה לא בשביל זה. עכשיו ברגע שתפתח את ה-STM32Cube, אז אתה תראה את זה ככה, אני אראה שנייה. Switch Workspace, אז ברגע שתוכל, תכניס את ה-path שיש לך במחשב ל-class8. תעשה browse ואתה עושה את זה, בסדר?
אור, הוא שואל פה על ה-Windows Defender אם לעשות לו exclude...
תעשה לו exclude, כן. פשוט רק שזה הגרסה החדשה, האמת שאני לא מכיר את זה. כן, תעשה לו exclude כדי ש-Microsoft Defender לא יחסום לך את הגישה.
אז מקודם דיברנו על פיצ'רים של מערכת הפעלה, אז הנה אנחנו רואים פיצ'ר של מערכת הפעלה. מערכת הפעלה Windows היא יכולה להחליט לחסום גישה לחומרה. אז אם ה-STM32Cube רוצה ליגשת לחומרה, אז היא שואלת אם לחסום את החומרה. מכיוון כשאנחנו נעשה exclude, אז אנחנו נגיד למערכת הפעלה שלא לחסום את החומרה, את הגישה.
## Operating System Components
אז שוב, בעצם אנחנו בוחרים את התיקייה של class8, ממנה אנחנו נעשה Launch או Launch, יותר נכון להגיד, Cancel, וזה אמור להופיע לכם.
אוקיי, אז בואו אנחנו נחזור. מה הקומפוננטות של מערכת הפעלה? מה הקומפוננטות העיקריות של מערכת הפעלה?
הקומפוננטה הראשונה זה ה-kernel, שזה הגרעין. הקומפוננטה ה-core, הקומפוננטה העיקרית, הלב של המערכת הפעלה. הוא בעצם מורץ עם privilege level, זאת אומרת שיש לו גישה להכל. הוא בעצם יכול להריץ לנו את ה-task ב-privilege או unprivileged. זאת אומרת שאם אנחנו רצים מתוך ה-kernel, אנחנו סליחה, אם אנחנו רצים מתוך ה-kernel, זאת אומרת שאם אנחנו מריצים קוד שהוא מוגדר שהוא קוד קרנלי, אז אנחנו יכולים לרוץ גם בצורה של privileged mode. מה הכוונה privileged mode? בצורה שיכולה לגשת לחומרה. אז אם אנחנו עובדים מתוך ה-kernel, אז יש לנו גישה ישירה לתוך החומרה. אנחנו יכולים לנהל את ה-CPU, זיכרון, ו-devices של input ו-output, לדוגמה UART, אוקיי?
יש לנו את האפשרות לעבוד עם system calls. זה תלוי אימפלמנטציה של מערכת הפעלה. אם אנחנו מכירים במערכות Unix, אז בעצם אנחנו יכולים לעשות open, וזה יקרא ברקע ל-open של חומרה ולמערכת הפעלה עצמה. אז system call זה איזשהו interface בין אפליקציה ל-kernel services.
גם בתוך מעבדי Cortex-M יש לנו את האפשרות לעשות אימפלמנטציה ל-system calls. איך עושים את זה? אז יש לנו את האפשרות לקרוא לפקודת אסמבלי שנקראת SVC, Supervisor Call. הפקודת אסמבלי הזאתי היא בעצם מכניסה אותנו לתוך interrupt, שזה interrupt ה-Supervisor Call, וממנו אנחנו יכולים להעביר לו פרמטר, שהפרמטר הזה יכול לתת גישה לאחד מה-system calls, בעצם לגישה בתוך ה-kernel של הפקודה.
אני אתן דוגמה, הדוגמה הכי קלה זה לעשות read לאיזשהו interface. יש לי interface שנקרא I2C1, ואני לא רוצה לחשוף אותו ל-user בצורה החומרתית, אז אני עושה לו אימפלמנטציה בתוך system call. אז מה, יבוא ה-user ויבקש לקרוא מה-I2C1, ברקע מערכת הפעלה תקרא ל-Supervisor Call. Supervisor Call יקרא ל-Supervisor Call עם איזשהו index. Supervisor Call יקפיץ לנו את ה-read מתוך ה-I2C driver, וככה אנחנו בעצם עושים אימפלמנטציה של system calls. ככה זה נעשה בתוך ה-kernel, ככה זה נעשה בתוך מערכות real-time אחרות. כרגע אנחנו מדברים על זה בצורה יותר אבסטרקטית, אנחנו לא מדברים על זה ספציפית ל-FreeRTOS, אבל אנחנו נראה בהמשך איך זה עובד ל-FreeRTOS.
עוד services שאנחנו מקבלים: services כלליים של device drivers, בעצם האפשרות לשלוט על חומרה, על הקומפוננטות של חומרה. זה service שנותנת לנו מערכת הפעלה. file system, בעצם ארגון של המערכת קבצים בצורה שהיא נוחה לעבוד. לדוגמה ב-Windows, יש לנו את ה-Program Files, איפה שכל התוכניות מותקנות. יש לנו בתוך מערכת הקבצים מדיה, יש לנו Downloads, ויש לנו עוד חלקים של Windows שנמצאים תחת תיקיית Windows, אוקיי? וכל זה זה בעצם מערכת הקבצים.
Network stack, בעצם אפשרות לגישה ל-network, זאת אומרת גישה אינטרנטית. אז יש כמה סוגים של network stack, אז אפשרות לתקשורת לדוגמה TCP/IP, אז גם ב-Windows, גם ב-Linux, יש לנו אימפלמנטציה של TCP/IP שנותנת לנו גישה לתוך האינטרנט. אם אנחנו מדברים על Bluetooth, אז יש לנו גם Bluetooth stack במערכות הפעלה. זאת אומרת שיש לנו את האפשרות פשוט לכתוב לתוך או לחפש device Bluetooth וה-stack עצמו בעצם מנוהל בתוך המערכת הפעלה. מה הכוונה ל-stack? ה-stack הכוונה לתקשורת עצמה. כל התקשורת מנוהלת בשכבות, אז כל השכבות האלה ממומשות עד שכבת האפליקציה בתוך המערכת הפעלה. שכבת האפליקציה היא...
כאשר השירותים נחשפים ל-user.
אז כאשר אני פותח... כאשר אני רוצה לשלוח הודעת WhatsApp, אז בעצם אני שולח את ההודעה, והיא עוברת את כל השכבות עד לשכבה הפיזית אם צריך, ומשמה זה נשלח אל אל ה... אל הנמען שמיועד, והוא בעצם מפרק את כל ההודעה עד שהוא מקבל אותה כמו שאני שלחתי לו אותה. אז זה בעצם ה-stack שנותנת לנו מערכת ההפעלה.
עוד פיצ'רים של מערכות הפעלה: אז user interface.
יש לנו מערכות הפעלה שמבוססות command line interface, אוקיי? זאת אומרת שזה terminal שבו אנחנו כותבים פקודות.
יש לנו מערכות שמבוססות GUI, שזה Graphical User Interface, בעצם אימפלמנטציה פיזית של אינטרפייס עם ה-user.
ויש לנו כמה system utilities כמו קונפיגורציות או maintenance שאנחנו עושים.
במערכות שהן יותר embedded, ה-interface הוא לא דווקא... הוא יכול להיות לא GUI, והוא יכול להיות גם לא CLI, הוא יכול להיות ממש פיזי. זאת אומרת, אמרנו, לדים, כפתורים, רטט, whatever, כאילו מה שעובד.
ושכבת אפליקציה. מה זאת אומרת שכבת אפליקציה? זאת שכבה שבעצם המערכות משתמשות כדי לתת גישה ישירה לשאר האפליקציות במערכת. מה זה אפליקציות במערכת? זה utilities ו-services שנתמכים על ידי מערכת ההפעלה.
אני אתן דוגמה, ב-Windows אז כתבן שאנחנו מקבלים, שזה גם תוכנה אבל זה גם service שאנחנו מקבלים. עוד דוגמאות לא עולות לי ככה מהר מהראש.
וספריות. גם מערכת ההפעלה מספקת לנו ספריות שנוכל להשתמש בהן.
לדוגמה, נתן דוגמה glibc, אוקיי?
למערכות Unix, הן מספקות לנו glibc. glibc זה ה-C library, הספרייה של C שבאמצעותה אנחנו יכולים לכתוב קוד ב-C, לקמפל אותו ולהריץ.
הקומפילציה מגיעה מה-compiler, וההרצה מגיעה ממערכת ההפעלה, אבל הספרייה שאנחנו משתמשים בה, כמו לדוגמה printf, זה נמצא בתוך ה-glibc.
אז מה זה glibc? glibc זה בעצם המעטפת שבה אני כותב ב-C והיא מריצה לי דברים על מערכת ההפעלה. זה ה-glibc.
לדוגמה, אני אתן מעטפת שכולכם מכירים, printf.
printf ברקע, זה בעצם wrapper, פונקציית מעטפת ל-open ו-write.
אנחנו עושים open ל-stdout שזה ה-file descriptor הבסיסי, עושים לו open ואנחנו גם עושים לו write, אוקיי? ואנחנו כותבים ל-stdout וזה מוצג לנו על המסך.
זה לדוגמה stdout, אוקיי?
אנחנו לא נכתוב פה... אפשר, אבל אנחנו לא נכתוב פה Hello World, כן נעשה בהמשך Hello World בתוך ה-STM32CubeIDE.
מבחינת התקנות אני חושב שסיימנו.
אני מתלבט מה לעשות. פשוט אני לא יודע אם נסיים את כל המצגת, מקסימום נוכל להמשיך אותה בשיעור הבא, או שניצור פרויקט. בואו נסיים את המצגת.
## סוגים של מערכות הפעלה
אלה סוגים של מערכות הפעלה. יש לנו מערכות הפעלה שהן תמיכה של user.
שהן בעצם מיועדות ל-user אחד, לדוגמה DOS או מערכות embedded, או שיש לנו מערכות שנוצרו לכמה users, זאת אומרת שהדיפרנציאציה, ההפרדה ביניהן היא לפי מספר ה-users.
אז מערכות שתומכות בכמה users זה Unix, Linux ו-Windows.
מערכות שהן בעצם לפי task handling.
זאת אומרת שיש לנו single tasking, זאת אומרת שכל המערכת רצה על ידי task אחד.
ויש לנו כבר מערכות מתקדמות יותר, לדוגמה MS-DOS, שזו מערכת של Windows הישנה,
ומערכות חדשות יותר שבהן רצים במקביל כמה tasks, לדוגמה Windows, Linux או macOS.
יש לנו מערכות שההפרדה ביניהן היא לפי response time.
מה הכוונה ב-response time? אז יש לנו מערכות שצריכות לעשות batch processing, שזה הרבה מאוד עיבוד בבת אחת. יש להן גם scheduler ספציפי משלהן (עוד מעט נדבר מה זה scheduler).
כל התכלית של המערכות האלה זה בעצם לעשות כמה שיותר עיבוד.
אנחנו יכולים לראות את זה במערכות עיבוד, לדוגמה סלולר, תאים סלולריים. כל מה שהם צריכים, הם צריכים לעבד כמה שיותר מידע סלולרי. זה לנהל חיבורים, להעביר הודעות ולעשות לדוגמה handover, להעביר טלפונים מתא סלולרי לתא סלולרי אחר. אז אלה מערכות שהן יותר batch processing.
יש לנו מערכות אינטראקטיביות שהן אמורות להגיב ל-user command בזמן אמת. זאת אומרת שאני בעצם נוגע לדוגמה בטלפון, אני נוגע במסך ואני רוצה שזה יקרה בזמן אמת.
ויש לנו מערכות שהן real-time, שזה המערכות שא אנחנו הולכים לדבר עליהן בעיקר, שהן מערכות שמבטיחות לנו response ב-constraint time, בעצם בתוך תקופת זמן קבועה מראש וכמה שיותר קטנה לרוב.
אז מערכות real-time בעצם אלה מערכות שמבטיחות response בתוך זמן ספציפי.
הפרדה נוספת של מערכות שאנחנו יכולים לעשות זה לפי הארכיטקטורה.
יש לנו מערכות עם ארכיטקטורה מונוליטית, זה בעצם אומר שכל ה-operating system רץ על ידי process אחד, לדוגמה ה-kernel space. כל ה-kernel space רץ על ידי process אחד, זאת אומרת שתמיד CPU אחד, מעבד אחד, תופס אותו.
יש לנו עוד מערכות כמו microkernel, שזה בעצם kernel מינימלי שהוא נותן services ל-user space, לדוגמה QNX ו-MINIX.
ויש לנו מערכות שהן היברידיות, שהן גם קטנות והן גם מונוליטיות, כמו Windows NT ו-macOS.
## OS מול Bare-Metal
בואו נדבר על bare-metal מול עבודה עם operating system.
מה זה בעצם bare-metal? Bare-metal זה בעצם אומר עבודה ישירה לתוך ה-MCU, לתוך ה-core או לתוך הפריפריאלים.
אז או שאנחנו כותבים לרגיסטרים של ה-core שלנו, שבמקרה שלנו זה יכול להיות Cortex-M משהו, ואנחנו יכולים לכתוב לו לגלגל לנו interrupt, או שאנחנו יכולים לכתוב לתוך החומרה עצמה, שבחומרה עצמה יכולים לכתוב לתוך GPIO שידליק לנו LED בסופו של דבר. אז זו עבודה ב-bare-metal.
ב-bare-metal יש גישה ישירה לחומרה. התוכנה שלנו, ה-program שלנו, בעצם ניגש ישירות לתוך הרגיסטרים ובאמצעות מניפולציה על הדאטה בתוך הרגיסטרים אנחנו עושים מניפולציה על החומרה.
אין לנו overhead, בעצם כל מיני עטיפות של מערכת ההפעלה. אנחנו מקבלים מקסימום performance עם כמה שפחות memory usage. למה? כי אנחנו לא מתחילים... שתבינו מה זה stack, ואנחנו לא מתחילים בעצם לעשות פונקציות של מעטפת, בעצם לעשות אבסטרקציה, אנחנו עושים את הדברים תכלס. אני רוצה שיידלק LED, אני מגדיר את ה-GPIO ואני לוחץ ברגיסטר שנקרא ODR 1, ושם יידלק לי ה-LED. אז זה בעצם בלי שום עטיפה.
הפעולה היא דטרמיניסטית, אני יודע תוך כמה זמן יקרה כל דבר. תוך כמה זמן זה בדרך כלל? תוך כמה זמן שה-bus של החומרה... ה-bus זה בעצם הקו שמקשר בין כל הרכיבים של החומרה, שברגע שאני כותב אליו דאטה, אז זמן הסינכרון זה הזמן של ה-execution.
אם אני לוקח אחד ולוקח לו להסתנכרן cycle כל 2 מילי-שניות, אז זה הזמן שייקח לדבר הזה לעבוד.
עד כדי זמן עדכון של הפריפראל הספציפי שאני עושה. לדוגמה, אם הרכיב הפריפריאלי שלי יש לו איזשהו זמן התעוררות, אז העדכון של ה-bus וזמן ההתעוררות.
עוד דברים לגבי bare-metal מול operating system:
כאשר אני עובד ב-bare-metal אז יש לי אפליקציה אחת, זו אפליקציה שרצה מהתוכנה הראשית.
ברגע שאני מקמפל את הקוד שלי אז יש לי תוכנית, ברגע שהתוכנית רצה היא נחשבת process. מה זה process? תוכנית שרצה.
ברגע שהתוכנית רצה יש לי process אחד ישיר.
וניהול הזיכרון שלי נעשה בצורה ידנית. אני עכשיו צריך להחליט איך אני מנהל את הזיכרון ומה קורה שם.
בגדול כל הזיכרון מוקצה אליי כי אני process אחד, וכל הזיכרון מוקצה אליי ואני יכול לעשות עם הזיכרון הזה את הניהול שלי. יכול בעצם להחליט לנהל אותו עם איזשהו queue שאני מנהל, או שאני יכול להחליט לא לנהל אותו בכלל ולתת ל-stack לגדול ולקטון.
לעומת זאת, מערכת ההפעלה מה היא נותנת לי? היא נותנת לי אבסטרקציה, גישה מופשטת לתוך החומרה עם API.
נותנת לי עבודה עם כמה אפליקציות בבת אחת, אז מערכת ההפעלה מריצה כמה תוכניות או כמה processes בצורה סימולטנית.
Resource sharing, בעצם שיתוף של ה-resources, אפשרות לשתף גם CPU, גם זיכרון וגם I/O devices, דברים של input ו-output בצורה משותפת.
בעצם ניהול של שגיאות, ככה שאם process אחד נופל, לא נופלת לי כל המערכת.
ו-productivity של המערכת, היא מבטיחה לי בעצם set של services וספריות שנותן לי במקביל את ה-productivity.
## מתי לבחור בכל גישה?
מתי נבחר בכל אחד?
נבחר ב-bare-metal כאשר בעצם אין לי הרבה זיכרון ויש לי CPU אחד ואני צריך לעשות הכול בצורה מאוד מדויקת ומה שנקרא עם איזמל, ממש בעדינות.
כאשר יש לי real-time שהוא מאוד קריטי ואני צריך לעמוד ב-hard timing, כמה שיותר קצר ובזמן.
כאשר האפליקציה שלי היא פשוטה וזה לא איזה משהו מסובך שאני צריך לסנכרן, אלא single purpose device. לדוגמה RTC, real-time clock, זו דוגמה טובה.
וכאשר יש לנו battery-powered device, שכמה שפחות עיבוד שאני אעשה זה כמה שפחות בזבוז של הסוללה.
מתי אני אבחר במערכת הפעלה? כאשר יש לי אפליקציות יותר מסובכות, אני צריך לעשות כמה tasks במקביל ולסנכרן ביניהם.
אני צריך לעשות user interaction, בעצם גם אינטרפייס עם user וגם כמה tasks.
גם צריך תקשורת לעולם החיצון, protocol stacks שאני רוצה להשתמש בהם.
ושאני צריך לפתח מהר, אז אני צריך גם אפליקציות מהירות וגם פיתוח מהיר של האפליקציות.
טוב, אני חושב שאנחנו נעצור פה, אוקיי? גם כי אנחנו קצת חורגים וגם כי אולי צריכים פה את הקו.
אנחנו עצרנו בשקף 17. תזכירו לי, בשיעור הבא אנחנו נמשיך את זה וגם אנחנו נעשה Hello World, אוקיי? נעשה איזה Hello World כדי לראות שכולנו עובדים עם ה-MCUs.
מי שרצה לשאול על ה-MCU של הקורס: אתם יכולים להשתמש בכל MCU של STM32.
אם אתם רוצים לעבוד בעולמות של ה-low power, אז אני ממליץ להשתמש ב-STM32L, משפחת L שזה ל-low power.
יש לנו גם LPUART שזה low power UART, וגם LPTIMER שזה timer שנשאר חי גם כשהמערכת הולכת לישון.
ה-timer הזה עוזר לנו לצרוך nanoamperes של זרם, ואנחנו בעצם יכולים לרוץ בצורה הרבה יותר... גם מבוססת סוללה. אז אם אתם רוצים המלצה, אז זה מה שאני ממליץ.
משפחת ה-MCU שאני הייתי הולך אליה זה M4. למה? כי הם גם יותר חזקים מה-M0 וגם יש אפשרות לעבוד עם Floating Point Unit ולעשות עיבוד של floating point.
- בעצם מה שאמרת על מה שיש לי על ה-F4...
- F4 מעולה. F4 מעולה.
- זה Floating Point או Fixed Point?
- Floating Point. Floating Point Unit.
- אוקיי.
M3 לא מגיע עם Floating Point Unit. יש גם M33, אתם יכולים לשאול את אריאל בצ'אט בפרטי.
- מה הכוונה Floating Point? כאילו יודע לתמוך ב-float? או כאילו מה זה, ה-type float כאילו?
- Floating Point Unit operations אנחנו יכולים לעשות בחומרה ייעודית. זו חומרה ייעודית שעושה לנו חיבור, חיסור, מכפלות וחילוק של מספרי float. לעבודה יותר מהירה עם Floating Point אנחנו עושים את זה. יש אפשרות לעשות את האימפלמנטציה גם בצורה תוכנתית וזה יותר איטי. אז אם אנחנו משתמשים ב-MCU עם Floating Point Unit, אנחנו יכולים לעשות את זה יותר מהר.
אתם צריכים את שחף?
- כן, בעיקרון, ברגע שהבחור יעלה אני אתן לך פינג.
## הודעות וסיכום השיעור
אנחנו ניפגש בשבוע... האמת היא שרציתי לעדכן, בשבוע הבא יכול להיות שאנחנו נצטרך לדחות את השיעור, מסתבר שיש לי חבר שמתחתן. אני אשלח לכם עדכון למתי אנחנו נזיז את זה, ננסה למצוא זמן שמתאים לכולם, ואם לא אנחנו פשוט נעשה append בסוף הקורס.
אז עד כאן, זה הכל. איתן, אתה צריך עזרה או שהסתדרת?
- שאלה קטנה אחרי זה, כן.
אוקיי, אז דבר איתי ב-WhatsApp, בסדר?
- סבבה, תודה.
- אני נתקלתי בבעיות להתקין, אבל אני אגיע מיושר לשבוע הבא, מקווה.
מעולה. שבוע הבא אנחנו כבר נראה איך אנחנו עובדים עם ה-debugger ואיך אנחנו עושים עוד דברים. אז להתראות לכולם, ניפגש בשיעור הבא.
- ביי, תודה.
- תודה, ביי.