מפגש 2 (2024-06-03)

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

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

והמטרה בסוף שתבינו.

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

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

אז מי שראה Enter to the Matrix, יש לנו 0 ו-1, וקוראים לזה Base 2. הבסיס 2. אנחנו עושים 2 בחזקת תמיד, נכון? אנחנו כל פעם מעלים את ה-2, כי תמיד זה קומבינציות של 1 ו-0.

## ספרות בינאריות - Binary Digit

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

יש לנו כל ביט, שזה Binary Digit. בינארי זה 1 ו-0, Digit - ספרה.

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

לדוגמה, אני רוצה לייצג את המספר 2, את הספרה 2, אז אני אייצג אותו כ-10.

אוקיי?

ככה שיהיה לי $1 \cdot 2^1$, ו-$0 \cdot 2^0$. ואז יהיה לי בעצם 1 ו-0. ככה אני יגיד למחשב שלי "זוהי הספרה 2".

איך אנחנו עושים את כל ההכפלות? אז במערכת בינארית יש חזקות של המספר 2. ספרה ימנית ביותר מייצגת את ה-1 ($2^0$), הבאה אחריה מייצגת את הספרה השנייה, $2^1$, וכן הלאה.

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

העברת ביט אחרי ביט, נכון? כשאנחנו מעבירים את ה-Enter to the Matrix בערוץ יחיד, קוראים לזה תקשורת סריאלית, זו ההגדרה.

## שערים לוגיים

אז איך אנחנו הופכים את 0 ו-1 לקבלת החלטות?

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

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

אם אנחנו לוקחים את הבסיס 2 שלנו, אז יש לנו קומבינציה של ארבעה רצפים: 00, 01, 10 ו-11. כל אחד מהם נותן לי output שונה.

ככה, על בסיס ה-Base 2, אני יכול לקבל החלטות. אם אני עושה את ה-00, 01, 10, 11 – זה AND, זה "וגם".

00, 01, 10 שיוצא לי בצורה הזאתי, הלוגיקה שלו תהיה 001... או 0111, זה יהיה OR. אתם מבינים את הלוגיקה?

אם זה 0 ו-0, זה 0. אם זה 0 או 1, זה 0. אם זה 1 ו-0, זה 0. אם זה גם 1 וגם 1 פה, זה 1.

OR – זה דווקא שונה: 00 ייתן לי 0. אם זה או 0 או 1, ייתן לי 1. אם זה 1 או 0, ייתן לי 1. אם זה 1 1, ייתן לי 1. כי פה למעשה זה מחובר.

אלא אם כן אם אני עובד על לוגיקה הפוכה שלו, שאני אומר לו "תחשוב הפוך ממה שעשית עד עכשיו", ואז תראו את ההבדל הלוגי בין OR ל-NOR. שפה ששני השערים מבוטלים זה נותן לי 1, ושאר השערים זה נותן לי 0.

פה ב-NAND, ב-NAND זה עושה לי גם כן בדיוק לוגיקה הפוכה מה-AND, וככה יש XOR ו-XNOR. זה בעצם ששת השערים הלוגיים הבסיסיים ביותר, שעל בסיס ה-Base 2, ה-0 ו-1, אני יכול לבצע עכשיו המון המון פעולות. עכשיו תחשבו שיש לי מיליארדי טרנזיסטורים, מיליארדי 0 ו-1-ים, שיוצרים לנו המון המון המון לוגיקה.

וזה הבסיס, באמת הבסיס של איך מחשב עובד.

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

## אותות דיגיטליים ואותות אנלוגיים

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

אז כבר מה-generation פה של ה-ChatGPT, אז אנחנו יכולים לראות שדיגיטלי זה משהו שהוא מאוד מאוד חד-ערכי, ואנלוגי זה משהו מאוד מאוד רציף.

אז בואו ניתן קצת דוגמאות. מצד ימין יש לנו את האותות האנלוגיים, שזה מייצג לנו את ה-Analog Input/Output, שאם אתם זוכרים ב-Arduino יש לנו בין 0 ל-5 ב-Uno, והאותות הדיגיטליים זה ה-Digital I/O-ים, זה שיש לנו בין, בוא נגיד 2 עד 13, כי ב-0 ו-1 אנחנו משתדלים לא להשתמש.

אז לרוב זה 0 ו-1 בדיגיטלי. יש בדידות, ללא טווח רציף. כלומר, אין בין ה-0 ל-1 כלום. זה או 0, או 1. בסדר?

יש באותות דיגיטליים עמידות לרעש הרבה יותר טובה. אם אנחנו עכשיו חושבים כמייקרים, ואנחנו רוצים לשים איזה שהוא מפסק שיודע לקרוא או 0 שזה מחובר, או 1 לא מחובר, עדיף לי לעבוד בצורה דיגיטלית, להבדיל מצורה אנלוגית שהוא יכול לפרש את זה עם רצף בין 0 ל-1, או בין 0 ל-1023, תלוי אם אני מחלק את זה ב-A2D converter שיש לו, אם אתם זוכרים.

ואז הוא יכול לזהות את כמעט 1 בתור 1. להבדיל מעולם דיגיטלי שאין כלום, אז אם זה לא 1, זה כלום, זה 0. בעולם רציף, ליד 1 זה יכול להיות עם טיפה רעש 1.

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

וזה ההבדל ביניהם.

אגב, ה-Arduino-JS, אם תפתחו את ה-Back שלכם שאנחנו ניגע בו, הוא מדבר בפקודות סריאליות עם ה-Arduino. ה-Node.js, ה-JavaScript הומר בכל מיני שלבים למצב שבסוף ה-Arduino, הבורד שלנו, מקבל 1 ו-0.

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

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

רגע, Arduino IDE. אתם יכולים לעשות את זה איתי אם אתם רוצים במקביל, לפתוח את ה-IDE שלכם.

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

זה ה-firmware של ה-Wi-Fi נגיד, שזה יחסית קוד מסובך. אני יכול לעשות פה Export Compiled Binary. אוקיי? מי שרוצה לעשות את התרגיל הזה.

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

מגלל זה מי שראה, היה דיון מאוד מאוד מעניין בקבוצה בשבוע האחרון, האם אפשר לעשות ייצוא של הקוד חזרה מה-Arduino החוצה בצורה של C++? ראיתם את הדיון הזה?

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

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

זה הקוד שעשה לכם את ה-Flash. אם אתה רוצה, אמיר, להחליף את זה, אתה יכול לחבר את ה-Arduino וזה בעצם עושה לנו צריבה של LED שמחובר לפין 11. תחליף את זה לפין 13 ואז זה יעבוד לך.

– זה ה-Blink שעשינו, נכון?

זה ה-Blink שעשינו. נו, לא, זה PWM. זה דוגמה ל-PWM. אנחנו נעשה את זה בסדנה. כי לפין 13 אין PWM, נכון? פין 13 לא יודע להיות PWM, אין לו את התילדה הזאתי מעל ה-Tab.

– נכון.

אז פה יש לולאה שרצה, שהיא בעצם מעממת ועושה כמו... כמו דימר של LED. מה שאנחנו עשינו, ה-Blink הכי פשוט, זה פה ב-Examples, אנחנו ב-Basics, ויש לנו פה Blink.

זה זה. שזה built-in LED, ב-Arduino Uno הוא משודך לפין 13. אז אם אני אומר לפין 13 להידלק, או שיש לו מילה שמורה שקוראים לה LED_BUILTIN, זה עובד לי. אז לזה אני יכול לעשות Extract.

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

