#2 (2025-04-09)

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

אז בגדול אני אנחנו נעשה את זה בהמשך השיעור כי אנחנו כבר נכתוב היום יש לנו שני סוגים של פרויקטים שאנחנו עושים אתה רואה איפה הסמן שלי אז יש לנו פרויקט שלס ויש לנו פרויקט שקוראים לו אז כשנפתח פרויקט אז אנחנו נעשה new ואז ש אוניקט כאילו נעשה זה שיעור ואז פרויקט של STM אז הוא גם נצרב לתוך הMCU ופרויקט של C זה פשוט פשוט משתמש בקומפיילר שעל המחשב זה הקומפיילר שהתקנו בשיעור הקודם טוב אז בואו נתחיל א בשיעור היום אנחנו בעצם נדבר על איך אנחנו יוצרים פרויקט אל הטרגט שלנו שטרגט שלנו זה הMCU לי יש את הMCU הזה זה כל אחד מכם אני מניח יש אחד אחר או גם כן זה אנחנו ננסה אנחנו נראה איך אנחנו משנים את ה משנים את ה א אתם יוצרים פרויקט ומשנים את מה שצריך כדי להריץ את זה אחר כך אנחנו נעשה hello world מהMCU בעצם נגרום לMCU להדפיס לנו אל המסך Hello World נדבר קצת על advancecy א על advancecy concept נדבר על bitwingים וכ היה לנו שאלה בשיעור הקודם א ואנחנו קצת נכנסים לזה יותר ממש עם הדגמה נדבר על complex data tyפes נעשה קצת ארגון של הפרויקט איך אנחנו עובדים עם header fילes ומולס source fילes ובעצם מה ה best practices כאשר אנחנו בונים פרויקט be metalbדed ובסוף אנחנו נסיים עם הbild process בעצם כל מה שקורה בקומפילציה באסמלי והלינ ‏thinking steps זה הזה נדבר על הF structure ובסוף אנחנו נבין גם איך אנחנו עושים אנליזה לאf איך אנחנו ממש פותחים את הקובץ ורואים מה הוא מה הוא הולך לעשות א אז ככה creating a project from target אתם מוזמנים לעשות איתי ביחד אז רק א אולי שנייה לפני א אוקיי א איך אנחנו עובדים בקורס אז יש לנו את הגיטבש אני קיבלתי הרבה מאוד א קיבלתי הרבה מאוד פידבק שאיגיד בשו לא משהו אז א אז אני אנסה להראות דוגמה בשיעור הבא איך אפשר לעבוד גם עם vsד זה לא כלי מושלם אבל בסדר אה אבל אולי יותר יציב מזה אוקיי אז אז פה דבר ראשון תחיל לעשות גיטקים אוקיי טוב זה אולי לעשות א זה לא יותר פתוח א שימו לב שכל פעם שאנחנו פותחים את הID אז הוא מייצר הרבה קבצי מטדata בשביל עצמו אז אני סוגר אותו לא להשתמש בפקודה שאני מראה בזה זה בעצם לנקות את כל הקבצים שהוא לא עוקב אחריהם אוקיי ועכשיו אנחנו נרצה לעבור brch נגידסוי אוקיי, חבר שיעור הנכון. אה, סבבה. אז זה באמת מה שאנחנו צריכים לעשות ועכשיו אחרי שעשינו אחרי שעברנו לזה אז גיט סוויch א מחליף לנו אתגיט צקאוט כי גיט צקאוט יש לו גם משמעות מבחינת קבצים ואם יש לנו פה איזשהו קונפליקט שגם השם של התיקייה וגם השם של הקובץ אתם מדברים אני אשתמש בגיטסויץ כדי להחליף פרנשיט אז גיטויץ לסן אדם מל גדול יעביר אותנו ללסן הנוכחי ואז 32 נוכל לפתוח את זה ופה צריך לבחור את ה את ה workקספייס של השיעור אז הו של השיעור יהיה לסן אחד בסדר זה שנייה אוקיי ונפתח לנו עכשיו הוספיס הזה אז בואו ניצור א בוא ניצור עכשיו בעצם נראה איך אנחנו יוצרים פרויקט אז אנחנו הולכים לניו אוקיי ואז אז STM 32 זה פרויקט על הטרגט עצמו. אוקיי, ניתן לו שנייה. הוא צריך להוריד קבוצים.

ומפה אנחנו מגיעים בעצם לטרגטקטור. עכשיו א בואו גם כדי שקצת תשתתפו בשיעור וגם את זה, כל אחד שיספר לי איזה איזה בורד הוא עובד או על איזה MCU. אצלי יש את ה F411 אני חושב. אוקיי אז בוא אז בוא אני אראה לכם בדיוק F411 זה בעצם מההתחלה של ה של הפארט נבר ואני אראה לכם שנייה על הבורד שלי ואחרי זה e דיסקו e דיסקו אז בדיוק זה אותו אותו דבר כמו שלי אז א אז אני אראה על זה אם יש עוד מישהו שיש לו בורד אחר אז הוא יכול להראות שיהיה לנו קצת גיוון אז כאן פה בדיוק רשום לנו את ה בדיוק את מה שאתה אמרת STM 32 F411 היא מקף דיסקור אז בשביל זה אנחנו צריכים להגיע אל הבורדסקטור עצמו אוקיי מהbורדסקטור אנחנו נחפש את הפט נבר שאנחנו רוצים אז STM 32 F411 E דיסקו שדיסקcoקו זה קיצור של discovery זה לא כי יש לו ארבע לדים אה בצבעים שונים אז א אז זה בעצם ה זה בעצם ה כאן אני בוחר את הבורד. שימו לב שאני בבורד סלקטור ולא בMCU MPUCור.

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

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

אז בוא בבקשה נעצור את ההורדה הזאתי. טוב, הטעות ללחוץ על זה. א בסדר. אוקיי אז נעשה את זה מחדש שיהיה לכםות לראות STM 32 proקט בורסטור אנחנו יכולים לבחור אם סימנתי אותו בכוכב הוא כבר יופיע כאן אז זה הבורד שאני רוצה ולאחר מכן אני לוחץ על next אוקיי כשר אני לוחץ על next אני יכול כבר ליצור את הפרויקט עצמו והפרויקט אנחנו נקרא לו א MCU MCU Hello Word עכשיו יש לנו כבר אחד כזה אז נקרא לו אחד ואנחנו נסמן פה אפטי ועכשיו אנחנו נסיים והוא ייצר לנו את הקבצים שאנחנו צריכים אוקיי אז עכשיו כאן יש לנו א יש לנו בעצם את הCLודים כאילו את כל הקבצי הדר שיהיו אנחנו נראה את זה ביותר מאוחר יש לנו את הקבציורce אז הוא מייצר לנו כבר שלושה קבצים שלסורce ויש לנו את הסטאטאפ אוקיי שזה בעצם איזשהו סקריפט שמסביר את התהליך של העלייה אבל אנחנו לא נוגעים בקשה זה כרגע אוקיי בואו נסגור את הכל וה ונתרכז כאן אז מה יש לנו כאן יש לנו א יש לנו אה א יש לנו פה בעצם איזשהו אינסופי אוקיי יש לנו פה איזשהו warning ואclוד אוקיי הclוד הזה נותן לנו את הCLU לגדלים של לגדלים של משתנים שראינו בשיעור הקודם שזה מ8 הוא זה טוב הוא UN8 U 16 אינטים א מה עוד היה שם? כל מיני כל מיני גדלים של א ספציפיים א ואחר כך יש לנו את הסיסק שזה בעצם אם אתם מכירים מלינוקס בעצם כל כל הסיסטם call בעצם אנחנו משתמשים read א exit [כחכוח] אה סליחה אוקיי read ואit ואחר כך יש לנו איזשהוטם mורy שזה בעצם עושה שימוש של הממורי אז זה בעצם הקבסי C שאנחנו משתמשים בהם אוקיי אז בואו ננסה לבנות את הפרויקט הזה אז נעשה project build אוקיי הצלחנו לבנות איך אנחנו יודעים שהצלחנו לבנות נוצר לנו כל מיני כל מיני דברים בדבאג ויש לנו binary שהביbyary עצמו זה הF שאותו הF אנחנו הולכים לצרוב לתוך א לתוך א לוך הMC el זה קיצור של אקיושן משהו פייל אני לא זוכר לגמרי אבל זה בגדול הבינרי ש שאנחנו מריצים.

בסדר? אז מה אז מה זה בעצם הורנינג שיש לנו במיקרוקונטרולרים? מסוג א מסוג א מיקרוקונטרולרים, מסוג א קורטק armורטeקס m מספר כלשהו. א אז יש לנו דבר כזה שנקרא floting point unit. מה זה?

מה זה הfloting point unit? זה בעצם אה ההרד מודול בעצם חתיכת חומרה שיושבת בתוך ה-CPU שלנו והיא אחראית על flotting point armic בעצם חיבור של floting point וחיסור וגם כפל וחילוק והעבודה עם ה עם הפטנ point unit הזה הרבה יותר מהירה מאשר לעבוד מול א בעצם לעשות את הכל בקומפיילר אוקיי שנייה רגע סליחה אוקיי, בעצם מה הכוונה? כי כאשר אני עושה א חיבור וחיסור, כאשר אני עושה בעצם הכפלות וחילוקים וחיבורים, אז בעצם פעולות שלוקחות הרבה זמן כשאני עובד עם floting point. וכדי לעתיד לקצר את זה אני יכול לעשות את הפעולות האלה ספציפית בחומרה. בעצם מה שאני אנסה ניתן לחומרה את ה בגדול איך זה נראה אנחנו לא לנו זה לא חשוף כמפתחים זה בעצם קורה אנחנו בעצם נותנים איזשהו פוינטר לשני משתנים ואת הפעולה בעצם מקום בזיכרון לשני משתנים ואת הפעולה ואז הוא מודול של הFPU מחזיר לנו את התשובה אוקיי אז איזה סוגים של מאבדים של מיקרוקונטרולרים תומכים בזה אז קורטקס M4 וM7 המשפחות האלה שמה זה כבר בתוך ארכיטקטורה אוקיי כן אקורטקס m33 זה פשוט תלוי באימפלימנטציה וקורטקס m0 m0 + וm3 זה m33 אז אין להם הרד floting point אוקיי בm7 יש לנו גם double prcision לא רקele prision double prision שזה נמצא בתקן של i triפל שמעניין אתה יכול לרשום i טריפל e ולחפש על הזה עצמו.

אז מה זה הארור הזה? בעצם מה שאנחנו עושים כאן זה כתבנו קוד כרון נכון לא כתבנו כלום ורק ג'נראטנו אותו כתבנו קוד שהקוד הזה בעצם הוא יכול להשתמש בפoting point אבל לא התחלנו בזה לא התחלנו את הפט point בסדר אז עכשיו אנחנו נראה איך אנחנו א מבטלים את הארור הזה ואם אנחנו פשוט רוצים בהמשך פשוט אנחנו נתעלם ממנו לגמרי אז מה אנחנו עושים אנחנו הולכים לפרויקט עצמו הולכים לפרט אוקיי, בפרויקט אנחנו הולכים ל לc+ blד זה המסך שאנחנו נראה אותו עוד הרבה בשיעור אחר כך יש לנו את הMCU MPU settings ופה יש לנו את האפשרות הזאתי אוקיי אז אם אנחנו נבטל את ה אם אנחנו נגיד לו לא להשתמש בפoting point unit ונגיד לו להשתמש בפing point ABI ABI זה א כמו API רק לבינרי ספציפי בעצם אנחנו הולכים להשתמש בקובץ אנחנו הולכים להשתמש בביינרי הספציפי של ה MCU שלנו כדי לעשות את זה אז אנחנו לא הולכים להשתמש בזה בצורה חומרתית בעצם את כל האofflודingנ את כל השימוש בחומרה אנחנו לא הולכים לעשות אלא אנחנו הולכים להשתמש בתוכנתית אוקיי זה מה שאנחנו מסמנים כאן עושים אומרים לו בסדר תבנה את הכל מחדש בואו נעשה אפילו עוד קליין ככה כדי להיות בטוחים ונעשה בילד ועכשיו השגיעה הזאתי נעלמה לנו הורning הזה שימו לב שזה רק warning זה לא מונע מאיתנו א לבנות את הפרויקט כרגיל אפשר גם למחוק את זה לא באמת אכפת לנו אוקיי זה ה זה בעצם ההתחלה שלנו נכון? א אוקיי, עכשיו ברגע שאנחנו נתקרב ל א ברגע שנתקרב להתחיל לצרוב את הקוד אז בואו נדבר על מה זה STנק. STנק זה בעצם איזשהו אינטרפייס של הרדור שאנחנו בעצם יכולים באמצעותו גם לתכנט את הרכיב של ST וגם לעשות דבאגינג. אוקיי?

