การพัฒนา Java อย่างมีประสิทธิภาพสำหรับ Raspberry Pi: 11 ขั้นตอน (พร้อมรูปภาพ)

2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:03

คำแนะนำนี้อธิบายวิธีที่มีประสิทธิภาพมากสำหรับการพัฒนาโปรแกรม Java สำหรับ 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 หรือ ภาษาซี/ซี++ Raspbian รุ่นล่าสุดมีการพัฒนาและรองรับรันไทม์สำหรับภาษาเหล่านี้ทั้งหมด

Python มีผล "ส่งเสริม" สำหรับใช้กับ Pi อย่างน้อยก็ในบางส่วนเพื่อความสะดวกในการเรียนรู้สำหรับโปรแกรมเมอร์ใหม่ ฉันเป็นโปรแกรมเมอร์ที่มีประสบการณ์และไม่ชอบ Python เนื่องจากไม่ชอบอัตนัยหลายประการ เช่น การพิมพ์แบบไดนามิก มีคุณลักษณะหนึ่งของ Python ที่ไม่ชอบคือวัตถุประสงค์ -- ประสิทธิภาพ แหล่งข้อมูลนี้แสดงให้เห็นว่า Java นั้นเร็วกว่า Python 3 เสมอ และที่จริงแล้วสามารถรันได้เร็วกว่าหลายร้อยเท่า ขึ้นอยู่กับงาน

ในความคิดของฉัน C เป็น "ภาษาเครื่องระดับสูง" เช่น สิ่งที่ใกล้เคียงกับฮาร์ดแวร์ของระบบมาก หรืออย่างน้อยก็ระบบปฏิบัติการ คุณสามารถทำอะไรก็ได้เกือบทุกอย่าง และคุณสามารถทำมันได้เร็วที่สุด อันที่จริง แหล่งข้อมูลนี้แนะนำ C สามารถทำงานได้ถึง 7X เร็วเท่ากับ Java ฉันไม่ชอบ C เพราะฉัน (ส่วนตัว) ไม่ชอบคุณลักษณะบางอย่างที่ฉันพบว่าเป็นความลับ โบราณ หรือทั้งสองอย่าง ตัวอย่างเช่น ตัวชี้ที่ชัดเจน ตามหลักการแล้ว ความจริงที่ว่าคุณสามารถทำอะไรก็ได้หมายความว่าคุณเป็นเพียงข้อบกพร่องที่ไม่ชัดเจน (เช่น เลขคณิตตัวชี้ที่ไม่ดีหรือ memcpy ที่ผิดพลาด) ห่างจากการเขียนทับหน่วยความจำและอาจทำให้โปรแกรมขัดข้อง หรือแม้แต่ระบบทั้งหมด Java ป้องกันอันตรายดังกล่าว ดังนั้น Java จึงปลอดภัยกว่า ฉันรู้สึกว่าความปลอดภัยยังช่วยปรับปรุงประสิทธิภาพการทำงานของโปรแกรมเมอร์อีกด้วย ฉันถือว่า C ++ เป็น "wrapper" เชิงวัตถุรอบ C ที่ไม่ทำอะไรเพื่อขจัดอันตรายของ C

บรรทัดล่าง: Java เร็วกว่า Python Java ปลอดภัยกว่า C.

มีข้อ จำกัด เมื่อใช้ Java หรือไม่?

จนถึงตอนนี้ ฉันสามารถทำทุกอย่างใน Java ที่ฉันสามารถทำได้ใน Python มีหลายสิ่งที่เราสามารถทำได้ใน C ที่ไม่สามารถทำได้ใน Java แต่อีกครั้ง จนถึงตอนนี้ ทุกสิ่งที่ฉันต้องการจะทำได้รับการกล่าวถึงโดยแฟน Java ในชุมชน Pi ฉันจะเสนอตัวอย่างในขั้นตอนต่อไป ที่กล่าวว่าฉันได้ซื้อเซ็นเซอร์จากผู้ขายที่ให้ "ไดรเวอร์" สำหรับเซ็นเซอร์ใน Python เท่านั้น (หรือ C / C ++ สำหรับ Arduino) ดังนั้นฉันจึงต้องเขียน Java ที่เทียบเท่า ความพยายามพิเศษไม่จำเป็นต้องมีประสิทธิผลเสมอไป แต่อาจส่งผลให้มีความเข้าใจที่ลึกซึ้งยิ่งขึ้นในการทำงานของเซ็นเซอร์

เหตุใดจึงต้องพัฒนาจากระยะไกลโดยใช้ NetBeans

ฉันพบว่าการพัฒนาระยะไกลบน NetBeans ช่วยเพิ่มประสิทธิภาพการทำงานอย่างมากเมื่อใช้ Java สำหรับ Raspberry Pi ฉันมั่นใจว่าคุณสามารถใช้แนวทางในการสร้างโปรแกรมที่รวดเร็วและปลอดภัยได้ เนื่องจากลักษณะเฉพาะของ Java ในขณะที่เขียน สร้าง และดีบั๊กได้เร็วกว่าวิธีอื่นๆ ที่ฉันพบ เนื่องจากการพัฒนาจากระยะไกลโดยใช้ "มืออาชีพ" เกรด" NetBeans Integrated Development Environment (IDE)

