פיתוח יעיל של ג'אווה ל- Raspberry Pi: 11 שלבים (עם תמונות)

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:12

הוראה זו מתארת גישה יעילה מאוד לפיתוח תוכניות ג'אווה עבור ה- Raspberry Pi. השתמשתי בגישה לפיתוח יכולות Java, החל מתמיכה במכשירים ברמה נמוכה וכלה בתוכניות מרובות נושאים ורשתות. הגישה היא לא רק יעילה, היא בחינם!

ביסודו של דבר, הגישה היא פיתוח מרחוק באמצעות NetBeans. NetBeans פועל בתחנת עבודה (מחשב נייח או מחשב נייד, לא ה- Raspberry Pi) המחובר באמצעות Wifi ל- Raspberry Pi. לאחר שהכל יוגדר כראוי, תוכל לכתוב תוכנית Java ב- NetBeans ולאחר מכן לחיצה אחת אוספת ובונה את התוכנית בתחנת העבודה, מורידה את התוכנית ל- Pi, מריצה את התוכנית ב- Pi ומספקת פלט למסוף NetBeans.. קֶסֶם! אתה יכול אפילו לאתר באגים בתוכנית הריצה, להגדיר נקודות שבירה ולבחון ערכים משתנים. עוד קסם!

שאר מבוא זה מתאר את המוטיבציה לשימוש ב- Java ולפיתוח מרחוק באמצעות NetBeans. אם אכפת לך ממוטיבציה, המשך לקרוא. אם לא אכפת לך, עבור לשלב 1.

למה להשתמש ב- Java ב- Raspberry Pi?

ישנן שפות תכנות רבות עבור ה- Raspberry Pi, אך אני אגביל את הדיון לשפות תכנות "ברמה מקצועית" המכוונות לתוכניות עצמאיות, תומכות במשימות מרובות, מאפשרות גישה לחומרה ורשת וכו '. כלומר Java, Python או C/C ++. המהדורות האחרונות של Raspbian כוללות פיתוח ותמיכה בזמן ריצה לכל השפות הללו.

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

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

השורה התחתונה: Java מהיר יותר מפייתון. ג'אווה בטוח יותר מ- C.

האם יש מגבלות בעת שימוש ב- Java?

עד כה הצלחתי לעשות כל מה שאני יכול לעשות ב- Java בפייתון. יש דברים שאפשר לעשות ב- C שאי אפשר לעשות בג'אווה, אבל שוב, עד כה טופל כל מה שרציתי לעשות על ידי אוהדי ג'אווה בקהילת הפי. אביא דוגמה בשלב מאוחר יותר. עם זאת, רכשתי חיישנים מספקים שסיפקו "מנהלי התקנים" לחיישנים רק בפייתון (או C/C ++ עבור הארדואינו), ולכן נאלצתי לכתוב את המקבילה ל- Java; המאמץ הנוסף אינו בהכרח פרודוקטיבי, אך יכול להביא לתובנה רבה יותר לגבי פעולת החיישן.

מדוע פיתוח מרחוק המבוסס על NetBeans?

גיליתי שפיתוח מרחוק מבוסס NetBeans מגביר מאוד את הפרודוקטיביות בעת שימוש ב- Java עבור ה- Raspberry Pi. אני בטוח שאתה יכול להשתמש בגישה ליצירת תוכניות מהירות ובטוחות, בשל המאפיינים הגלומים של ג'אווה, תוך כתיבה, בנייה וניפוי באגים בהן הרבה יותר מהר מאשר גישות אחרות שמצאתי, עקב פיתוח מרחוק באמצעות "איש המקצוע" כיתה "סביבת הפיתוח המשולבת של NetBeans (IDE).

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

שרת VNC הכלול ב- Raspbian מספק ממשק משתמש גרפי מרוחק (GUI) המאפשר צורה של פיתוח מרחוק, כאשר רק ה- GUI המרוחק פועל על תחנת העבודה וכל השאר, כתיבה, הידור ובנייה, מתרחש ב- Pi. עם VNC קל להשתמש בכלי הפיתוח התומכים ב- Java המגיעים ב- Raspbian, כמו BlueJ, Geany ו- Greenfoot. חלק מאלה יכולים להיחשב IDE; עם זאת, אני מוצא אותם רחוקים מהציון המקצועי.