כל האינטרפייס הזה אם אתם מסתכלים על הבורדים שלכם גם מי שיש לו ניקליו האמת ש אין לי פה את הניקליו שלי אבל אני יכול להראות לכם אחרי ההפ הפסקה א אם אתם רואים הבורד שלנו כאילו מחולק לשניים יש לנו את החלק העליון ויש לנו את החלק התחתון החלק העליון בעצם פה נמצא הדיבאגר יש לנו תגידו לי אם אתם רואים יש לנו את הרכב השחור הזה באמצע זה בעצם ה זה בעצם הלינקד debager unit יש לנו פה עוד כל מיני דברים יש לנו פה איזשהו קוץ שחרי שאחרי על ה על השעון וא ולדים סורי סליחה ואחרי הלדים אז מה בעצם ה הפונקציונליות סליחה מה בעצם הפונקציונליות שהstלינק נותן לנו בעצם נותן לנו לצרוב את ה את הפלאש של הMCU שלנו נותן לנו לעשות בגing byפ ונותן לנו את הסינגל vi שנייה צירה סליחה אני פה א ונותן לנו גם את הסינ בעצם מה זהסנגle wire viw זה בעצם איזשהו אינטרפי שהוא רץ על קו אחד של דataה והוא אנחנו משתמשים בו לעשות advance tracing מה זה בעצם ל בעצם טריסינג הרבה פעמים אנחנו משתמשים בזה כדי לסמן נקודות בקוד א ולראות שהגענו אליהם אז בעצם אנחנו גם הולכים לעשות את זה אמת עכשיו [כחכוח] להשתמש לפחות בזה וגם א זה כלי מאוד חשוב כאשר עושים דבאגינג למערכות הרבה יותר מסובכות. א אז איך אנחנו בעצם מתחברים לSTM? אנחנו מתחברים אליו עם SWD שזה serial wireb. [כחכוח] א בעצם הוא ככה משתמשים בו ברוב המערכות ST 32. בעבר היו עובדים עם Jטג.

Jטג זה ישן יותר פחות מודרני. מי שעבד במערכות א מטסות של חיל האוויר וכל מיני כאלה עדיין רואה את הג'יטג. כאילו זה משהו מאוד מיוחד אבל זה בתכלס טכנולוגיה ממדישנה. לSWD יש לנו שני פינים שני קווים שמשתמשים בהם SWD input output SWD input output וSWock שהם אחראים על הדטה ועל הקלוק פחות פחות רלוונטי זה שקוף אבל אנחנו רק עושים איזשהו ריקאפ א בנוסף יש לנו עוד איזה קו של ריסט כאשר לפעמים הדיבגר מה לעשות המערכת נתקלת והדבאגר צריך בעצם לעשות ריסט א [כחכוח] כאשר אנחנו בעצם עובדים יודעים עם הפרויקטים שהם לא פרויקטים של הבורדים האלה אז מאוד חשוב שאנחנו נבטיח שיש לנו בעצם קודם כלקנקtion כמו שצריך בSWDפין נודא שאנחנו משתמשים בכבל שהוא מאוד קצר ככה שאנחנו לא נהיה לא נהיה נתונים לרעשים ונשתמש בפאורספליי חיצוני ולא לא נשתמש בפורספליי פנימי כדי בעצם לבודד את ה SWWDP א אז איך אז מה אנחנו עושים כאשר אנחנו מקמפלים אנחנו בעצם נקבל את את הקוד שלנו בתצורה של elf והקס ה אנחנו בעצם טוענים את הביינרי לתוך הMCU ובאמצעות לינק ואים להריץ את הקוד עצמי א אז ככה אז מה זה בעצם פלאש mורy flash mורy זה בעצם non volול stורage זה בעצם זיכרון שהוא לא נדיף זאת אומרת שאם אני אקבל את המתח אז אז את הצורה שהייתה בו היא נשמרת אוקיי לעומת דיכאון נדיף לדוגמה הרם שלנו במחשב שכל פעם שאנחנו מחבים בים אותו אז אנחנו א בסדר אנחנו לא יכולים לחזור למצב שהוא היה אז שמה שמה המיקרוקונטרולר הקונטרולר עצמו הוא שומר את הפרוגרם קוד בעצם את הקוד שכתבנו ומה המקום שלו ברוב הצ'יפים זה נמצא באמת על הצ'יפה זה למה זה כאילו זה נמצא על הצ'יפ בעצם MCU זה בעצם שכבה אחת יותר קטנה מSOC אוקיי יש לנו SOC שזה Sםem on שזה הרבה פעמים יהיה לנו כמה א כמה מסל [‏צחוק] קצת אלרגיות יהיה לנו בעצם כמה מודולים שירוצו על הצ'יפ עצמו וואנחנו ואנחנו יהיה לנו גם את הCPU שירוץ בפנים ויהיה לנו כמה זה MCU זה אותו דבר אז יש לנו לרוב במודול אחד וכמה פריפריאלים יותר קלים אז א הרבה פעמים גם הזיכרון בפחות בSTים ובשאר המיקרוקונטרולרים גם הזיכרון ריצה גם הוא יהיה בתוך הצ'יפ עצמו כעוד איזה כעוד איזה חלק של הסיסטם א הקפסיטי של הMC משתנה בין כמה קילובייטים קטנים כמו שראינו על הבורד שלי יש 512 קילובייט של 10 רם עד כמה מגהבייטים ככה שזה לא הרבה קוד ואנחנו בשיעורים בהמשך נראה גם איך אנחנו מצמצמים את כמות הקוד כדי שיהיה לנו יותר מקום בזיכרון א והקסקיושן הCPU הוא בעצם כל פעם עושה פצ'ינג לוקח את הפקודות מה א מהmc מהפלאש ואז אנחנו באמצעות אנטרנal בס ואז בעצם הוא משתמש בהם כדי לעשות את execution א אוקיי מה בעצם איך מה הקרקטרסטיק של ה מה המאהפינים של ה של הזיכרון הזה אז הוא read right א read while right בעצם יש לנו אפשרות לכתוב ולקרוא בו זמנית ו ואנחנו יכולים למחוק אותו ולכתוב אותו הרבה מאוד פעמים ויש לנו right liמitationש של 10,000 סייקלים בעצם אחרי בין 10,000 ל-100,000 פעמים אנחנו שאנחנו כותבים לפלאש יכול להיות שאנחנו דופקים אותו א שזה הרבה מאוד לרוב אנחנו לא כותבים לפלאש כל כך הרבה פעמים וגם אנחנו יכולים להשתמש ב אם אנחנו דואגים לזה דואגים מזה אנחנו יכולים להשתמש בכל מיני בפרים או בכל מיני א כל מיני שיטות בעצם לכתוב פחות אם זה DMA וכל מיני דברים שהם קצת מכוט את הסקופ של הקורס הזה אנחנו בעצם נוגעים בזה בקורסים יותר מתקדמים א מבחינת סקיוריטי יש לי את האפשרות לנעול את הזיכרון אוקיי ככה אף אחד לא יכול להסניף לי את מה שבעצם נמצא בפנים ולגנוב לי את הכל זה פיצ'ר שהוא מאוד נחמד אם מישהו רוצה להשתמש בצ'יפ אחרי שנהלתי אותו אז הוא באמת חייב למחוק את הכל ולהתחיל מחדש ואז אין לו שום גישה לזיכרון א אוקיי שאלות עד לפה לפני שנמשיך עם MCUL Award מישהו איתי אה כן א RWW אה לא משנה זה read כן זה קצת מבלבל כי יש לנו X XRW שזה ה שזה הרד executable בלינוקס אבל זה תמיד רושמים את זה גם XWR שזה נראה מבלבל קצת א בקיצור של MCU זה זה בעצם מיקרוקונטרולר ש מיקרוקונטרולר הבנתי בתוך הMC טוב אנחנו גם נראה את זה יותר בשיעורים הבאים מה נמצא באמת וגמה זה כרגע אנחנו עדיין משתמשים ועושים איזשהו אלין כאחרון לשיא שיעור הבא אנחנו כבר ממש כותבים לתוך הMC מסתכלים בתוך המסמכים וגם ואפילו פותחים את המסמך של הארכיטקטורה. אוקיי?

אז MCUL Word מה א מה אנחנו הולכים לעשות? אנחנו הולכים בעצם לקחת את הSTD out. אוקיי? בעצם את מה שמדפיס לנו הפרינט F. אוקיי?

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

אנחנו לא הולכים לעבוד עם פייל דסקריפטורים גדולים פה בלינוקס. אנחנו הולכים לעבוד עם כל מיני התאמות שעשו לזה ל שעשו לזה למיקרוקונטרולרים. זה נמצא בכל מיקרוקונטרולר. אז יש לנו כמה מ כמה פייל דסקריפטורים סטנדרטים שאנחנו עובדים מולם. יש לנו את הtestd in שזהפילפטור אפס יש לנו test out שזהפילפטור מספר אחד ויש לנו testd l א הרבה [כחכוח] פעמים שאנחנו כותבים לתוך הפיילפטורים האלה אנחנו עושים את זה באמצעות printי או באמצעות עוד איזשהי מטיפות א או p er או כשאנחנו רושמים מתוך אנחנו לוקחים מתוך הסקנפ ככה אנחנו קולטים מתוך std in מה אנחנו הולכים לעשות אנחנו הולכים לקחת את הtd out ולעשות להוריד בעצם לקחת אותו ולהעביר אותו לתוך המסך שלנו כאן כדי שנוכל גם בעצם להדפיס לנו בעצם לראות את מה שאנחנו עושים.

