Ефективно развитие на Java за Raspberry Pi: 11 стъпки (със снимки)

2024 Автор: John Day | [email protected]. Последно модифициран: 2024-01-30 07:50

Тази инструкция описва много ефективен подход за разработване на Java програми за Raspberry Pi. Използвах подхода за разработване на възможности на Java, вариращи от поддръжка на устройства на ниско ниво до многонишкови и мрежови програми. Подходът е не само ефективен, но и безплатен!

По принцип подходът е отдалечено разработване с помощта на NetBeans. NetBeans работи на работна станция (настолен или преносим компютър, а не Raspberry Pi), свързана чрез Wi -Fi към Raspberry Pi. След като всичко е настроено правилно, можете да напишете Java програма в NetBeans и след това с едно щракване да компилира и изгради програмата на работната станция, да я изтегли на Pi, да стартира програмата на Pi и да достави изход към конзолата NetBeans. Магия! Можете дори да отстраните грешки в работещата програма, да зададете точки на прекъсване и да проверите стойностите на променливите. Още магия!

Останалата част от това въведение описва мотивацията за използване на Java и за отдалечено разработване с помощта на NetBeans. Ако ви е грижа за мотивацията, прочетете нататък. Ако не ви пука, преминете към стъпка 1.

Защо да използвате Java на Raspberry Pi?

Налични са много езици за програмиране за Raspberry Pi, но ще огранича дискусията до езици за програмиране „професионален клас“, които са насочени към самостоятелни програми, поддържат многозадачност, позволяват хардуерен и мрежов достъп и т.н. Това означава Java, Python или C/C ++. Последните версии на Raspbian включват разработка и поддръжка за всички тези езици.

Python на практика е „популяризиран“за използване в Pi, поне отчасти заради лекотата на обучение за нови програмисти. Аз съм опитен програмист и не обичам Python поради признато субективно неприязън към редица негови характеристики, например динамично писане. Има една характеристика на Python, за която моето неприязън е обективно - производителността. Този източник показва, че Java винаги е по -бърза от Python 3 и всъщност може да работи стотици пъти по -бързо, в зависимост от задачата.

C според мен е "машинен език на високо ниво", т.е. нещо, което е много близко до системния хардуер или поне до операционната система. Можете да направите почти всичко и можете да го направите възможно най -бързо; всъщност този източник предполага, че C може да работи до 7X толкова бързо, колкото Java. Аз също не обичам C, тъй като (субективно) не харесвам някои негови характеристики, които намирам за тайнствени, архаични или и двете; например изрични указатели. Обективно, фактът, че можете да направите всичко, означава, че сте само неясна грешка (например лоша аритметика на указател или грешна memcpy), далеч от презаписване на паметта и потенциално сриване на програмата или дори цялата система. Java предотвратява подобни опасности, така че Java е по -безопасна. Чувствам, че безопасността също подобрява производителността на програмиста. Смятам, че C ++ е обектно-ориентирана "обвивка" около 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 (IDE).

Може да е полезно да обсъдим накратко тези „други подходи“. Всички те отговарят на основните критерии, че Raspberry Pi няма свързана клавиатура, мишка или дисплей. Има много причини за този критерий, но основната ми причина е, че разработвам мобилни роботи и не искам Pi да бъде свързан с никакви периферни устройства, с изключение на роботизирани подсистеми, дори по време на разработката.

VNC сървърът, включен в Raspbian, осигурява отдалечен графичен потребителски интерфейс (GUI), който позволява форма на отдалечено разработване, където само отдалеченият GUI работи на работната станция, а всичко останало, писане, компилиране и изграждане, се извършва на Pi. С VNC е лесно да използвате инструментите за разработка, поддържащи Java, които се доставят в Raspbian, като BlueJ, Geany и Greenfoot. Някои от тях могат да се считат за IDE; обаче ги намирам далеч от професионална оценка.

Технически е възможно да се инсталира Java IDE от професионален клас като Eclipse или NetBeans на Raspberry Pi и да се използва дистанционно чрез VNC. Докладите и здравият разум предполагат, че резултатите биха били разочароващи поради големия отпечатък на паметта и мощността на процесора, каквито изискват тези IDE, както и мрежовата латентност, въведена от отдалечен графичен интерфейс.

И Eclipse, и NetBeans работят много добре на работна станция. С Eclipse писането на код е приятно изживяване, но изграждането на програмата не е; изтеглянето на програмата трябва да се извършва извън Eclipse; изпълнението на програмата на Pi е напълно независимо от Eclipse. Общият резултат е многоетапен, почти болезнен процес, който не може да поддържа дистанционно отстраняване на грешки. NetBeans има вградено компилиране, изграждане, изтегляне, отдалечено изпълнение и отдалечено отстраняване на грешки, което го прави превъзходен подход.

