עבודה עם VSCode+PlatformIO

מבוא

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

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

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

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

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

במדריך זה נראה איך מתקינים PlatformIO בתוך VSCode. נוסיף כמה פרוייקטים לכרטיס Arduino, נוסיף ספריות ונראה לכם איך עובדים עם זה.

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

מה זה VSCode?

ה-VSCode הוא למעשה תוכנת ה-Visual Studio הפופולרי והידוע מבית Microsoft. הם שחררו את הקוד של התוכנה והפכו אותה לנפוצה מאוד בכל מערכות ההפעלה.

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

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

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

מבחינתינו, VSCode הוא ה-עורך עבור הכל חוץ מקבצי Word.

• קוד HTML או CSS? יש.
• צריכים להכין הסבר ארוך לספריה שאתם מעלים ל-GitHub וצריך לכתוב את זה עם סימני Markdown? יש.
• צריכים לראות את המבנה של הודעה בפורמט JSON? אין שום בעיה.
• מסמך XML בצורה מסודרת? כמובן.
• פקודת SQL ארוכה לא מסתדרת לכם בעין? תעתיקו אותה לחלון חדש ב-VSCode, תעשו Format document ותהנו מהסדר.
• רוצים לראות קובץ בינארי בתצורת HEX? יש תוספים גם לזה.
• יש לכם מסמך בפורמט שלא קיים ב-VSCode? יותר מבטוח שמישהו כבר הוסיף את התמיכה בתור תוסף, או שגם אתם יכולים לעשות את זה.

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

מה זה PlatformIO?

PlatformIO הוא תוסף לסביבת ה-VSCode לפיתוח עבור מערכות Embedded שונות. התוסף מפותח ע"י צוות אוקראיני וכולו Open Source.

ארדואינו היא רק פלטפורמת Embedded אחת מרבות אחרות ש-PlatformIO תומך בהן.

בדומה לסביבת Arduino IDE, גם ל-PlatformIO יש כפתורי קומפילציה "V" וצריבה לכרטיס "<-". יש לו גם מערכת Debug פנימית לכרטיסים שמאפשרים זאת, תמיכה במגוון צורבים חיצוניים, Serial Monitor וכלים נוספים שתזדקקו להם מבהלך הפיתוח.
העבודה עם PlatformIO מאוד דומה לוגית ל-Arduino IDE.

למעשה, גם PlatformIO וגם Arduino IDE מייצרים ברקע קבצי Makefile עבור כלים נוספים כמו הקומפיילר והלינקר (שלבים בתהליך ההידור - "תרגום" של התוכנית שכתבתם לשפה שמעבדים ומיקרובקרים מבינים).
השוני העיקרי ביניהם הוא ש-Arduino IDE מחביא כמעט את הכל בלי שאפשר לשלוט על התהליך, כאשר PlatformIO משאיר לכם את האפשרות לשלוט על תהליך ההידור, אם צריך, מה שמקל לייצר פרוייקטים גדולים ומשוכללים יותר מאשר הבהוב לד (Blink).

התקנה של VSCode

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

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


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

התקנה של PlatformIO

ההתקנה של תוסף ה-PlatformIO מתבצעת מתוך ה-VSCode עצמו.

עקבו אחר השלבים הבאים מתוך המסך הראשי של VSCode:

1. לחצו על כפתור התוספים (Extensions) בצידו השמאלי של המסך. הכפתור נראה כמו 4 קוביות, עם קוביה ימנית עליונה מנותקת משלושת האחרות.
2. כתבו בשדה החיפוש "PlatformIO IDE".
3. בחרו את הרשומה של "PlatformIO IDE" מרשימת התוספים שתופיע לכם. רוב הסיכויים שהרשומה הזו תהיה הראשונה ברשימה.
4. לחצו על כפתור ה-"Install" בחלון הימני שיפתח לכם. כפתור זה מופיע גם ברשומה עצמה שבחרנו בסעיף הקודם, שני הכפתורים עושים את אותה הפעולה.
5. תשאירו את השדה "Auto Update" בחלון הימני מסומן, כך שלא תצטרכו להתעסק עם העדכונים בעתיד. תוסף זה מתעדכן די הרבה.