בסדר? אנחנו הולכים לעשות את זה מכיוון שזה מאוד נוח ומאוד א ומאוד א א מאוד זמין וגם אנחנו לא צריכים להשתמש בכל מיני טולים חיצוניים כמוסמי הוסטינג ועוד כל מיני דברים שהם באמת סתם מסובכים ולא צריך. א אוקיי אז איך מה מה זה עוד נותן לנו אנחנו יכולים להשתמש רגע אנחנו יכולים להשתמש ב בסינגלפ SW outpפט מהMCU בשביל הדבגר וגם אנחנו יכולים להשתמש בו על הדרך כדי להדפיס וזה הרבה יותר נוח מאשר להשתמש בUR שזה פריפרל שנמצא בתוך ה בתוך הMCU שזה בעצם איזה תקשורת אתם מכירים אותה אולי כRS23 3 ש תקשורת מדפסת אבל זה בעצם הרמה שהיא בורד אם אתם במועדון יש לנו שיעור היה שיעור מאוד מעניין לפני כמה שבועות חודשים על onbורד communication ואתם יכולים להשל א אוקיי אז מה בעצם אנחנו אז מה בעצם אנחנו הולכים אנחנו הולכים להשתמש בIT instrumental trace מקרס מה זה הדבר הזה זה בעצם איזשהיא חומרה שנמצאת בתוך הרכיב השחור הקטן הזה שהראתי לכם והחומרה הזאתי [כחכוח] היא מאפשרת למיקרופרוסור שלנו לשלוחטריסד datטה בעצם לשלוח הודעות כל מיני evנטים על SWINS אוקיי מה בעצם אנחנו מה בעצם החומרה הזאת נותנת לנו הITM היא נותנת לנו כמה פורטים בעצם 32 פורטים שאני יכול להשתמש על ידי הפירמר של [נחירות בוז] הבורד ואני יכול לשלוח שם דטה אז הרבה פעמים אנחנו משתמשים בפורט אפס כדי לעשותטting של א של פרינט של printינט f כדי לראות אותו אצלנו ומה שאנחנו הולכים לעשות אנחנו הולכים להשתמש בitm data כדי להעביר את הקarקטרס שבהם אנחנו משתמשים א על ה בעצם על הפורט regגיסטרס ואחר כך אנחנו נקרא את זה ונשלח אוקיי יש לנו שני פיצרים שאנחנו צריכים להפעיל יש לנו את הtrace inable ודbag regגסטר אז יש לנו את הdmcr [כחכוח] שזה exception ומוקול register אנחנו צריכים לאפשר אותו כדי שנוכל להשתמש בטריסing את האפשר הזה אנחנו עושים על הMCU ואני נראה עוד רגע איך זה נראה ויש לנו את הITM trace enable שאנחנו מאפשרים באמצעות אותו ספציפיקספציפיים פורטים ספציפיים שנוכל בעצם להקליט א מה היתרונות של זה זה בעצם איזשהי שיטה שהיא nonרוס בעצם אני לא מוסיף ‏capability ספציפית לקוד שלי בעצם אני לא משנה את הקוד כדי לדבק למה אם אני משנה את הקוד אז בעצם זה לוקח לי א בעצם זה יכול לשנות את ההתנהגות של הקוד עצמו ואולי אני לא יוכל לתפוס ככה באגים או בעיות אחרות או שאני כבר לא אעבוד בריט timeים אז זה משאיר אותי לעבודה בריט timeים וזה הרבה יותר מהיר מכל מיני פיצ'רים אחרים כמו סמוסטינג והוא לא עוצר לי ספציפית את ה-CPU ולא פוגע בפרפורמנס שלו אמ א אוקיי אז איך אנחנו עושים את זה? אז א בואו בואו נראה אוקיי אז כן אז שמתי לכם גם אצלכם פה בקוד בל one יש לנו sarסק for cl שזה בעצם שני שתי קבצים אחד זה headerפיל ואחד זהסורceפיל א מה שאנחנו הולכים לעשות בעצם זה למשוך את הITM classס c שזה הסource פיל הולכים למשוך אותו לתוך הסource עצמו מור אוקיי ופשוט לעשותקופי ואחר כך יש לנו את ההדר ואנחנו הולכים לשים אותו א בתוך הclוד אוקיי ואז זה נראה ככה א עכשיו אז יש לנו פה את הפונקציה בעצם פה אנחנו משתמשים ברגיסטר עם עוצמם שזה פחות רלוונטי לנו יש לנו את הפונקציה הפונקציה הזאת היא בעצם לוקחת ודוחפת לתוך פורט אפס וא את כל הקרקטר שאנחנו נשתמש אבל איך אנחנו אמורים להשתמש בזה ומאיפה אנחנו אמורים לעשות overriד או [כחכוח] overriיד לרט ולריד יותר נכון לריד פחות קריטי לנו כי אנחנו לא הוא לא אנחנו לא נשתמש לקרוא אנחנו נשתמש ברי איך אנחנו עושים את האoverיד הזה יש לנו שתי אפשרויות אנחנו נעשה אפשרות אחת עכשיו אפשרות אחת בהמשך בהמשך השיעור א יש לנו דבר כזה שנקרא אבute week בעצם זה איזשהו פיצר של ה של הגנו של הGCC של הגנו compילר שהוא בעצם נותן לנו את האפשרות לעשות over אוקיי ברגע שאנחנו נגדיר פונקציה עם אותו שם אז היא בעצם תדרוס את הפונקציה הזאתי ותשתמש בה אנחנו לא נעשה בצורה הזאתי אנחנו קודם כל נשתמש ונעשה בעצם את הפאצ'ינג הזה אז א אז בואו ניקח את הפונקציה שלנו אוקיי נשים אותה כאן ובאותה צורה אנחנו ניקח א את הפויינטר הזה זה ונקדם אותו ככה ואז בעצם כל פעם שאנחנו הולכים לכתוב אנחנו הולכים להעביר את הפוינטר ולקדם אותו לתוך ITM char אבל הסיסק הזה כרגע הוא לא מכיר את ITMDbag אז אנחנו צריכים לעשות inclוד אז נעלה למעלה העמוד נגיע לאינקלוד האחרון ונעשה inclוד ועכשיו אנחנו צריכים לפתוח גרשיים כי זה כי זה קובץ מקומי ‏ITM ITM דבג והוא גם משלים אותנו. אם נעשה קונטרול רווח.

נשמור כאן את זה וננסה לקמפל נראה שהכל בסדר. אז א אז שוב clean project ובildד ואנחנו הצלחנו הכל. אז מה השלב הבא שנשאר לנו לעשות? זה לכתוב את הקוד שאנחנו רוצים להדפיס. אז איזה קוד אנחנו רוצה להדפיס?

‏print f hell א metal plusס ואנחנו צריכים לשים בקס לשן בסוף למה כי בקס לשן בעצם עושה לנו פלאשינג מה זה אומר עושה לנו פלאשינ יש לנו כשר אנחנו עובדים וזה הקונספט כרגע של כתיבה ל לקבצים. כאשר אנחנו עובדים קבצים יש לנו שתי אפשרויות. יש לנו אפשרות לעבוד ככה שכל פקודה אנחנו כל שורה עושה פלאש א או שיש לנו לעשות איזשהו בפר או לעבוד עם איזשהו איזשהיא קונפיגורציה שונה. כאשר אנחנו עושים בקס לשל אנחנו מבטיחים שתהיה שיהיה פלאש מהבפר הזה לתוך הזיכרון והכל יכתב. אם לא אז יכול להיות שזה היה נכתב ויכול להיות ש נשמור את הכל.

אוקיי נבנה שוב. אנחנו לא צריכים לעשות קליין עכשיו. עכשיו מה חסר לנו כאן? חסר לנו בעצם לעשות include לSTDO. אז include std iOS שימו לב שהפעם אנחנו משתמשים ב ש צריך ללמוד את השם של הסוגריים האלה ש בסוגריים משולשים נקרא להם ככה כדי שנוכל לקבל את print fclude ונעשה שוב build אפשר לעשות גם קנטרול b פשוט פונה את כל הפרויקט את כל הפרויקטים אז עשינו buildד א ועכשיו אנחנו יכולים ממש לבדוק את זה אנחנו עושים אנחנו נרצה לצרוב את זה לתוך הMC אז א מכאן אנחנו נלחץ על הדבגר אוקיי ובדיבגר עצמו אנחנו נעבור לדבגר setינס פה אנחנו נענבל את ה אין לנו בזרח שטוב אנחנו נענבל את הsWV וזה הכל בגדול זה הכל מה שאנחנו צריכים לעשות לעשות לא אמורים לעשות אפשר לעשות אפשר לעשות ישר אנחנו בונים שוב ועכשיו אנחנו כבר ממש בתוך ה א עכשיו אנחנו ממש סורבים לתוך הMCU משהו אחד קטן יכול להיות שיש לכם בורדים חדשים ואתם צריכים לעשות להם אפגריד ל לפ ל לפירמר של הצ'יפ הזה בעצם פירמר זה הקוד שרץ על הMC אתם צריכים לעשות את האפגריד לפלאשר א אם הוא מבקש ש מכם ועושה לכם כל מיני בעיות.

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

אוקיי אז אנחנו נמצאים כאן [כחכוח] אבל כמעט סיימנו אנחנו קודם כל צריכים לאפשר את הsWV ITM data collection אוקיי אז הגדרנו את הdbac configuration אוקיי אז הלכנו לSWD אפשרנו את הS זה כמו שעשינו כאן אחזור עם כדי שנראה את זה שוב אפשר גם להגיע לזה מכאן מbag deb configuration ואז יש לנו את הbag configuration הזה אנחנו לוחצים פה swd זה האינטרפי swv זה הסרal wire viw אותו אנחנו מאפשרים וזה וזה כל מה שאנחנו צריכים לעשות צריכים עוברים לעשות ללחוץ על דבאג ואחר כך אנחנו צריכים לאפשר בעצם להקליט את את הדטה שעובר אנחנו לא צריכים רק את זה אז איך אנחנו עושים א בינתיים הכל מחכה שנריץ אותו ואנחנו עושים show viw SWV SWV ITM dataקסול אה וזה כאן סורי זה כבר היה כאן א כי זה כבר מוגדר זה האחד אנחנו לוחצים על הס setting f configury trace ופה אנחנו מאפשרים את הפורט הזה את פורט אפס אוקיי גם זה לא מספיק. אנחנו צריכים ללחוץ על startט trace. וברגע שאני אעשה את זה הופה יש לנו פה hellow be metal clow word ואנחנו יכולים מעכשיו לקבל אינדיקציה מהקוד של מרס. אוקיי, זה היה הכל. שאלות לגבי זה.

אם זה כל כך חשוב, למה בעצם אי לא מאפשרים את זה כמשהו דפאולטיבי בכל דבג מוד? אה, שאלה טובה. א יש לנו כמה דרכים נוספות לעבוד עם זה. יש לנו אפשרות לעבוד עם אוקיי? בעצם איזשהו דרייבר של אחד הפריפרל שאנחנו משתמשים בו שהוא שולח לנו דטה והוא יכול להגיע לקצבים יותר גבוהים ואפשר להשתמש בו וכאילו זה יותר סטנדרטי להשתמש בו כי למה מה מה החיסרון של זה שהוא צריך לבוא עם חומרה אני צריך ממש להשתמש חומרה ודית של STM 32 כדי להשתמש בו לעומת זאת אני יכול אם לא אני יכול להשתמש בעצם באיזשהו פיצ'ר של הMC עצמו עצמו ואז אני בעצם לא צריך עוד חומרה וזה עניין של קוסט אוקיי א עוד דבר אם אני משתמש בו אז אני קלו ואני בכוונה אומר קלו מול הIDE הזה אני לא אני לא רואה תמיד ארצה לעבוד ספציפית עם IDE אולי אני רוצה באמת לעבוד כאילו ישירות עםקפורט בורא ככה ככה עובדים בחלק מהמקום אז זה הסיבה שלא תמיד משתמשים בו דרך בתעש כן דבר דל בתעשייה אנחנו נשתמש בדיבג מוד בורט או בזה זה תלוי לרוב בט כן זה כלי נחמד א אפשר להשתמש בו גם אני לא רואה סיבה שלו פשוט זה עוד משהו נוסף וזה לא מצריך מאיתנו ללמוד לעבוד עם כרגע אוקיי א בסדר בואו נמשיך לדvance CONSP זה בעצם החלק החלקים הבאים של השיעור אז בשיעור הקודם קצת דיברנו על א דיברנו על איך קוראים לזה על א על bitוז operator אנחנו נעשה היום איזשהיא דוגמה עם הדבאגר ואנחנו לא עם הדבגר סליחה ואנחנו ממש נראה בעצם איך מה אנחנו עושים אז יש לנו פה אה א כמה דוגמאות וכמה הסברים.

אז יש לנו כמה אופרטורים שאנחנו משתמשים בהם. יש לנו את הנ בעצם כמו שהראינו אז אנ ברגע שאנחנו משתמשים בו אז אנחנו אז רק אם יש לנו אחד בשניים בשני ה א בשני הביטים רק אז הוא הופך להיות אחד בעצם בתצורה ה אחרי ה בוצאה אחרי בעצם הפעולה של שני האופרנטים. בעצם יש לנו את אופרנט A ואופרנט B וכשאר אנחנו עושים ביניהם אד אז אנחנו בעצם נקבל 0 B1 זה דוגמה אחת אחר כך יש לנו אור בעצם אם אם באחד מהם יש אחד אם באחד מהבית יש אחד אז בסוף בבית יהיה אחד יש לנו קסור שבעצם קסור הוא אקסקלוסיבי זאת אומרת שרק אם באחד מהם יש אחד רק אז יהיה לנו אחד כמו שאתם רואים את הביט הרביעי אז הביט הזה הוא הופך להיות אפס כי בשניהם יש אחד ויש לנו not נות הופך לנו שימו לב ש הופך לנו את הביטים [כחכוח] אה נו תופך לנו את הביטים בעולם שבו אנחנו נמצאים אם אנחנו נמצאים בU ש8 אז בעצם אין פה ארבע ביטים יש לנו פה שמונה ביטים וכאשר אני אעשה נוט אז בעצם כל השמונה ביטים יתהפכו אז הארבע האלה אנחנו יותר לנו יותר קל לנו לראות מה יהיה אז יהיה לנו 1 רא האפסים בהמשך יהיו גם אחד אוקיי זה ה זה אנו not אחר כך יש לנו גם שיפט שיפט אני בכוונה חוזר על זה כי זה אופרטורים מאוד חשובים לעבודה א באמת יש לנו לפס שיפט בעצם לפט שיפט עושה לנו חזקה של שתיים אוקיי והוא מזיז לנו שמאלה את כל המספר מזיז לנו את את כל המספר אז אם יש לנו אחד ואנחנו עושים לו left שיפט שלו אז יש לנו 2 בחזקת 1 ועוד שזה זה 2 בחזקת 4 שזה שמונה 1 2 4 8 כן שונה א אז זה בעצם מה שאנחנו עושים ויש לנו אתשיפט שהוא עושה לנו שורש אוקיי אז הוא בעצם מזיז לנו את כל המספר ימינה א [כחכוח] הוא מזיז לנו את כל המספר ימינה ובעצם עושה לנו בעצם חלוקה בשורש סבבה אז איך אנחנו בעצם עובדים עם אה איך אנחנו בעצם איך אנחנו בעצם עובדים עם אה עם הפעולות האלה? אנחנו בעצם הרבה פעמים נרצה לעשות set וקleיר לביטים ספציפיים. אוקיי?