הוא מזהה לי פה את COM3 פתוח, לא משנה, מנסה להתחבר אליו. ואני עושה לזה Extract כקוד בינארי. עכשיו, כדי לפתוח קוד בינארי, אני צריך למצוא איזה שהוא editor, כי זה משהו מאוד איזוטרי, אנשים לא משתמשים בקוד בינארי ביום-יום שלהם. יש כל מיני editors אונליין שיכולים לנסות לעזור לנו. אז אני אכתוב .bin reader online. .bin זה בינארי.

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

איפה זה שמר לי את זה? בוא נראה Blink. אה, אני חושב שאצלי זה ב-C. כי גררתי את זה ל-C. Arduino, פה. בוא נראה מה יש לי פה.

בוא נשמור את זה רגע ב-C מחדש. את ה-Blink הזה, כי זה קוד... זה לא Save As... נשמור אותו שם ב-Arduino ב-Blink. Arduino... כן, זה C, Arduino, Copy של Blink. בתיקייה שלי. Blink.bin.

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

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

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

איפה יש לנו פה .bin? הנה. .bin.

אז בוא נקח את ה-Path שלו, נזכור אותו ו... נלך לפתוח אותו. וככה אני אוכיח לכם שמחשבים עובדים ב-1 ו-0.

רגע...

– רגע, הוא לא מקבל את זה.

אין טוב מאיברי עיניים. רגע... אני אעלה לי את זה. Blink without bootloader... רגע, בוא נפתח את זה.

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

View it now, יפה.

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

Select... בינארי... bin... או, יפה. 000000, 000010, 000020, ככה בינארי, ככל שיש לו יותר זיכרון, ככה הוא שומר יותר קומבינציות.

זה טבלה אקסדצימלית?

סליחה?

זה טבלה אקסדצימלית?

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

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

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

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

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

## איך הטרנזיסטור שינה לנו את העולם?

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

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

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

## סקירה היסטורית

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

לא, אבל תיקנתי מקלטי רדיו שהיו להם כאלה דברים.

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

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

אז מה שהם עושים, נכון אמרנו שיש לנו שלושה הדקים? אנחנו כבר ניגע בזה. יש לנו את ה-Gate, Drain ו-Source. הם מצליחים לקרב בין ה-Source ל-Drain. ותחשבו על זה: ככל שיש לי דרך יותר קצרה בין מה שאני צריך להעביר בו את הזרם, בין שני ההדקים שלי, האינפורמציה עוברת הרבה יותר מהר, קצב המיתוג הרבה יותר מהר.

כך שנגיד Arduino Uno הוא ב-16 MHz, נכון? זה קצב המיתוג שלו. ה-Cycle של המעבד שלו הוא ב-16 Hz. והיום יש לכם בתוך, אם תראו את ה-Intel Inside הזה, זה כבר מגיע ל-4 GHz. שג'יגה זה כבר שלושה סדרי גודל יותר ממיגה. זה כבר מיליארד פעמים לשנייה. כלומר, כמה שהמוח שלנו טוב ומהיר ואנחנו אנשים חכמים ומוכשרים, אנחנו לא יכולים לבצע 4 מיליארד פעולות בשנייה.

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

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

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

ונעבור ככה על איך העולם נהיה יותר ויותר קטן. אז אם באמת תיקנת בעבר, אז תראו, יש לנו פה scale של typical size, אוקיי? זה בסקאלה לוגריתמית, זה לא ליניארי. 1 µm זה מיקרון, זה 10 בחזקת מינוס 6, זה מיליונית המטר, וזה 1 מילימטר. פה אנחנו מדברים על משהו באזור ה-30-40 מילימטר. כלומר, הגודל של זה... הגודל של זה הוא באזור ה-30 מילימטר.

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

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

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

## חוק מור

זה מכפיל כל 1.6 שנים את המהירות של הקצב.

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

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

זה פי שניים כל 1.6 שנים.

כן.

ואז כשאנחנו רואים את כמות הטרנזיסטורים שמספרים במעבד, בסדר? טרנזיסטורים שמספרים במעבד. אנחנו מדברים כבר על 3 ננומטר לטרנזיסטור, נכון לני, ומדברים פה על שנת 2020, השנה האחרונה. אז אתם רואים שפה כמעט אין תחרות ל-Intel. הרוב פה זה Intel, Pentium. Pentium זה היה מאוד מטורף. מדי פעם יש איזה AMD שנתנו להם, אבל Pentium, Pentium, Pentium... זה גם זה Intel, Pentium. הם היו מאוד חזקים והגרף נראה די ליניארי. עד שברמת שהורע, ש-Intel התחילו... לא יודע, קצת השתבש להם גם המפעל בקרית גת של 10 ננומטר, פיטרו שם את כל ההנהלה, את המדען הראשי שלהם, הביאו מנכ"ל חדש, קצת התברברו.

ונכנסו פה עוד כמה חברות, יש איזה חברה שקוראים לה Apple שנכנסה מאוד חזק לעולם השבבים. גם כן חברה קטנה מסילוקון ואלי שהעיפה את Intel מהמחשבים שלה. ואז אתם רואים שפה כבר נהיה יותר כאוטי, והגענו למצב שיש 50 מיליארד טרנזיסטורים בשבב, אוקיי? שיושב לנו בתוך המחשב. נכון, זה מחשבי אקסטרים, אבל סתם, Dual Core, GPU, i7 יש לו אזור ה... שני מיליארד טרנזיסטורים בשבב נתון. תחשבו כמה קומבינציות של 0 ו-1 אפשר לעשות בשבב כזה.

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

ו... אנחנו מדברים פה על, כן, מיליארדים. נכון, 9 אפסים, סליחה, זה ה מיליונים פה. נכון, אנחנו במיליארדים. כן, זה 50 מיליארד. המחשוב היום, AMD EPYC שלהם, שכבר אתה יודע, הוא ישן, זה כבר מלפני שלוש שנים, היום יש Jetson-ים, זה 50 מיליארד טרנזיסטורים לשבב שיושב במחשב.

זה פשוט כמות דאטה וחישובים פנומנלית שקורית בו-זמנית. זה... כל טרנזיסטור כאמור זה 0 ו-1, 0, 1, 0, 1, 0, 1, שבסוף מתרגמים אותו לזה שאנחנו יכולים לדבר בזום, אתם שומעים אותי נורמלי, אתם קולטים אותי ב-Wi-Fi, ואתם רואים אותי ב-4K. אוקיי? זה מדהים.

## החוק בימינו

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

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

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

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

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

אז שוב, ככל שיש יותר תחרות הצליחו לשבור את חוק מור, ואנחנו זכינו שהיום אפילו ב-Arduino UNO R4 יש כבר ARM Cortex-M4, שזה מעבד מדהים, מאוד זול, שאם לא הייתה תחרות טובה בשוק, אז כנראה לא היינו מקבלים אותו ככה על מגש של כסף ב-Arduino.

## מושגי יסוד חיוניים

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

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

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

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

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

## מוליך למחצה Type N

אנחנו צריכים להבין מה זה N-type ו-P-type, נכון? שמעתם את המונחים האלו. יש לנו Negative ו-Positive.