อาจเป็นประโยชน์ที่จะพูดคุยสั้นๆ "แนวทางอื่นๆ" เหล่านั้น ทั้งหมดเป็นไปตามเกณฑ์พื้นฐานที่ Raspberry Pi ไม่ได้เชื่อมต่อแป้นพิมพ์ เมาส์ หรือจอแสดงผล มีหลายสาเหตุสำหรับเกณฑ์นี้ แต่เหตุผลหลักของฉันคือฉันพัฒนาหุ่นยนต์เคลื่อนที่ และฉันไม่ต้องการให้ Pi เชื่อมต่อกับอุปกรณ์ต่อพ่วงใดๆ ยกเว้นระบบย่อยของหุ่นยนต์ แม้แต่ในระหว่างการพัฒนา

เซิร์ฟเวอร์ VNC ที่รวมอยู่ใน Raspbian มีส่วนติดต่อผู้ใช้แบบกราฟิกระยะไกล (GUI) ที่ช่วยให้สามารถพัฒนารูปแบบระยะไกลได้ โดยจะมีเฉพาะ GUI ระยะไกลที่ทำงานบนเวิร์กสเตชันเท่านั้น และทุกอย่างอื่น เช่น การเขียน การคอมไพล์ และการสร้าง จะเกิดขึ้นบน Pi ด้วย VNC มันง่ายที่จะใช้เครื่องมือการพัฒนาที่รองรับ Java ซึ่งจัดส่งใน Raspbian เช่น BlueJ, Geany และ Greenfoot สิ่งเหล่านี้บางส่วนถือได้ว่าเป็น IDE; แต่ฉันพบว่าพวกเขาอยู่ไกลจากระดับมืออาชีพ

ในทางเทคนิคแล้ว เป็นไปได้ที่จะติดตั้ง Java IDE ระดับมืออาชีพ เช่น Eclipse หรือ NetBeans บน Raspberry Pi และใช้งานจากระยะไกลผ่าน VNC รายงานและสามัญสำนึกแนะนำว่าผลลัพธ์ที่ได้จะน่าผิดหวัง เนื่องจากหน่วยความจำขนาดใหญ่และพลังงานของ CPU ต้องการ IDE ดังกล่าว รวมถึงเวลาแฝงของเครือข่ายที่แนะนำโดย GUI ระยะไกล

ทั้ง Eclipse และ NetBeans ทำงานได้ดีบนเวิร์กสเตชัน ด้วย Eclipse การเขียนโค้ดเป็นประสบการณ์ที่น่าพึงพอใจ อย่างไรก็ตาม การสร้างโปรแกรมกลับไม่เป็นเช่นนั้น การดาวน์โหลดโปรแกรมจะต้องเกิดขึ้นนอก Eclipse; การรันโปรแกรมบน Pi นั้นไม่ขึ้นกับ Eclipse โดยสิ้นเชิง ผลลัพธ์โดยรวมคือกระบวนการหลายขั้นตอนที่เกือบจะเจ็บปวด ซึ่งไม่สามารถรองรับการดีบักจากระยะไกลได้ NetBeans มีการคอมไพล์ สร้าง ดาวน์โหลด เรียกใช้งานจากระยะไกล และดีบักระยะไกลในตัว ทำให้เป็นแนวทางที่เหนือกว่า

ขั้นตอนที่ 1: ตั้งค่า Raspberry Pi

ในการใช้แนวทางการพัฒนาระยะไกล คุณต้องเริ่มต้นด้วยการตั้งค่าเป้าหมาย Raspberry Pi มีแหล่งข้อมูลมากมาย รวมถึง Instructables ที่พร้อมให้ความช่วยเหลือในการตั้งค่า Raspberry Pi ดูข้อมูลพื้นฐานในการตั้งค่า Pi (และอื่น ๆ)

คำแนะนำนี้ถือว่าคุณ

• ติดตั้ง Raspbian ล่าสุด ตรวจสอบให้แน่ใจว่าคุณได้บันทึก ID ผู้ใช้ Pi และรหัสผ่าน
• ตั้งค่า Wifi และเชื่อมต่อกับเราเตอร์ของคุณ (ดูสิ่งนี้); ตรวจสอบให้แน่ใจว่าคุณบันทึกที่อยู่ IP ของ Pi
• เปิดใช้งาน SSH (ดูสิ่งนี้) เพื่ออนุญาตการเข้าถึงระยะไกลไปยัง Pi จากเวิร์กสเตชัน

เมื่อคุณตั้งค่าเสร็จแล้ว คุณสามารถปิดเครื่องและยกเลิกการเชื่อมต่อจอแสดงผล แป้นพิมพ์ และเมาส์จาก Pi นี่เป็นหนึ่งในข้อดีที่สำคัญของการพัฒนาทางไกล คุณต้องปล่อยให้ดองเกิล Wifi เชื่อมต่ออยู่ (แน่นอนว่าไม่จำเป็นสำหรับ Pi รุ่น 3 หรือ Pi Zero W) จากนั้นคุณจะสามารถเปิดเครื่อง Pi ได้

ในการทดสอบ ให้เปิดไคลเอ็นต์ ssh บนเวิร์กสเตชันของคุณ เช่น Terminal บน MacOS หรือ putty บน Windows จากนั้นป้อนคำสั่ง ssh (secure shell) ด้วยแบบฟอร์มต่อไปนี้:

ssh the_pi_ip_address -l the_pi_user_id