אפשר מבחינה טכנית להתקין Java IDE ברמה מקצועית כמו Eclipse או NetBeans ב- Raspberry Pi ולהשתמש בו מרחוק באמצעות VNC. דיווחים והיגיון בריא מצביעים על כך שהתוצאות יהיו מאכזבות, בשל טביעת הרגל הזיכרון הגדולה והעוצמה של מעבדים כאלה, כמו גם השהיית רשת שהציגה ממשק משתמש מרוחק.

הן Eclipse והן NetBeans פועלות היטב בתחנת עבודה. עם Eclipse, כתיבת קוד היא חוויה נעימה, אולם בניית התוכנית אינה; הורדת התוכנית חייבת להתבצע מחוץ ל- Eclipse; ביצוע התוכנית ב- Pi אינו תלוי לחלוטין ב- Eclipse. התוצאה הכוללת היא תהליך רב שלבי, כמעט כואב, שאינו יכול לתמוך באיתור באגים מרחוק. ל- NetBeans יש הידור מובנה, בנייה, הורדה, ביצוע מרחוק וניפוי באגים מרחוק, מה שהופך אותו לגישה מעולה.

שלב 1: הגדר את ה- Raspberry Pi

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

הוראה זו מניחה אותך

• התקן את ה- Raspbian העדכני ביותר; הקפד לרשום את מזהה המשתמש והסיסמה של Pi
• הגדר Wifi והתחבר לנתב שלך (ראה זאת); הקפד לרשום את כתובת ה- IP של ה- Pi
• אפשר SSH (ראה זאת) כדי לאפשר גישה מרחוק ל- Pi מתחנת העבודה

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

כדי לבדוק, פתח לקוח ssh בתחנת העבודה שלך, למשל, מסוף ב- MacOS או מרק ב- Windows. לאחר מכן הזן את הפקודה ssh (מעטפת מאובטחת) עם הטופס הבא:

ssh the_pi_ip_address -l the_pi_user_id

אתה אמור לקבל הודעה להזין את סיסמת מזהה המשתמש שלך ב- Pi. אם לא מופיעה הודעה, ודא שהזנת את כתובת ה- IP הנכונה בפקודה ssh. הזן את הסיסמה שלך (היא תהיה מוסתרת) ואז אתה אמור לראות את שורת הפגז של ה- Pi שמופיעה בערך כך:

pi@raspberrypi: ~ $

אם אינך רואה את ההנחיה, בדוק את מזהה המשתמש והסיסמה שבה השתמשת.

כעת עליך למצוא את הנתיב לזמן הריצה של Java ולאשר שגירסת ברירת המחדל היא Java 8 (אמורה להיות נכונה לגבי ה- Raspbian האחרונה). כדי למצוא את נתיב זמן הריצה של Java, הזן את הפקודה בלקוח ssh

סודו עדכון-חלופות-תצוגת java

אתה אמור לראות תגובה עם שתי השורות הראשונות שנראות כך:

java - מצב אוטומטי

הקישור הגרסה הטובה ביותר היא/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java

ה- "-8-" בשורה השנייה מאשרת שזמן הריצה המוגדר כברירת מחדל הוא Java 8. רשום את הנתיב בשורה השנייה כפי שתזדקק לו להגדרת NetBeans לפיתוח מרחוק בשלב מאוחר יותר.

אם זמן הריצה המוגדר כברירת מחדל אינו Java 8, בלקוח ssh הזן את הפקודה הבאה כדי לעבור ל- Java 8 (בהנחה שהוא מותקן)

סודו עדכון-חלופות-הגדרת java

שלב 2: התקן את NetBeans בתחנת העבודה

כעת עליך להתקין את NetBeans בתחנת העבודה שלך. כוון את דפדפן תחנת העבודה שלך לדף ההורדות של NetBeans. תראה כמה חבילות אפשריות התומכות בשתי המהדורות של Java כמו גם בשפות אחרות. כל מה שאתה צריך לפיתוח ג'אווה עבור ה- Raspberry Pi הוא Java SE, אבל אתה יכול להשיג את חבילת Java EE או את כל החבילה. לאחר שתחליט איזה צרור אתה רוצה לחץ על כפתור ההורדה המתאים. תוכל למצוא הוראות התקנה נוספות למערכת ההפעלה של תחנת העבודה שלך כאן.