אז איך אנחנו עושים את זה? אמרנו שהמצע של כל הטרנזיסטורים שלנו זה סיליקון. לוקחים חול ים, בדרך כלל מיפן, מגדלים אותו למה שנקרא Single Crystal, מנקים אותו באמת ברמה של 99.99999% שזה סיליקון אמיתי. לוקחים אותו לוויפרים מאוד מאוד דקים, עושים את זה בקרית גת, במפעל של Intel שם, מייצרים שם ב-10 ננומטר, ואז מתחילים להעביר אותו תהליך שקוראים לו Doping.

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

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

## מוליך למחצה Type P

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

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

## סוגי טרנזיסטורים

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

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

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

## Bipolar Junction Transistor (BJT)

בואו נתחיל שנייה עם ה-Bipolar Junction Transistor שלנו, שאפשר לזהות אותו לפי, אמרנו, שלושה הדקים. השמות של ההדקים שלו שונים מהשמות של ההדקים של מה שנקרא ה-FET-ים. פה אנחנו מכנים אותם Collector, Base ו-Emitter. קולט, בסיס ופולט.

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

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

יש לנו שני סוגים. אמרנו שאנחנו יכולים לזהם את החומר או כ-N או כ-P. בגלל שאיש לנו פה את שלושת החומרים האלה, אנחנו מזהמים אותו בצורה אחת כזאתי: אנחנו רוצים ליצור פה אם זה PNP או NPN, ככה אנחנו יוצרים את הזרימה הזאתי. אנחנו נותנים לאלקטרון את היכולת לעבור ממקום למקום. ואז אנחנו מזהמים את ה-Collector ב-N ואז P ו-N, או לחילופין PNP.

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

כך שהם מאוד דומים. בגדול, צריך לקרוא Data sheets. צריך לקרוא Data sheets, כי לפעמים יש לכם NPN, PNP, יש המון בלבול בדברים האלה. וכל מה שלפעמים צריך לעשות כדי שהטרנזיסטור במעגל יעבוד זה לסובב אותו, כי במקום שבין ה-Emitter ל-Collector, שמנו בין ה-Collector ל-Emitter, והזרם לא יכול לעבור ברוורס. אז לפעמים פשוט צריך לקחת ולסובב אותו 180 מעלות, כי זה לא NPN, זה PNP. אבל שוב, זה בכפוף ל-Data sheet.

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

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

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

BC547B, טרנזיסטור, Data sheet. באופן כללי אנחנו מאוד אוהבים Data sheets, כי Data sheets עוזרים לנו לעשות דברים נכון ולא לאלתר. אז זה הטרנזיסטור החמוד שלנו, General Purpose Transistor, NPN.

ומה עוד חשוב לנו לדעת? רגל 1 זה ה-Collector שלו, רגל 2 זה ה-Base שלו, ורגל 3 זה ה-Emitter שלו. ככה שהזרם שלי עובר בין ה-Emitter ל-Collector, וככה אני צריך לדעת לחבר אותו.

- מה-Collector ל-Emitter, לא? זה מה שהצגת במצגת.

- ה-Collector אוסף, ה-Emitter פולט.

- אז זה בא מה-Collector ל-Emitter, לא? זה מה שהצגת במצגת קודם.

- זה סימנתי אם אתה ב-NPN או ב-PNP. כי אם תשים לב לסימונים פה... ב-NPN, רגע... ב-NPN מי הקולט? מה-Collector ל-Emitter, נכון. וב-PNP זה מה-Emitter ל-Collector, אתה צודק. אתה צודק. יש לנו פה את הסכמה הזאת, אתה רואה Collector וכיוון הזרם הוא אל ה-Emitter.

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

- נכון, אתה צודק. ממש צודק ותודה על ההערה הזאתי.

## Field Effect Transistor (FET)

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

שמה השפה היא טיפה שונה. אנחנו מדברים על Drain, Gate ו-Source. התרגום הישראלי של זה זה ניקוז, שער ומקור.

הם Field Effect Transistor, הם ה-FET-ים.

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

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

- מה אנחנו מרוויחים מהטרנזיסטור הזה?

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

גם פה יש PNP ו-NPN, תלוי אם המצע שלכם זה P-type וה-Gate שלכם זה N-type.

- שאלה קטנה. אז זאת אומרת שהטרנזיסטורים האלה זה לא 0 ו-1?

- זה גם 0 ו-1, דולק / לא דולק.

- אתה אומר ששדה משפיע עליו, אז השדה הוא יכול להיות משתנה או אנלוגי.

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

אבל בסוף זה 0 ו-1. אפשר לעשות את המניפולציה של PWM ולמתג אותו. בגלל שהוא מאוד מאוד מהיר, אתה יכול ליישם עליו PWM.

## MOSFET

אבל כל מה ש-Intel עובדים בו, הם המציאו את ה-Gate oxide הזה ב-MOSFET-ים, שכבת אוקסידציה מטורפת שנותנת להם יכולת להיות מאוד מאוד קטנה, עם יכולת בידוד מאוד מאוד גבוהה ולא להיפרץ. ומרוב שהם היו יהירים, הם אפילו לא כתבו על זה פטנטים, כי הם חשבו שאף אחד לא יוכל להעתיק אותם. אבל הם כבר די היסטוריה, Intel.

זה ה-MOSFET, שזה Metal Oxide Semiconductor Field Effect Transistor, שהוא עובד בשיטה שהיא טיפה שונה. הוא פשוט יש לו פה שכבה של אוקסיד, יש לו פה Gate, ובין ה-Source ל-Drain אנחנו מסננים את ה-Source ואת ה-Gate שלנו בחומרים שונים, ואז הבאדי שלנו הוא P. אז יש לנו NPN, ואני משחק פה עם ה-Field, והזרם שלי עובר בצורה הזאתי.

זה כמה יישומים. הם פחות נפוצים ב-Arduino.

## השוואה בין סוגי טרנזיסטורים

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

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

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

אם נעשה את ההשוואה בין מה שאמרנו ה-Bipolar לבין ה-FET-ים, אז תראו למה יותר נוח להשתמש ב-Arduino דווקא ב-BJT-ים ולא ב-MOSFET-ים, למרות ששוב, אפשר גם להשתמש ב-MOSFET. פשוט תדעו לפי ה-Data sheet במה אתם משתמשים ואיך לחבר נכון את הרגליים.

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

מבחינת הסימונים, איך שמסמנים, אפשר לראות את זה כאן. יש שונות. ובגדול, אם יש לכם Collector, Base ו-Emitter, אתם ב-Bipolar-ים. ואם יש לכם Drain, Gate ו-Source, אז אתם בעולם ה-FET-ים.

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

זה הפרק על הטרנזיסטור.

## Registers

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

אתם עכשיו תכתבו ב-Node.js "תדליק לי לֶד", או תעשה לי איזושהי מניפולציה מתמטית של אריתמטיקה: 1 + 1, 1 - 1, 1 * 1, כל מיני דברים כאלה. וזה לא קסם, יש המון המון חשיבה ומדע מאחורי איך שהפעולה הזאתי קורת.

וכדי לאפשר אותה, יש רכיב שקוראים לו Register.

ואם ראיתם את הדיון שהיה בקבוצה, שאלו אנשים מה...

מה הצורה הכי יעילה ליישם משתנה? אם ראיתם את זה, `A = 1` או `A`... `A N = 1`, כל מיני שיטות שיש לעשות. ובסוף אחד האנשים, החבר'ה שם, הלך, כתב את הפעולה הזאתי, קמפל אותה, והלך לקוד ה-Assembly, וראה מה המשמעות ברמת הרג'יסטרים, כמה זיכרון, כמה פעולות זה דורש כדי לבצע יישום של משתנה.

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

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

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

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

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

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