คุณควรได้รับข้อความแจ้งให้ป้อนรหัสผ่าน ID ผู้ใช้ Pi ของคุณ หากไม่มีข้อความแจ้ง ให้ตรวจสอบว่าคุณได้ป้อนที่อยู่ IP ที่ถูกต้องในคำสั่ง ssh ป้อนรหัสผ่านของคุณ (จะถูกซ่อนไว้) จากนั้นคุณควรเห็นพรอมต์เชลล์ของ Pi ที่ปรากฏขึ้นดังนี้:

pi@raspberrypi:~ $

หากคุณไม่เห็นข้อความแจ้ง ให้ตรวจสอบ ID ผู้ใช้และรหัสผ่านที่คุณใช้

ตอนนี้ คุณต้องค้นหาเส้นทางไปยังรันไทม์ Java และยืนยันว่าเวอร์ชันเริ่มต้นคือ Java 8 (ควรเป็นจริงสำหรับ Raspbian ล่าสุด) หากต้องการค้นหาเส้นทางรันไทม์ของ Java ในไคลเอ็นต์ ssh ให้ป้อนคำสั่ง

sudo update-ทางเลือก --display java

คุณควรเห็นการตอบกลับด้วยสองบรรทัดแรกที่มีลักษณะดังนี้:

java - โหมดอัตโนมัติ

ลิงก์เวอร์ชันที่ดีที่สุดคือ /usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java

"-8-" ในบรรทัดที่สองยืนยันว่ารันไทม์เริ่มต้นคือ Java 8 บันทึกพาธในบรรทัดที่สอง เนื่องจากคุณจะต้องใช้พาธในการกำหนดค่า NetBeans สำหรับการพัฒนาระยะไกลในขั้นตอนต่อไป

หากรันไทม์เริ่มต้นไม่ใช่ Java 8 ในไคลเอ็นต์ ssh ให้ป้อนคำสั่งต่อไปนี้เพื่อเปลี่ยนเป็น Java 8 (สมมติว่ามีการติดตั้งไว้)

sudo อัพเดตทางเลือก --config java

ขั้นตอนที่ 2: ติดตั้ง NetBeans บนเวิร์กสเตชัน

ตอนนี้ คุณต้องติดตั้ง NetBeans บนเวิร์กสเตชันของคุณ ชี้เบราว์เซอร์เวิร์กสเตชันของคุณไปที่หน้าดาวน์โหลด NetBeans คุณจะเห็นชุดรวมที่เป็นไปได้หลายชุดที่รองรับ Java สองรุ่นรวมถึงภาษาอื่นๆ สิ่งที่คุณต้องการสำหรับการพัฒนา 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 ให้เลือก Tools -> Java Platforms คุณจะเห็นหน้าต่างป๊อปอัป Java Platform Manager (ภาพที่หนึ่ง)
2. คลิกเพิ่มแพลตฟอร์มที่ด้านล่างซ้าย คุณจะเห็นป๊อปอัป Add Java Platform [ประเภทแพลตฟอร์ม] (รูปภาพที่สอง)
3. เลือก Remote Java Standard Edition คลิกถัดไป คุณจะเห็นป๊อปอัป Add Java Platform [ตั้งค่าแพลตฟอร์มระยะไกล] (รูปที่ 3 แสดงป๊อปอัปหลังจากที่ฉันป้อนค่าที่เหมาะสมสำหรับสภาพแวดล้อมของฉันในฟิลด์)
4. ในฟิลด์ ชื่อแพลตฟอร์ม ให้ป้อนชื่อสำหรับ Pi คุณสามารถใช้อะไรก็ได้ แต่ต้องไม่ซ้ำกัน
5. ในฟิลด์ Host ให้ป้อนที่อยู่ IP สำหรับ Pi ที่พบในขั้นตอนที่ 1
6. ในฟิลด์ ชื่อผู้ใช้ ให้ป้อนชื่อผู้ใช้ที่คุณใช้ในขั้นตอนที่ 1
7. เลือก Use Password Authentication ทิ้งไว้ และในช่อง Password ให้ป้อนรหัสผ่านที่คุณสร้างในขั้นตอนที่ 1
8. ในฟิลด์ Remote JRE Path คุณต้องป้อนพาธส่วนใหญ่ไปยังรันไทม์ 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 (ภาพที่ 3)
10. คลิกเสร็จสิ้นที่ด้านล่างขวาของป๊อปอัป หลังจากประมวลผล คุณควรเห็นหน้าต่างป๊อปอัป Java Platform Manager อีกครั้ง ตอนนี้คุณควรเห็น Pi ระยะไกลของคุณ (ภายใต้ชื่อที่คุณใช้ในการดำเนินการ 4 ด้านบน) ภายใต้หมวดหมู่ Remote Java SE (ภาพที่สี่)
11. คลิกทดสอบแพลตฟอร์มที่ด้านล่างซ้ายเพื่อทดสอบการเชื่อมต่อระหว่าง NetBeans และ Pi ของคุณ ขั้นแรกคุณจะเห็นป๊อปอัปแจ้งว่า Verifying Remote Platform หากสำเร็จ คุณจะได้รับป๊อปอัปที่สองซึ่งระบุว่าการเชื่อมต่อ … สำเร็จแล้ว หากไม่เป็นเช่นนั้น คุณต้องตรวจสอบและแก้ไขข้อมูลที่คุณป้อนลงในป๊อปอัป Add Java Platform [ตั้งค่าแพลตฟอร์มระยะไกล] ในการดำเนินการ 5-9 ด้านบน คุณสามารถทำได้จากป๊อปอัป Java Platform Manager เพียงเลือกแพลตฟอร์ม Pi ของคุณแล้วแก้ไขฟิลด์ทางด้านขวาของป๊อปอัป
12. หลังจากเชื่อมต่อสำเร็จ ให้คลิก ปิด ในป๊อปอัป Java Platform Manager ตอนนี้คุณจะเห็นหน้าต่างหลักของ NetBeans