אם אתם במערכת הפעלה חלונות, התוכנה תשאל אם אתם סומכים על מפיץ התוסף הזה. לחצו על "Trust Publisher & Install" כדי להמשיך.

הכפתור "Install" ישתנה ל-"Installing" במהלך ההתקנה. חכו כמה דקות להשלמה… תוך כדי יופיעו הודעות שונות של התוסף וגם סרגל המראה את ההתקדמות בחלקו הימני התחתון של המסך. ההודעות האחרונה שתופיע שם היא שההתקנה הסתיימה, ושצריך להפעיל מחדש את ה-VSCode.


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

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

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

עקבו אחר השלבים הבאים:

1. לחצו על הכפתור עם ראש חייזר בצידו השמאלי של המסך.
2. בחרו באפשרות של "PIO Home" -> "Platforms" ברשימה שתופיע.
3. בחרו בלשונית "Frameworks".
4. כתבו "Arduino" בשדה החיפוש.

רשימת סביבות הקומפילציה תצטמצם ותראה רק את סביבת ה-Arduino עם פלטפורמות חומרה הנתמכות ע"י PlatformIO:


לחצו על כל אחת מהפלטפורמות הבאות כדי להתקין אותן אחת אחרי השניה:

• Atmel AVR - תמיכה בכרטיסי ארדואינו הקלאסיים, המבוססים על מיקרובקר 8bit כמו ה-ATMega328 הפופולרי או ATMega32u, המורכבים בכרטיסים מדגמים כמו UNO, Mega, Nano, Micro, Mini, Pro ו-Pro Mini וכרטיסים רבים אחרים.
• Atmel SAM - דור ה-32bit של מיקרובקרים של Atmel (או MicroChip היום), כמו ה-SAMD21, ואח הגדול שלו ה-SAMD51, שמורכבים בכרטיסי Zero, Due, M0, משפחת כרטיסי MKR וכרטיסים אחרים.
• Atmel megaAVR - תמיכה במיקרובקר ATMega4809 המורכב על הכרטיסים החדשים כמו ה-Nano Every, Uno WiFi Rev2 ואחרים.
• Espressif 32 - משפחת ה-ESP32 הפופולרית, מגוון רחב של מיקרובקרים עם פונקציונליות מגוונת, כולל תמיכה בתקשורת WiFi ולרוב גם Bluetooth.
• Espressif 8266 - משפחת ה-ESP8266 המבוססת על בקר 8bit הנפוץ בכרטיסי פיתוח זולים כמו ה-WeMos ו-NodeMCU.
• Teensy - משפחת כרטיסי Teensy עם יכולות עיבוד מהטובות שאפשר למצוא.

תוכלו להתקין סביבות נוספות אם יש לכם צורך.

כך נראה מסך ההתקנה עבור פלטפורמה Atmel SAM:


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

יצירת פרוייקט

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

פרוייקטים ב-VSCode נקראים Folders (תיקיות). משהו כללי כדי שיתאים לכל הסביבות שאפשר להריץ בתוך התוכנה.

את הפרוייקט מייצרים מתוך העמוד הראשי של PlatformIO.
בצעו את השלבים הבאים:

1. לחצו על הכפתור עם ראש חייזר בצידו השמאלי של המסך.
2. לחצו על הכפתור "Create New Project" בצידו השמאלי של המסך.
3. בחלון הימני יופיע מסך PIO Home, שם תלחצו על הכפתור "New Project".

יפתח חלון "Project Wizard" בו אתם צריכים למלא את שם הפרוייקט בשדה "Name" (שיהיה גם שם התיקיה).



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

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

בשדה "Location" אפשר לציין איפה הפרוייקט ישמר. ה-"v" מציין שהפרוייקט ישמר במיקום ברירת המחדל של הסביבה. בחלונות זה יהיה ב:
Home directory -> Documents -> PlatformIO -> Projects

לחיצה על הכפתור "Finish" במקרה שלנו תייצר את הפרוייקט בשם Blink עבור כרטיס Arduino UNO במיקום ברירת המחדל.

אם אתם במערכת הפעלה חלונות, כנראה שיפתח לכם חלון עם שאלה האם אתם סומכים על יוצר ספריית Projects. לחצו על הכפתור "Yes, I trust the authors" כדי להמשיך.

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