## סוגי רג'יסטרים עיקריים

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

כל דבר אני שומר אותו. אוקיי, וגם פה אנחנו מדברים בגודל של ביטים בסוף. כמה יכולת לרג'יסטר לשמור ביטים, כמה 1 ו-0 יכולים להיכנס בכל רג'יסטר.

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

אז לקחתי פה 256, אוקיי? שזה 2 בחזקת 8, 8 bit. יש לנו Most Significant Bit שזה הראשון, ו-Least Significant Bit שזה האחרון, זה מבחינת ההגדרה, איך אני תוחם את זה.

מה עשיתי פה? שמתי שמונה אפסים: `00000000` שווה לי 0.

`00000001` שווה 1.

`00000010` שווה 2.

תעשו את כל הקומבינציות האלו, וכל פעם תעבירו את ה-1 הזה, ותעשו 11, ותעשו 111, אתם יכולים לנסות את זה. תגיעו בסוף למצב של `11111111` שווה 255.

אוקיי? אם היו לי 10 ביטים, הייתי מוסיף פה עוד אפסים, עוד שני אפסים, נכון? והייתי מקבל כבר 1024. בסוף זו קומבינטוריקה, כמה אופציות ל-0 ו-1 יש לי.

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

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

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

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

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

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

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

## איך זה קורה?

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

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

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

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

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

ה-cache זה קצת ה... זיכרון שלו, אבל זה לא אותו דבר כמו מוח.

סליחה?

אמרתי שה-cache והרג'יסטר זה זיכרון, אבל זה לא בדיוק כמו המוח.

נכון, אבל עדיין יש את ה... את ה... את ה-delay הזה, את השהות הזאתי כדי שהוא יגיע לשם וימשוך את זה.

נכון.

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

נכון.

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

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

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

בקר קטן מאוד.

זה לא הגודל הפיזי שלו, אוקיי?

סתם התלוצצתי.

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

## איך בנוי מיקרו-בקר?

אז המיקרו-בקר הזה יש לו את האלמנטים הבסיסיים ביותר, שהם חייבים, אוקיי? יש לו RAM וזיכרון מהיר וזיכרון איטי יותר. ה-RAM זה ה-Random Access Memory, בסדר? וזיכרון קבוע זה ה-ROM, אז בארדואינו יש לנו באמת את ה-Flash, כמו שאמרת אמיר, יש לנו את ה-EEPROM.

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

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

יש סוללה שמחזיקה את זה.

לא.

אין סוללה.

לא, במיקרו-בקר אין סוללה שמחזיקה את זה. במחשב, אם תפרק... אין לך, במיקרו-בקר אין לך. אם תפרק את המחשב, יש לך סוללה שקוראים לה סוללת BIOS, שהיא אחראית על השעון. אוקיי? אין לך את זה במיקרו-בקר.

גם הסוללה הזאתי, גמדה מה שהיא עושה, היא אחראית על ה-BIOS, ה-BIOS זו התוכנה שמעלה את ה-Windows. זה כמו ה-bootloader שיש לנו ב-UART, בסדר? אבל במיקרו-בקר, בארדואינו, אין לך שום סוללה. גם אם תקח אותו עוד 100 שנה, תכניס אותו לחשמל, לא יקרה כלום, הוא יעבוד, כאילו אין לך סוללה, אין לך BIOS.

אוקיי.

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

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

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

יפה. מה עוד יש לנו שזה בסיסי? אז USB, UART ו-SPI. אמרנו UART זה ה-bootloader, זה מה שמתרגם לנו מה שעכשיו עבדתי עם אמיר. צרבנו דרייבר של הרכיב החומרתי הזה כדי שהמחשב בכלל יזהה את הרכיב הזה. הוא לוקח את ה-Serial commands מה-USB וזורק אותו לזיכרון ה-Flash של המיקרו-מעבד.

ו-SPI זה אם אתם זוכרים, הששישה פינים שאני יכול לדלג על ה-bootloader ולדבר ישר בתקשורת סריאלית עם המיקרו-מעבד, להעביר לו ישר 1 ו-0 ולהגיד לו תדליק את זה, תכבה את זה, תעשה פה PWM, תקח את הדאטה האנלוגית הזאתי ותגיד לי מה היא.

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

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

ואפשר לדבר פה על פילוסופיות של מערכות הפעלה, שזה לא קשור למה שאנחנו לומדים פה, זה קשור אולי יותר ל-Embedded Linux, הקורס שאנחנו עכשיו רוצים לפתוח בקהילה. שזה שתי גישות של איך אנחנו מתזמנים פעולות במעבדים. שאפשר לפתוח על זה ערוץ שלם, אבל בגדול שתי הגישות זה Real-Time Operating System, כלומר מה שמגיע קורה, לעומת ה-RTOS, לעומת ה-Linux. Embedded Linux שזה Time-sharing, שזה תזמון פעולות בצורה יותר מקבילית. שזה שתי פילוסופיות, זה כמו Apple ו-Microsoft. זה שתי פילוסופיות שכל אחד מה שהוא מתחבר ומציע לו. אפשר לריב על זה הרבה זמן מה עדיף למה. שוב, Embedded Linux תפס, RTOS תפס, אני לא יודע מה יותר טוב, שוב אלה אסכולות, קשה לי לתפוס פה צד.

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

סע לשלום.

מדהים. יפה.

עוד מה שיש לנו, אז יש לנו את ה-Digital-to-Analog Converter ו-Analog-to-Digital Converter. שוב, בארדואינו החדש יש לנו את שניהם, ב-R3 יש לנו רק Analog-to-Digital.

General Purpose I/O-ים, שזה בעצם הייעוד של הארדואינו, הוא נותן לנו המון המון מתגים שאנחנו יכולים לעשות איתם מה שאנחנו רוצים, וה-CPU, יחידת העיבוד המרכזית שלו.

## מה התהליך של הפקודות?

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

אבל עד שהגענו לשם, אז יש לנו בעצם, אמרנו אנחנו כותבים את זה בכלל ב-Node.js, נכון? אנחנו נמצאים פה, ב-Node.js מעל. אבל בוא נגיד שאנחנו בפירמטה ב-C++, עובר קומפילציה ל-Assembly. שפת מכונה נצרבת בזיכרון,

המעבד קורא פקודות מהזיכרון ומבצע אותן באמצעות הרג'יסטרים, ובסוף אנחנו מפעילים את זה, קוראים אותות או שולחים אותות מה-analog-to-digital או digital-to-analog converter שלנו, ומכבים ומדליקים את הפינים ב-general purpose I/O-ים שלנו. זה בגדול איך שזה עובד.

## CPU

עכשיו אם אנחנו לקחנו את כל המיקרו-מעבד, הוא מכיל את כל הדברים האלה. אחד מהדברים האלה זה CPU, זה ה-Central Processing Unit שלו. איפה שקורות הפעולות של העיבוד עצמו. עד עכשיו דיברנו על לגשת לזיכרון ולצרוב, איך העיבוד עצמו נעשה?

המעבד הוא בסוף היחידה הכי חשובה. ה-CPU שלנו הוא הדבר הכי חשוב שיש לנו בתוכו, הוא עושה את כל החשיבה שלנו.

## תהליך עיבוד ההוראה

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

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

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

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

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

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

— סליחה? זה תלוי במעבד, יש פעולות שלוקחות כמה סייקלים.

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