לאחר התקנת NetBeans, הפעל אותו (הוא עשוי לעשות זאת באופן אוטומטי לאחר ההתקנה). אתה אמור לראות את החלון הראשי של NetBeans כפי שמוצג בתמונה. התמונה צולמה ב- Mac, והחלון הראשי עשוי להיראות מעט שונה ב- Windows.

לאחר שהתקנת והפעלת את NetBeans בהצלחה, המשך לשלב הבא.

שלב 3: הגדר את ה- Raspberry Pi כפלטפורמה מרוחקת ב- NetBeans

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

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

כדי להגדיר את ה- Pi כפלטפורמה מרוחקת:

1. בשורת התפריטים הראשית של NetBeans, בחר כלים -> פלטפורמות Java. תראה את החלון המוקפץ של Java Platform Manager (תמונה אחת).
2. לחץ על הוסף פלטפורמה בפינה השמאלית התחתונה. תראה את הקופץ הוסף פלטפורמת Java [סוג פלטפורמה] (תמונה שתיים).
3. בחר Remote Java Standard Edition. הקש "הבא. תראה את הקופץ הוסף פלטפורמת Java [הגדרת פלטפורמה מרוחקת] (תמונה שלוש מציגה את הקופץ לאחר שהכנסתי את הערכים המתאימים לסביבה שלי בשדות).
4. בשדה שם פלטפורמה הזן שם ל- Pi. אתה יכול להשתמש כמעט בכל דבר, אבל זה חייב להיות ייחודי.
5. בשדה מארח הזן את כתובת ה- IP של ה- Pi שנמצאה בשלב 1.
6. בשדה שם משתמש הזן את שם המשתמש בו השתמשת בשלב 1.
7. השאר את אימות הסיסמה השתמש נבחר ובשדה סיסמה הזן את הסיסמה שיצרת בשלב 1.
8. בשדה JRE Remote JRE עליך להזין את רוב הנתיב לזמן הריצה של Java ב- Pi. בשלב 1, זה היה/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java. עם זאת עליך להוריד /bin /java בערך השדה.
9. NetBeans מוריד את התוכנית הניתנת לריצה לספריית עבודה ב- Pi, המזוהה בשדה Working Dir. ברירת המחדל היא/the_Pi_user_ID/NetBeansProjects/וזה מקובל לחלוטין. אתה יכול להשתמש במשהו אחר אם אתה רוצה, אם כי זה חייב להיות זמין ל-_Pi_user_ID (תמונה שלוש).
10. לחץ על סיום בפינה השמאלית התחתונה של המוקפץ. לאחר העיבוד, אתה אמור לראות שוב את החלון המוקפץ של Java Platform Manager. כעת אתה אמור לראות את ה- Pi המרוחק שלך (בשם שבו השתמשת בפעולה 4 למעלה) בקטגוריה Remote Java SE מרחוק (תמונה ארבע).
11. לחץ על בדיקת פלטפורמה בפינה השמאלית התחתונה כדי לבדוק את החיבור בין NetBeans ל- Pi שלך. תחילה תראה קופץ שאומר אימות פלטפורמה מרוחקת. אם תצליח, תקבל חלונות קופצים נוספים המציינים את החיבור … הוקם בהצלחה. אם לא, עליך לבדוק ולתקן את המידע שהזנת בחלון הקופץ הוסף פלטפורמת Java [הגדר פלטפורמה מרוחקת] בפעולות 5-9 למעלה. אתה יכול לעשות זאת מהקופץ המנהל של Java Platform Manager; פשוט בחר את פלטפורמת ה- Pi שלך ולאחר מכן ערוך את השדות בצד ימין של המוקפץ.
12. לאחר חיבור מוצלח, לחץ על סגור בחלון המוקפץ של Java Platform Manager. כעת תראה את החלון הראשי של NetBeans.

עכשיו הכיף האמיתי יכול להתחיל!

שלב 4: צור פרויקט Java בתחנת העבודה

זה לא נועד להוות הסבר מלא לאופן השימוש ב- NetBeans או ב- Java, אך אתאר את הפעולות המינימליות לכתיבת תוכנית ב- NetBeans בתחנת העבודה ובסופו של דבר הפעלת התוכנית מרחוק ב- Raspberry Pi.

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