מבנה התיקיות

קבצים ותיקיות חבויות

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

תיקיית test

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

תיקיית lib

תיקיית lib נועדה לספריות הפרטיות שלכם שקשורות לפרוייקט זה. לא מדובר על ספריות שכנראה יצא לכם להתקין ב-Arduino IDE דרך תפריט "Manage libraries…", אלא ספריות שאתם כותבים בעצמכם עבור הפרוייקט הספציפי הזה, או משתמשים בקוד של מישהו שהעתקתם למחשב שלכם.

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

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

גם ב-PlatformIO יש מנהל ספריות. נסביר גם עליו בהמשך.

נוסיף רק שעם הגדרות מסוימות ב-platformio.ini אפשר לקבל מצב עבודה דומה ל-Arduino IDE, בו הספריות יהיו גלובליות לכל הפרוייקטים. הסביבה מאפשרת גמישות רבה בתהליך הקומפילציה, כך שהכל אפשרי.

תיקיית include

תיקיית include נועדה לקבצי הגדרות של פונקציות. קבצים אלה בדרך כלל יהיו עם סיומת h. או hpp. ה-"h" מציין שמדובר בקובץ Header - כותרת. אלה הקבצים שאתם עושים להם include# מתוך הקוד שלכם.
זה משהו שלא כל כך משתמשים בו בפרוייקטים שמפותחים ב-Arduino IDE, כי כל הפרוייקטים בדרך כלל קטנים וכל הקוד נמצא בקובץ אחד. ה-include# שאתם בדרך כלל עושים הם לספריות והדוגמאות שאתם מוצאים באינטרנט בדרך כלל לא מעודדות חלוקה לוגית של הקוד למודולים. החלוקה מוסיפה המון סדר בפרוייקטים גדולים, מאפשרת עבודת צוות קלה יותר, ומספקת גמישות רבה להחליף בין רכיבי חומרה או חלקים לוגיים שונים של הפרוייקט.

במקרה של הדוגמה שלנו לפרוייקט התחלתי של Blink, כל הקוד נמצא בקובץ אחד, כך שלא יהיו לנו קבצי h.

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

תיקיית src

תיקיית src הוא המקום לקוד שאנו כותבים. זהו קיצור של Source - המקור. בתיקיה זו יהיו קבצים עם סיומת cpp. שמציינת שזהו קובץ עם קוד C-Plus-Plus (++C). זוהי הסיומת המקובלת לקבצים אלה ולא ino. כמו שזה ב-Arduino IDE.

בתיקיה זו נמצא את הקובץ main.c, שזהו הקובץ שממנו מתחילה להתבצע כל תוכנית שנכתבה בשפת C/C++. אם נדייק יותר, הביצוע בדרך כלל מתחיל מפונקציית ()main שאמורה להיות בקובץ זה, אבל כמו הרבה דברים אחרים, ב-Arduino החליטו "לפשט" ולהחביא כמה דברים מהמשתמש. פונקציית ()main היא בין הדברים החבויים. למשתמשים נתנו את הפונקציות ()setup ו-()loop.

קובץ ה-main.cpp שקיבלנו לאחר יצירת הפרוייקט כולל את הפונקציות ()setup וה-()loop כדי להזכיר את המבנה של הקוד וגם עוד פונקציה ()myFunction בתור דוגמה.

אנחנו נמחק את הקוד שקיבלנו ב-main.cpp ונחליף אותו בקוד מדוגמת ה-Blink שצוות הארדואינו מספק.

שימו לב לשורת ה-include# הראשונה ב-main.cpp שנוצר לנו:

קוד: בחר הכל

#include <Arduino.h>

שורה זו לא מופיעה בקוד הדוגמה של צוות ארדואינו. זה עוד משהו שהחביאו בסביבת Arduino IDE. למעשה, ברקע הם מוסיפים שורה זו לכל קובץ שהסביבה מקמפלת (מהדרת). סביבת PlatformIO זקוקה לשורה זו כדי שתוכלו להשתמש בפונקציונליות שכולנו רגילים לראות בכרטיסי ארדואינו. תשאירו את שורת ה-include# הזו ואחריה תוסיפו את קוד ה-Blink, כך שנקבל את הקוד הבא:

קוד: בחר הכל

#include <Arduino.h>

// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);  // turn the LED on (HIGH is the voltage level)
  delay(1000);                      // wait for a second
  digitalWrite(LED_BUILTIN, LOW);   // turn the LED off by making the voltage LOW
  delay(1000);                      // wait for a second
}

כפתורי פעולה

קומפילציה (הידור)

כדי לקמפל (להדר) את הקוד לוחצים על כפתור ה-"V" בחלקו השמאלי התחתון של המסך:


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


אם משהו משתבש, תראו הודעת [FAILED] אדומה עם פירוט הבעיה בהודעות שמעל. כך זה יראה אם אתם מנסים לקמפל בלי שורת ה-include# הראשונה:

צריבה

המשך העבודה די דומה ל-Arduino IDE. כותבים את הקוד בקובץ main.cpp (או קבצים נוספים אם זה פרוייקט קצת יותר גדול מהבהוב לד), מקמפלים עם הכפתור "V" וצורבים את הכרטיס ע"י לחיצה על הכפתור "<-" הנמצא מימין לכפתור "V" בתחתית המסך.

Serial Monitor

כפתור שימושי נוסף הוא כפתור התקע, שפותח חלון של מה שאנחנו רגילים אליו כ-Serial Monitor בסביבת Arduino IDE.

בחירת חיבור

המערכת מנסה לזהות את החיבור לכרטיס בצורה אוטומטית, אבל לא תמיד זה מצליח (לא בגלל הסביבה, אלא בגלל שלפעמים הכרטיס מתנתק ומתחבר בצורה מהירה ומערכת ההפעלה מחליפה שמות לחיבור, בחלונות זה נקרא כ-COM port). אם הצריבה או ה-Serial Monitor לא עובדים לכם, נסו לבחור את החיבור בצורה ידנית ע"י לחיצה על כפתור התקע עם הכיתוב Auto:


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

כפתורים נוספים

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


כפתור המבחנה - יריץ את תוכניות הבדיקה מספריית ה-test


כפתור הטרמינל - יפתח חלונית טרמינל (Command line) להרצת פקודות טקסט שקשורות לפרוייקט (למתקדמים).


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


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

נסו לקשקש משהו לא תקין בחלון של הקוד (ב-main.cpp). לא צריך אפילו לשמור את הקובץ ואחרי שניה תראו שהמספרים התעדכנו והמיקום בעייתי סומן על המסך.

Minimap

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

גם ה-Minimap יראה לכם את מיקום הבעיות בקובץ (Error באדום ו-Warning בצהוב), וגם מיקום המחרוזות שתחפשו בקובץ ע"י לחיצה על Ctrl+F (בצבע חום).


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

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

השלמות אוטומטיות

יש עוד הרבה מאוד מנגנונים שימושיים שמייעלים את תהליך הפיתוח בסדרי גודל בהשוואה לעבודה עם Arduino IDE. נסו את השלמת שמות הפונקציות למשל (תתחילו לכתוב שם פונקציה קיימת ותלחצו על Ctrl+Space), או הצגת פרמטרים של הפונקציה (כתבו את השם של הפונקציה עם סוגר פתיחה, הפרמטרים יופיעו לבד. ואם לא, תלחצו על Ctrl+Shift+Space).

ספריות

כדי להדגים הוספת ספריות לפרוייקט, נסגור את פרוייקט ה-Blink שיצרנו קודם (תפריט הראשי File -> Close Folder), ונייצר פרוייקט חדש בשם Sweep, שיתבסס על דוגמה קוד להפעלת מנוע סרוו. דוגמה זו משתמשת בספריית Servo שנצטרך להוסיף לפרוייקט.

תהליך יצירת הפרוייקט זהה למה שהוסבר מקודם.

תחליפו את התוכן של קובץ main.cpp בקוד מדוגמת Sweep של צוות ארדואינו, תשאירו את ה-<include <Arduino.h# בשורה הראשונה, כך שנקבל את הקוד הבא:

קוד: בחר הכל

#include <Arduino.h>
#include <Servo.h>

Servo myservo;  // create servo object to control a servo
// twelve servo objects can be created on most boards

int pos = 0;    // variable to store the servo position