— הרענון של ה-RAM, לא? או שאין את זה ב-Arduino?

— אני שומע אותך במעומעם.

— סייקל רביעי כדי לרענן את ה-RAM גם...

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

— המתח יורד ואז מטפס...

— אם אתה עושה אותו על אפס, ה-RAM נמחק. אם אתה מוציא את המתח, אז... כן, אבל זה גם פעולה, לֵך ל-0. לגמרי הכל.

## ארכיטקטורת CPU

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

אנחנו לא ניכנס לזה. ב-high level זה מה שקובע את הביצועים ואת היעילות של המעבד שלנו. יש קרב ענקים בין ארכיטקטורות. יש כיום x86 של Intel, זאת ארכיטקטורה שעובדת בצורה מסוימת. ויש ARM, שהיא יעילה. זה התחיל כפרויקט של BBC בכלל. הייתה איזו אג'נדה באנגליה, מחשב לכל ילד. רצו לעשות מחשבים מאוד מאוד זולים, ומי שהמציא את ה-ARM ראתה שכמעט בלי חשמל, רק על איזשהו שדה חשמלי שהיה ליד, הוא הצליח לעבוד.

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

והם התחילו עם ARM ל-Palm, פאלמים של Apple שהיו כישלון חורץ, ואחרי זה לקחו את זה גם לאייפונים כי פשוט לא הייתה להם ברירה. והתחילו לייצר ב-TSMC ARM. והגיעו לביצועים מדהימים, והיום אפילו ב-Mac-ים יש ארכיטקטורת ARM, הם הוציאו את Intel החוצה. Mac-ים יכולים להיות גם 14 ו-18 שעות על סוללה. ואני שמעתי את מנכ"ל Adobe של פוטושופ, אומר ש-Apple הוציאו מעבדים כל כך חזקים, שברמה התוכנתית עדיין לא יודעים מה לעשות עם זה. הם צריכים להמציא תוכנות יותר טובות, יותר חזקות כדי לנצל את יכולת העיבוד שיש כיום במחשבים של Apple. אז זה מה שמעניין.

אז מה שיש לנו הכי בסיסי כיום ב-CPU-ים, אמרנו: זה רג'יסטרים, יש יחידה שאחראית על האריתמטיקה (ALU), יש יחידה שאחראית על שליטה (CU), יש את זיכרון ה-cache, שזה זיכרון מאוד מהיר. המטרה שלו זה באמת לשפר את הגישה לזיכרון. זיכרון ה-cache הוא הזיכרון הסופר מהיר, הכי מהיר שיש למעבד. אם צריך איזשהו משתנה לשמור אותו, ישים אותו ב-cache, בזיכרון מטמון, ואחרי זה גם אפשר למחוק אותו.

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

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

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

## Atmega 328

שזה ה-Atmega 328 שלנו, שיש לו שתי תצורות. התצורה הזאת קוראים לה dual in-line package, כי יש לו שתי שורות, וזה 28 פינים או 32 פינים ב-thin quad, שהוא הרבה יותר קטן. אותו מיקרו-מעבד, עניין של כמה פינים יש לו. היום אנחנו שואפים לחסוך במקום, יותר משתמשים בזה.

זה איזה מיקרו-מעבד שהורידו אותו מהמדף אי שם ב-2005. הם היו שותים בירה בבר, והמציאו את הארדואינו. אמרו "בוא נשתמש בו", וגרמו למכירות של ה-Atmega האלה לעלות בטירוף. משתמשים בזה המון, וכל החיקויים.

מה מעניין אותנו פה? יש לו מעבד של 8 ביט, מעבד לא נחשב מטורף. עד 20MHz במהירות שעון מקסימלית, ה-nominal שלו זה 16MHz.

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

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

אם יש לכם סיסמה עכשיו של 80 תווים, אתם לא תוכלו לשמור אותה בארדואינו, לפחות לא ב-Uno, כי יש לכם רק 1KB. יש לכם פה 1,000 בתים שאתם יכולים לשמור עליהם מידע. אתם יכולים לחשב את זה: כמה כל מספר, כמה כל ספרה דורשת, ולהגיע למצב שאתם מתכנסים ל-1,000 בתים שיש לכם פה, הקילובייט.

איזה עוד תכונות יש לו? מה הוא תומך לנו? הוא תומך בסך הכל עד 23 יציאות של PWM. הארדואינו עצמו לא בהכרח מאפשר את כל היציאות האלה, אבל המיקרו-מעבד עצמו תומך ב-23 יציאות כולל PWM, 6 יציאות אנלוגיות, שישה ערוצים של ממיר analog-to-digital, שזה כל היציאות האנלוגיות שלו, תקשורת I2C, SPI ו-UART, ויש לו טיימרים שגם בארדואינו אפשר לנהל אותם עם כל מיני ספריות מתקדמות.

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

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

— עד איזה רמה אנחנו צריכים להכיר את כל מה שדיברת עליו?

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

כדי להיות מייקר, בדרך כלל מה שמייקר עושה, זה לוקח עושה trial and error. הוא לא יודע מה זה מחשב, הוא לא יודע מה זה משתנה, הוא לא יודע מה זה 8 ביט, 16 ביט, 80 ביט. לא אכפת לו.

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

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

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

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

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

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

— 10 דקות הפסקה?

— בבקשה. בוא נחזור ב-8:28, 7 דקות?

— יאללה, תודה.

זה פועל ישיר לזה שאנחנו מתחילים לחבר בין הארדואינו, ה-C++, ה-IDEs וסביבת הפיתוח שאנחנו עובדים איתה בצורה מסורתית נקרא לזה, לבין איך אנחנו מחברים את זה ל-Node.js, ל-JavaScript.

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

— מה אתה כותב בדרך כלל?

— אני יותר טיפוס של... אני אוהב compiled strongly-typed languages.

— הארדקור.

— דווקא JavaScript מאוד פתחה את העולם הזה של ה-front end, עם כל ה-Vue, Angular, React...

— זה שינה את העולם של ה-front.

— ו-Node... על זה לא נדבר.

— Node לקח את ה-JavaScript ואמר "בוא נפתח אותו כ-back, כשרת". לפני זה היה את כל ה-C#, את כל ה-.NET-ים למיניהם, ג'אוות, דברים ארכאיים. למרות שהיום דיברתי עם מישהו שהתחיל להגיד לי ש-Rust ו-Go תופסים עכשיו מאוד חזק מאיזושהי סיבה. אני לא הצלחתי להבין למה Go, כי לא התחברתי אליה. אבל הן הולכות להחליף את C++ ו-C בהרבה מאוד אפליקציות.

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

React תפס חזק.

React, כן. הוא ספרייה בסוף של Facebook.

כשאני מנסה להסביר לאנשים שלא יודעים מה זה אינטרנט, איך Google ו-Facebook אוספים עלינו מידע, להגיד להם שהאפליקציות, האתרים, כל מה שהם חווים זה או Google או Facebook. שכבר ברמת הקוד הם יודעים מה קורה איתנו. שאתה מוריד את הפעם הראשונה את ה-React ואת ה-Angular, או Flutter, או React Native, שזה לאפליקציות, אתה כבר ברמת הקוד הם כבר עושים עליך דאטה. יודעים עליך יותר מדי. ואתה לא יכול לברוח מזה. וזה הכוח שלהם, בלייצר שפות. זה כוח אדיר.

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

[לא ברור] לא כולם, לא כולם רוצים.

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

## Firmata - סקירה והיכרות