เริ่มความสนุกที่แท้จริงได้แล้ว!

ขั้นตอนที่ 4: สร้างโปรเจ็กต์ Java บนเวิร์กสเตชัน

นี่ไม่ได้มีวัตถุประสงค์เพื่อเป็นคำอธิบายแบบเต็มเกี่ยวกับวิธีการใช้ NetBeans หรือ Java แต่ฉันจะอธิบายการดำเนินการขั้นต่ำในการเขียนโปรแกรมใน NetBeans บนเวิร์กสเตชันและในที่สุดก็เรียกใช้โปรแกรมจากระยะไกลบน Raspberry Pi

ใน NetBeans คุณต้องสร้างโปรเจ็กต์เพื่อเก็บคลาส Java สำหรับโปรแกรมก่อน นอกจากนี้ ใน Java คลาสจะอยู่ในแพ็คเกจเพื่อรองรับองค์กรและความปลอดภัย ในการสร้างโปรเจ็กต์และเลือกสร้างแพ็คเกจและไฟล์คลาส:

1. ในหน้าต่างหลักของ NetBeans ให้คลิกไอคอนโปรเจ็กต์ใหม่ (ที่ 2 จากซ้าย) คุณจะเห็นป๊อปอัป New Project [เลือกโครงการ] (ภาพที่หนึ่ง)
2. ค่าดีฟอลต์ (Category: Java, Project: Java Application) ถูกต้องสำหรับตัวอย่างนี้ ดังนั้นเพียงแค่คลิก Next คุณจะเห็นป๊อปอัปแอปพลิเคชัน Java ใหม่ [ชื่อและตำแหน่ง] (รูปภาพที่สองแสดงค่าสำหรับตัวอย่างของฉัน) หมายเหตุ: ฉันได้แก้ไขข้อมูลผู้ใช้ของฉันโดยใช้สี่เหลี่ยมสี
3. ในฟิลด์ ชื่อโปรเจ็กต์ ป้อนชื่อโปรเจ็กต์ Java ที่ถูกต้องที่คุณเลือก ชื่อต้องขึ้นต้นด้วยตัวพิมพ์ใหญ่ และแบบแผนแนะนำกรณีอูฐเมื่อเชื่อมคำ
4. ฟิลด์ตำแหน่งโครงการจะควบคุมตำแหน่งที่โปรเจ็กต์อยู่ในระบบไฟล์ของคุณ ค่าเริ่มต้นจะแตกต่างกันไปขึ้นอยู่กับระบบปฏิบัติการ แต่ยอมรับได้อย่างปลอดภัย
5. ฟิลด์โฟลเดอร์โปรเจ็กต์ช่วยให้คุณควบคุมชื่อโฟลเดอร์สำหรับโปรเจ็กต์ได้ ฉันคิดว่ามันดีที่สุดที่จะใช้ค่าเริ่มต้น ซึ่งก็คือการต่อกันของฟิลด์ตำแหน่งและฟิลด์ชื่อ
6. เมื่อเลือกช่องทำเครื่องหมาย Create Main Class NetBeans จะสร้างแพ็คเกจและไฟล์คลาสหลักโดยอัตโนมัติ (โปรแกรมที่สามารถเรียกใช้จากบรรทัดคำสั่ง) โดยใช้ชื่อเดียวกับโปรเจ็กต์ ฉันคิดว่าปกติแล้วไม่ควรเลือก แต่ในกรณีนี้ ฉันจะปล่อยให้มีการตรวจสอบซึ่งจะช่วยขจัดการกระทำที่โจ่งแจ้งเป็นอย่างอื่นที่จำเป็นในการทำเช่นนั้น (รูปที่ 2)
7. คลิก เสร็จสิ้น เพื่อสร้างโปรเจ็กต์ แพ็คเกจ และไฟล์คลาสหลัก ตอนนี้บานหน้าต่างด้านซ้ายบนของหน้าต่างหลัก NetBeans จะแสดงโปรเจ็กต์ของคุณ ซึ่งมีแพ็คเกจเดียว ซึ่งจะมีไฟล์คลาสเดียวที่มีเมธอด main() บานหน้าต่างด้านขวาบนมีซอร์สโค้ดเริ่มต้นสำหรับคลาสหลัก (โปรแกรม) ที่สร้างโดย NetBeans โดยอัตโนมัติ (ภาพที่ 3)

ณ จุดนี้ คุณสามารถเขียนโค้ดในเมธอดหลักและรันบนเวิร์กสเตชันได้ อาจเป็นที่ต้องการในบางครั้ง แต่ไม่จำเป็นสำหรับคำแนะนำนี้ ดังนั้นให้ดำเนินการในขั้นตอนต่อไป

ขั้นตอนที่ 5: กำหนดค่าโครงการ NetBeans เพื่อเรียกใช้จากระยะไกลบน Raspberry Pi