1. בחלון הראשי של NetBeans, לחץ על סמל הפרויקט החדש (השני משמאל). תראה את הקופץ של פרויקט חדש [בחר פרויקט] (תמונה אחת).
2. ברירות המחדל (קטגוריה: Java, פרוייקט: יישום Java) נכונות בדוגמה זו, אז פשוט לחץ על הבא. תראה את יישום Java החדש [שם ומיקום] (תמונה שנייה מציגה ערכים לדוגמא שלי). הערה: ערכתי את פרטי המשתמש שלי באמצעות המלבנים הצבעוניים.
3. בשדה שם הפרויקט, הזן שם פרוייקט Java חוקי לבחירתך. השם חייב להתחיל באות גדולה, והאמנה מציעה כיתוב גמלים בעת חיבור מילים.
4. השדה מיקום הפרוייקט שולט היכן שוכן הפרויקט במערכת הקבצים שלך. ברירת המחדל משתנה בהתאם למערכת ההפעלה, אך בטוח לקבלה.
5. השדה תיקיית פרוייקט מאפשר לך לשלוט בשם התיקיה של הפרויקט. אני מוצא שהכי טוב להשתמש בברירת המחדל, שהיא צירוף של שדה המיקום ושדה השם.
6. כאשר תיבת הסימון צור מחלקה ראשית מסומנת, NetBeans יוצר אוטומטית חבילה וקובץ מחלקה ראשית (תוכנית שניתן להריץ משורת הפקודה) עם אותו שם כמו הפרויקט. אני חושב שבדרך כלל לא צריך לבדוק את זה, אבל במקרה זה אשאיר את זה מסומן, דבר שמבטל פעולות מפורשות שצריך לעשות זאת אחרת (תמונה שתיים).
7. לחץ על סיום כדי ליצור את הפרויקט, חבילה וקובץ מחלקה ראשית. כעת החלונית השמאלית העליונה של החלון הראשי של NetBeans מציגה את הפרויקט שלך, המכיל חבילה אחת, שבתורה מכילה קובץ מחלקה יחיד בשיטה ראשית (). החלונית הימנית העליונה מכילה את קוד המקור המוגדר כברירת מחדל עבור המחלקה הראשית (התוכנית) שנוצר אוטומטית על ידי NetBeans (תמונה שלוש).

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

שלב 5: הגדר את פרויקט NetBeans כך שיופעל מרחוק ב- Raspberry Pi

כדי להגדיר את פרוייקט NetBeans ותוכנית שהוא מכיל להפעלה מרחוק ב- Raspberry Pi, בצע את הפעולות הבאות:

1. קליק ימני או 2 אצבעות (תלוי במערכת ההפעלה של תחנת העבודה) על הפרויקט בחלונית הפרויקטים בחלון הראשי של NetBeans כדי להציג את תפריט הפרויקט ולחץ על מאפיינים. תראה את הקופץ 'מאפייני פרוייקטים' (התמונה מציגה את הקופץ עם הערכים המתאימים לדוגמא שלי).
2. תחת קטגוריות משמאל, בחר הפעלה.
3. לחץ על חדש מימין לשדה התצורה. בחלון הקופץ יצירת תצורה חדשה שנוצר, הזן שם לתצורה ולחץ על אישור. השם יכול להיות כל דבר; הרגע השתמשתי מחדש בשם הפלטפורמה ("My Pi"). שוב תראה את הקופץ 'מאפייני פרוייקטים'.
4. לחץ על הסמל הנפתח מימין לשדה פלטפורמת Runtime. מהרשימה בחלון המוקפץ, בחר את הפלטפורמה המרוחקת שיצרת קודם לכן (בסביבה שלי, "My Pi").
5. לחץ על אישור כדי להגדיר את הפלטפורמה המרוחקת לפרויקט. שוב תראה את החלון הראשי.

כעת אתה מוכן לכתוב קוד ולהפעיל את התוכנית מרחוק.

שלב 6: כתוב תוכנית Java בתחנת העבודה והפעל אותה ב- Raspberry Pi

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

כדי להפעיל את התוכנית ב- Pi, לחץ על סמל הפעלה (החץ הירוק שמצביע שמאלה) בחלון הראשי. NetBeans אוסף את הקוד, בונה קובץ jar, מוריד את קובץ ה- jar ל- Raspberry Pi שזוהה על ידי הפלטפורמה המרוחקת, מבצע את התוכנית ב- Pi, לוכד את הפלט (System.out) של התוכנית ומהדהד את הפלט ל- NetBeans חלונית פלט בפינה השמאלית התחתונה של החלון הראשי (תמונה שתיים).