יפה. אחר כך ניכנס לפראקטיקה. הראיתי לכם קצת ה-Firmata Wi-Fi, נצלול קצת לקוד הזה. לא נחפור בחפירי חפירות מה הוא עושה, כי הוא כתוב מאוד ב-low level. מי שזה מעניין אותו יכול לשבת ולחקור מה זה עושה שם. הוא כתוב באמת ברמה מאוד מאוד נמוכה, ברמה של C מאוד נמוכה. כאילו, מבחינת שכבות, מבחינת low level הוא רשום מאוד low.

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

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

ואם אנחנו בגרסה הבאה שלה נתמוך כבר ב-Firmata Wi-Fi, אז למעשה לא יצטרכו שום קשר בין משהו לוקאלי, בין המחשב הלוקאלי לבין ה-Arduino למעט דפדפן. כי כל הפקודות יעבדו, יקבלו אותם מאיזה שהיא ענן אל הדפדפן שלנו. איזה wizard קטן שיתרגם את הפקודות בין מה שאנחנו עושים בדפדפן שלנו ל-TCP ויתן את זה ל-Arduino. אנחנו צריכים את ה-wizard הקטן הזה תמיד שישב במחשב, כי דפדפן לא יכול ליגשת לספריות של המערכת ההפעלה. תמיד יש עם זה בעיה, שהדפדפן הוא מנותק לחלוטין מכל מה שקשור לחומרה שלנו במחשב.

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

ו-Node.js זה משהו שרץ לוקאלית על המחשב שלנו והוא יודע ניגשת לספרייה שלנו, ל-file system, ל-Windows ולספריות החשובות שלנו כדי להפעיל את ה-Arduino. והוא מה שמדבר לנו עם המיקרו-בקר. הוא מדבר לנו דרך ה-Node.js עם המיקרו-בקר בעזרת הפרוטוקול שאנחנו עכשיו לומדים עליו.

## מה זה פרוטוקול?

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

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

יש פרוטוקולים מפורסמים: HTTP זה פרוטוקול מפורסם, TCP זה פרוטוקול שאנחנו משתמשים בו ב-Firmata Wi-Fi, למי שזה רלוונטי עבורו. וסך הכל זה handshake ששני הצדדים יודעים מראש מה הם מצפים לקבל ומה הם מצפים להחזיר.

## סקירה והיסטוריה של ה-Firmata

וכחלק מזה שנולד ה-Arduino, נוצר הפרוטוקול הזה של ה-Firmata ב-2005, כדי באמת לתת את היכולת לעוד מכשירים להשתלט ולשלוט ב-Arduino הזה. ככה שבתחילת שנות ה-2000 כבר התחילו את הדבר הזה. כמו שאמרתי, פעם לא היה עננים. ב-2005 לא היה Azure ולא היה AWS כמו שיש היום על סטרואידים, או Google Cloud. זה היה ממש בחיתולים שלו ולא נפוץ, ובטח ובטח שלא היה אינטרנט של 600 מגה או לא יודע, ראיתי בזק כבר מפרסמים 5 גיגה אינטרנט. אז ב-2005 זה היה עוד מחשבים שהיינו צריכים להגיד לאמא לנתק את הטלפון כדי להתחבר לאינטרנט. דברים כאלו מוזרים.

ולאט לאט ככל שזה התקדם, אז גם התחילו להוסיף תמיכה ב-Wi-Fi וב-Bluetooth ברמת הפרוטוקול הזה, ועוד תמיכה בעוד בורדים שונים ומשונים, ולייצב אותו. בגלל שהוא יחסית מסובך, זה פרוטוקול שבאמת כתוב low level, ויש הרבה מאוד מקרי קצה שהיו צריכים לפתור אותם, הוא היה בהתחלה מאוד לא יציב, והיה מאוד קשה להשתמש בו. אז לאט לאט התחילו לשפר אותו.

## Johnny-Five

וב-2012 התחילה הספרייה שקוראים לה Johnny-Five, שזו הספרייה שאנחנו נשתמש בה המון, ש-Rick Waldron הוא המפתח הראשי בה. וזה גם כן open source שהתחילה קהילה מאוד גדולה סביב הדבר הזה, שלצערי הפסיקה לעבוד מלפני משהו כמו 3-4 שנים. ומי שיצא לו להתעסק בקוד פתוח, מאוד קשה לשמור את הגחלת הזאת של קוד פתוח ולשמור על אנשים שיתרמו מהזמן והידע שלהם כדי לתחזק קוד. אז יכול להיות שהקורונה גמרה אותם, כי מבחינת הזמנים זה איפשהו בקורונה הם הפסיקו לתמוך בספרייה הזאותי, לצערי. יש לה תמיכה דווקא ב-TypeScript ובכל מיני קונפיגורציות אחרות.

וזה פותח כחלק מ-Bocoup, זה פרויקט שרצה להנגיש את JavaScript לעולם הרובוטיקה. אנשים ראו שכל האינטרנט שלנו כתוב ב-JavaScript, זו שפה שסף הכניסה, ה-entry level אליה, הוא הרבה יותר נמוך מ-C++. אנחנו כבני אדם שואפים לדבר בצורה כמה שיותר טבעית עם המחשב. ראו את הערך של ChatGPT, שאנחנו כותבים לו כאילו חבר שלנו והוא עונה לנו תשובות אמיתיות, ואנשים ממש עם, לא יודע, אנגלית של שלוש יחידות יכולים לכתוב לו דברים והוא יבין אותם. ממש ברמה של טראמפ יכול לדבר עם מחשב ולקבל תשובות רציניות.

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

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

עוד שני דברים שזה נתן לנו: אז הקוד לא עובר קומפילציה, זה יותר דומה ל-SPI אם אתם זוכרים, שאנחנו מדלגים על ה-bootloader הזה וב-real-time שולחים את הפקודות למיקרו-מעבד, אנחנו מדלגים ישירות... אנחנו למעשה לא עוברים קומפילציה. שפות תכנות מחולקות לשניים.

שחר, זה חיסרון, לא? בכללי.

ב-production או כ-maker?

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

בוא נחלק את זה לשניים, אנחנו חצי makers, חצי מקצוענים. בסדר? כ-maker, יותר נחמד לכתוב JavaScript. ואם יש בעיה, אני אתפל בה. נכון? TypeScript לעומת duck typing, שתי אסכולות.

אין בקרה על מה שאתה כותב?

סליחה?

זאת אומרת, אין בקרה על מה שאתה כותב ב-JavaScript?

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

הבנתי.

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

הוא לא פותר בעיות של לוגיקה, הוא פותר בעיות של דקדוק.

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

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

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

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

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

אוקיי.

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

באיזה שהוא מקום, לדעתי, סתם ככה כ-maker זה מאבד את הקסם שלו.

מאבד את מה?

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

אוקיי.

בוא ניקח דוגמה לאיך אנחנו כותבים ב-Johnny-Five.

## מה בפועל קורה?

אז דבר ראשון, ספרייה שאנחנו קוראים לה מ-NPM, אנחנו נלמד על זה, שזה ה-Node Package של Node.js, וככה אנחנו מגדירים את זה. כבר בקוד שאתם הורדתם והרצתם של הפרויקט של הזרוע, אז אתם יכולים לראות את הקריאה של Johnny-Five. אני עושה לה require, אני מגדיר Board כ-class, מגדיר לאיזה COM אני מדבר, וזהו, ה-Board שלי מוכן. עשיתי איתו את האתחול, ובצורה הזאתי אני יכול ממש להשתלט עליו, וכל פעם ש... אני אפעיל את ה-server, אני אכתוב לו, מה שזה נותן לי יתרון אדיר, שאני גם לא עובר קומפילציה ברמת ה-real time, עזוב, יכול להיות שהקוד כן עובר קומפילציה, אבל ב-real time הוא לא עובר קומפילציה ואני משנה אשכרה פקודות במיקרו-מעבד, נכון?