ในการกำหนดค่าโปรเจ็กต์ NetBeans และโปรแกรมที่มีอยู่ เพื่อเรียกใช้จากระยะไกลบน Raspberry Pi ให้ทำดังต่อไปนี้:

1. คลิกขวาหรือคลิก 2 นิ้ว (ขึ้นอยู่กับระบบปฏิบัติการของเวิร์กสเตชัน) บนโปรเจ็กต์ในบานหน้าต่างโปรเจ็กต์ของหน้าต่างหลักของ NetBeans เพื่อเปิดเมนูโปรเจ็กต์และคลิก Properties คุณจะเห็นป๊อปอัปคุณสมบัติของโครงการ (รูปภาพแสดงป๊อปอัปพร้อมค่าที่เหมาะสมสำหรับตัวอย่างของฉัน)
2. ภายใต้ หมวดหมู่ ทางด้านซ้าย ให้เลือก เรียกใช้
3. คลิกใหม่ทางด้านขวาของฟิลด์การกำหนดค่า ในป๊อปอัป Create New Configuration ที่เป็นผลลัพธ์ ให้ป้อนชื่อสำหรับการกำหนดค่าแล้วคลิก ตกลง ชื่อสามารถเป็นอะไรก็ได้ ฉันเพิ่งใช้ชื่อแพลตฟอร์มซ้ำ ("My Pi") คุณจะเห็นป๊อปอัปคุณสมบัติของโครงการอีกครั้ง
4. คลิกไอคอนดรอปดาวน์ทางด้านขวาของฟิลด์ Runtime Platform จากรายการในป๊อปอัป ให้เลือกแพลตฟอร์มระยะไกลที่คุณสร้างไว้ก่อนหน้านี้ (ในสภาพแวดล้อมของฉันคือ "My Pi")
5. คลิกตกลงเพื่อตั้งค่าแพลตฟอร์มระยะไกลสำหรับโครงการ คุณจะเห็นหน้าต่างหลักอีกครั้ง

ตอนนี้คุณพร้อมที่จะเขียนโค้ดและรันโปรแกรมจากระยะไกลแล้ว

ขั้นตอนที่ 6: เขียนโปรแกรม Java บนเวิร์กสเตชันและเรียกใช้บน Raspberry Pi

แผงด้านขวาในหน้าต่างหลักของ NetBeans จะแสดงไฟล์คลาสหลักที่สร้างโดย NetBeans พิมพ์คำสั่งการพิมพ์อย่างง่ายในวิธีการหลักของไฟล์คลาส (ภาพที่หนึ่ง) ตอนนี้เป็นโปรแกรม Java ที่สมบูรณ์ซึ่งทำบางสิ่ง แม้ว่าจะเป็นสิ่งที่ง่ายมาก

ในการรันโปรแกรมบน Pi ให้คลิกไอคอน Run (ลูกศรชี้ซ้ายสีเขียว) ในหน้าต่างหลัก NetBeans รวบรวมโค้ด สร้างไฟล์ jar ดาวน์โหลดไฟล์ jar ไปยัง Raspberry Pi ที่ระบุโดยแพลตฟอร์มระยะไกล รันโปรแกรมบน Pi จับเอาต์พุต (System.out) ของโปรแกรม และส่งเสียงสะท้อนที่ส่งออกไปยัง NetBeans บานหน้าต่างผลลัพธ์ที่ด้านล่างขวาของหน้าต่างหลัก (รูปภาพที่สอง)

ตอนนี้คุณได้ขยายชุดทักษะของคุณอย่างมากสำหรับการพัฒนาโครงการบน Raspberry Pi แล้ว! แต่เดี๋ยวก่อน…. มีมากขึ้น!

ขั้นตอนที่ 7: ดีบักโปรแกรม Java ด้วย NetBeans

หนึ่งในคุณสมบัติที่ทรงพลังที่สุดของความเข้มแข็งทางอุตสาหกรรม Integrated Development Environment เช่น NetBeans คือความสามารถในการดีบักโปรแกรมในขณะทำงาน NetBeans ช่วยให้คุณใช้ประโยชน์จากชุดเครื่องมือดีบั๊กเต็มรูปแบบในขณะที่ทำงานจากระยะไกล ซึ่งรวมถึงการตั้งค่าเบรกพอยต์ที่ตำแหน่ง "สำคัญ" หรือ "มีปัญหา" ในโปรแกรม และตรวจสอบค่าของตัวแปรในสถานะการดำเนินการปัจจุบัน

โปรแกรมง่าย ๆ ในขั้นตอนสุดท้ายนั้นง่ายเกินไปที่จะสาธิตการดีบัก ดังนั้นฉันจึงเพิ่มโค้ดเพิ่มเติมลงในโปรแกรม รหัสเพิ่มเติมเพิ่มสองตัวแปร

ในการใช้ประโยชน์จากเครื่องมือดีบั๊ก คุณต้องตั้งค่าเบรกพอยต์อย่างน้อยหนึ่งจุดก่อน การตั้งค่าเบรกพอยต์ ให้คลิกหมายเลขบรรทัดที่คุณต้องการระงับการดำเนินการ ไอคอนรูปสี่เหลี่ยมผืนผ้าสีแดงจะปรากฏขึ้น และทั้งเส้นจะมีพื้นหลังสีแดง (ภาพที่หนึ่ง)