אם אנחנו נרצה לעשות set רק ל [כחכוח] רק לביטים ספציפיים, אנחנו נשתמש בפגים היוכחים. אז יש לנו את האופרטור הזה. יש לנו את האופרטור אור שווה והאור שווה יהיה יהיה עם אחד left shiיפט בn אז אנחנו נרצה לשים לשתס set לביט במקום האני אם יהיה פה אפס אז ביט האפס ואם יהיה פה שלוש אז אנחנו נעשה סט בביט השלישי שזה 0 1 2 3 בסדר שזה הביט הרביעי סליחה הביט הרביעי א אוקיי אוקיי, זה בעצם ה בעצם ככה אנחנו עושים סט לביטים. אם אנחנו רוצים לעשות סט לשני ביטים, אז אנחנו צריכים לשים מסק של בעצם שלוש, נכון? כי שלוש זה אחד ושתיים.

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

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

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

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

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

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

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

בואו נפוך את זה שנייה להיות אחד כדי שזה יהיה יותר ברור ואחרי זה אנחנו שני. אוקיי, אז אנחנו בעצם אנחנו נרצה לראות שבעצם אנחנו עשינו והוספנו לו 1 בבית השלישית. 0 1 2 3 אוקיי אז בעצם אנחנו לוקחים אחד מזיזים אותו שלוש פעמים 1 2 3 שזה שזה זה אז אחרי שאנחנו נעשה את זה אז זה מה שיהיה לנו כאן ואחר כך אנחנו ננקה את הביט השלישי אז אותו דבר גם כן אז אנחנו נעשה נשים נשים מס הפוך בעצם נהפוך את כל שאר הביטים ונעשה אד אז אחד הזה יישאר אותו דבר ואחד על הזה יתנקה ובסוף אנחנו נעשה תאג אל הביט החמישי פעמיים אז בואו נראה איך זה נראה נריט את הדבר הזה אנחנו לוחצים ימני run as stלal appliקש וזה נראה וזה נמצא כאן אז א בעצם אז זו הנקודת ההתחלה שלנו אחר כך הוספנו את הביט ה א הוספנו את הביט השלישי אוקיי את הביט ה 1 2 3 4 את הביט הזה וקיבלנו ת אתם רואים שיש לנו בהקס ת כאן אוקיי אחר כך ניכינו אותו אז שוב קיבלנו אחד ועשינו טגל עם הביט החמישי אז 1 2 3 4 5 אז יש לנו לא טועה נכון סליחה ביט החמישי אז יש לנו אחד 1 2 3 4 5 כן אז זה הנקודה אז קיבלנו כאן 21 בהקס אוקיי אנחנו כרגע אנחנו מדברים בהקסט ואחרי זה ניכינו אותו ועושים ככה מה יקרה אם נרצה לעשות סט לשתי ביטים אז בעצם אנחנו נשתמש ב ערך הזה בשלוש אז בעצם יש לנו שלוש אוקיי שלוש והזזנו אותו שלוש פעמים אז 1 2 3 אז זה הערך אוקיי אז בעצם אנחנו משתמשים ונוסיף 18 אנחנו נוסיף 18 לביט הזה. אז בואו נבנה את זה שוב. אוקיי, הערך הראשוני היה אחד.

בואנה, הערך הראשוני שלנו היה אחד. ול ואליו הוספנו את המסק הזה שהוא מוז בשלוש. עזב הוספנו את שני אלה. אז קיבלנו 19 קצת הדצימלית יכול גם לשים ישר כאן שיהיה ברור יותר ואחר כך אנחנו ניכינו את מה שעשינו אז בעצם ניכינו את שני אלה אז חזרנו להיות אחד וזה כבר אותו דבר כיפה שנקור אוקיי אז זה עבודה עם beיט manipulation זה בעצם מאוד חשוב ויש לכם גם מטלה ממש נחמדה לעשות כדי שללמוד לעבוד עם זה כי הרבה פעמים מהנדסי פירמר או הם בדת אנחנו רוצים שזה יהיה ממש מהיר כי הרבה מהפעולות אנחנו עושים על ביטים ספציפיים אה אחר כך אנחנו נדבר על compפלקסד data tyפes אוקיי א פה יש לנו משהו ממש נחמד אז יש לנו בעצם אה א יש לנו פה ממש בעצם אה יש לנו איזשהי דוגמה חמודה א אני מתלבט אולי אנחנו נעשה איזשהי הפסקה ואנחנו נמשיך בשמו אז בואו נעשה הפסקה של חמש דקות א אפילו דקה פחות נמשיך בשמונה [כחכוח] ו ואז נדבר על compפלקסדה טייפ אני גם קצת עלה את הקצב כדי שנתחיל לקלוט נספיק לעשות את רוב השיעור ואם צריך אנחנו גם נשאר עוד איזה חמש דקות סבבה אז בואו נמשיך עוד חמש דקות ‏Oké. א רק תסו לי אם אתם כאן תן עוד איזה דקה ‏Ja.

חברים, אתם כאן? [כחכוח] שומעים אותי? כן, שומעים. אוקיי. א אז אה קצת אדata tyפס יותר שהם קצת יותר מסובכים.

יש לנו א C structures, יש לנו bit fieldד וunיו שהם מאפשרים לנו בעצם לגשת ולארגן את הזיכרון ש את הדטה שלנו בצורה נוחה יותר. למה זה משנה? הרבה פעמים אנחנו נמפא את הרגיסטרים לתוך הזיכרון באמצעות Bitfieldדס ונשתמש בגoup related logical way. Way. בעצם אנחנו נעטוף ביחד את כל ה אה את כל הדברים שהם א כל המבנים שהם משותפים בצורה לוגית אם זה א פאפרים וכל מיני כאלה והניהול שלהם ונעשה א וניצה share mורy על הגדלים האלה ככה שנוכל לחסוך בזיכרון באמצעותיו זה עוד שנייה נסתכל אז בעצם מה זה איך נראה structures אז structure זה user define א טייפ שבעצם אנחנו בונים בעצמנו והוא הרבה פעמים יראה ככה [כחכוח] אז א אנחנו נגדיר strruct example in זה הטyפ שבו אנחנו נשתמש ואז השם שלו ואז יש לנו עוד טייפ אם אנחנו נרצה להגדיר בפנים מערך שזה כמות של בתים רצופים א אז אנחנו גם נגדיר את הטייפ של המערך את השם שלו ואת הגודל כאן אוקיי ה אה הסטרקט עצמו הוא שמור בזיכרון בצורה רציפה ככה שאנחנו יודעים שבדיוק בזיכרון לאחר א האינט יהיה לנו את הפט עכשיו יש פה איזשהו עניין שימו לב שהם אנחנו לא אומרים לקומפיילר שאנחנו רוצים את זה שהם יהיו ממש ישירות אחת לשני אז בעצם מה שהקומפיילר עושה הוא מוסיף לנו פadingנפingנ זה בעצם כמה א כמה ביטים ריקים רק כדי שנהיה עליין לזיכרון.

למה הוא עושה את זה? כי כי מבחינתו זה יהיה לו יותר מהיר שאנחנו נשים אותם לפי הליינפ של הזיכרון. יש לנו את הSTM. הSTM הוא STM 32 ביט. STM 32 ביט זאת אומרת שהלימנט של הזיכרון שלו הוא 32 ביט.

זאת אומרת שכל פעם שהוא יכול לגשת לזיכרון שהוא בת 32 זה ארבעה בתים שהוא עליינד לארבעה בתים 0 4 8 12 וכן הלאה א אז יהיה לו יותר מהיר מאשר ללכת ל ללכת ל-12 ולזוז שתי בתים אתם רואים זה שתי פעולות אז מה שיעשה הקומפיילר אז הוא בעצם ימלא לי כל את כל הזיכרון שהוא לא עליינד לארבעה בתים א אז הוא ממלא לי אותו עם אפסים שזה מה שנקרא פדינing עכשיו ספציפית יש הגדרות לקפילר ואנחנו לא יודעים מה ההגדרות של היום אז גם אם זה 32 אז יכול להיות שהנייטיב שלו או מה שהוא בוחר זה 16 ביט במקרה שלנו זה 16 ביט מבדיקה אבל אף פעם לא אף פעם עדיף שלא לשחק בזה מתי זה באמת קריטי כאשר הקוד שלי עובר בין כמה א בין כמה מיקרו מיקרוקונטרולרים שונים אוקיי, אם אני כותב קוד אחד לכמה מיקרוקונטרולרים שונים והוא משתמש בזיכרון בצורה ספציפית, אני לא ארצה שבו א שבו א יהיה לי בעצם התנהגות שהיא לא ידועה, שיכול להיות באג. אוקיי? אז אני אגדיר לו בעצם או שהוא עובד עם מסוים, שיש אפשרות להגדיר את זה, או שאפשר להגדיר בלינמנט בכלל. אוקיי, אנחנו נראה פה את הדוגמה עוד רגע ואני אראה לכם בעצם מה זה נראה. ואנחנו אפילו נראה את זה אחר כך באסמבלי.

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

הכתובת של ה הכתובת של הממבר הראשון זה בעצם הכתובת של הסטרקטר עצמו. זאת אומרת אם אני רוצה להשתמש בכתובת של הסטרקטר עצמו זה בעצם אותו כתובת כמו הID כמו הID במקרה הזה. ויש לנו את האפשרות ללמד בפד. בעצם מה זה הפדינג אז בואו באמת נמשיך עם המצגתפדינing זה בעצם אקסטרה ביטים שהקמפיילר בעצם רוצה לעשות כדי שיהיה לנו את הalment הטבעית של של הCPU CPU זה יחידה בתוך הMCU שלנו אוקיי אנחנו רגילים שCPU זה cנטרal processing unit אבל בתוך הMCU שלנו יש CPU אוקיי הרבה פעמים אפשר גם לקרוא לו Core או איזשהו אנחנו אפשר להגיד קור אני משתמש בCPU ואני רק שתדעו שcpu ‏CPU הכוונה לא לcp של המחשב לcp של הMCU אוקיי א אז הנatural alignment זה בעצם ה הדהטי הטבעי שהCPU משתמש בו א למיקרוקונטרולר שלנו אמרנו שזה 16 ביט מה זה נותן בעצם זה חוסך לי פעולות ואז אני בעצם יכול לרוץ מהר יותר הרבה מהקונספט של רילטיים ועבודה עם מיקרוקונטרולרים זה ריצה מהירה יותר ואנחנו עושים בזה גם באמצעות קוד יעיל יותר וגם באמצעות כל מיני שני התמות של הקפייל [כחכוח] אם הדטה עצמו הוא בעצם ביט 16 ביט עליין אז כל מה שהוא לא יהיה באלייןמנט הזה נגיד דוגמה בית אחד שלושה ביתים וכל מה שהוא בעצם אי זוגי במקרה שלנו אם היינו עם אליןמנט של 32 ביט אז כל מה שהוא בגודל של א שתיים או שלוש אז בעצם הוא לא יהיה אלין ואליו יתבוסף פדינג בסדר א אם יש לנו שלושה שלושה בתים אז יש עוד בית אחד שהמיקרוקונטרולר שהקומפיילר יוסיף לנו כדי שהמיקרונטרולר ירוץ יותר מהר. אוקיי, אז זה הדוגמה ובוא נסתכל קצת איך זה.

