Wydajne tworzenie Java dla Raspberry Pi: 11 kroków (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:27

Ten Instructable opisuje bardzo wydajne podejście do tworzenia programów Java dla Raspberry Pi. Zastosowałem podejście do rozwijania możliwości Java, począwszy od obsługi urządzeń niskiego poziomu po programy wielowątkowe i sieciowe. Podejście jest nie tylko skuteczne, ale także bezpłatne!

Zasadniczo podejście polega na zdalnym programowaniu za pomocą NetBeans. NetBeans działa na stacji roboczej (komputer stacjonarny lub laptop, nie na Raspberry Pi) połączonej przez Wifi z Raspberry Pi. Gdy wszystko jest poprawnie skonfigurowane, możesz napisać program Java w NetBeans, a następnie jednym kliknięciem kompiluje i buduje program na stacji roboczej, pobiera program do Pi, uruchamia program na Pi i dostarcza dane wyjściowe do konsoli NetBeans. Magia! Możesz nawet debugować uruchomiony program, ustawiając punkty przerwania i sprawdzając wartości zmiennych. Więcej magii!

Pozostała część tego wprowadzenia opisuje motywację do używania Javy i zdalnego programowania przy użyciu NetBeans. Jeśli zależy Ci na motywacji, czytaj dalej. Jeśli Ci to nie zależy, przejdź do kroku 1.

Dlaczego warto korzystać z Javy na Raspberry Pi?

Istnieje wiele języków programowania dostępnych dla Raspberry Pi, ale ograniczę dyskusję do języków programowania „profesjonalnej”, które są ukierunkowane na samodzielne programy, obsługują wielozadaniowość, umożliwiają dostęp do sprzętu i sieci itp. Oznacza to, że Java, Python lub C/C++. Najnowsze wydania Raspbiana obejmują obsługę programistyczną i uruchomieniową dla wszystkich tych języków.

Python jest w rzeczywistości „promowany” do użytku na Pi, przynajmniej częściowo ze względu na łatwość uczenia się dla nowych programistów. Jestem doświadczonym programistą i nie przepadam za Pythonem ze względu na subiektywną niechęć do wielu jego cech, na przykład dynamicznego pisania. Jest jedna cecha Pythona, do której nie lubię obiektywnie – wydajność. To źródło pokazuje, że Java jest zawsze szybsza niż Python 3 i faktycznie może działać setki razy szybciej, w zależności od zadania.

Moim zdaniem C jest "językiem maszynowym wysokiego poziomu", tj. czymś, co jest bardzo bliskie sprzętowi systemowemu, a przynajmniej systemowi operacyjnemu. Możesz zrobić prawie wszystko i możesz to zrobić tak szybko, jak to możliwe; w rzeczywistości to źródło sugeruje, że C może działać do 7 razy szybciej niż Java. Nie przepadam również za C, ponieważ (subiektywnie) nie lubię niektórych jego cech, które uważam za tajemnicze, archaiczne lub jedno i drugie; na przykład wyraźne wskaźniki. Obiektywnie rzecz biorąc, fakt, że możesz zrobić wszystko, oznacza, że jesteś tylko niejasnym błędem (np. zła arytmetyka wskaźników lub błędna memcpy) z dala od nadpisywania pamięci i potencjalnego zawieszenia programu, a nawet całego systemu. Java zapobiega takim zagrożeniom, więc Java jest bezpieczniejsza. Uważam, że bezpieczeństwo poprawia również produktywność programistów. Uważam, że C++ jest zorientowanym obiektowo „opakowaniem” wokół C, które nie robi nic, aby wyeliminować zagrożenia związane z C.

Podsumowując: Java jest szybsza niż Python. Java jest bezpieczniejsza niż C.

Czy istnieją ograniczenia podczas korzystania z Javy?

Do tej pory byłem w stanie zrobić wszystko w Javie, co mogę zrobić w Pythonie. Są rzeczy, które można zrobić w C, których nie można zrobić w Javie, ale jak dotąd wszystko, co chciałem zrobić, zostało zaadresowane przez fanów Javy w społeczności Pi. Podam przykład w późniejszym kroku. To powiedziawszy, kupiłem czujniki od dostawców, którzy dostarczyli „sterowniki” dla czujników tylko w Pythonie (lub C/C++ dla Arduino), więc musiałem napisać odpowiednik w Javie; dodatkowy wysiłek niekoniecznie jest produktywny, ale może skutkować lepszym wglądem w działanie czujnika.

Dlaczego zdalny rozwój w oparciu o NetBeans?

Odkryłem, że zdalny rozwój oparty na NetBeans znacznie zwiększa produktywność podczas korzystania z Javy dla Raspberry Pi. Jestem przekonany, że można zastosować podejście do tworzenia szybkich i bezpiecznych programów, ze względu na nieodłączną charakterystykę Javy, podczas pisania, budowania i debugowania ich znacznie szybciej niż inne podejścia, które znalazłem, dzięki zdalnemu programowaniu z wykorzystaniem „profesjonalnego klasy NetBeans Integrated Development Environment (IDE).

Przydatne może być krótkie omówienie tych „innych podejść”. Wszystkie spełniają podstawowe kryteria, że Raspberry Pi nie ma podłączonej klawiatury, myszy ani wyświetlacza. Istnieje wiele powodów dla tego kryterium, ale moim głównym powodem jest to, że opracowuję roboty mobilne i nie chcę, aby Pi było podłączone do jakichkolwiek urządzeń peryferyjnych z wyjątkiem podsystemów robotycznych, nawet podczas opracowywania.

Serwer VNC zawarty w Raspbian zapewnia zdalny graficzny interfejs użytkownika (GUI), który umożliwia formę zdalnego programowania, gdzie tylko zdalny GUI działa na stacji roboczej, a wszystko inne, pisanie, kompilowanie i budowanie, odbywa się na Pi. Dzięki VNC można łatwo korzystać z narzędzi programistycznych obsługujących język Java, które są dostarczane w języku Raspbian, takich jak BlueJ, Geany i Greenfoot. Niektóre z nich można uznać za IDE; jednak uważam, że są dalekie od profesjonalnej jakości.

Technicznie możliwe jest zainstalowanie profesjonalnego środowiska Java IDE, takiego jak Eclipse lub NetBeans, na Raspberry Pi i używanie go zdalnie przez VNC. Raporty i zdrowy rozsądek sugerują, że wyniki byłyby rozczarowujące ze względu na dużą ilość pamięci i moc procesora, jakich wymagają takie IDE, a także opóźnienia w sieci wprowadzone przez zdalny GUI.

Zarówno Eclipse, jak i NetBeans działają bardzo dobrze na stacji roboczej. W środowisku Eclipse pisanie kodu jest przyjemnym doświadczeniem, jednak budowanie programu już nie; pobieranie programu musi odbywać się poza Eclipse; wykonanie programu na Pi jest całkowicie niezależne od Eclipse. Ogólny wynik to wieloetapowy, prawie bolesny proces, który nie obsługuje zdalnego debugowania. NetBeans ma wbudowaną kompilację, kompilację, pobieranie, zdalne wykonywanie i zdalne debugowanie, co czyni go lepszym podejściem.

Krok 1: Skonfiguruj Raspberry Pi

Aby użyć podejścia do zdalnego programowania, musisz zacząć od skonfigurowania docelowego Raspberry Pi. Istnieje wiele zasobów, w tym Instructables, które pomagają w konfiguracji Raspberry Pi. Zobacz to, aby zapoznać się z podstawami konfigurowania Pi (i nie tylko).

Ta instrukcja zakłada, że

• zainstaluj najnowszy Raspbian; upewnij się, że zapisałeś identyfikator użytkownika i hasło Pi
• skonfiguruj Wifi i połącz się z routerem (zobacz to); upewnij się, że zapisałeś adres IP Pi
• włącz SSH (zobacz to), aby zezwolić na zdalny dostęp do Pi ze stacji roboczej

Po zakończeniu konfiguracji możesz wyłączyć i odłączyć wyświetlacz, klawiaturę i mysz od Pi. Jest to jedna z kluczowych zalet zdalnego rozwoju. Musisz pozostawić podłączony klucz Wifi (nie jest to oczywiście potrzebne w przypadku modelu Pi 3 lub Pi Zero W), a następnie możesz zasilić Pi.

Aby przetestować, otwórz klienta ssh na swojej stacji roboczej, np. Terminal na MacOS lub putty na Windows. Następnie wprowadź polecenie ssh (secure shell) w następującej postaci:

ssh adres_ip_pi -l identyfikator_użytkownika_pi

Powinieneś otrzymać monit o wprowadzenie hasła identyfikatora użytkownika Pi. Jeśli nie pojawi się żaden monit, sprawdź, czy w poleceniu ssh wpisałeś poprawny adres IP. Wprowadź swoje hasło (zostanie ukryte), a następnie powinieneś zobaczyć monit powłoki Pi, który wygląda mniej więcej tak:

pi@raspberrypi:~ $

Jeśli nie widzisz monitu, sprawdź użyty identyfikator użytkownika i hasło.

Teraz musisz znaleźć ścieżkę do środowiska wykonawczego Java i potwierdzić, że domyślna wersja to Java 8 (powinna być prawdziwa dla najnowszego Raspbiana). Aby znaleźć ścieżkę Java runtime, w kliencie ssh wpisz polecenie

sudo update-alternatives -- wyświetl java

Powinieneś zobaczyć odpowiedź z dwoma pierwszymi wierszami, które wyglądają jak poniżej:

java - tryb automatyczny

link najlepsza wersja to /usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java

Znak „-8-” w drugim wierszu potwierdza, że domyślnym środowiskiem wykonawczym jest Java 8. Zapisz ścieżkę w drugim wierszu, ponieważ będzie ona potrzebna do skonfigurowania NetBeans do zdalnego programowania w późniejszym kroku.

Jeśli domyślnym środowiskiem wykonawczym nie jest Java 8, w kliencie ssh wprowadź następujące polecenie, aby przełączyć się na Java 8 (zakładając, że jest zainstalowany)

sudo update-alternatives --config java

Krok 2: Zainstaluj NetBeans na stacji roboczej

Teraz musisz zainstalować NetBeans na swojej stacji roboczej. Skieruj przeglądarkę stacji roboczej na stronę pobierania NetBeans. Zobaczysz kilka możliwych pakietów, które obsługują dwie edycje Javy, a także inne języki. Wszystko, czego potrzebujesz do programowania Java dla Raspberry Pi, to Java SE, ale możesz uzyskać pakiet Java EE lub pakiet All. Gdy zdecydujesz, który pakiet chcesz, kliknij odpowiedni przycisk Pobierz. Dodatkowe instrukcje dotyczące instalacji systemu operacyjnego stacji roboczej można znaleźć tutaj.

Po zainstalowaniu NetBeans uruchom go (może to zrobić automatycznie po instalacji). Powinieneś zobaczyć główne okno NetBeans, jak pokazano na rysunku. Zdjęcie zostało zrobione na komputerze Mac, a główne okno może wyglądać nieco inaczej w systemie Windows.

Po pomyślnym zainstalowaniu i uruchomieniu NetBeans przejdź do następnego kroku.

Krok 3: Skonfiguruj Raspberry Pi jako zdalną platformę w NetBeans

Poniższe działania konfigurują Raspberry Pi jako zdalną platformę Java SE dla NetBeans. Dzięki temu NetBeans może pobierać i uruchamiać programy Java na Pi. Tutaj znajdziesz nieco ogólny opis.

UWAGA: W tym i kolejnych krokach pokazuję wartości specyficzne dla mojego środowiska dla różnych aspektów konfiguracji i kodowania; twój będzie oczywiście inny.

Aby skonfigurować Pi jako zdalną platformę:

1. Na pasku menu głównego NetBeans wybierz Narzędzia -> Platformy Java. Zobaczysz wyskakujące okno Java Platform Manager (zdjęcie pierwsze).
2. Kliknij Dodaj platformę w lewym dolnym rogu. Zobaczysz wyskakujące okienko Dodaj platformę Java [typ platformy] (zdjęcie dwa).
3. Wybierz opcję Remote Java Standard Edition. Kliknij Następny. Zobaczysz wyskakujące okienko Add Java Platform [skonfiguruj zdalną platformę] (zdjęcie 3 pokazuje wyskakujące okienko po wprowadzeniu w polach odpowiednich wartości dla mojego środowiska).
4. W polu Nazwa platformy wprowadź nazwę dla Pi. Możesz użyć prawie wszystkiego, ale musi to być wyjątkowe.
5. W polu Host wprowadź adres IP dla Pi znalezionego w kroku 1.
6. W polu Nazwa użytkownika wprowadź nazwę użytkownika używaną w kroku 1.
7. Pozostaw zaznaczoną opcję Użyj uwierzytelniania hasła i w polu Hasło wprowadź hasło utworzone w kroku 1.
8. W polu Remote JRE Path musisz wpisać większość ścieżki do środowiska wykonawczego Java na Pi. W kroku 1 był to /usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/jre/bin/java. Musisz jednak pozostawić /bin/java w wartości pola.
9. NetBeans pobiera uruchamialny program do katalogu roboczego na Pi, określonego w polu Working Dir. Wartość domyślna to /the_Pi_user_ID/NetBeansProjects/ i jest to całkowicie akceptowalne. Możesz użyć czegoś innego, jeśli chcesz, ale musi to być dostępne dla_Pi_user_ID (zdjęcie 3).
10. Kliknij Zakończ w prawym dolnym rogu wyskakującego okienka. Po przetworzeniu powinieneś ponownie zobaczyć wyskakujące okno Java Platform Manager. Teraz powinieneś zobaczyć swoje zdalne Pi (pod nazwą, której użyłeś w akcji 4 powyżej) w kategorii Remote Java SE (zdjęcie czwarte).
11. Kliknij Testuj platformę w lewym dolnym rogu, aby przetestować połączenie między NetBeans a Twoim Pi. Najpierw zobaczysz wyskakujące okienko z napisem Weryfikacja platformy zdalnej. Jeśli się powiedzie, pojawi się drugie wyskakujące okienko wskazujące, że połączenie… zostało pomyślnie ustanowione. Jeśli nie, musisz sprawdzić i poprawić informacje wprowadzone w wyskakującym okienku Add Java Platform [skonfiguruj zdalną platformę] w czynnościach 5-9 powyżej. Możesz to zrobić z wyskakującego okienka Java Platform Manager; po prostu wybierz swoją platformę Pi, a następnie edytuj pola po prawej stronie wyskakującego okienka.
12. Po pomyślnym nawiązaniu połączenia kliknij Zamknij w wyskakującym okienku Java Platform Manager. Zobaczysz teraz główne okno NetBeans.

Teraz zaczyna się prawdziwa zabawa!

Krok 4: Utwórz projekt Java na stacji roboczej

Nie jest to pełne wyjaśnienie, jak korzystać z NetBeans lub Javy, ale opiszę minimalne czynności, aby napisać program w NetBeans na stacji roboczej i ostatecznie uruchomić program zdalnie na Raspberry Pi.

W NetBeans musisz najpierw utworzyć projekt, który będzie zawierał klasy Java dla programu. Ponadto w Javie klasy znajdują się w pakietach wspierających organizację i bezpieczeństwo. Aby utworzyć projekt i opcjonalnie utworzyć pakiet i plik klasy:

1. W głównym oknie NetBeans kliknij ikonę nowego projektu (2. od lewej). Zobaczysz wyskakujące okienko Nowy projekt [wybierz projekt] (zdjęcie pierwsze).
2. Wartości domyślne (Kategoria: Java, Projekt: Aplikacja Java) są poprawne w tym przykładzie, więc po prostu kliknij Dalej. Zobaczysz wyskakujące okienko Nowa aplikacja Java [nazwa i lokalizacja] (zdjęcie 2 pokazuje wartości dla mojego przykładu). UWAGA: Zredagowałem informacje o moim użytkowniku za pomocą kolorowych prostokątów.
3. W polu Nazwa projektu wprowadź prawidłową nazwę wybranego projektu Java. Nazwa musi zaczynać się wielką literą, a konwencja sugeruje wielbłądy przy łączeniu słów.
4. Pole Lokalizacja projektu określa, gdzie projekt znajduje się w systemie plików. Wartość domyślna różni się w zależności od systemu operacyjnego, ale można ją bezpiecznie zaakceptować.
5. Pole Folder projektu pozwala kontrolować nazwę folderu projektu. Uważam, że najlepiej jest użyć wartości domyślnej, która jest połączeniem pola Lokalizacja i pola Nazwa.
6. Gdy pole wyboru Create Main Class jest zaznaczone, NetBeans automatycznie tworzy pakiet i plik głównej klasy (program, który można uruchomić z wiersza poleceń) o tej samej nazwie co projekt. Myślę, że zwykle powinno być odznaczone, ale w tym przypadku zostawię to zaznaczone, co eliminuje wyraźne działania, które w przeciwnym razie byłyby do tego potrzebne (zdjęcie drugie).
7. Kliknij przycisk Zakończ, aby utworzyć projekt, pakiet i główny plik klasy. Teraz lewy górny panel głównego okna NetBeans pokazuje Twój projekt, który zawiera pojedynczy pakiet, który z kolei zawiera pojedynczy plik klasy z metodą main(). Prawy górny panel zawiera domyślny kod źródłowy głównej klasy (programu) generowany automatycznie przez NetBeans (rysunek trzeci).

W tym momencie możesz napisać kod w głównej metodzie i uruchomić go na stacji roboczej. Czasami może to być pożądane, ale nie jest potrzebne w przypadku tej instrukcji, więc przejdź do następnego kroku.

Krok 5: Skonfiguruj projekt NetBeans do zdalnego uruchamiania na Raspberry Pi

Aby skonfigurować projekt NetBeans i zawarty w nim program do zdalnego uruchamiania na Raspberry Pi, wykonaj następujące czynności:

1. Kliknij prawym lub dwoma palcami (w zależności od systemu operacyjnego stacji roboczej) projekt w panelu Projekty głównego okna NetBeans, aby wyświetlić menu projektu, a następnie kliknij Właściwości. Zobaczysz wyskakujące okienko Właściwości projektu (zdjęcie pokazuje wyskakujące okienko z odpowiednimi wartościami dla mojego przykładu).
2. W sekcji Kategorie po lewej stronie wybierz Uruchom.
3. Kliknij Nowy po prawej stronie pola Konfiguracja. W wyświetlonym oknie dialogowym Utwórz nową konfigurację wprowadź nazwę konfiguracji i kliknij przycisk OK. Nazwa może być dowolna; Właśnie ponownie użyłem nazwy platformy ("My Pi"). Po raz kolejny zobaczysz okno właściwości projektu.
4. Kliknij ikonę rozwijaną po prawej stronie pola Runtime Platform. Z listy w wyskakującym okienku wybierz zdalną platformę, którą utworzyłeś wcześniej (w moim środowisku „My Pi”).
5. Kliknij OK, aby skonfigurować zdalną platformę dla projektu. Ponownie zobaczysz główne okno.

Jesteś teraz gotowy do pisania kodu i zdalnego uruchamiania programu.

Krok 6: Napisz program Java na stacji roboczej i uruchom go na Raspberry Pi

Prawy panel w głównym oknie NetBeans pokazuje główny plik klasy wygenerowany przez NetBeans. Wpisz prostą instrukcję print w metodzie main pliku klasy (obrazek pierwszy). Jest to teraz kompletny program Java, który robi coś, choć coś bardzo prostego.

Aby uruchomić program na Pi, kliknij ikonę Uruchom (zielona strzałka skierowana w lewo) w oknie głównym. NetBeans kompiluje kod, buduje plik jar, pobiera plik jar do Raspberry Pi zidentyfikowanego przez zdalną platformę, wykonuje program na Pi, przechwytuje dane wyjściowe (System.out) programu i przekazuje je do NetBeans Okienko danych wyjściowych w prawym dolnym rogu okna głównego (rysunek drugi).

Teraz znacznie rozszerzyłeś swój zestaw umiejętności do tworzenia projektów na Raspberry Pi! Ale poczekaj…. Jest więcej!

Krok 7: Debuguj program Java za pomocą NetBeans

Jedną z najpotężniejszych cech przemysłowego zintegrowanego środowiska programistycznego, takiego jak NetBeans, jest możliwość debugowania programu podczas jego działania. NetBeans umożliwia korzystanie z pełnego zestawu narzędzi do debugowania podczas pracy zdalnej. Obejmuje to ustawianie punktów przerwania w „ważnych” lub „kłopotliwych” lokalizacjach w programie oraz sprawdzanie wartości zmiennych w bieżącym stanie wykonania.

Prosty program w ostatnim kroku jest zbyt prosty, aby zademonstrować debugowanie, więc dodałem do programu dodatkowy kod. Dodatkowy kod dodaje dwie zmienne.

Aby wykorzystać narzędzia do debugowania, musisz najpierw ustawić co najmniej jeden punkt przerwania. Aby ustawić punkt przerwania, kliknij numer wiersza, w którym chcesz zawiesić wykonanie; pojawi się ikona czerwonego prostokąta, a cała linia nabierze czerwonego tła (zdjęcie 1).

Aby debugować program uruchomiony na Pi, kliknij ikonę Debug (bezpośrednio po prawej stronie ikony Uruchom) w głównym oknie NetBeans. Podobnie jak w przypadku normalnego wykonywania, NetBeans kompiluje, buduje, pobiera, wykonuje, przechwytuje dane wyjściowe i odtwarza je. Jednak dzięki debugowaniu NetBeans zatrzymuje wykonywanie w punktach przerwania i pozwala zbadać stan wykonania (rysunek drugi, pokazujący panel Zmienne w prawym dolnym rogu).

Wykonanie zatrzymuje się w punkcie przerwania przed wykonaniem instrukcji w linii z punktem przerwania. Zielone tło wskazuje następną instrukcję do wykonania. Tak więc w moim przykładzie, z punktem przerwania w linii 9, zmienna a jeszcze nie istnieje, a tym bardziej ma wartość.

Teraz najedź kursorem na ikonę menu debugowania w oknie głównym (pierwsza ikona podwójnej strzałki w dół po prawej stronie ikony debugowania) i kliknij ikonę Przejdź przez (ma w tle niebieski dokument i zieloną strzałkę skierowaną w lewo na pierwszym planie). [UWAGA: jeśli ustawisz wystarczająco szerokie okno główne NetBeans, menu debugowania rozwinie się, a ikony akcji debugowania pojawią się po prawej stronie ikony Debug.] NetBeans wykonuje instrukcję w punkcie przerwania i zatrzymuje wykonywanie przed następną instrukcją. Zobaczysz teraz, że zmienna a istnieje i ma oczekiwaną wartość (rysunek 3).

Kliknij dwukrotnie ikonę Step Over. Zobaczysz, że wszystkie trzy zmienne mają wartości; zauważ, że c jest nadal zerem (rysunek czwarty).

Kliknij raz ikonę Przekrocz. Zobaczysz, że zmienna c ma teraz właściwą wartość, tj. sumę zmiennych a i b (rysunek piąty).

Na koniec w menu debugowania kliknij ikonę Uruchom (zielone kółko z białą strzałką). Powoduje to kontynuowanie wykonywania do następnego punktu przerwania lub do końca programu, w zależności od tego, co nastąpi wcześniej. Teraz pojawia się okienko Output i pokazuje te same dane wyjściowe, co przy normalnym wykonaniu, w tym przypadku tekst w instrukcji print.

Krok 8: Uruchom program niezależny od NetBeans

Może nadejść czas, kiedy zechcesz uruchomić swój program na Raspberry Pi, bez „pomocy” lub „zakłóceń” ze strony NetBeans. To bardzo proste. Najpierw otwórz klienta ssh na swoim Pi.

Pamiętaj z kroku 3, że NetBeans umieszcza twój projekt jar w katalogu roboczym na Pi. Domyślną bazą jest /home/pi/NetBeansProjects dla użytkownika pi. Określony katalog ma taką samą nazwę jak Twój projekt. NetBeans umieszcza słoik w podkatalogu o nazwie dist. W moim przykładzie pełna ścieżka to /home/pi/NetBeansProjects/MyRemoteProg/dist. W kliencie ssh na Pi, aby uruchomić program, możesz użyć polecenia java z opcją 'jar':

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

Zobaczysz wyniki wykonania w kliencie ssh; w moim przykładzie wynik będzie

Witam z Raspberry Pi!

Działa to, ponieważ informacje w pliku jar identyfikują klasę główną w pliku jar do wykonania.

Możesz również zmienić katalog roboczy (przez cd) na lokalizację pliku jar, a następnie wydać krótsze polecenie, aby uzyskać te same wyniki.

java -jar MyRemoteProg.jar

Krok 9: Kompiluj i pobieraj, ale nie uruchamiaj programu za pośrednictwem NetBeans

Są sytuacje, w których chcesz, aby NetBeans skompilował i pobrał twój program, ale nie wykonał go. Jedna z takich sytuacji ma miejsce, gdy program wymaga wprowadzania danych z klawiatury. W takim przypadku, korzystając z techniki z poprzedniego kroku, po skompilowaniu i pobraniu program działa na Raspberry Pi i oczekuje na wejście klawiatury z Pi, ale oczywiście nie ma klawiatury podłączonej do Pi, więc program się zawiesza -- niedobrze.

Aby wykonać program, musisz użyć nieco innej techniki. Zasadniczo tworzysz "fałszywy" plik głównej klasy, który zasadniczo nic nie robi, i identyfikujesz go jako program, który ma zostać wykonany po pobraniu. W tym przypadku "manekin" zostanie wykonany, a następnie możesz uruchomić swój "prawdziwy" program bezpośrednio na Pi.

Aby użyć tej techniki, najpierw utwórz nową klasę główną:

1. Wywołaj menu projektu jak w kroku 5 i kliknij Nowa->Java Main Class. Zobaczysz wyskakujące okienko Nowa klasa główna Java.
2. W polu Nazwa klasy wprowadź nazwę. Nazwa może być dowolna; Użyłem "Manekina". Pole Package pozwala zidentyfikować pakiet klasy; pakiet wybierasz za pomocą listy rozwijanej po prawej stronie pola. Klasa może znajdować się w tym samym pakiecie co Twój „prawdziwy” program lub w innym pakiecie; Umieściłem nową klasę w tym samym pakiecie. Kliknij Zakończ. Zobaczysz teraz główne okno NetBeans z nowym plikiem w prawym górnym panelu (zdjęcie pierwsze). Dodałem proste oświadczenie o wydruku na temat uruchamiania na Pi, ale tak naprawdę nic nie jest potrzebne.

Aby uruchomić "Dummy" po pobraniu, musisz ustawić go jako "główną klasę do domyślnego wykonywania" dla projektu:

1. Otwórz Właściwości projektu jak w kroku 5. Wybierz kategorię Uruchom. Kliknij Przeglądaj po prawej stronie pola Klasa główna. Zobaczysz wyskakujące okienko Przeglądaj główne klasy (zdjęcie drugie).
2. Wybierz klasę „Manekin”. Kliknij opcję Wybierz klasę główną. Ponownie zobaczysz Właściwości projektu.
3. Kliknij OK. Powrócisz do głównego okna.

Teraz, gdy klikniesz ikonę Uruchom, NetBeans spełnia/buduje cały projekt, pobiera plik jar zawierający wszystkie pliki klas do Pi i wykonuje klasę „Dummy” (zdjęcie 3).

Aby wykonać swój prawdziwy program na Pi, musisz teraz użyć polecenia java z opcją „classpath”, która wymaga wyraźnego zidentyfikowania głównej klasy do wykonania. Z klienta ssh przejdź do katalogu dist dla swojego projektu. Właściwa komenda ma postać:

java -cp nazwa_projektu.jar nazwa_pakietu.nazwa_klasy

nazwa_projektu oczywiście odnosi się do projektu; zmienia się to tylko wtedy, gdy mamy do czynienia z nowym projektem. Nazwa_pakietu oczywiście odnosi się do pakietu, a nazwa_klasy odnosi się do głównej klasy do wykonania. Jak wspomniano wcześniej, projekt może zawierać wiele pakietów. Podobnie pakiet może zawierać wiele klas, a wszystkie mogą być klasami głównymi lub programami, które można uruchomić z wiersza poleceń. Tak więc technika „ścieżka klas” jest całkiem użyteczna przy opracowywaniu zaawansowanych programów z wieloma klasami, z których niektóre są klasami głównymi tylko w celu wspomagania testowania jednostkowego.

Następujące polecenie wykonuje mój przykładowy program:

java -cp MyRemoteProg.jar myremoteprog. MyRemoteProg

Krok 10: Wykorzystaj zarządzanie biblioteką NetBeans

Jednym z najtrudniejszych, ale najważniejszych aspektów zaawansowanych programów jest zajmowanie się bibliotekami, czyli kodem, który ktoś już napisał. NetBeans wykonuje godną podziwu pracę, usuwając większość problemów związanych z zarządzaniem biblioteką.

Jako przykład użyję Pi4J, który daje programom Java dostęp do GPIO Raspberry Pi, magistrali I2C i innych sprzętowych I/O. Pi4J jest tylko jednym z przykładów wsparcia robienia wielu zabawnych rzeczy na Pi z Javą.

Musisz najpierw pobrać bibliotekę na swoją stację roboczą. Zobacz stronę pobierania Pi4J. Ponieważ nie instalujesz Pi4J na Pi, pobierz zip na swoją stację roboczą. Możesz lub nie musisz jawnie rozpakować po pobraniu zip.

Teraz musisz stworzyć „globalną bibliotekę” w NetBeans:

1. W menu głównym NetBeans kliknij Narzędzia -> Biblioteki. Zobaczysz wyskakujące okienko Ant Library Manager (zdjęcie pierwsze).
2. Kliknij Nowa biblioteka w lewym dolnym rogu. Zobaczysz wyskakujące okienko Nowa biblioteka (zdjęcie drugie).
3. Wpisz zrozumiałą nazwę, której chcesz użyć, i kliknij OK. Ponownie zobaczysz wyskakujące okienko Ant Library Manager. Teraz pokazuje nową bibliotekę, którą utworzyłeś (zdjęcie 3).
4. Kliknij Dodaj JAR/Folder po prawej stronie. Zobaczysz wyskakujące okienko Browse JAR/Folder (rysunek czwarty).
5. Przejdź do, a następnie wybierz pi4j-core.jar. Następnie kliknij Dodaj JAR/Folder. Powrócisz do wyskakującego okienka Menedżer biblioteki Ant.
6. W oknie Ant Library Manager kliknij OK. Powrócisz do głównego okna NetBeans.

Dodałeś bibliotekę, aby można było jej używać w dowolnym projekcie. Teraz musisz dodać bibliotekę do swojego projektu:

1. Otwórz okno Właściwości projektu (patrz krok 5) i wybierz kategorię Biblioteki (rysunek piąty).
2. Kliknij Dodaj bibliotekę po prawej stronie wyskakującego okienka. Zobaczysz wyskakujące okienko Dodaj bibliotekę (zdjęcie 6).
3. Przejdź do biblioteki i wybierz ją. Następnie kliknij Dodaj bibliotekę. Ponownie zobaczysz wyskakujące okno Właściwości projektu. Biblioteka pojawi się teraz na liście bibliotek czasu kompilacji w wyskakującym okienku.
4. W wyskakującym okienku Właściwości projektu kliknij OK. Powrócisz do głównego okna.

Dodałeś bibliotekę do swojego projektu, aby Twój program mógł z niej korzystać. Możesz wykonać tę samą sekwencję działań dla dowolnej biblioteki, której potrzebujesz dla programu.

Potrzebujesz biblioteki trzy razy - kompilacja, kompilacja i wykonanie. Na szczęście w przypadku NetBeans dodanie biblioteki, jak pokazano powyżej, obsługuje wszystko. Aby to potwierdzić, stworzyłem kolejną główną klasę, która wykonuje absolutne minimum niezbędne do wykorzystania możliwości I2C w Pi4J (zdjęcie siódme). Fakt, że nie wyświetlają się żadne błędy oznacza, że klasa TestPi4J się kompiluje. Kliknięcie Uruchom pomyślnie kompiluje i pobiera; NetBeans pobiera bibliotekę oprócz pliku jar, więc program zostanie uruchomiony. Aby zweryfikować to ostatnie, możesz użyć techniki w kroku 9 i w kliencie ssh wpisać następującą komendę (z katalogu dist):

java -cp MyRemoteProg.jar myremoteprog. TestPi4J

Pouczające jest zrozumienie, jak NetBeans obsługuje biblioteki. Będąc w katalogu dist dla twojego projektu, wypisz zawartość katalogu (użyj polecenia ls), a zobaczysz podkatalog lib. Wypisz zawartość tego katalogu, a zobaczysz plik jar zidentyfikowany w globalnej bibliotece, którą w moim przykładzie jest pi4j-core.jar. Wszystkie biblioteki, które dodasz do projektu, pojawią się w katalogu lib, dzięki czemu będą dostępne dla wszystkich programów w pliku jar projektu.

Krok 11: Idź baw się dobrze

Opisałem podejście do uzyskania bardzo wydajnego programowania w języku Java dla Raspberry Pi. Raspberry Pi to niezwykle popularna technologia dla szerokiego spektrum projektów. Java to profesjonalny język programowania, który oferuje przewagę wydajnościową w porównaniu z Pythonem i zapewnia korzyści w zakresie bezpieczeństwa w porównaniu z C/C++. NetBeans to profesjonalne środowisko IDE, które znacznie zwiększa produktywność programistów.

Myślę, że połączenie jest dość atrakcyjne. Teraz idź baw się dobrze, używając kombinacji dla swoich projektów.