ในการดีบักโปรแกรมที่ทำงานบน Pi ให้คลิกไอคอน Debug (ทางด้านขวาของไอคอน Run ทันที) ในหน้าต่างหลักของ NetBeans เช่นเดียวกับการดำเนินการปกติ NetBeans จะคอมไพล์ สร้าง ดาวน์โหลด ดำเนินการ จับเอาต์พุต และสะท้อนเอาต์พุตนั้น แต่ด้วยการดีบัก NetBeans จะหยุดการทำงานที่จุดสั่งหยุด และอนุญาตให้คุณตรวจสอบสถานะการดำเนินการ (รูปภาพที่สอง แสดงบานหน้าต่างตัวแปรที่ด้านล่างขวา)

การดำเนินการหยุดที่จุดพักก่อนที่จะดำเนินการคำสั่งในบรรทัดที่มีเบรกพอยต์ พื้นหลังสีเขียวระบุคำสั่งถัดไปที่จะดำเนินการ ดังนั้นในตัวอย่างของฉัน เมื่อมีเบรกพอยต์ที่บรรทัดที่ 9 ตัวแปร a ยังไม่มีอยู่ มีค่าน้อยกว่ามาก

ตอนนี้เลื่อนเคอร์เซอร์ไปที่ไอคอนเมนูแก้ไขข้อบกพร่องในหน้าต่างหลัก (ไอคอนลูกศรชี้ลงสองครั้งแรกทางด้านขวาของไอคอนดีบั๊ก) แล้วคลิกไอคอนข้ามขั้นตอน (มีเอกสารสีน้ำเงินในพื้นหลังและลูกศรทวนเข็มนาฬิกาสีเขียว ในเบื้องหน้า) [หมายเหตุ: หากคุณทำให้หน้าต่างหลักของ NetBeans กว้างพอ เมนูแก้ไขจุดบกพร่องจะขยาย และไอคอนการดำเนินการแก้ไขจุดบกพร่องจะแสดงขึ้นทางด้านขวาของไอคอนแก้ไขจุดบกพร่อง] NetBeans ดำเนินการคำสั่งที่จุดพักและหยุดการดำเนินการก่อนคำสั่งถัดไป ตอนนี้คุณจะเห็นว่าตัวแปร a มีอยู่และมีค่าที่คาดหวัง (ภาพที่ 3)

คลิกไอคอน "ก้าวข้าม" สองครั้ง คุณจะเห็นว่าตัวแปรทั้งสามมีค่า โปรดทราบว่า c ยังคงเป็นศูนย์ (ภาพที่สี่)

คลิกไอคอนก้าวข้ามหนึ่งครั้ง คุณจะเห็นว่าตอนนี้ตัวแปร c มีค่าที่เหมาะสม นั่นคือ ผลรวมของตัวแปร a และ b (ภาพที่ห้า)

สุดท้าย ในเมนูแก้ไขข้อบกพร่อง ให้คลิกไอคอนเรียกใช้ (วงกลมสีเขียวที่มีลูกศรสีขาว) ซึ่งทำให้การดำเนินการดำเนินต่อไปยังเบรกพอยต์ถัดไป หรือสิ้นสุดโปรแกรม แล้วแต่ว่าจะถึงอย่างใดก่อนตอนนี้บานหน้าต่างผลลัพธ์จะปรากฏขึ้นและแสดงผลลัพธ์เหมือนกับการดำเนินการปกติ ในกรณีนี้คือข้อความในคำสั่งพิมพ์

ขั้นตอนที่ 8: ดำเนินการโปรแกรมโดยไม่ขึ้นกับ NetBeans

อาจถึงเวลาที่คุณต้องการรันโปรแกรมของคุณบน Raspberry Pi โดยไม่มี "ความช่วยเหลือ" หรือ "การรบกวน" จาก NetBeans มันง่ายมาก ขั้นแรก เปิดไคลเอ็นต์ ssh ให้กับ Pi ของคุณ

จำจากขั้นตอนที่ 3 ที่ NetBeans วาง jar โปรเจ็กต์ของคุณในไดเร็กทอรีที่ทำงานบน Pi ฐานเริ่มต้นคือ /home/pi/NetBeansProjects สำหรับผู้ใช้ pi ไดเร็กทอรีเฉพาะมีชื่อเดียวกับโปรเจ็กต์ของคุณ NetBeans วาง jar ในไดเร็กทอรีย่อยที่เรียกว่า dist สำหรับตัวอย่างของฉัน เส้นทางแบบเต็มคือ /home/pi/NetBeansProjects/MyRemoteProg/dist ในไคลเอนต์ ssh บน Pi เพื่อรันโปรแกรม คุณสามารถใช้คำสั่ง java พร้อมตัวเลือก 'jar':

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

คุณจะเห็นผลลัพธ์ของการดำเนินการในไคลเอ็นต์ ssh ในตัวอย่างของฉัน ผลลัพธ์จะเป็น

สวัสดีจาก Raspberry Pi!

สิ่งนี้ใช้ได้เพราะข้อมูลในไฟล์ jar ระบุว่าคลาสหลักใดใน jar ที่จะดำเนินการ

คุณยังสามารถเปลี่ยนไดเร็กทอรีการทำงาน (ผ่าน cd) เป็นตำแหน่งของไฟล์ jar จากนั้นออกคำสั่งที่สั้นลงเพื่อให้ได้ผลลัพธ์ที่เหมือนกัน