אז יש לנו פה שני אסטרקטרס שאנחנו שגדרתי. אחד מהם הוא עם עם ה עםפדינing והשני הוא בלי פדינing אוקיי? אותו ה אותו הסרקצר אותו בלי הפנ הוא מוגדר מי 32 של טמפרטורה in8 של סטטוס ונ 16 של prשר אוקיי א וגם השני מוגדר באותה תשועה אז אנחנו בעצם מצהירים על המשתנה מסוג strctס sנסורד datataה ויש לנו סנסור אחד זה אפשרות אחת שבה שבה אני יכול להציר על הערכים שבהם אני שימו לב ש-25 זה יהיה הערך הראשון טמפרטורה אחד יהיה הערך השני זה בעצם ספציפית זה אחד יהיה הערך השני ו113 אה 1013 יהיה הפרשר אוקיי אז זה חייב להיות בסדר יש עוד אפשרות לעשות את זה באמצעות האופרטור נקודה אז אני פותח ככה סוגריים מסולסלים נקודה יהיה 25 ואז אני יכול להגדיר דווקא את הפרשר להיות א 1112 והסטטוס ואיך אני ניגש לסטרקט לאסטרקט הזה אני ניגש אליו באמצעות השם שלו זה נראה ממש ככה סנסור סנסור אחד יש לי את ההשלמה אוטומטית שזה קונטרול רווח תלמדו להשתמש בזה זה ממש נחמד ואז אני אשתמש בנקודה ואני יכול לגשת שלה ואז בעצם אני יכול להשתמש ולקרוא אנחנו נדפיס באמצע אותו אז אנחנו נדפיס את זה ככהסנסור אחד temperature אנחנו נדפיס אותו עם הספciיפייר של long in l זה long כי הוא 32 ואחר כך אנחנו נדפיס את סנסור אחד שזה הפרשר עם אחוז d ואת סנסור אחד הנוסף עם עם א א א כקסה דצימלי אוקיי ובסיס 16 אחר כך אנחנו נדפיס את הגודל של המשתנה כדי שנראה כמה בתים הוא תופס לנו בזיכרון ואותו דבר אנחנו גם נעשה א לשני עכשיו בואו את זה אני אסיר כאן כי אנחנו כזה להמשך הדוגמה ונקמפל את זה ונבנה אז איך אנחנו מקמפלים שוב א שנייה קנטרול s שומר לי את הזה איך אנחנו מקמפלים אז אנחנו א אנחנו נעשה cen ואחר כך אנחנו נלך לכאן ונעשה buildד אוקיי ואש אנחנו נרצה לצרוב את זה לMCU הוא אז אנחנו יכולים להגיד לו להריץ יכולים להגיד לו גם לדבג אז יש לנו פה את האפשרות להריץ ואת האפשרות לדבג אז שימו לב שדיברנו מקודם על הITM שאנחנו משתמשים בו לדבג אז אמרנו שיש שתי אפשרות אפשרות אחת זה ללכת לפונקציה right בתוך הסisס calls אוקיי יכולים להגיע להגם מכאן נחמד ושמנו לב שיש פה אבute weק מה זה אביוט we זה נותן לי את האפשרות לדרוס בעצם בעצם אם אני אגדיר פונקציה עם אותה חתימה כמו זאתי אז אני אדרוס אותה אוקיי אז בעצם הקמפי השתמש בפונקציה שלי אז זה אטריביוט weיק זה מוכר משפות אחרות אבל גם בC יש לנו את זה זה פשוט פיצ'ר של compפיילר לא של השפה א אז בעצם יש לנו בפרויקט הזה יש לנו את ה את הקובץ הזה ויש לנו את הקובץ של הITMבbג אוקיי בתוך הITMבג אז יש לי את החתימות של הפונקציה כדי שאני אוכל לשים אותם להכיר אותם לקבצים אחרים. ראינו את הדוגמה של אקסטרן בת השיעור הקודם ובשיעור הזה אנחנו ממש ממש רואים את הדוגמה של עבודה עם הרים ויש לנו גם עוד א אוקיי אז ITM sendarge שזה מה שראינו וט אז איך אני עכשיו רוצה לדרוס את את ה את הri הזה בתוךס calls אני אלך לתוךס calls ולמעלה אני פשוט אעשה include לITM דבג עם גרשיים למה עם גרשיים? כי אם זה אם זה אינקל שהוא מקומי אני משתמש בגרשיים.

אם זה inclוד שהוא נמצא ב במקומות ספציפיים אז אני משתמש בסוגריים המשולשים בלינוקס אם אתם רוצים inclודש user include וסclude א וסisיס include אני חושב אפשר לחפש ממש א אז אוקיי אז ברגע שאני מצרף את זה בעצם מה שעושה הקפיילר הוא לוקח את הITMבג ומדביק אותו ישירות על הסיסקס ובעצם בזה אנחנו משתמשים ברייט שלנו כדי להדפיס למסך. בסדר? אז בואו נסגור הכל. נחזור נחזור אחורה ו נבנה מחדש או שבנינו כבר לא משנה זה בדיוק שנייה נבנה את ה את ה פרויקט הזה ונצרוב אותו. אז בוא נצרוב אותו.

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

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

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

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

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

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

בעצם אפשרות א בעצם הרבה יותר מהיר לעבודה עם א עם א מספרים קטנים. אוקיי? אנחנו בעצם ממש מגדירים כמה ביטים יהיה כל מספר והרבה יותר מהיר לאימולציה. מה מה זה חשוב? הלא של הקומפיילר א הרבה פעמים הקומפיילר שלנו יש לנו את הסדר שבו סליחה ה הרבה פעמים הקומפיילר הוא מתאים לארכיטקטורה ובארכיטקטורה יש לנו את הסדר שבו הבתים נמצאים אוקיי יש לנו את בית אפס ואז בית אחד ואז בית שתיים ואז בית שלוש זה זה מילה בת 32 ביט נכון ארבעה בתים אז יש קומפיילרים שאפס ואחד יופיעו קודם ואז שתיים ושלוש ויש קומפיילרים שבעצם ישלימו את זה לנnS אחר שבו שתיים ושלוש נמצאים קודם ואז אפס ו1 אוקיי אם זה באמת אם זה מעניין אתכם אתם יכולים לשאול את זה שאלות אבל אני רק אגיד שלרוב x86 שזה ה שזה הארכיטקטורה שאנחנו עובדים בפיסים שלנו עובד בביגns שזה 01 2 3 א ו עובד ביds הפוך אז יש לנו 1 שת אז שימו לב כאשר עובדים עם ביטפלד להתחשב בזה ואם יש לנו כמה בתים אז אנחנו צריכים להתחשב בזה ואם אנחנו בעצם הקוד שלנו הוא גנרי אז זה בסדר ג איך אנחנו מצירים על פייטפלד בדיוק כמו שאנחנו מצירים עלסטרקט רק שיש לנו עוד איזשהו שינוי קטן אז אנחנו יכולים להציר אסטרקט בשתי צורות יש לנו את האפשרות להציר עליו כמו שראינו מקודם בעצם strctס sנסורד data ואז את הזה ואז כל פעם שאני ארצה לגשת לסטרק הזה זה אני צריך לקרוא לקרוא לו בצורה הזאתקסנסורד data שומעים אותי אה אוקיי שומעים נכון כן כן אוקיי פשוט א היה שמנו אוזניות עכשיו בשיטו אז בעצם זה א בקשה לא לחזור את המשך השיעור אז זה בעצם איפה היינו אז זה בעצם צורה אחת להגדיר סטראקטי אוקיי שנייה זה בעצם צורה אחת להגדיר אסטרקטים א צורה נוספת זה באמצעות המילה בעצם typידף מגדיר לנו סוג חדש של typeפ אוקיי ואנחנו משתמשים בצורה הזאתי typeפד def ‏strct contolול regם החדש אז כל פעם במקום לרשום strctק control register שזה סתם דוגמה אנחנו נרשום קנטרול regג והרבה פעמים משתמשים בו עם ס כטייפ חדש אוקיי כמו un 32t אם שימו לב מה שאנחנו נלחץ כאן מה יהיה פה tyפ de unsigned זה בעצם un 32t אז כל פעם שאנחנו עושים un 32t בעצם אנחנו משתמשים בסine in בגדול א אז אוקיי אז אנחנו אנחנו לוקחים ואנחנו מגדירים את הסטרקט באותה צורה כמו מקודם אז strctטק contנטרול regג זה השם שלו אנחנו מגדירים את הגודל עכשיו הגודל הזה צריך להיות א לרוב דומה אבל הוא לא באמת משנה לנו כי הגודל שאנחנו משתמשים בו הוא הגודל שמוגדר כאן אז זה אומר שלמוד יש לנו שלושה ביטים מה זה אומר שלושה ביטים זה אומר שיש לנו ביט אפס 1 ושתיים שבהם אנחנו משתמשים למוד אז זאת אומרת שאנחנו שהערכים שם יהיו מאפס עד שתיים בחזקת 3 מי 1 מפ עד ש אוקיי אחר כך יש לנו את enable enable זה ביטח יש לנו נקודתיים ביט 1 ורב יש לנו ארבעה ביטים counter שמונה ביטים וunused זה עוד איזשהי צורה שזה פשוט רשום unused אבל אפשר להשתמש בו מבחינתנו כרגע זה 16 ביט אוקיי בואו נמשיך ונדבר על unions ואז נעשה את הדוגמה מה זה בעצם union זה עוד user defined structure שבעצם כל הממברס, כל מי שנמצא בתוך היוון הם בעצם חולקים את הזיכרון.

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

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

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

אז אז הוא יד זה עדיין שונה ביט. אם אני אגדיר לכאן איזשהו אגדיר לכאן עוד כזה ונגדיר אותו מהסוג הזה אז הגודל הגדול ביותר בעצם יהיה דאבל tyפ בעצם הוא לא באמת דאבל אבל בוא נקרא לו dt tyפ אוקיי סתם בשביל השם dtפ בגודל 32 אז זה 4 * 32 וזה יהיה הגודל של כל היונין אוקיי אז בואו עכשיו אני אמחק את זה כי זה לא יבלבל א מתי אנחנו משתמשים בזה? כאשר אנחנו בעצם רוצים לעשות אינטרפטציה של דata בכמה צורות. אני רוצה להגדיר משתנה ולהגדיר לו את הביטים ספציפית ואחר כך אני רוצה להעביר אותו כUN64 בצורה הזאתי אני יכול להשתמש בזה. אני יכול גם לעשות המרה של קסטינג אבל אפשר לעשות או ככה או ככה בעצם בעצם בכל מקרה הקומפיילר הוא זה שיחליט איך נראת איך נראה האסמבלי של הדבר הזה.

אז איך אנחנו מגדירים? אנחנו מגדירים את זה בדיוק כמו strטct אנחנו משתמשים במילה שמורה unו וגם פה עדיף לנו להשתמש בatribute pct אוקיי א ובעצם האatuteפק זה בעצם איזשהי הגנה על זה זה לא זה לא משנה לי פדing במקום אחר זה משנה לי רק ספציפית על היוני אז יש לי שני משתנים שנכנסים לתוך היו הזה יש לי את bit fieldד datה שזה זה אוקיי אני מגדיר אותו לכאן ויש לי unsign data שזה 34 אני מגדיר אותו בצורה הזאתי כי השתמשנו בטyפדף אוקיי גם פה יש tyפדף וגם פה יש tyדף ראיתם שלא הייתי צריך לרשום strct contנטרול regג אגב אני עדיין יכול זה לא מונע ממני אני משתמש בקנטרול regג t regג זה קיצור של regגיסטר לדוגמה א אז עכשיו מוגדר לי פה הטyפ הזה ואני מגדיר אותו בתוך המיין שלי dataקverטר t אז הוא בעצם רגיסטר וזו דרך שבה אני בעצם שם בכל מקום בתוך הטרctט אפס אוקיי, עוד שנייה אנחנו נמשיך. אז מה אני בעצם עושה? אני הולך לרג, שזה הטייפ הזה, הולך את הצורה הביitטפלדית שלו, בעצם את הצורה של קנטרול רגיסטר ושם אני שם חמש במוד. אותו דבר אני גם מאפשר את הביט הספציפי ואני גם מאפשר את הביit fieldד counter.

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

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

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

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

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