Стъпка 1: Настройте Raspberry Pi

За да използвате подхода за отдалечено разработване, трябва да започнете, като настроите целевата Raspberry Pi. Има много ресурси, включително Instructables, на разположение за подпомагане при настройването на Raspberry Pi. Вижте това за основите на настройката на Pi (и повече).

Този Instructable предполага вас

• инсталирайте най -новия Raspbian; уверете се, че сте записали потребителския идентификатор и парола на Pi
• настройте Wifi и се свържете с вашия рутер (вижте това); уверете се, че сте записали IP адреса на Pi
• активирайте SSH (вижте това), за да разрешите отдалечен достъп до Pi от работната станция

След като завършите настройката, можете да изключите и изключите дисплея, клавиатурата и мишката от Pi. Това е едно от ключовите предимства на дистанционното развитие. Трябва да оставите всеки Wi -Fi ключ свързан (разбира се, не е необходим за 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 клиента

sudo update-alternative --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 update-alternatives --config java

Стъпка 2: Инсталирайте NetBeans на работната станция

Сега трябва да инсталирате NetBeans на вашата работна станция. Насочете браузъра на вашата работна станция към страницата за изтегляне на NetBeans. Ще видите няколко възможни пакета, които поддържат двете издания на Java, както и други езици. Всичко, от което се нуждаете за разработката на Java за Raspberry Pi, е Java SE, но можете да получите пакета Java EE или пакета All. След като решите кой пакет искате, щракнете върху съответния бутон за изтегляне. Тук можете да намерите допълнителни инструкции за инсталиране на вашата работна станция.

След като инсталирате 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. В полето Host въведете IP адреса за Pi, намерен в стъпка 1.
6. В полето Потребителско име въведете потребителското име, което сте използвали в стъпка 1.
7. Оставете Използване на удостоверяване с парола избрано и в полето Парола въведете паролата, която сте създали в стъпка 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/и е напълно приемливо. Можете да използвате нещо различно, ако желаете, въпреки че трябва да е достъпно за the_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 -ра отляво). Ще видите изскачащ прозорец Нов проект [изберете проект] (снимка първа).
2. По подразбиране (Категория: Java, Проект: Приложение Java) са правилни за този пример, така че просто щракнете върху Напред. Ще видите изскачащ прозорец New Java Application [name and location] (снимка две показва стойности за моя пример). ЗАБЕЛЕЖКА: Редактирах потребителската си информация, използвайки цветните правоъгълници.
3. В полето Име на проект въведете валидно име на проект на Java по ваш избор. Името трябва да започва с главна буква, а конвенцията предполага камилски регистър при свързване на думи.
4. Полето Местоположение на проекта контролира къде се намира проектът във вашата файлова система. По подразбиране варира в зависимост от операционната система, но е безопасно да се приеме.
5. Полето Project Folder ви позволява да контролирате името на папката за проекта. Смятам, че е най -добре да използвам по подразбиране, което е конкатенация на полето Местоположение и полето Име.
6. Когато квадратчето Създаване на основен клас е поставено отметка, NetBeans автоматично създава пакет и файл с основен клас (програма, която може да се изпълнява от командния ред) със същото име като проекта. Мисля, че обикновено трябва да бъде отметнато, но в този случай ще го оставя проверено, което елиминира изрични действия, които иначе са необходими за това (снимка втора).
7. Щракнете върху Готово, за да създадете проекта, пакет и файл с основен клас. Сега горният ляв прозорец на главния прозорец на NetBeans показва вашия проект, който съдържа един пакет, който от своя страна съдържа един файл с клас с метод main (). Горният десен панел съдържа изходния код по подразбиране за основния клас (програмата), автоматично генериран от NetBeans (снимка три).

В този момент можете да напишете някакъв код в основния метод и да го стартирате на работната станция. Това понякога може да е желателно, но е ненужно за тази инструкция, така че преминете към следващата стъпка.

Стъпка 5: Конфигурирайте проекта NetBeans да работи отдалечено на Raspberry Pi

За да конфигурирате проекта NetBeans и програма, която той съдържа, за да се изпълнява отдалечено на Raspberry Pi, направете следното:

1. Щракнете с десния бутон или с два пръста (зависи от операционната станция) върху проекта в прозореца Проекти на главния прозорец на NetBeans, за да изведете менюто на проекта и щракнете върху Свойства. Ще видите изскачащото меню Project Properties (снимката показва изскачащия прозорец с правилните стойности за моя пример).
2. Под Категории вляво изберете Изпълни.
3. Щракнете върху New вдясно от полето Configuration. В изскачащия прозорец Създаване на нова конфигурация въведете име за конфигурацията и щракнете върху OK. Името може да бъде всичко; Току -що повторно използвах името на платформата ("My Pi"). Още веднъж ще видите изскачащия прозорец Свойства на проекта.
4. Щракнете върху иконата на падащото меню вдясно от полето Runtime Platform. От изскачащия списък изберете отдалечената платформа, която сте създали по -рано (в моята среда „My Pi“).
5. Щракнете върху OK, за да настроите отдалечената платформа за проекта. Отново ще видите главния прозорец.

Вече сте готови да напишете код и да стартирате програмата от разстояние.

Стъпка 6: Напишете Java програма на работната станция и я стартирайте на Raspberry Pi

Десният панел в главния прозорец на NetBeans показва файла на основния клас, генериран от NetBeans. Въведете просто изявление за печат в основния метод на файла на класа (снимка първа). Сега това е пълна Java програма, която прави нещо, макар и нещо много просто.

За да стартирате програмата на Pi, щракнете върху иконата Run (зелената стрелка, сочеща вляво) в главния прозорец. NetBeans компилира кода, изгражда jar файл, изтегля jar файла в Raspberry Pi, идентифициран от отдалечената платформа, изпълнява програмата на Pi, улавя изхода (System.out) на програмата и отразява този изход към NetBeans Изходен прозорец в долния десен ъгъл на главния прозорец (снимка втора).

Вече значително разширихте своя набор от умения за разработване на проекти на Raspberry Pi! Но почакай…. Има още!

Стъпка 7: Отстранете грешката в програмата Java с NetBeans

Една от най -мощните характеристики на интегрирана среда за развитие на индустриална сила като NetBeans е възможността за отстраняване на грешки в програмата, докато работи. NetBeans ви позволява да използвате пълния набор от инструменти за отстраняване на грешки, докато работите отдалечено. Това включва задаване на точки на прекъсване на „важни“или „обезпокоителни“места в програмата и изследване на стойността на променливите при текущото състояние на изпълнение.

Простата програма в последната стъпка е твърде проста, за да демонстрира отстраняване на грешки, затова добавих допълнителен код към програмата. Допълнителният код добавя две променливи.

За да използвате инструментите за отстраняване на грешки, първо трябва да зададете една или повече точки на прекъсване. За да зададете точка на прекъсване, щракнете върху номера на реда, където искате да спрете изпълнението; се появява икона на червен правоъгълник и целият ред придобива червен фон (снимка първа).

За да отстраните грешките в програмата, работеща на Pi, щракнете върху иконата Debug (непосредствено вдясно от иконата Run) в главния прозорец на NetBeans. Както при нормалното изпълнение, NetBeans компилира, изгражда, изтегля, изпълнява, улавя изхода и отразява този изход. Но с отстраняване на грешки, NetBeans спира изпълнението в точки на прекъсване и ви позволява да проверите състоянието на изпълнение (снимка втора, показваща прозореца Променливи в долния десен ъгъл).

Изпълнението спира на точката на прекъсване преди изпълнение на инструкцията на линията с точката на прекъсване. Зеленият фон показва следващото изявление, което трябва да бъде изпълнено. Така в моя пример, с точка на прекъсване на ред 9, променлива а все още не съществува, още по -малко има стойност.

Сега задръжте курсора върху иконата на менюто за отстраняване на грешки в главния прозорец (първата икона с двойна стрелка надолу вдясно от иконата за отстраняване на грешки) и щракнете върху иконата Step Over (тя има син документ на заден план и зелена стрелка обратно на часовниковата стрелка на преден план). [ЗАБЕЛЕЖКА: ако направите главния прозорец на NetBeans достатъчно широк, менюто за отстраняване на грешки се разширява и иконите за отстраняване на грешки се показват вдясно от иконата за отстраняване на грешки.] NetBeans изпълнява израза в точката на прекъсване и спира изпълнението преди следващото изявление. Сега ще видите, че променливата а съществува и има очакваната стойност (снимка три).

Щракнете два пъти върху иконата Step Over. Ще видите, че и трите променливи имат стойности; имайте предвид, че c все още е нула (снимка четири).

Щракнете веднъж върху иконата Step Over. Ще видите, че променливата c вече има правилната стойност, т.е. сумата от променливите a и b (снимка пет).