java -jar MyRemoteProg.jar

ขั้นตอนที่ 9: สร้างและดาวน์โหลด แต่ไม่เรียกใช้โปรแกรมผ่าน NetBeans

มีบางสถานการณ์ที่คุณต้องการให้ NetBeans สร้างและดาวน์โหลดโปรแกรมของคุณ แต่ไม่สามารถดำเนินการได้ สถานการณ์ดังกล่าวเกิดขึ้นเมื่อโปรแกรมของคุณต้องการการป้อนข้อมูลด้วยแป้นพิมพ์ หากเป็นกรณีนี้ โดยใช้เทคนิคในขั้นตอนก่อนหน้า เมื่อคุณสร้างและดาวน์โหลด โปรแกรมจะทำงานบน Raspberry Pi และคาดว่าจะได้รับคีย์บอร์ดจาก Pi แต่แน่นอนว่าไม่มีแป้นพิมพ์ติดอยู่กับ Pi โปรแกรมค้าง -- ไม่ดี

คุณต้องใช้เทคนิคที่แตกต่างกันบ้างเพื่อรันโปรแกรม โดยพื้นฐานแล้ว คุณสร้างไฟล์คลาสหลัก "จำลอง" ซึ่งโดยพื้นฐานแล้วไม่ทำอะไรเลย และระบุว่าเป็นโปรแกรมที่จะดำเนินการหลังจากดาวน์โหลด ในกรณีนี้ "จำลอง" จะถูกดำเนินการ จากนั้นคุณสามารถเรียกใช้โปรแกรม "ของจริง" ได้โดยตรงบน Pi

หากต้องการใช้เทคนิคนี้ ก่อนอื่นให้สร้างคลาสหลักใหม่:

1. เปิดเมนูโปรเจ็กต์ตามขั้นตอนที่ 5 แล้วคลิก New->Java Main Class คุณจะเห็นป๊อปอัปคลาสหลักของ Java ใหม่
2. ในฟิลด์ ชื่อคลาส ให้ป้อนชื่อ ชื่อสามารถเป็นอะไรก็ได้ที่คุณชอบ ฉันใช้ "ดัมมี่" ฟิลด์ Package ช่วยให้คุณสามารถระบุแพ็คเกจของคลาสได้ คุณเลือกแพ็คเกจโดยใช้ดรอปดาวน์ทางด้านขวาของฟิลด์ คลาสสามารถอยู่ในแพ็คเกจเดียวกันกับโปรแกรม "ของจริง" ของคุณหรือในแพ็คเกจอื่น ฉันใส่คลาสใหม่ในแพ็คเกจเดียวกัน คลิกเสร็จสิ้น ตอนนี้คุณจะเห็นหน้าต่างหลักของ NetBeans พร้อมไฟล์ใหม่ในแผงด้านขวาบน (ภาพที่หนึ่ง) ฉันเพิ่มคำสั่งพิมพ์อย่างง่ายเกี่ยวกับการรันบน Pi แต่ไม่มีอะไรจำเป็นจริงๆ

หากต้องการเรียกใช้ "Dummy" หลังจากดาวน์โหลด คุณต้องทำให้เป็น "คลาสหลักที่จะดำเนินการตามค่าเริ่มต้น" สำหรับโครงการ:

1. เปิด Project Properties ตามขั้นตอนที่ 5 เลือกประเภท Run คลิก เรียกดู ทางด้านขวาของฟิลด์คลาสหลัก คุณจะเห็นป๊อปอัปเรียกดูคลาสหลัก (รูปที่สอง)
2. เลือกคลาส "ดัมมี่" คลิกเลือกคลาสหลัก คุณจะเห็นคุณสมบัติโครงการอีกครั้ง
3. คลิกตกลง คุณจะกลับไปที่หน้าต่างหลัก

ตอนนี้เมื่อคุณคลิกไอคอน Run NetBeans จะปฏิบัติตาม/สร้างโครงการทั้งหมด ดาวน์โหลด jar ที่มีไฟล์คลาสทั้งหมดไปยัง Pi และเรียกใช้คลาส "Dummy" (ภาพที่ 3)

ในการรันโปรแกรมจริงของคุณบน Pi ตอนนี้คุณต้องใช้คำสั่ง java พร้อมตัวเลือก 'classpath' ซึ่งกำหนดให้คุณระบุคลาสหลักเพื่อดำเนินการอย่างชัดเจน จากไคลเอ็นต์ ssh ไปที่ไดเร็กทอรี dist สำหรับโครงการของคุณ คำสั่งที่ถูกต้องอยู่ในรูปแบบ:

java -cp project_name.jar package_name.class_name

เห็นได้ชัดว่า project_name หมายถึงโครงการ ที่เปลี่ยนแปลงเฉพาะเมื่อต้องรับมือกับโครงการใหม่ แน่นอน package_name หมายถึงแพ็คเกจ และ class_name หมายถึงคลาสหลักที่จะดำเนินการ ดังที่กล่าวไว้ก่อนหน้านี้ โปรเจ็กต์สามารถมีแพ็คเกจได้มากมาย ในทำนองเดียวกัน แพ็คเกจสามารถมีได้หลายคลาส และทั้งหมดอาจเป็นคลาสหลัก หรือโปรแกรม ที่สามารถดำเนินการได้จากบรรทัดคำสั่ง ดังนั้น เทคนิค 'เส้นทางของคลาส' จึงค่อนข้างมีประโยชน์สำหรับการพัฒนาโปรแกรมที่ซับซ้อนซึ่งมีหลายคลาส ซึ่งบางคลาสเป็นคลาสหลักเพื่อช่วยในการทดสอบหน่วยเท่านั้น