void setup() {
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object
}

void loop() {
  for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
    // in steps of 1 degree
    myservo.write(pos);              // tell servo to go to position in variable 'pos'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
  for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
    myservo.write(pos);              // tell servo to go to position in variable 'pos'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
}

נסו לקמפל. הקומפילציה תכשל מכיוון שהמערכת לא מוצאת את הקובץ Servo.h אותו צירפנו לפרוייקט בשורת include# השניה בקוד.

קוד: בחר הכל

src\main.cpp:2:10: fatal error: Servo.h: No such file or directory

זה היה צפוי, מכיוון שקובץ זה והמימוש של הפעלת מנועי סרוו נמצאים בספריית Servo.
ב-Arduino IDE היינו מוסיפים את הספריה דרך התפריט "Manage libraries…", ב-PlatformIO התהליך מאוד דומה:

בצעו את השלבים הבאים:

1. לחצו על הכפתור עם ראש חייזר בצידו השמאלי של המסך.
2. בחרו באפשרות של "Libraries" מהרשימה של פעולות.
3. החלון הימני יציג מנגנון חיפוש בין הספריות הקיימות. כתבו את שם הספריה הרצויה בשדה החיפוש, במקרה שלנו "Servo", ולחצו על זכוכית המגדלת או מקש Enter כדי לבצע את החיפוש.
4. הרשימה תצטמצם לספריות המתאימות לחיפוש. במקרה שלנו אנחנו צריכים את את הרשומה השניה ברשימה, שנקראת "Servo" בלי תוספות. מצד ימין של הרשומה אתם יכולים לראות שהיא מתאימה לסביבת העבודה שלנו - Arduino. לחצו על השם הכחול של הספריה כדי לעבור לשלב הבא.

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



בחרו את הגרסה הרצויה, או השאירו את הגרסה האחרונה כברירת מחדל ולחצו על הכפתור "Add to Project".

החלון ישתנה למסך "Add project dependency", בו PlatformIO יראה לכם את פרטי הספריה שבחרנו
(במקרה שלנו "arduino-libraries/Servo@^1.2.2") ובשדה השני יבקש לבחור את הפרוייקט אליו צריך להוסיף את הספריה.


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

בלחיצה על השדה השני תפתח רשימה עם כל הפרוייקטים ש-PlatformIO הצליח למצוא בתיקיית ה-Projects. בחרו בשדה זה את הפרוייקט השני שיצרנו במדריך זה, הוא יופיע כ-"Projects\Sweep". ולחצו על הכפתור "Add" כדי להמשיך.

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

קוד: בחר הכל

lib_deps = arduino-libraries/Servo@^1.2.2

עכשיו אפשר לקמפל את הפרוייקט ולראות את הודעת ה-"[SUCCESS]" הירוקה.

כל התהליך של הוספת ספריה הוא למעשה אשף (Wizard) שעוזר לכם למצוא את הספריה הרצויה. אם הייתם יודעים את השם והגרסה המדוייקים של הספריה, הייתם יכולים להוסיף שורה זו לתוך הקובץ platformio.ini ידנית.

את הספריות והוראות התקנה שלהן בצורה ידנית אפשר למצוא גם ברשימת הספריות באתר PlatformIO. החיפוש שם לא בהכרח יותר קל מכיוון שהמערכת מציגה גם את הספריות, פלטפורמות שנתמכות, וכלים נוספים. ניסיתי למצוא שם את ספריית ה-Servo כדוגמה, וגם עם סינון הצגה רק של ספריות ורק של סביבת Arduino עדיין קיבלתי מעל 250 רשומות וה-Servo לא הופיע בעמודים הראשונים של הרשימה. חיפוש של "Servo arduino-libraries" צמצם את הרשימה ל-4 תוצאות בלבד, אבל זה רק בגלל שאני כבר יודע את השם המלא של הספריה, מה שלא קורה במצב רגיל.

וזה מוביל אותנו לנושא המתקדם ביותר של המדריך…

קובץ הגדרות platformio.ini

קובץ ה-platformio.ini קיים בכל פרוייקט שנוצר בתוך הסביבה של PlatformIO ומכיל את כל ההגדרות הדרושות לפרוייקט שמשנות את התנהגות ברירת המחדל (defaults).

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