אה יפה. אז זה כן מוגדר כאילו זה כן אפס אבל זה יכול להיות לא מוגדר. א אוקיי זה ה זה הUNS א קצת על proectanation. יש לנו בתוך הפרויקט כמה כמה תיקיות ואני אראה את זה על hell clס בוא נראה את זה על מה שאנחנו יצרנו על m world 1 אוקיי יש לנו כמה תיקיות יש לנו את התיקייה של הבינary שהם שמה אנחנו רואים את התוצר שלנו בעצם זה הקובץ הרצה שהולך לרוץ לתוך הה נכון שהולך לרוץ לתוך ה א [כחכוח] לתוך הMC שלנו ואותו אנחנו הולכים צריכים לה אחר כך יש לנו את include ו שזה בעצם אותו דבר מה יש לנו בתוך inclוד זה בתוך inclוד יש לנו את כל האנקלים שעשינו בסדר אז זה בעצם בעצם מראה לנו כל מיני אקלודים שאנחנו עושים C tyפגע שאנחנו משתמשים בכל מיני אינקלודים בקוד שלנו כמו לדוגמה std in אזה מצטרף לכאן זה בעצם איזשהיא הצורה אחרת לאclודים שלנו זה לא באמת קיים זה בעצם צורה כזאתי שבה אנחנו רואים כמו שפה אנחנו עושים סיסקול ואנחנו רואים פונקציות זה פשוט דרך לראות שם אז זה האנקלים פה יש לנו גלובלים בוא אני אראה לדוגמה פה יש לנו גלובלים שמוגדרים וכל מיני משתנים שמוגדרים לכל הפרויקט שלנו בסדר אחר כך יש לנו את source רגע יש לנו את הinclude שהוא מוגדר כנק זה בעצם קבצים שאנחנו משתמשים בהם שאנחנו יכולים אחר כך צך לצרף אותם לתוך קבצים אחרים. ברגע שאני אעשה inclוד מכאן למקום אחר, אז הוא פשוט יקח את התוכן, יותר נכון את החלק הזה וידביק אותו בכל מקום ששמתי.

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

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

יש לנו את הרסט handlar. אנחנו מסתכלים על הרבה דברים. יש לנו את הקopy דataה בעצם איך הוא עושה קופי וכל מיני דברים שהm צריך כדי להתחיל. יש לנו את הלופבר איך הוא בעצם עושה לופ לנצח ולא סוגר את עצמו כי שמתם לב שבסוף אנחנו יש שמים פה לופ למה אנחנו שמים פה לופ אינסופי כדי שהmcu לא יכבה את עצמו אוקיי אחר כך יש לנו דבג בתוך דבג יש לנו פה גם את הסource שקומפל אנחנו נדבר על זה עוד רגע ואת הסטארטאפ שאנחנו גם קמפלנו יש לנו את הביינary עצמו את המיקפייל שיוצר לנו ה שיצר לנו ה א הסביבת א הסביבת פיתוח ועוד קבצים ועוד קבצים יש לנו את הקובץ של הזיכרון בעצם א קובץ הליסט שבו אנחנו זה סליחה יש לנו את הקובץ של הדיס אסמבלי אנחנו ניגע בו עוד רגע ואנחנו נראה גם את הדוגמה עליו יש לנו את הקובץ של המאפ שבו אנחנו משתמשים בכל הזיכרון איך הוא מופה אלינו לMCU קובץ האובייקטים ובעצם איך אנחנו חיברנו אותם יש לנו את הקונפיגורציה ש א צריך ה ה שצריכה סביבת הפיתוח כדי להבין מה ואז יש לנו שני קבצים של לינקינ מה זה הקבצים של לינקינ בעצם אנחנו [כחכוח] אנחנו שאנחנו מקמפלים אנחנו יוצרים הרבה אובייקטים האובייקטים האלה הם אובייקטים קבצי אובייקט שאותם אני רוצה לצרף לתוך איזשהו אקטable בעצם לטוף את כולם שיהיה לנו קובץ הרצה כמו מה שאנחנו מריצים כל מיני קבצים אז בעצם צרפו אותם ועשו להם לינקינ לתוך הרצה אז יש לנו שני סוגים של לינקינ יש לנו לינקינג של הפלאש mמורי אוקיי איך אנח איך הקוד נשמר שם בחלק של הקוד ויש לנו את הלינקינג של הרם שזה עוד חתיכה של זיכרון שבה משתמש הMCU כדי להריץ אוקיי אוקיי. א אז איזה סוגים של קבצים יש לנו?

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

מה זה מקרו? זה בעצם אה בעצם זה זה בעצם איזשהו א טיפיין שמוגדר א חתיכת קוד שמוגדרת עם ההשמרק הזה הסולמית והחתיכת קוד הזאתי היא פשוט מודבקת בשלב של הפריק קומפילציה שזה השלב שלפני הקומפילציה אז ואנחנו משתמשים בה להגדיר א חתימות של פונקציות פרוטוטייפים כדי שאי אפשר לחלוק אותם בעצם לשתף אותם בין כמה קבצים אנחנו משתמשים בו כדי להגדיר strקטורס בעצם אפשר אפשר להגדיר structures כמו שראינו פה אז הייתי יכול להגדיר את הסטרקט הזה גם פה אוקיי א טוב אני אעשה את זה אבל אנחנו לא נקפל כדי שזה הקומפילציה אז אנחנו נעשה את הכלים להגדיר את הסטרקטר הזה כאן ואז כל קובץ שבעצם עושים inclוד לheר פייל הזה יוכל לגשת גם לסטראקטר הזה בנוסף ולא אצטרך להגדיר אותו מחדש ככה אנחנו בעצם חוסכים כפל קוד וחוסכים באגים אוקיי בעצם ברגע שהסטרקטר זה מוגדר פעם אחת אני לא צריך לשל אותו בכל מיני מקומות אני משל אותו רק במקום אחד וכולם יכולים לגשת אלו שימו לב שכרגע זה לא כזה קריטי לנו כי בעצם על הITMDבג הזה אנחנו עושים לו include רק פה רק בתוךס calls אזסisיס calls גם ככה לא משתמש בסרקטר הזה אז כן אנחנו כן פעמים קמפי לדעתי מעולה הוא לא כעס על זה אוקיי עכשיו אנחנו יכולים גם לעשות כזה דבר אנחנו יכולים ללכת לתוך המיין הזה זה ונשים את זה בomמנ ככה שהוא לא מכיר אותו ונעשה ככה include include לITMbag אוקיי וברגע שאנחנו נקמפל עזוב זה בדיוק כמו אותו דבר ראיתם הוא פשוט הדביק את זה הוא הדביק עוד דברים שהם לא הוא הדביק את זה הוא הדביק גם את שני אלה שהם לא רלוונטים לנו כי לא השתמשנו בהם מתוך המיין אבל זה בעצם זה עובד בואו נחזיר את זה כי זה לאלא לא נכון לעבוד ככה וזה לא מסודר עדיף לשים כל אחד לפי הנושא שלו. אם אנחנו עושים ITMDב אז רק דברים של ITMDב. ככה אנחנו נמנע כל מיני א כל מיני בעיות קומפילציה ופה אנחנו גם לא צריכים. בסדר?

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

אז בעצם יש לנו פה איזשהו. זה if של prקומפילציה. מה זה אומר האף הזה? אומר if not define, אתם רואים שיש פה n if not define itm debug data. אז תיכנס לתוך הא ואז תגדיר אותו ותסיים.

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

אז נעשה פה buildד ו אה תעשה את זה. נעשה קודם cleן אולי ונעשה פה buildד אה בגלל שזה רק חתימות של פונקציה זה לא משנה אז בואו שנייה נעשה א נעשה הצרה כזאתי או שזה לא די בג נכון נכון את הכל רק שנהיה ברורים זה ITM בג H כן זה קרה נעשה פה שמירה ונבנה עכשיו את זה ואתם רואים שהוא כועס עלינו למה הוא כועס עלינו הוא גם רושם definition of structure sensor data זה אומר שהגדרנו אותו פעמיים ואי אפשר להגדיר פעמיים שני דברים באותו ש אוקיי מה יקרה עכשיו כאשר נחזיר את הCLUD guardד הזה זה אנחנו נעשה buildד והכל יהיה בסדר. למה עכשיו הכל בסדר? כי הוא בעצם עשה לו אנוד רק פעם אחת וזו ההגנה הזאתי. זה ההגנה של האinclוד guardד.

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

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