คำสั่งต่อไปนี้รันโปรแกรมตัวอย่างของฉัน:

java -cp MyRemoteProg.jar myremoteprog. MyRemoteProg

ขั้นตอนที่ 10: ใช้ประโยชน์จากการจัดการไลบรารี NetBeans

หนึ่งในแง่มุมที่ยากที่สุดแต่สำคัญที่สุดของโปรแกรมที่ซับซ้อนคือการจัดการกับไลบรารี นั่นคือโค้ดที่คนอื่นเขียนไว้แล้ว NetBeans ทำงานได้อย่างน่าชื่นชมในการขจัดความเจ็บปวดส่วนใหญ่จากการจัดการห้องสมุด

ฉันจะใช้เป็นตัวอย่าง Pi4J ซึ่งช่วยให้โปรแกรม Java เข้าถึง Raspberry Pi GPIO, บัส I2C และ I/O ฮาร์ดแวร์อื่นๆ Pi4J เป็นเพียงตัวอย่างหนึ่งของการสนับสนุนการทำสิ่งต่างๆ สนุกๆ บน Pi ด้วย Java

คุณต้องดาวน์โหลดไลบรารีไปยังเวิร์กสเตชันของคุณก่อน ดูหน้าดาวน์โหลด Pi4J เนื่องจากคุณไม่ได้ติดตั้ง Pi4J บน Pi ให้ดาวน์โหลดไฟล์ zip ไปยังเวิร์กสเตชันของคุณ คุณอาจจะหรือไม่ต้องเปิดเครื่องรูดอย่างชัดเจนเมื่อดาวน์โหลด zip แล้ว

ตอนนี้ คุณต้องสร้าง "ไลบรารีส่วนกลาง" ใน NetBeans:

1. ในเมนูหลักของ NetBeans คลิกเครื่องมือ ->ไลบรารี คุณจะเห็นป๊อปอัป Ant Library Manager (ภาพที่หนึ่ง)
2. คลิก New Library ที่ด้านล่างซ้าย คุณจะเห็นป๊อปอัป New Library (รูปที่สอง)
3. พิมพ์ชื่อที่สื่อความหมายที่คุณต้องการใช้แล้วคลิกตกลง คุณจะเห็นป๊อปอัป Ant Library Manager อีกครั้ง ตอนนี้จะแสดงไลบรารีใหม่ที่คุณสร้างขึ้น (ภาพที่ 3)
4. คลิกเพิ่ม JAR/โฟลเดอร์ทางด้านขวา คุณจะเห็นป๊อปอัปเรียกดู JAR/โฟลเดอร์ (ภาพที่สี่)
5. ไปที่แล้วเลือก pi4j-core.jar จากนั้นคลิกเพิ่ม JAR/โฟลเดอร์ คุณจะกลับไปที่ป๊อปอัป Ant Library Manager
6. ในป๊อปอัป Ant Library Manager ให้คลิกตกลง คุณจะกลับไปที่หน้าต่างหลักของ NetBeans

คุณได้เพิ่มไลบรารีเพื่อให้สามารถใช้ในโปรเจ็กต์ใดก็ได้ ตอนนี้ คุณต้องเพิ่มไลบรารีในโครงการของคุณ:

1. เปิดป๊อปอัปคุณสมบัติของโปรเจ็กต์ (ดูขั้นตอนที่ 5) และเลือกหมวดหมู่ไลบรารี (ภาพที่ห้า)
2. คลิก เพิ่มไลบรารี ที่ด้านขวาของป๊อปอัป คุณจะเห็นป๊อปอัปเพิ่มไลบรารี (ภาพที่หก)
3. ไปที่ห้องสมุดและเลือก จากนั้นคลิกเพิ่มไลบรารี คุณจะเห็นป๊อปอัปคุณสมบัติของโครงการอีกครั้ง ขณะนี้ไลบรารีจะปรากฏในรายการ Compile-time Libraries ในป๊อปอัป
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 ของโปรเจ็กต์

ขั้นตอนที่ 11: ไปสนุกกันเถอะ

ฉันได้อธิบายวิธีการบรรลุการพัฒนา Java อย่างมีประสิทธิภาพมากสำหรับ Raspberry Pi Raspberry Pi เป็นเทคโนโลยีที่ได้รับความนิยมอย่างมหาศาลสำหรับโครงการต่างๆ Java เป็นภาษาโปรแกรมระดับมืออาชีพที่มีข้อได้เปรียบด้านประสิทธิภาพเหนือ Python และมีข้อได้เปรียบด้านความปลอดภัยเหนือ C/C++ NetBeans เป็น IDE ระดับมืออาชีพที่เพิ่มประสิทธิภาพการทำงานของโปรแกรมเมอร์อย่างมาก

ฉันคิดว่าการรวมกันนี้ค่อนข้างน่าสนใจ ตอนนี้ไปสนุกกับการใช้ชุดค่าผสมสำหรับโครงการของคุณ