И накрая, в менюто за отстраняване на грешки щракнете върху иконата Изпълнение (зелен кръг с бяла стрелка). Това кара изпълнението да продължи до следващата точка на прекъсване или до края на програмата, което от двете настъпи първо. Сега се появява прозорецът Output и показва същия изход като при нормалното изпълнение, в този случай текста в оператора print.

Стъпка 8: Изпълнете програмата независимо от NetBeans

Може да дойде моментът, в който искате да изпълните програмата си на Raspberry Pi, без „помощ“или „намеса“от NetBeans. Много е просто. Първо, отворете ssh клиент към вашия Pi.

Запомнете от стъпка 3, че NetBeans поставя вашия буркан за проекти в работна директория на Pi. Базата по подразбиране е/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!

Това работи, защото информацията във jar файла идентифицира кой основен клас в бурканчето да се изпълни.

Можете също да промените работната директория (чрез cd) на местоположението на jar файла и след това да издадете по -кратка команда, за да получите същите резултати.

java -jar MyRemoteProg.jar

Стъпка 9: Изградете и изтеглете, но не изпълнявайте програмата чрез NetBeans

Има ситуации, в които искате NetBeans да изгради и изтегли вашата програма, но не и да я изпълни. Една такава ситуация възниква, когато вашата програма се нуждае от въвеждане на клавиатура. Ако случаят е такъв, използвайки техниката в предишната стъпка, след като изградите и изтеглите, програмата се изпълнява на Raspberry Pi и така очаква въвеждане на клавиатура от Pi, но разбира се, няма клавиатура, свързана към Pi, така че програмата виси - не е добре.

Трябва да използвате малко по -различна техника за изпълнение на програмата. По същество вие създавате "фиктивен" файл от основния клас, който по същество не прави нищо, и го идентифицирате като програмата, която ще бъде изпълнена след изтеглянето. В този случай "манекенът" се изпълнява и след това можете да стартирате вашата "истинска" програма директно на Pi.

За да използвате тази техника, първо създайте нов основен клас:

1. Отворете менюто на проекта както в стъпка 5 и щракнете върху Ново-> Основен клас Java. Ще видите изскачащ прозорец Нов основен клас Java.
2. В полето Име на клас въведете име. Името може да бъде всичко, което харесвате; Използвах "Dummy". Полето Package ви позволява да идентифицирате пакета на класа; избирате пакет, като използвате падащото меню вдясно от полето. Класът може да бъде в същия пакет като вашата „истинска“програма или в различен пакет; Сложих новия клас в същия пакет. Щракнете върху Готово. Сега ще видите главния прозорец на NetBeans с новия файл в горния десен панел (снимка първа). Добавих просто изявление за печат относно работата с Pi, но всъщност не е необходимо нищо.

За да стартирате „Dummy“след изтегляне, трябва да го направите „основния клас за изпълнение по подразбиране“за проекта:

1. Отворете свойствата на проекта както в стъпка 5. Изберете категорията Изпълнение. Щракнете върху Преглед вдясно от полето Основен клас. Ще видите изскачащия прозорец Преглед на основните класове (снимка втора).
2. Изберете класа „Dummy“. Щракнете върху Избор на основен клас. Ще видите отново свойствата на проекта.
3. Щракнете върху OK. Ще се върнете към главния прозорец.

Сега, когато щракнете върху иконата "Изпълнение", NetBeans изпълнява/изгражда целия проект, изтегля буркана, съдържащ всички файлове на класа, в Pi и изпълнява класа "Dummy" (снимка три).

За да изпълните истинската си програма на Pi, сега трябва да използвате командата java с опцията 'classpath', която изисква изрично да идентифицирате основния клас за изпълнение. От ssh клиент отидете в директорията dist за вашия проект. Правилната команда е от вида:

java -cp project_name.jar package_name.class_name

Project_name очевидно се отнася до проекта; това се променя само при работа с нов проект. Разбира се, името на пакета се отнася до пакета, а името на класа се отнася до основния клас за изпълнение. Както беше казано по -рано, проектът може да съдържа много пакети. По същия начин пакетът може да съдържа много класове и всички могат да бъдат основни класове или програми, които могат да се изпълняват от командния ред. По този начин техниката „classpath“е доста полезна за разработване на сложни програми с много класове, някои от които са основни класове само за подпомагане на единичното тестване.

Следващата команда изпълнява моята примерна програма:

java -cp MyRemoteProg.jar myremoteprog. MyRemoteProg

Стъпка 10: Използвайте управлението на библиотеките в NetBeans