כעת הרחבת משמעותית את מערך המיומנויות שלך לפיתוח פרויקטים ב- Raspberry Pi! אבל חכה…. יש עוד!

שלב 7: ניפוי באגים של תוכנית Java באמצעות NetBeans

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

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

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

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

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

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

לחץ פעמיים על סמל מעבר. תראה שלשלושת המשתנים יש ערכים; שים לב ש- c עדיין אפס (תמונה ארבע).

לחץ פעם אחת על סמל מעבר. תראה שלמשתנה c יש כעת את הערך הנכון, כלומר סכום המשתנים a ו- b (תמונה חמישית).

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

שלב 8: בצע את התוכנית ללא תלות ב- NetBeans

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

זכור משלב 3 ש- NetBeans ממקם את צנצנת הפרויקטים שלך בספריית עבודה בפי. בסיס ברירת המחדל הוא/home/pi/NetBeansProjects עבור משתמש pi. לספרייה הספציפית יש אותו שם כמו הפרויקט שלך. NetBeans ממקם את הצנצנת בספריית משנה הנקראת dist. לדוגמא שלי, הנתיב המלא הוא/home/pi/NetBeansProjects/MyRemoteProg/dist. בלקוח ssh ב- Pi, לביצוע התוכנית תוכל להשתמש בפקודת java עם האפשרות 'jar':

java -jar /home/pi/NetBeansProjects/MyRemoteProg/dist/MyRemoteProg.jar

תראה את תוצאות הביצוע בלקוח ssh; בדוגמה שלי, הפלט יהיה

שלום מ- Raspberry Pi!

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

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

java -jar MyRemoteProg.jar

שלב 9: בנה והורד, אך אל תבצע את התוכנית באמצעות NetBeans

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

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

כדי להשתמש בטכניקה זו, צור תחילה מחלקה ראשית חדשה:

1. העלה את תפריט הפרויקט כמו בשלב 5 ולחץ על New-> Java Main Class. תראה את החלון הקופץ החדש מסוג Java הראשי.
2. בשדה שם מחלקה הזן שם. השם יכול להיות כל מה שאתה אוהב; השתמשתי ב"דמה ". השדה חבילה מאפשר לך לזהות את חבילת המחלקה; אתה בוחר חבילה באמצעות התפריט הנפתח מימין לשדה. השיעור יכול להיות באותה חבילה של התוכנית ה"אמיתית "שלך או בחבילה אחרת; שמתי את הכיתה החדשה באותה חבילה. לחץ על סיום. כעת תראה את החלון הראשי של NetBeans עם הקובץ החדש בחלונית השמאלית העליונה (תמונה אחת). הוספתי הצהרת הדפסה פשוטה על הפעלה על ה- Pi, אך אין צורך באמת בשום דבר.

כדי להריץ את "דמה" לאחר ההורדה עליך להפוך אותו ל"מחלקה הראשית לביצוע כברירת מחדל "עבור הפרויקט:

1. פתח את מאפייני הפרויקט כמו בשלב 5. בחר את קטגוריית הפעלה. לחץ על עיון מימין לשדה המעמד הראשי. תראה את המוקפץ עיון בשיעורים מרכזיים (תמונה שתיים).
2. בחר את הכיתה "דמה". לחץ על בחר מחלקה ראשית. שוב תראה את מאפייני הפרויקט.
3. לחץ על אישור. תחזור לחלון הראשי.

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

כדי לבצע את התוכנית האמיתית שלך ב- Pi, כעת עליך להשתמש בפקודת java עם האפשרות 'classpath', הדורשת ממך לזהות במפורש את המחלקה הראשית לביצוע. מלקוח ssh עבור לספריית dist עבור הפרויקט שלך. הפקודה הנכונה היא בצורה:

java -cp project_name.jar package_name.class_name

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

הפקודה הבאה מבצעת את התוכנית לדוגמא שלי:

java -cp MyRemoteProg.jar myremoteprog. MyRemoteProg

שלב 10: מינוף ניהול ספריית NetBeans

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