כלומר, גם אם אני כותב TypeScript הוא עובר קומפילציה פעם אחת, את הקוד. אחרי זה, שיש לי מה שנקרא dynamic variables, משתנים שאני יכול להחליף בקוד, זה לא יעבור שוב קומפילציה. זה משהו חשוב, אתם מבינים מה אמרתי? הקוד עצמו שכתבתי עובר קומפילציה...

זה שעכשיו כתבתי את arduinostudio.com שאמרתי תיכנסו אליה והפעלתי LED, אז אני יכול להגדיר אותו בפין 11 ובפין 12. אני שיניתי מהמשתנה בארדואינו עצמו ולא צרבתי קוד ++C חדש עליו.

עשיתי את זה ב-Real Time בעזרת Dynamic Variables. הקוד עצמו, המסגרת של ה-TypeScript עברה קומפילציה, כי זו אפליקציה ב-Production, באפליקציה ששיחררנו אותה לעולם. אז כן עשינו אותה ב-TypeScript ולא ב-JavaScript, בסדר? יאדה יאדה, יפה.

## איך ה-Firmata עובד?

אז בסוף גם הפקודות האלה, אם אנחנו ניכנס למה זה Firmata, אז יש לנו את ה- בצד בקוד לדוגמה יש לכם את ה-package, את ה-node, את כל הספריות של ה-npm, נכון? כתבתם npm i, התקנתם, יש לכם node_modules, כל המודולים ש-Node משתמש בהם, זה ספריות על ספריות על ספריות... סליחה, על ספריות על ספריות על ספריות, שבסוף כל ספרייה משתמשת ב-1001 ספריות.

אז פה ניסיתי להגיע לספריית מקור של ה-Firmata עצמה, של ה-firmata.js, ואתם תראו שזה כתוב בצורה של פקודות סריאליות שממש שולטות ברג'יסטרים עצמם. זה כתוב מאוד מאוד Low Level כדי לתקשר בתקשורת כמה שיותר טובה עם המיקרו-מעבד. זה ממש פקודות של I2C ופקודות שמאוד, לנו כבני אדם, קשה כבר להבין מה עושים פה, בסדר? אבל ANALOG_MESSAGE משויך ל-`0xE0`, כי זה עושה את המאפינג לזה. זה פקודות מאוד מאוד נמוכות שקשה להבין מה הן עושות, אוקיי? DIGITAL_MESSAGE, יאדה יאדה יאדה. מי שזה מעניין אותו, יכול לצלול לזה. זה קוד שכתוב באמת ב- פרוטוקולים כתובים מאוד מאוד נמוך. באמת צריך רמת תכנות מאוד גבוהה כדי להבין מה קורה שם, כדי להבין מה קורה בפרוטוקולים.

זה לא הסינטקס שתתמודדו איתו. זה בתוך ה-node_modules, אתם רואים? יש firmata-io, והספריות שה-firmata-io משתמש בהן הן ספרייה שקוראים לה Firmata. זה עובר הרבה המרות בין אנחנו, כספירה של בני אדם, שאנחנו כותבים בסינטקס של JavaScript, עד שזה מתורגם לדבר הזה, כדי שיגיע בסוף ויעשה את ה-Handshake הזה עם ה-Firmata של... על הבורד עצמו. בסדר? ממש ברמה של לדבר איתו ברג'יסטרים, בתקשורת I2C.

## מה בפועל קורה?

וככה זה נראה בצד של ה-++C, איך נראית לנו ה-Firmata.

אוקיי, זה גם כן מאוד Low Level, מדבר איתו ב-I2C, מקבל פקודות. I2C זה תקשורת סריאלית שגם כן של 0 ו-1 שמגדירה את הדברים. ו- גם כן מאוד Low Level. להגיד לכם שאני מבין פה הכל, זה יהיה שקר. אני לא יודע באמת מה הרג'יסטר הזה מסמן, ומה זה מסמן, ומה זה מסמן. מי שמעניין אותו יכול להיכנס ל-Session של יומיים-שלושה ולחקור את זה עם ChatGPT.

אבל מה שרציתי להראות פה זה סך הכל שאנחנו מעבירים איזשהו נתון מ-Node.js ב-JavaScript ל-++C של ה-Firmata שצרוב עליו.

## IoT

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

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

## איך מתחברים לרשת?

צורות התקשורת הבסיסיות ביותר זה באמת Wi-Fi, Bluetooth, Cellular ו-LoRa למיניהם, כל ה-Low Power שיש לנו.

ראיתם את הדיון עכשיו שיש ב- גם כן בקבוצה, על Transmitter ו-Receiver, אמרו לו "תיקח LoRa". אז אנחנו יודעים מה ה-Wi-Fi וה-Bluetooth וה-Cellular, זה הבסיסיים. ה-Low Power Wide Area Networks זה באמת גלים שיודעים להתפזר לטווח יחסית יותר ארוך והם פחות אנרגטיים. הם...

- זה רדיו, נכון?

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

- כן.

זה נכון. ככל שאורך גל שלי יותר נמוך, הוא יותר אנרגטי, יותר מהיר, ואז אני צריך יותר אנטנות כדי שהוא יצליח לעבור במרחב. אם אתם תראו את הראוטר שלכם בבית, הוא בעצם דיואל בנד (Dual Band), יש לכם 2.4 ו-5. 2.4 הוא יותר איטי, אבל יש לו טווח יותר ארוך. נכון, זה GHz. וה-5 הוא יותר מהיר, אבל הטווח שלו יותר קצר. הגל יותר אנרגטי, אבל הטווח שלו יותר קצר. ככה שאם אני רוצה שיהיה לי אינטרנט יותר מהיר, אני שם יותר אנטנות, נכון? זה המאש (Mesh).

אז זה תמיד ה-Trade-off הזה. זה נכון, ככל שאנחנו נתקדם והאינטרנט יותר מהיר, יהיו לנו יותר אנטנות.

- ב-LoRa, על איזה טווח מדובר? סליחה?

LoRa, אז יש כמה LoRa. יש...

- קילומטר, לא?

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

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

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

GPS של... כל מיני מבנים סגורים, יצא לכם להיתקל בזה?

- מה?

GPS בתוך מבנה. הוא לא קולט לוויינים, הרי. הוא צריך איזשהו להתמצא במרחב.

- משתמשים בזה לצלם מבנים ולעשות מפות של מבנים ולסרטט...

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

אז יש המון המון סוגים של איך לייצר תקשורת IoT ומעבר מידע בתוך שטחים. כל אחד מה שהוא אוהב. Bluetooth יכול להיות טיפה יותר חסכוני מ-Wi-Fi. LTE, אם אתם מציצים משהו אז אין לכם Wi-Fi ואין לכם Bluetooth, אז אתם חייבים להתחבר ל-LTE או ל-3G לפחות. כל מיני שימושים כאלה.

## שימושים אפשריים

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

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

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

## Firmata WiFi