Един от най -трудните, но най -важни аспекти на сложните програми е работата с библиотеки, т.е. кода, който някой друг вече е написал. NetBeans върши чудесна работа, като премахва по -голямата част от болката от управлението на библиотеките.

Ще използвам като пример Pi4J, който дава достъп на Java програмите до Raspberry Pi GPIO, I2C шина и друг хардуерен I/O. Pi4J е само един пример за поддръжка за правене на много забавни неща на Pi с Java.

Първо трябва да изтеглите библиотеката на вашата работна станция. Вижте страницата за изтегляне на Pi4J. Тъй като не инсталирате Pi4J на Pi, изтеглете zip на вашата работна станция. Може да се наложи, а може и да не се наложи да разархивирате, след като ципът бъде изтеглен.

Сега трябва да създадете „глобална библиотека“в NetBeans:

1. В главното меню на NetBeans щракнете върху Инструменти -> Библиотеки. Ще видите изскачащия прозорец Ant Library Library (снимка първа).
2. Щракнете върху Нова библиотека в долния ляв ъгъл. Ще видите изскачащ прозорец Нова библиотека (снимка втора).
3. Въведете смислено име, което искате да използвате, и щракнете върху OK. Ще видите отново изскачащия прозорец Ant Library Library Manager. Сега показва новата библиотека, която сте създали (снимка три).
4. Щракнете върху Добавяне на JAR/папка вдясно. Ще видите изскачащото меню Browse JAR/Folder (снимка четвърта).
5. Придвижете се до и след това изберете pi4j-core.jar. След това щракнете върху Добавяне на JAR/папка. Ще се върнете към изскачащия прозорец на Ant Library Library.
6. В изскачащия прозорец Ant Library Library щракнете върху OK. Ще се върнете към главния прозорец на NetBeans.

Добавихте библиотеката, така че да може да се използва във всеки проект. Сега трябва да добавите библиотеката към вашия проект:

1. Отворете изскачащия прозорец Свойства на проекта (вижте стъпка 5) и изберете категорията Библиотеки (снимка пета).
2. Щракнете върху Добавяне на библиотека от дясната страна на изскачащия прозорец. Ще видите изскачащ прозорец Добавяне на библиотека (снимка шеста).
3. Отидете до библиотеката и я изберете. След това щракнете върху Добавяне на библиотека. Отново ще видите изскачащия прозорец Свойства на проекта. Библиотеката вече се появява в списъка на библиотеките по време на компилиране в изскачащия прозорец.
4. В изскачащия прозорец Свойства на проекта щракнете върху OK. Ще се върнете към главния прозорец.

Вие сте добавили библиотеката към вашия проект, за да може програмата ви да я използва. Можете да извършите същата последователност от действия за всички библиотеки, от които се нуждаете за дадена програма.

Има три пъти, от които се нуждаете от библиотеката - компилиране, изграждане и изпълнение. За щастие, с NetBeans добавянето на библиотеката, както е показано по -горе, обработва всичко. За да потвърдя това, създадох друг основен клас, който прави абсолютния минимум, необходим за използване на I2C способността в Pi4J (снимка седем). Фактът, че няма грешки при показване, означава, че класът TestPi4J компилира. Щракването върху Run успешно изгражда и изтегля; NetBeans изтегля библиотеката в допълнение към jar файла, така че програмата ще се изпълни. За да проверите последното, можете да използвате техниката в стъпка 9 и в ssh клиента въведете следната команда (от директорията dist):

java -cp MyRemoteProg.jar myremoteprog. TestPi4J

Поучително е да се разбере как NetBeans борави с библиотеките. Докато сте в директорията dist за вашия проект, избройте съдържанието на директорията (използвайте командата ls) и ще видите поддиректория lib. Избройте съдържанието на тази директория и ще видите jar файла, идентифициран в глобалната библиотека, който в моя пример е pi4j-core.jar. Всички библиотеки, които добавяте към проекта, ще се появят в директорията lib и по този начин са достъпни за всички програми във файла на проекта на проекта.

Стъпка 11: Забавлявайте се

Описах подход за постигане на много ефективна разработка на Java за Raspberry Pi. Raspberry Pi е изключително популярна технология за широк спектър от проекти. Java е професионален език за програмиране, който предлага предимства на производителността пред Python и предлага предимства за безопасност пред C/C ++. NetBeans е професионална IDE, която значително увеличава производителността на програмистите.

Мисля, че комбинацията е доста завладяваща. Сега се забавлявайте, като използвате комбинацията за вашите проекти.