בעצם כל גרופ תכתבו תשימו לדברים הספציפיים שאתם צריכים. דרייברים תשימו במקומות ספציפיים מידלו שזה תקשורת בין הדרייברים לבין השכבה של האפליקציה של הקוד הלוגי עצמו תשימו גם תעשו איזולציה בין ההרדוור ספציפיקות לבין האפליקציה זאת אומרת שאל תכתבו את הכל בקובץ אחד אל תכתבו גם את גם את הדרייבר הספציפי אנחנו לא נוגעים בדרייבר בשיעור בקורס הזה כל כך אנחנו רק לקראת הסוף עם הGP אבל בקורס של הדרייברים אנחנו הולכים לגעת הרבה בדרייברים ואנחנו נעשה בעצם את ההפרדה הזאתי כמו שצריך למה עושים את ההפרדה אני אסביר ככה במילה כדי שאם אם מחר אני רוצה להחליף את הדרייבר בדרייבר אחר אני לא צריך עכשיו לשנות קוד ספציפי אני פשוט מחליף קובץ אז בגלל זה אנחנו הרבה פעמים רוצים לעשות הפרדה בין דרייבר וזה גם חלק מהמודל של השכבות של התקשורת שגם פה אנחנו כרגע א תשמרו על שמות קוסיסטנטים ככה שאם אתם כותבים בצורה מסוימת תכתבו בה אל תכתבו גם באיך זה נקראקבלקיס וגם א וגם בקיצור אני לא זוכר את השמות של ה שלing convention בס נהוג להשתמש בל casס בעצם באותיות קטנות עם אדרסקור קו תחתון כהפרדה c+ס+ נהוג בעצם שכל מילה שנייה בעצם משתמשים בזה ככה כל מילה שנייה בעצם C++ אני חושב ברוב השפות שהם objectינטד משתמשים בתצורה הזאתי שנקרא נקראת camיס אם אני זוכר נכון שבה מילה שנייה מתחילה בזה אנחנו הולכים להשתמש בתצורה הזאתי בפרויקט הזה כי זה תצורה שלרוב עובדים בה בס אפשר לעבוד עם עוד הצורות סך הכל nameing convention אה תעשו [כחכוח] את הפרויקט שיהיה מאורגן בעצם את הbildד prococess תשתמשו במיק פיילים או בסמיקים א היתרון שיש לנו בID הזה שהוא מייצר לנו מקפיל זה ספציפי וראינו אותו אוקיי א תשמרו על דוקומנטציה בעצם תכתבו אה תכתבו אהמנטים וכל מה שצריך קונפיגורציות וממורy management גם כן הרבה פעמים כדאי לעשות לו well define ואם אנחנו כותביםלינקפט אז גם אותם אנחנו רוצה להגדיר א testing ודbaging תכתבו testים לקוד שלכם וקוד הספציפי ככה אתם יכולים להימנע מבאגים בעתיד שבו אתם צריכים לדבק גם את הקוד שכתבתם וגם קוד בהמשך א אוקיי אז בואו נדבר על החלק האחרון של השיעור ונדבר דבר על הect build process א תהליך הבנייה של קוד למיקרוקונטרולרים הוא מאוד דומה לתהליך בנייה של קוד לC וC+ רק יש לזה כמה שינויים קטנים שבהם זה הלינקing והפוסטפיל א בעצם מה הם התהליכים של הבנייה אז כל תהליך בנייה הוא מורכב מהתהליכים האלה אז יש לנו את הפרocessing prepפר prococessing שזה עיבוד מקדים בעברית אז אנחנו בעצם בעצם הקומפיילר הולך והולך עושה את כל האינקלודים של הפייל שדיברנו לוקח את כל המקרואים שמוגדרים בוא נעשה בוא נחפש פה שנייה דוגמה למקרו ש שנמצא א אני חושב שבטח כאן יש עוד רגע אם לא פשוט נגדיר אה אנחנו הגדרנו מקרו ב אנחנו הגדרנו מקרו בדוגמה של הbit manipפulation אוקיי אז יש לנו את המקרו הזה מקרו מוגדר דר ככה ויש לנו את הדבר הזה ביט 3 אוקיי מה זה הביט 3 הזה זה אומר שכל מקום שרשום ביט 3 יבוא הקפילר יעשה ככה קנטרול c קנטרול v וידביק את זה אוקיי בלי ה-V בלי הדבר הזה זה אני והפייפingס שלי א ידביק את זה למה אנחנו למה למה אנחנו עושים את זה ככה אנחנו בעצם כותבים קוד שהוא ברור יותר במקום המסק הזה שהוא לא כזה ברור אז אני כותב ביטו בביטו הרבה יותר ברור בסדר אז זה בעצם הפריפרונing זה השלב שבו הקפיילר לוקח ופותח את כל הדברים האלה את האinclוד הזה אז את כל מה שנמצא בתוך stדי כל הדבר הזה שנמצא מתחת לinclודגד הוא בא ומדביק לי פה ככה על הקובץ אותו דבר על std זה הפרocessing אוקיי ומכין הוא בעצם השלב הזה מכין את הקוד לקומפילציה בשלב של הקומפילציה הקומפיילר הופך את הקוד מסור קוד לאסמבלי לקוד אסמלי שכבר המכונה יודעת לקרוא ולהפעיל אחר כך בשלב הבא האסמבלי שזה האסמבלי א שזה ה א עוד פיצ'ר של הטול שהתקנו הוא לוקח את הקוד וממיר אותו לתוך objectפיל מה זה objectפל זה בעצם קובץ בינרי שכבר המיקרוקונטרולר יודע להריץ אוקיי והשלב הבא זה הלינקינ אנחנו משלבים כמה קבצי אובייקט ואנחנו בעצם מחברים את הרפרנסים שלהם ככה שקובץ אובייקט שפונה לקובץ אובייקט אחר יודע להכיר אותו ו [כחכוח] יודע להכיר אותו ובאמצעות הלינקר הלינקרסקריפט שראינו שם אנחנו לא מיצרים לינקר סקריפט כרגע אין מה לדאוג אבל תדעו שזה עושה לנו את זה אוטומטית ואת כל הדבר הזה אנחנו הופכים לתוך א ואנחנו נרצה להפוך אותו לתוך קובץ מינרי שנקרא אוקיי יש עוד כל מיני סוגים של קבצים בינריים elf זה הסטנדרט שמשתמשים בו בלינוקס וגם אצלנו א את הזה אנחנו נמיר לכל מיני קבצים שאנחנו יכולים להשתמש בהם כמו קובץ הבינרי קובץ הקס ועוד כל מיני קבצים של אסמלי שנוכל לקרוא בזה אוקיי אז בעצם מה קורה בפרוessינג ה שוב אנחנו עוברים את זה ואנחנו נראה גם את הפקודות שעושה הקפילר בואו נסתכל על את זה אה בואו ניקח את strטקצטר כי עליו אנחנו נדבר עכשיו אני שוב סוגר את הכל אנחנו ניקח אתקצטר נעשה לו clean cen אוקיי אני מגדיל פה ואתם תראו בעצם את כל הפקודות עכשיו בתוך הקונס אז יש לנו קודם את המקרופש מה הפקודה gcc מ e מmain ולתוך מינוס o שזה הפג של מינו o לתוך main i שi זה קובץ שהוא אחרי prepפר prococessי אוקיי הרבה פעמים אנחנו נסתכל כן, אנחנו נגיד וואו, זה כל הקוד שכתבתי. כן. ברגע שעושים כמה אנקלודים, פתאום נהיה קודם. א buildד.

אוקיי, אז זה הGC של ה של ה זה הGCC שהוא הטולצן שהוא ספציפי למיקרוקונטרולר שלנו. אז בואו נסתכל על מה שהוא עושה. אז טוב אז הוא לא עושה את השלב של הפרocessינפים זה כבר הרבה פעמים זה כבר מובנה בתוך השלב של ה מינוס C שזה הקפילationש אוקיי שזה האסמלי אתם רואים כאן אז השלבים האלה הם הרבה פעמים הם כבר שקופים לנו כי המינוס C כבר לוקח את הכל אם זה לא נמצא אז זה השלב בעצם זה השלב של הפרק compפilation אם אנחנו רוצים לעשות אותו בצורה ידנית אז אנחנו פשוט עושים GC ‏CC או במקרה הזה הקפיילר הזה הטולצן הזה סליחה מינוס E והשם שלו אחר כך יש לנו את הCOM STפ שאותו אנחנו משתמשים במינוס S בוא נראה אם אנחנו יכולים לחפש פה מינוס S גם זה פה שקוף לנו אבל אנחנו אבל אנחנו נראה את הקבצים בסוף אז אז על דאגה מינוס S זה הCOM stפ בעצם הוא לוקח את כל הסורק שאנחנו פתחנו בפרק compפilation והוא בודק את הסנטקס בעצם אם יש לנו שגיעות אז אנחנו נראה אותם בשלב הזה בודק איזשהם קורקשן ונותן לנו גם ונותן לנו גם אופטימיזציות יש אופטימיזציות לקוד אנחנו נראה אותם בשני השיעורים הבאים נכון או בשיעור או בעוד שני שיעורים אנחנו כבר מגיעים אליהם האoutטפוט של זה בעצם קוד אסמלי שהוא קובץ s עצמו אנחנו לא נראה אותו כאן אנחנו נראה את הסמבלי שיוצא לנו בסוף וזה אנחנו משתמשים בפקודה GCC מינוס S לתוך MS לאחר מכן האסמלי אנחנו ממירים את הקובץ של ה שהאסמלי שמליable בעצם זה קובץ שבעצם כתוב בשפת אסמלי אוקיי ואנחנו ממירים אותו למשין קוד בעצם לקובץ שה לקוד שהmcu שאני יודע לקרוא ואנחנו עושים את זה באמצC וגם פה כבר יכולים לראות מינוס C אוקיי ויש פה עוד כל מיני פלגים שהוא מגנרate לבד אבל לא קריטי לנו ואנחנו לוקחים את הקוד עצמו ואנחנו בסוף יש לנו מינוס O זה הסטאטאפ אתם רואים ויוצר לי קובץ אובייקט ואם אנחנו נסתכל על אחרים אז יש לנו את ITMבג ואז אנחנו צריכים את האobייקט שנקרא ITMAG מינוס O זוכרים שדיברנו עליו אז הוא לוקח אותו יש לנו פה גם את main ויש עוד כל מיני דברים שהוא צריך בשביל עצמו לאחר מכן הפקודה היא GCC מלא ראינו לאחר מכן יש לנו את הלינקינ אז יש לנו ה הוא בעצם מצרף את כמה קבצים ולוקח את כל המשתנים הגלובליים שהם המשתנים שהם חשופים לכל הקוד ובעצם קובע את הכתובות של כל ה של כל הקוד בעצם אפשר להגיע לקוד אפשר להגיע מהכתובת שלו זה ככה בעצם קורה אותו הCPU ואת ה כל הקוד שלו קורה הCPU ואת הכתובות של הזיכרון ככה אני גם יכול להשתמש במשתנים שלי אז זה בעצם המה שעושה הלינקר והוא בעצם לוקח את כל המה שיצרנו ושם לו כתובות ומה ומה קורה ומה קורה אחר כך בפוסט בילד בצריבה הכתובות האלה יפכו להיות הכתובות של הMC כי למ יש את הכתובות שלו והוא יכתוב אותם לשם. אז GCC מינוס O ואז אנחנו בסוף הופכים אותו להיות עם הפריפרלס סתם עם כל מיני דוגמאות של אובייקטים והסטאטאפ ואת כל זה הולך עם הlinker script שזה הדבר הזה והוא אומרים לו תעיצר לנו app.f אוקיי אז אנחנו רואים את זה כאן אז הוא אומר לו קח את הקבצים האלה עם הלינקר סקריפט הזה ותהפוך לי את זה בסוף להיות איפה זה בסוף להפוך את זה להיות להיות 01 אוקיי א אחר כך יש לנו את הפוסטלינקing שבו בעצם אנחנו אנחנו מכינים את ה מכינים את ה בעצם מפים את הזיכרון אז יש לנו כמה מקומות של שבו הזיכרון נמצא יש לנו את המקום שבו נמצא הקוד שזה נקראדקסט לשם בעצם נכתב הקוד כדי שהמכונה בעצם הCPU שלה אני אוכל לקרוא אותו יש לנו את הניד data והרבה פעמים הוא מחולק לכמה כאלה אalata זה בעצם כל מיני משתנים שהם עוד לא הותחלו אוקיי אחר כך יש לנו את השלדה שזה בעצם דטה שהוא כבר מאותח במשתנים בגודל בגדלים שהם ידועים לתוכנית מראש מתדטה ויש לנו גם את הסטק וועוד זה אבל זה אנחנו נגיע במשך א בואו נדבר על על [כחכוח] elf אוקיי elf elf זה בעצם את הצורה שבה גנו מייצרים קבצי הרצאה משתמשים בDlf כשנחנו רוצים לראות את האדרפ פייל ואת כל הסימבולים שאנחנו משתמשים בו זה בעצם איזשהיא פקודה משתמשים בobקד dum בשביל לראות את ה disassembly לנו זה כבר נוצר אוטומטית אני רק מסביר בשביל לראות את המineקד ואת הuman readable assembly כדי לראות את האassem שהולך להשתמש בו ה א הMCU שלנו ואחר כך יש לנו ו וא ו טוב אני לא יצאתי את את הusage אבל יש לנו את הנד list ואנחנו נסת סתכל על הכל ובואו א נסתכל בעצם על מה על איך אנחנו אז יש לנו פה יש לנו בתוך אוקיי יש לנו את ה עצמו ויש לנו את הrucure list ויש לנו גם את המemמורy map אוקיי א המורy mפ בעצם כל ה כל האזור של הbss של הדata הכל נכתב ב אליו מתוך מקומות ספציפיים. זה פחות קריטי לנו לקרוא, אלא אם כן אנחנו ממש רוצים לקרוא את המקום שבו א שבו אנחנו יכולים לעשות דבאגים והכל.

לעומת זאת יש לנו פה את הrucר list. אוקיי? בהתחלה יש לנו את כל הסקtionס ואת כל החלוקה שלהם. יש לנו את החלוקה של אזור הטקסט, את החלוקה של הBSS, של הדata ואחר כך את כל בעצם את כל הסטק פריים ואת כל מה שאנחנו משתמשים בו. אנחנו נדבר על זה בהמשך.

א בהמשך אנחנו פתאום מתחילים לראות שאנחנו נראה קצת קוד מוכר עוד רגע עוד רגע אז יש לנו פה את הITM sendata אנחנו כבר מתחילים לראות איך זה נראה בעצם הוא אומר לנו תסתכלו כל פעם שאתם עושים את זה אני עושה את כל זה אוקיי זה בעצם האמרה יש לנו move W יש לנו load לו ככה הוא טוען אותו לזיכרון יש לנו פה את הור operation הזה ויש לנו את הסטור בעצם את העסמה אחר כך אוקיי זה הפעולות עצמם לא צריך לדעת אותם בעל פי אנחנו כותבים בס אנחנו כותבים באסמבלי כרגע א אחר כך יש לנו את זה וגם כן את זה בסדר זה פשוט אם בא לכם לקרוא אתם יכולים להסתכל יש לנו גם אחר כך את החזרה מהפונקציה אנחנו נגיע לזה אל תדאגו יש לנו פה גם את הר פחות קריטי לנו אנחנו רוצים להסתכל על ה א על המשתנים הספציפיים שהגדרנו אוקיי אז יש לנו אם אתם רוצים אם אתם זוכרים אמרתי לכם שימו לב שכאשר אני משתמש בסטרקט בלי פדינג עם פading אז יש לי הרבה פחות פעולות שאני עושה שימו לב שזו העסמה לתוך הסטרקט הוא לוקח 25 1 ו113 אז ושם אותם בתוך הסטרקט אז לתוך R3 את הזה בואו לא ניכנס שימו לב שזה רק ארבע פעולות מה קורה שאני עושה לאותו אסטרקט הסמה כאשר אני לא עושה פדינג. שימו לב כמה פעולות אנחנו עושים כאן. אנחנו שמים פה שש עושים שש פעולות. אוקיי? א אז זה ה זה ה א זה האסטרקט עצמו.

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