מה זה חותר? זה חותר לזה שיכול להיות שתיווצר איזושהי אפליקציה שתצטרכו Firmata WiFi.

עשיתי פה הדגמה של הזרוע הרובוטית שחיברתי אותה עם Wi-Fi. ה-USB פה רק נותן את החשמל, בסדר? ואני לא מחובר ב-USB, ואני מזיז את הפקדים. זה הממשק שאתה, עמיר, העלית אותו. ימינה, שמאלה, קצת שינו אותו. אני בזמנו זה היה הראשון, אחרי זה מישהו הוסיף לזה header, בחור בשם עילאי מהקהילה הוסיף לזה header. וזה עובד נחמד.

איך זה עובד? עם Transmission Control Protocol. יש עוד פרוטוקול שב-Node.js שלנו אנחנו עושים איזושהי המרה, במקום להעביר את זה ב-COM, ב-Serial Command, בפקודות סריאליות, אנחנו מעבירים את זה ב-TCP, ספרייה של JavaScript שאנחנו קוראים לה ועושה את ההמרה הזאתי.

בצד של ה-Node זה יחסית פשוט. בצד של ה-Firmata אנחנו כבר ניגע בזה.

## ArduinoJS

אבל ככה בואו נעשה סיכום של כל מה שאנחנו הולכים ללמוד. למעשה את החלק של ה-Hardware של הארדואינו ושל ה-Firmata, אנחנו יכולים לעשות על זה V, נכון? אנחנו יודעים כבר מה זה ארדואינו, אנחנו יודעים מה זה הפינים הדיגיטליים שלו, הפינים האנלוגיים שלו, אנחנו יודעים מה זה המתח שיש לו, 3.3 ו-5V, אנחנו יודעים שה-Grounds שלו מקוצרים גם פה וגם פה, מקוצרים לאותו דבר, כי מתח זה דבר יחסי, אנחנו יודעים שזה לא מכשיר שיודע להעביר זרמים, אז אנחנו צריכים לחבר מקור זרם חיצוני. אנחנו יודעים שזה UART שמעביר לי פקודות של 0 ו-1 לזיכרון Flash שיושב פה, זיכרון מאוד מאוד מהיר, זה ה-SPI שאנחנו יכולים לדבר בלי bootloader, ישירות עם המיקרו-מעבד ב-0 ו-1, TX, RX, וגם כן להעביר פקודות סריאליות. למדנו את זה די טוב, וזה משהו שאנחנו כבר מכירים אותו.

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

וכדי לפתוח פה, זה משהו שאנחנו נתחיל ללמוד אותו עם יואב, אנחנו ניפתח Socket. Socket זה Real-Time Communication, Real-Time, שמעביר לנו פקודות בין ה-Front ל-Back.

ככה אנחנו יכולים... יש לנו פה איזשהו חיישן טמפרטורה שמודד לי עכשיו... אני קצת חם לי, אז בערך יש בחדר הזה 26 מעלות צלזיוס. יש לי ממיר Analog-to-Digital Converter שמזהה את זה לפי הטווח שלו, הוא יודע להגיד שזה 500 בין 0 ל-1023, אז אני בערך 500. כי נגיד המקסימום של החיישן הזה שהוא מכויל אליו זה נגיד 50 מעלות, אנחנו בערך באמצע. הוא מעביר את זה לפה, הוא מדבר עם הפרוטוקול הזה, אני קורא אותו ב-Node בעזרת ספריות של Johnny-Five, ואני יכול להציג אותו פה ב-Front שלי: 26 מעלות צלזיוס.

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

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

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

אז ב-2009 לקחו את השפה המדהימה הזאת של ה-Front, ואמרו: "בואו נעשה אותה גם כן לא בדפדפן". יש המון שיטות לכתוב דפדפנים, יש ספרייה ב-Python שקוראים לה Python Flask, שאפשר לכתוב איתה Back, C#, .NET, כל מיני דברים. הוא אמר: "אני רוצה את זה ב-JavaScript, JavaScript זו השפה שאני הכי אוהב, נעשה את זה ב-JavaScript". וב-2009 הוא לקח את מנוע V8 של הדפדפן והפך אותו ללוקאלי על המחשב.

יש לזה המון יתרונות.

היא יכולה לרוץ ישירות על מערכת ההפעלה. אנחנו ניגשים ל-file system, מה שהדפדפן עצמו לא יכול.

וה-NPM, ה-Node Package Manager, זה מה שנותן לנו לקרוא לכל הספריות, וזה קסם. יש אינסוף ספריות ל-Node.js שעושות הכול, ש-C++ היה מדמיין שהוא יכול לעשות חלק מהדברים האלה.

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

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

- אני חושב שבקורונה היה מיזם כזה.

- היד עוברת ככה... נפתחת היד...

- עוד חמישה שקלים, עוד חמישה שקלים.

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

- מה אמרת? שיש מיזם כזה?

- בקורונה עשו כזה.

- כן, מישהו בקהילה, אז הוא שיתף את זה. זה היה מאוד יפה.

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

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

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

- קופרמן מלא באבק. רק מהאבק מהשטיח אי אפשר להגיע לזה.

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

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

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

כדי לעשות פעולות, אז לא דווקא הייתי כותב את זה ב-Node.js בצורה הזאתי. כי אם אני רוצה להיות מאוד מאוד יעיל, לכל ההמראות, הייתי כותב את זה ב-C לצורך העניין, או ב-C++. תלוי למה אני צריך. בדרך כלל רוב האפליקציות שלנו, שאנחנו מדברים על millisecond, Arduino JS מצוין. millisecond זה אלפית השנייה. אם אתם צריכים אפליקציות של microsecond, אז ארדואינו באופן כללי לא ישמש אתכם לדבר הזה. אתם תצטרכו כנראה מיקרו-מעבדים יותר חזקים, ואז הם ייכתבו כנראה ישירות ב-C++ כדי לעבד את המידע הזה מאוד מאוד מהר. אבל רוב האפליקציות של בני אנוש, אנחנו לא מגיעים לנקודות קצה האלה. מי שסופר מיליוניות השנייה, זה דברים קיצוניים.

- שאלה לגבי ה-JavaScript: זה לא תופס הרבה יותר זיכרון מ-C++?

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

## סקירת הסילבוס

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

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

אז יש לנו למעשה... מה זה, ברח פה? מוזר. הנה הוא חזר.

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

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

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

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

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

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

פה אנחנו ב-16.6. תמיד כשאתם לא יודעים מה אנחנו הולכים לעשות, תיכנסו פה ל-arduinojs.com/course ותגיעו לסילבוס.

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

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

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

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

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

ובסוף יש הרצאה שהיא מאוד מעניינת וחשובה, על Git, GitHub ו-Open Source. איך אתם עכשיו רוצים לעבוד, שוקי ושחר, אחד בגבעת עדה ואחד בגבעתיים, איך אתם רוצים לעבוד על אותו קוד ביחד בלי לדרוס אחד לשני גרסאות, אם נשפך לכם לא יודע, קפה על המחשב, אז איך הקוד שלכם נשמר באיזה ענן כלשהו ולא הולך לכם לאיבוד.

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

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

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

ונקבל תעודות וניזרוק את הכובעים באוויר.

זה הקורס שיש לנו, וב-real-time, אם אתם צריכים משהו, גם בקבוצה, תרגישו חופשי לשתף אותי.

- מעולה.

- טוב, תודה רבה, שחר.

- תודה רבה.

- בכיף.

- ביי ביי, להתראות.

- ביי ביי.