אתם יכולים לנסות לשנות את הגרסה של הספריה מ-1.2.2 ל-1.2.0 למשל ולשמור את הקובץ. מייד תראו שהסביבה טוענת ומעדכנת משהו.

קובץ ההגדרות platformio.ini הוא רב עוצמה ורצוי להתייחס אליו בזהירות. זה כלי שלא קיים ב-Arduino IDE, והוא למעשה מאפשר לכם לשלוט כמעט על הכל. על תהליך הקומפילציה, איזה כרטיס בשימוש, איזה קומפיילר אמור לעבוד והאם בכלל מדובר על סביבת Arduino…

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

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

ל-platformio.ini יש המון הגדרות ולא נוכל לעבור על כולן במדריך זה. תוכלו לראות את כולן בתיעוד באתר של PlatformIO.

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

ספריות

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

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

קוד: בחר הכל

lib_deps =
    arduino-libraries/Servo@^1.2.2
    Wire
    SPI

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

קוד: בחר הכל

lib_deps =
;    arduino-libraries/Servo@^1.2.2
    symlink:://../MyServo
    Wire
    SPI

שימו לב ל-; (נקודה-פסיק) בשורה של ספריית ה-Servo של סביבת ארדואינו. תו זה מבטל את כל מה שמופיע אחריו. כמו ה-// בשפת C/C++. במקרה הזה השארתי את ההגדרה של ספריית Servo למקרה שצריך יהיה לחזור אליה בעתיד והוספתי הגדרה של ספריית MyServo בצורה של קישור (symlink) למיקום מחוץ לפרוייקט.

דגלי קומפילציה

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

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

כדי להגדיר דגל קומפילציה משתמשים בפרמטר build_flags עם צורת כתיבה דומה ל-lib_deps. לדוגמה, אם אתם רוצים להגדיר דגל DEBUG_PRINTS, וגם FAST_EXECUTION_TEST, תוסיפו שורות אלה ל-platformio.ini:

קוד: בחר הכל

build_flags =
    -D DEBUG_PRINTS
    -D FAST_EXECUTION_TEST

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

כדי להשתמש בדגלים אלה בקוד שלכם, תוסיפו בלוק של ifdef# ו-endif# סביב קטעי הקוד הרלוונטיים:

קוד: בחר הכל

#ifdef DEBUG_PRINTS
    Serial.println("This is my debug print.");
#endif

#ifdef FAST_EXECUTION_TEST
    result = param >> 3;
#else
    result = param / 8;
#endif

הגדרות Serial Monitor

כמו שראינו קודם, לסביבת PlatformIO יש Serial Monitor ולפעמים צריך לשנות את ההגדרות שלו, כמו מהירות התקשורת, האם לשלוח את השורה שהקלדתם כשלוחצים Enter או רק להוסיף תו המציין שורה חדשה למחרוזת. האם ציון של שורה חדשה הוא רק תו 13? או אולי 13 ו-10? האם להדפיס על המסך את מה שאתם מקלידים, או רק את מה שמתקבל מהכרטיס (הגדרת echo)?

כל זה אפשר להגדיר ב-platformio.ini ע"י פרמטרים הבאים:

קוד: בחר הכל

monitor_speed = 9600
monitor_eol = CRLF
monitor_filters = send_on_enter
monitor_echo = yes

יש עוד כמה פרמטרים לשינוי הגדרות ה-Monitor, אבל אלה כנראה הכי שימושיים.

רשימה מלאה של הפרמטרים שאפשר להגדיר ב-platformio.ini, כולל דוגמאות, תוכלו למצוא כאן.

סיכום

לסיכום, סביבת ה-VSCode+PlatformIO מספקת חווית פיתוח מקצועית ויעילה בהרבה בהשוואה ל-Arduino IDE.
למעשה, גרסאות Arduino IDE החל מ-2.0 מבוססות על מערכת VSCode מופשטת כדי לספק חווית פיתוח עכשוית יותר, עם השלמת שמות הפונקציות וכדומה. אבל עדיין, יש הרבה דברים חבויים ומושבטים כדי לפשט את העבודה למשתמש מתחיל, מה שיפריע לכם בפרוייקטים גדולים יותר.

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