והצורה להשתמש בו זה באמצעות ככה מינוס A יש לנו אתllf שהוא קיים לנו כבר בתוך ה בתוך הקומנד line שימו לב ששמנו אותו בפנים אד לא בוא שנייה ניכנס טוב, בוא נלך לתיקה הזאתי. יש לנו את א מW מה זה ווינדוס אדיר. אחר כך מתוך זה אנחנו רוצים להסתכל בתוך בן ועוד פעם נעשה דיר כדי לראות מה שיש בפנים ואתם רואים שיש לנו פה את obgeפ ויש לנו פה אתllf א יכול להיות שליד משהו לא מוגדר נכון אבל הוא היה אמור כבר לתת לי להשתמש בו אבל אם אני רוצה אני יכול להשתמש ביד כאן א ואז אני יכול בעצם לראות את כל המידע על הקובץ אנחנו רואים יכולים לעשות את זה כדוגמה זה פחות פותחות רלוונטי כי הוא מייצר לנו את זה. אוקיי, אחר כך יש לנו את obgeum. Obg'ump בעצם נותן לנו את כל האובייקטים שאנחנו שהתוכנית שלנו משתמשת ואינה שזה טול מאוד נחמד שהוא מראה לנו את כל האobקט פייל ואת כל הפונקציות שנקראות מאיפה הם נקראות.

א מתי הם משתמשים בזה? משתמשים בזה הרבה פעמים לדבאגינ ומשתמשים בזה כדי לעשות. ועכשיו יש לנו את הdיסass assembly ואנחנו נסתכל קצת על הdיסassembly של התוכנית שלנו. א [כחכוח] אה אז יש לנו פה את זה א יש לנו כאן את זה ועכשיו אני אחזיר את הקוד עצמו שאני רציתי שנראה אוקיי אז בעצם לכל אחד מהם יצרתי איזשהו א איזשהו פונקציה שנקראת מודיפי דה אנחנו מעבירים לפוינטר עוד לא נגענו בפוינטר ניגע בהם בהמשך והם עושים אותו דבר s1 משנה לי סטטוס לשלו וS2 משנה לי אותו ל וS2 שזה האחד שהוא פקט בעצם אנחנו רואים שאנחנו עושים עוד שתי פעולות כאשר אנחנו פונים לפרשר מה זה הפרשר הפרשר הוא Uן 16 אוקיי למה אנחנו עושים יותר פעולות כי בעצם הפרשר הוא נמצא ממש מיד לאחר הS8 לאחר הסטטוס בעצם אין לנו את הפדינג אז אנחנו לא טוענים מילה אנחנו טוענים אותו ישירות אז איך אנחנו עושים disassembly disassembly זה היכולת להשתמש בדdגר כדי לראות את האסמבלי שרץ בזמן ברגע נוכחי. אז בואו אנחנו נשים ברקפוינט שזה נקודה שיוצרת את הCPU את הריצה שלנו.

נלחץ על debaging נגיד לו בסדר הוא יתחיל יתחיל את את מה שאנחנו עושים ומהתחלה נגיד לו רוץ לכאן. ושימו לב שפה בצד נפתחים לנו כל מיני דברים. דבר ראשון לדבאגינג אנחנו יכולים לראות את הערכים של כל מה ששמנו כאן גם בכל מיני הצורות אם אנחנו רואים 112 אנחנו רואים איך זה נראה בזיכרון גם בקס וגם בבסיס ש יש לנו את הבריקפוינט שהגדרנו פחות קריטי לנו לעכשיו את הזה ויש לנו גם אפשרות לראות את ה א דרייברים ואם אנחנו לוחצים על ה פה אז הוא מראה לנו ספציפית את הקוד אז שימו לב מה קורה כשאנחנו עושים כאן אז יש לנו פה פה שני אפשרויות. יש לנו stפ in שזה להיכנס לתוך הפונקציה וספ over שזה לעבור. בואו ניכנס לבפנים.

אוקיי אז [כחכוח] בעצם זה הפעולה שבה אנחנו עושים את זה. התקתי לכם את זה כדי שיהיה לכם נוח לראות את זה גם כאן. אבל זה אותו דבר. אז פה ברגע שאני אעשה next instructiontion אז הוא יעבור לאructiontion הבא. איפה זה?

כאן. אתם רואים הוא מריץ instruction לא שורה שורה. אז זה אפשרות לעשות disembly אם אנחנו רוצים לדעת ברגע אמיתי מה קורה ויש לנו את הBX שזה branch return שככה אנחנו חוזרים מהפונקציה אוקיי אותו דבר גם כאן אנחנו נכנסים לבפנים ואנחנו מבצאים את הפעולות אז שתי פעולות כדי להגדיר את הסטטוס וארבע פעולות כדי להגדיר את הפרשר [כחכוח] אז זה בעצם ה אה א זה בעצם האפשרות לעשות disמלי זה טול שיהיה מאוד שימושי כשנייצר את הסקדולר בהמשך הקורס אבל א כרגע זה בעצם סתם ניסט to וסתם כדי אז א מה זה בעצם הדיס assembly בעצם אנחנו יכולים להשתמש בקוד ולקרוא אותו עשינו כאן זה בעצם הקובץ שנקרא lט אני חוזר שפה אנחנו ולים לראות את כל הפעולות שאנחנו נעשה אנחנו הולכים לראות את הקובץ הזה עוד כמה פעמים בהמשך הקורס אה שימו לב שיש לנו את הדיבגר הדבגר נותן לנו instructiontion level אוקיי עשינו את זה הרגע instructiontion lel זה בעצם לעבור על פקודה פקודה ולהגדירקפוי ספציפית על הפקודות עצמן פקודות assembly מה זה הלינקריפט זה ובזה אנחנו נסיים להיום ונראה את ונראה את האסinמנ שיש לכם הלינקפט זה בעצם בעצם דטה שבו אנחנו משתמשים כדי בעצם למפות את הזיכרון לתוך התוכנית כל דטה וכל הכל וכל השאר הם בעצם ממופים לתוך הMCU הספציפית מה למה הסיבה שאנחנו עושים את זה? אנחנו רוצים בעצם לשלוט על מה הסטאט ממור אדס ובעצם להכין קוד שהוא מותאם ספציפית לMC שלנו. [כחכוח] א לרוב לא עושים את זה הרבה פעמים זה כבר אנחנו משתמשים במשהו שמייצר לנו את זה אוטומטית או הקומפילר שלנו מייצר לנו את זה אוטומטית.

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

כי כעיקרון אנחנו רוצים שהאפליקציה תדע באמת מאיפה היא מריצה את ה מאיפה היא מריצה את הקוד ומאיפה היא מריצה את הדataס structרקט שמשתמשת וזה אם אנחנו נרצה לעשותפי קנטרול לכל מיני דברים אז אנחנו בעצם משתמשים בזה הרבה פעמים לא נוגעים א זה הכל היום אז בואו נסגור את זה ונסתכל על האסinמנ שלכם אז האסinמנ שלכם יופיעו בתוך השיעור אז יש לנו פה assignments ויש לנו בגדול לא הרבה בסדמס אז בואו נפתח אותם ונעבור על זה אוקיי אז המטרה המטרה הראשונה שלכם [כחכוח] זה בעצם לקמפל ולבנות את הקוד לMC שלכם הראנו איך אנחנו עושים את זה אני אעבור עוד פעם ככה מהיר כי הרבה פעמים אני קלתי שלא קולטים את זה אז בעצם אני עושה פרויקט חדש לMCU הספציפי שלי אוקיי ואז אני בוחר את הבורד שלי בבורדסקטור אני מכניס את הפאטנבר אם זה לדוגמה יש פה מישהו עם נוקלאו תיתן על נוקליו אני חושב שהוא מאוד נפוץ אז בוא ניקח את הנוקליו שיש לי כאן אוקיי אז יש לי את הנוקליאו stm 32 יש את הנוקליו הזה. אוקיי? זה הנוקליו שהוא לבורדים שהוא לא פאור. שימו לב שאת הMC כמה עצום הוא. א זה הMCים של STM הם די גדולים.

א והמקט שלו הוא ניוקיו L4 R5 Zi/P. אז ניוקאו ניוקאו ואנחנו מדברים על הבורד ספציפי. ‏L4 RZ IP הנה זה גם הדוגמה שלו כאן אוקיי ואני עכשיו בוחר בבורד הספציפי הזה אז אני אעשה next אקרא לפרויקט בשם ואני אעשה אותו אמטי ומפה אני אסים ואחר כך אני כבר אפשר לחזור על השיעור קלה הקלטה ולראות בעצם את מה שעשיתי אוקיי אחרי זה אני ארצה שתצרו איזשהו לו אוקיי א והלופ הזה הוא כל פעם תקבלו את ה זה כבר בקוד זה כבר בקוד שלכם א או שאנחנו זה כבר בקוד כאילו על א על פרויקט אחר תצרו לופ שהלופ הזה יקבל את המ masקסיז את הoperation בעצם האפרat שדיברנו עליו זה זה bit fieldד operator יש לכם פה בדוגמה של הbit manipulation את כל מה שאתם צריכים תיקחו גם את הפעולה עצמה. אז יש לנו or and not ו א וזה האופרטור שאתם צריכים וכל פעם ש וכל בכל לופ בעצם ה א רגע יש לנו ואת הביט אוקיי אז כל כל לופ אז תקבלו את הביitטקש את המסיז מהuser כאילו ואת האופרצות תבצו את זה לא אדם מריגיסטר כמו שאני הגדרתי פה סתם רגסטר עם ערך אפס ואז תבצו את זה ואחרי זה תנסו ואחרי זה תדפיסו את את הערך שהשתנה. תנסו להשתמש במקרו כמו שעשינו כאן במקרואים.

אוקיי? חייבים [כחכוח] להגדיר מקרו לכל דבר. להגדיר define גליתי שככה עשו בתעשייה אווירית. יש חבר שם א או opיטור את מי להשים אחרי זה בבד? בדיוק.

אועד או אמר לי אתה יודע ש אתה יודע שהם עושים פיין וזה קיצר אור או opיטור אתם יכולים לעשות ואז כל בקום שאתם צריכים אתם יכולים להשתמש בו אני לא בטוח שאתם יכולים להשתמש בו בתוך זה כי זהטור ספציפי של orend assignment אז בשביל זה אתם צריכים לעשות define אחר or and אור שווה ואז אתם יכולים ממש להחליף פה את זה. אוקיי. א תנסו להשתמש בכל מיני כאלה. זה דבר אחד. אחר כך את הפרויקט שיצרתם, את הellow word.

א תשתמשו בו ותצרו איזשהו טוב פה חסר J. בואו נסלח לבחור. אה פרוקט ואחד את הפרויקט עצמו. שימו על אה שימו את הallowור שלכם. תשימו על א על המיקרוקונטרולר ותבדקו את הalf settingס ואחר כך תדברו עםצ'אט GPT או שאתם יודעים או שתבדקו לבד ותשאלו אותם מה זה בעצם הכמה אינסtion שאתם רואים ותלמדו קצת את האינסtionס זה רק בשבילכם זה זה הסינמ שלכם א זה הסיין שלכם לשיעור ממש פשוט כאילו אם אתם מסתבכים שוב תשאלו בקבוצה אני רואה שאתם מאוד פעילים ועוזרים אחד לשני אז זה הכל אה זהו זה הכל היה מבחינתנו להיום.

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

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

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