אשתמש כדוגמה Pi4J, המעניקה לתוכנות ג'אווה גישה ל- Raspberry Pi GPIO, I2C bus ו- I/O חומרה אחרות. Pi4J היא רק דוגמה אחת לתמיכה בעשייה של הרבה דברים מהנים ב- Pi עם ג'אווה.

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

כעת עליך ליצור "ספרייה גלובלית" ב- NetBeans:

1. בתפריט הראשי של NetBeans, לחץ על כלים -> ספריות. תראה את המוקפץ של מנהל ספריית הנמלים (תמונה אחת).
2. לחץ על ספרייה חדשה בפינה השמאלית התחתונה. תראה את הקופץ החדש של הספרייה החדשה (תמונה שתיים).
3. הקלד שם בעל משמעות שבו ברצונך להשתמש ולחץ על אישור. שוב תראה את החלון המוקפץ של מנהל ספריית הנמלים. כעת הוא מציג את הספרייה החדשה שיצרת (תמונה שלוש).
4. לחץ על הוסף JAR/תיקייה מימין. תראה את החלון המוקפץ Browse JAR/Folder (תמונה ארבע).
5. נווט אל ולאחר מכן בחר pi4j-core.jar. לאחר מכן לחץ על הוסף JAR/תיקיה. תחזור לחלון המוקפץ מנהל ספריית הנמלים.
6. בחלון המוקפץ מנהל ספריית הנמלים לחץ על אישור. תחזור לחלון הראשי של NetBeans.

הוספת את הספרייה כך שניתן יהיה להשתמש בה בכל פרויקט. כעת עליך להוסיף את הספרייה לפרויקט שלך:

1. העלה את הקופץ 'מאפייני פרוייקטים' (ראה שלב 5) ובחר את קטגוריית הספריות (תמונה חמש).
2. לחץ על הוסף ספרייה בצד ימין של המוקפץ. תראה את הקופץ הוסף ספרייה (תמונה שש).
3. נווט לספרייה ובחר אותה. לאחר מכן לחץ על הוסף ספרייה. שוב תראה את הקופץ 'מאפייני פרוייקט'. הספרייה מופיעה כעת ברשימת הספריות בזמן הידור בחלון המוקפץ.
4. בחלון המוקפץ מאפייני פרוייקט לחץ על אישור. תחזור לחלון הראשי.

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

יש שלוש פעמים שאתה צריך את הספרייה - הידור, בנייה וביצוע. למרבה המזל, עם NetBeans, הוספת הספרייה כפי שמוצג לעיל מטפלת בכל. כדי לאשר זאת, יצרתי מחלקה ראשית נוספת שעושה את המינימום המוחלט הדרוש כדי להשתמש ביכולת I2C ב- Pi4J (תמונה שבע). העובדה שאין שגיאות בהצגה פירושה שהמחלקה TestPi4J אוספת. לחיצה על הפעלה בונה והורדה בהצלחה; NetBeans מוריד את הספרייה בנוסף לקובץ ה- jar, כך שהתוכנית תבוצע. כדי לאמת את האחרון, תוכל להשתמש בטכניקה בשלב 9 ובלקוח ssh להזין את הפקודה הבאה (מספריית dist):

java -cp MyRemoteProg.jar myremoteprog. TestPi4J

מלמד להבין כיצד מטפלת NetBeans בספריות. כאשר אתה נמצא בספריית dist עבור הפרויקט שלך, רשום את תוכן הספרייה (השתמש בפקודה ls) ותראה ספריית משנה של lib. רשום את תוכן הספרייה הזו ותראה את קובץ ה- jar המזוהה בספרייה העולמית, בדוגמה שלי הוא pi4j-core.jar. כל הספריות שאתה מוסיף לפרויקט יופיעו בספריית lib, וכך הן זמינות לכל התוכניות בקובץ jar project.

שלב 11: לכו תיהנו

תיארתי גישה להשגת פיתוח Java יעיל מאוד עבור ה- Raspberry Pi. ה- Raspberry Pi היא טכנולוגיה פופולרית ביותר למגוון רחב של פרויקטים. Java היא שפת תכנות מקצועית המציעה יתרונות ביצועים על פני פייתון ומציעה יתרונות בטיחות על פני C/C ++. NetBeans הוא IDE ברמה מקצועית שמעלה מאוד את תפוקת המתכנתים.

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