Desenvolvimento eficiente de Java para o Raspberry Pi: 11 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Este Instructable descreve uma abordagem muito eficiente para desenvolver programas Java para o Raspberry Pi. Usei a abordagem para desenvolver recursos Java que variam de suporte a dispositivos de baixo nível a programas multi-threaded e baseados em rede. A abordagem não é apenas eficiente, é gratuita!

Fundamentalmente, a abordagem é o desenvolvimento remoto usando o NetBeans. O NetBeans é executado em uma estação de trabalho (um computador desktop ou laptop, não o Raspberry Pi) conectada via Wifi ao Raspberry Pi. Depois que tudo estiver configurado corretamente, você pode escrever um programa Java no NetBeans e, em seguida, um único clique compila e constrói o programa na estação de trabalho, baixa o programa para o Pi, executa o programa no Pi e entrega a saída para o console do NetBeans. Magia! Você pode até mesmo depurar o programa em execução, definindo pontos de interrupção e examinando os valores das variáveis. Mais magia!

O restante desta introdução descreve a motivação para usar Java e para desenvolvimento remoto usando NetBeans. Se você se preocupa com a motivação, continue lendo. Se você não se importar, vá para a etapa 1.

Por que usar Java no Raspberry Pi?

Existem muitas linguagens de programação disponíveis para o Raspberry Pi, mas vou limitar a discussão a linguagens de programação de "nível profissional" que visam programas autônomos, suportam multitarefa, permitem acesso a hardware e rede, etc. Isso significa Java, Python ou C / C ++. Os lançamentos mais recentes do Raspbian incluem suporte de desenvolvimento e tempo de execução para todas essas linguagens.

O Python é, na verdade, "promovido" para uso no Pi, pelo menos em parte por sua facilidade de aprendizado para novos programadores. Eu sou um programador experiente e não gosto de Python devido a uma antipatia admitidamente subjetiva de várias de suas características, por exemplo, tipagem dinâmica. Há uma característica do Python pela qual não gosto de objetivo - desempenho. Esta fonte mostra que o Java é sempre mais rápido que o Python 3 e, na verdade, pode ser executado centenas de vezes mais rápido, dependendo da tarefa.

C, na minha opinião, é uma "linguagem de máquina de alto nível", ou seja, algo que está muito próximo do hardware do sistema, ou pelo menos do sistema operacional. Você pode fazer praticamente qualquer coisa e o mais rápido possível; na verdade, esta fonte sugere que C pode ser executado até 7 vezes mais rápido que o Java. Também não gosto de C, já que (subjetivamente) não gosto de algumas de suas características que considero misteriosas, arcaicas ou ambas; por exemplo, ponteiros explícitos. Objetivamente, o fato de que você pode fazer qualquer coisa significa que você é apenas um bug obscuro (por exemplo, aritmética de ponteiro ruim ou um memcpy errante) de sobrescrever a memória e potencialmente travar o programa ou até mesmo todo o sistema. Java evita esses perigos, portanto, Java é mais seguro. Acho que a segurança também melhora a produtividade do programador. Eu considero C ++ um "invólucro" orientado a objetos em torno de C que não faz nada para eliminar os perigos de C.

Resumindo: Java é mais rápido que Python. Java é mais seguro que C.

Existem limitações ao usar Java?

Até agora, fui capaz de fazer tudo em Java que posso fazer em Python. Há coisas que podem ser feitas em C que não podem ser feitas em Java, mas, novamente, tudo o que eu queria fazer foi abordado por fãs de Java na comunidade Pi. Oferecerei um exemplo em uma etapa posterior. Dito isso, comprei sensores de fornecedores que forneciam "drivers" para os sensores apenas em Python (ou C / C ++ para o Arduino), então tive que escrever o equivalente em Java; o esforço extra não é necessariamente produtivo, mas pode resultar em maior percepção da operação de um sensor.

Por que desenvolvimento remoto baseado no NetBeans?

Descobri que o desenvolvimento remoto baseado no NetBeans aumenta muito a produtividade ao usar Java para o Raspberry Pi. Estou confiante de que você pode usar a abordagem para criar programas rápidos e seguros, devido às características inerentes do Java, ao escrever, construir e depurá-los muito mais rapidamente do que outras abordagens que encontrei, devido ao desenvolvimento remoto usando o "profissional grau "NetBeans Integrated Development Environment (IDE).

Pode ser útil discutir brevemente essas "outras abordagens". Todos atendem aos critérios básicos de que o Raspberry Pi não possui um teclado, mouse ou monitor conectado. Existem muitos motivos para esse critério, mas meu principal motivo é que eu desenvolvo robôs móveis e não quero o Pi conectado a nenhum periférico, exceto subsistemas robóticos, mesmo durante o desenvolvimento.

O servidor VNC incluído no Raspbian fornece uma interface gráfica de usuário (GUI) remota que permite uma forma de desenvolvimento remoto, onde apenas a GUI remota é executada na estação de trabalho e todo o resto, escrita, compilação e construção, ocorre no Pi. Com o VNC, é fácil usar as ferramentas de desenvolvimento compatíveis com Java que vêm no Raspbian, como BlueJ, Geany e Greenfoot. Alguns deles podem ser considerados um IDE; no entanto, acho que estão longe do nível profissional.

É tecnicamente possível instalar um IDE Java de nível profissional como Eclipse ou NetBeans no Raspberry Pi e usá-lo remotamente via VNC. Os relatórios e o bom senso sugerem que os resultados seriam decepcionantes, devido ao grande consumo de memória e à potência da CPU que esses IDEs exigem, bem como à latência da rede introduzida por uma GUI remota.

Tanto o Eclipse quanto o NetBeans funcionam muito bem em uma estação de trabalho. Com o Eclipse, escrever código é uma experiência agradável, no entanto, construir o programa não é; o download do programa deve ocorrer fora do Eclipse; a execução do programa no Pi é completamente independente do Eclipse. O resultado geral é um processo de várias etapas, quase doloroso, que não oferece suporte à depuração remota. O NetBeans possui compilação, construção, download, execução remota e depuração remota integrados, tornando-o uma abordagem superior.

Etapa 1: configurar o Raspberry Pi

Para usar a abordagem de desenvolvimento remoto, você deve começar configurando o Raspberry Pi de destino. Existem muitos recursos, incluindo Instructables, disponíveis para auxiliar na configuração de um Raspberry Pi. Veja isso para os fundamentos da configuração do Pi (e mais).

Este Instructable assume que você

• instale o Raspbian mais recente; certifique-se de registrar o ID de usuário e senha Pi
• configurar Wifi e conectar ao seu roteador (veja isto); certifique-se de registrar o endereço IP do Pi
• habilite SSH (veja isto) para permitir acesso remoto ao Pi a partir da estação de trabalho

Depois de concluir a configuração, você pode desligar e desconectar o monitor, o teclado e o mouse do Pi. Esta é uma das principais vantagens do desenvolvimento remoto. Você deve deixar qualquer dongle Wifi conectado (não necessário, é claro, para um Pi modelo 3 ou Pi Zero W), e então você pode ligar o Pi.

Para testar, abra um cliente ssh em sua estação de trabalho, por exemplo, Terminal no MacOS ou putty no Windows. Em seguida, insira o comando ssh (shell seguro) com o seguinte formato:

ssh the_pi_ip_address -l the_pi_user_id

Você deve receber um prompt para inserir a senha do seu ID de usuário Pi. Se nenhum prompt aparecer, verifique se você inseriu o endereço IP correto no comando ssh. Digite sua senha (ela ficará oculta) e você deverá ver o prompt do shell do Pi que aparece mais ou menos assim:

pi @ raspberrypi: ~ $

Se você não vir o prompt, verifique o ID do usuário e a senha que você usou.

Agora você deve encontrar o caminho para o tempo de execução Java e confirmar que a versão padrão é Java 8 (deve ser verdadeiro para o Raspbian mais recente). Para encontrar o caminho do Java Runtime, no cliente ssh, digite o comando

sudo atualizar-alternativas - exibir java

Você deverá ver uma resposta com as duas primeiras linhas semelhante a esta:

java - modo automático

a melhor versão do link é / usr / lib / jvm / jdk-8-oracle-arm32-vfp-hflt / jre / bin / java

O "-8-" na segunda linha confirma que o tempo de execução padrão é Java 8. Registre o caminho na segunda linha, pois você precisará dele para configurar o NetBeans para desenvolvimento remoto em uma etapa posterior.

Se o tempo de execução padrão não for Java 8, no cliente ssh, digite o seguinte comando para mudar para Java 8 (supondo que esteja instalado)

sudo atualizar-alternativas --config java

Etapa 2: Instale o NetBeans na estação de trabalho

Agora você precisa instalar o NetBeans em sua estação de trabalho. Aponte o navegador da estação de trabalho para a página de download do NetBeans. Você verá vários pacotes possíveis que suportam as duas edições do Java, bem como outras linguagens. Tudo que você precisa para o desenvolvimento Java para o Raspberry Pi é Java SE, mas você pode obter o pacote Java EE ou o pacote All. Depois de decidir qual pacote deseja, clique no botão Download correspondente. Você pode encontrar instruções de instalação adicionais para o sistema operacional de sua estação de trabalho aqui.

Depois de instalar o NetBeans, inicie-o (pode fazê-lo automaticamente após a instalação). Você deve ver a janela principal do NetBeans conforme mostrado na imagem. A foto foi tirada em um Mac, e a janela principal pode ser um pouco diferente no Windows.

Depois de instalar e iniciar o NetBeans com sucesso, prossiga para a próxima etapa.

Etapa 3: configurar o Raspberry Pi como uma plataforma remota no NetBeans

As ações a seguir configuram o Raspberry Pi como uma plataforma Java SE remota para NetBeans. Isso permite que o NetBeans baixe e execute programas Java no Pi. Você pode encontrar uma descrição um tanto genérica aqui.

NOTA: Nesta e nas etapas seguintes, mostro valores específicos para meu ambiente para vários aspectos de configuração e codificação; o seu obviamente será diferente.

Para configurar o Pi como uma plataforma remota:

1. Na barra de menu principal do NetBeans, selecione Ferramentas -> Plataformas Java. Você verá a janela pop-up do Java Platform Manager (imagem um).
2. Clique em Adicionar plataforma no canto inferior esquerdo. Você verá o pop-up Adicionar plataforma Java [tipo de plataforma] (imagem dois).
3. Escolha Remote Java Standard Edition. Clique em Avançar. Você verá o pop-up Adicionar plataforma Java [configurar plataforma remota] (a imagem três mostra o pop-up depois de inserir os valores apropriados para meu ambiente nos campos).
4. No campo Nome da plataforma, insira um nome para o Pi. Você pode usar praticamente qualquer coisa, mas deve ser único.
5. No campo Host, digite o endereço IP do Pi encontrado na etapa 1.
6. No campo Nome de usuário, insira o nome de usuário que você usou na etapa 1.
7. Deixe a opção Usar autenticação por senha selecionada e, no campo Senha, digite a senha que você criou na etapa 1.
8. No campo Caminho JRE remoto, você deve inserir a maior parte do caminho para o tempo de execução Java no Pi. Na etapa 1, era / usr / lib / jvm / jdk-8-oracle-arm32-vfp-hflt / jre / bin / java. No entanto, você deve inserir / bin / java no valor do campo.
9. O NetBeans baixa o programa executável para um diretório de trabalho no Pi, identificado no campo Working Dir. O padrão é / the_Pi_user_ID / NetBeansProjects / e é perfeitamente aceitável. Você pode usar algo diferente se desejar, embora deva estar disponível para the_Pi_user_ID (imagem três).
10. Clique em Concluir na parte inferior direita do pop-up. Após o processamento, você deve ver mais uma vez a janela pop-up do Java Platform Manager. Agora você deve ver seu Pi remoto (com o nome que você usou na ação 4 acima) na categoria Java SE remoto (imagem quatro).
11. Clique em Test Platform no canto inferior esquerdo para testar a conexão entre o NetBeans e seu Pi. Primeiro, você verá um pop-up dizendo Verificando a plataforma remota. Se for bem-sucedido, você obterá um segundo pop-up indicando a conexão … estabelecida com sucesso. Caso contrário, você precisa verificar e corrigir as informações inseridas no pop-up Adicionar plataforma Java [configurar plataforma remota] nas ações 5-9 acima. Você pode fazer isso no pop-up do Java Platform Manager; simplesmente selecione sua plataforma Pi e edite os campos no lado direito da janela pop-up.
12. Após uma conexão bem-sucedida, clique em Fechar no pop-up do Gerenciador de plataforma Java. Agora você verá a janela principal do NetBeans.

Agora a verdadeira diversão pode começar!

Etapa 4: Crie um projeto Java na estação de trabalho

Não pretendo ser uma explicação completa de como usar o NetBeans ou Java, mas vou descrever as ações mínimas para escrever um programa no NetBeans na estação de trabalho e, eventualmente, executar o programa remotamente no Raspberry Pi.

No NetBeans, você deve primeiro criar um projeto para conter a (s) classe (s) Java para o programa. Além disso, em Java, as classes residem em pacotes para oferecer suporte à organização e segurança. Para criar o projeto e, opcionalmente, criar um pacote e um arquivo de classe:

1. Na janela principal do NetBeans, clique no ícone do novo projeto (2º da esquerda). Você verá o pop-up Novo projeto [escolher projeto] (imagem um).
2. Os padrões (Categoria: Java, Projeto: Aplicativo Java) estão corretos para este exemplo, então simplesmente clique em Avançar. Você verá o pop-up Novo aplicativo Java [nome e local] (a imagem dois mostra os valores do meu exemplo). NOTA: Eu editei minhas informações de usuário usando os retângulos coloridos.
3. No campo Nome do projeto, insira um nome de projeto Java válido de sua escolha. O nome deve começar com uma letra maiúscula, e a convenção sugere maiúsculas e minúsculas ao concatenar palavras.
4. O campo Localização do projeto controla onde o projeto reside em seu sistema de arquivos. O padrão varia dependendo do sistema operacional, mas é seguro aceitar.
5. O campo Pasta do projeto permite controlar o nome da pasta do projeto. Acho melhor usar o padrão, que é uma concatenação do campo Local e do campo Nome.
6. Quando a caixa de seleção Criar classe principal está marcada, o NetBeans cria automaticamente um pacote e um arquivo de classe principal (um programa que pode ser executado na linha de comando) com o mesmo nome do projeto. Acho que normalmente deveria estar desmarcado, mas neste caso, vou deixar marcado, o que elimina ações explícitas de outra forma necessárias para fazê-lo (figura dois).
7. Clique em Concluir para criar o projeto, um pacote e um arquivo de classe principal. Agora, o painel superior esquerdo da janela principal do NetBeans mostra seu projeto, que contém um único pacote, que por sua vez contém um único arquivo de classe com um método main (). O painel superior direito contém o código-fonte padrão para a classe principal (o programa) gerado automaticamente pelo NetBeans (imagem três).

Neste ponto, você pode escrever algum código no método principal e executá-lo na estação de trabalho. Isso pode ser desejável às vezes, mas é desnecessário para este Instructable, então prossiga para a próxima etapa.

Etapa 5: configurar o projeto NetBeans para ser executado remotamente no Raspberry Pi

Para configurar o projeto NetBeans e um programa que ele contém para ser executado remotamente no Raspberry Pi, faça o seguinte:

1. Clique com o botão direito ou com dois dedos (depende do SO da estação de trabalho) no projeto no painel Projetos da janela principal do NetBeans para abrir o menu do projeto e clique em Propriedades. Você verá o pop-up Propriedades do projeto (a imagem mostra o pop-up com os valores apropriados para o meu exemplo).
2. Em Categorias à esquerda, selecione Executar.
3. Clique em Novo à direita do campo Configuração. No pop-up Criar nova configuração resultante, insira um nome para a configuração e clique em OK. O nome pode ser qualquer coisa; Acabei de reutilizar o nome da plataforma ("My Pi"). Mais uma vez, você verá o pop-up Propriedades do projeto.
4. Clique no ícone suspenso à direita do campo Runtime Platform. Na lista pop-up, selecione a plataforma remota que você criou anteriormente (em meu ambiente, "My Pi").
5. Clique em OK para configurar a plataforma remota para o projeto. Você verá mais uma vez a janela principal.

Agora você está pronto para escrever o código e executar o programa remotamente.

Etapa 6: escreva um programa Java na estação de trabalho e execute-o no Raspberry Pi

O painel direito na janela principal do NetBeans mostra o arquivo de classe principal gerado pelo NetBeans. Digite uma instrução de impressão simples no método principal do arquivo de classe (imagem um). Agora é um programa Java completo que faz algo, embora algo muito simples.

Para executar o programa no Pi, clique no ícone Executar (a seta verde apontando para a esquerda) na janela principal. O NetBeans compila o código, cria um arquivo jar, baixa o arquivo jar no Raspberry Pi identificado pela plataforma remota, executa o programa no Pi, captura a saída (System.out) do programa e ecoa essa saída para o NetBeans Painel de saída no canto inferior direito da janela principal (imagem dois).

Agora você expandiu significativamente seu conjunto de habilidades para o desenvolvimento de projetos no Raspberry Pi! Mas espere…. Há mais!

Etapa 7: depure o programa Java com o NetBeans

Um dos recursos mais poderosos de um Ambiente de Desenvolvimento Integrado de força industrial como o NetBeans é a capacidade de depurar o programa durante a execução. O NetBeans permite que você aproveite o conjunto completo de ferramentas de depuração enquanto é executado remotamente. Isso inclui definir pontos de interrupção em locais "importantes" ou "problemáticos" no programa e examinar o valor das variáveis no estado de execução atual.

O programa simples na última etapa é muito simples para demonstrar a depuração, então adicionei algum código adicional ao programa. O código adicional adiciona duas variáveis.

Para aproveitar as ferramentas de depuração, você deve primeiro definir um ou mais pontos de interrupção. Para definir um ponto de interrupção, clique no número da linha onde deseja suspender a execução; um ícone de retângulo vermelho aparece e toda a linha adquire um fundo vermelho (foto um).

Para depurar o programa em execução no Pi, clique no ícone Depurar (imediatamente à direita do ícone Executar) na janela principal do NetBeans. Como na execução normal, o NetBeans compila, constrói, baixa, executa, captura a saída e ecoa essa saída. Mas com a depuração, o NetBeans para a execução em pontos de interrupção e permite que você examine o estado de execução (imagem dois, mostrando o painel Variáveis no canto inferior direito).

A execução para no ponto de interrupção antes de executar a instrução na linha com o ponto de interrupção. O fundo verde indica a próxima instrução a ser executada. Assim, em meu exemplo, com um ponto de interrupção na linha 9, a variável a ainda não existe, muito menos tem um valor.

Agora passe o cursor sobre o ícone do menu de depuração na janela principal (o primeiro ícone de seta dupla para baixo à direita do ícone de Depuração) e clique no ícone Avançar (tem um documento azul no fundo e uma seta verde no sentido anti-horário em primeiro plano). [NOTA: se você deixar a janela principal do NetBeans larga o suficiente, o menu de depuração se expande e os ícones de ação de depuração aparecem à direita do ícone de depuração.] O NetBeans executa a instrução no ponto de interrupção e interrompe a execução antes da próxima instrução. Você verá agora que a variável a existe e tem o valor esperado (figura três).

Clique no ícone Step Over duas vezes. Você verá que todas as três variáveis têm valores; observe que c ainda é zero (figura quatro).

Clique no ícone Step Over uma vez. Você verá que a variável c agora tem o valor adequado, ou seja, a soma das variáveis aeb (figura cinco).

Finalmente, no menu de depuração, clique no ícone Executar (um círculo verde com uma seta branca). Isso faz com que a execução continue até o próximo ponto de interrupção ou até o final do programa, o que ocorrer primeiro. Agora, o painel Saída aparece e mostra a mesma saída da execução normal, neste caso o texto na instrução de impressão.

Etapa 8: execute o programa independente do NetBeans

Pode chegar o momento em que você deseja executar seu programa no Raspberry Pi, sem "assistência" ou "interferência" do NetBeans. É muito simples. Primeiro, abra um cliente ssh para o seu Pi.

Lembre-se da etapa 3 que o NetBeans coloca o jar do projeto em um diretório de trabalho no Pi. A base padrão é / home / pi / NetBeansProjects para o usuário pi. O diretório específico tem o mesmo nome do seu projeto. O NetBeans coloca o jar em um subdiretório chamado dist. Para meu exemplo, o caminho completo é / home / pi / NetBeansProjects / MyRemoteProg / dist. No cliente ssh no Pi, para executar o programa você pode usar o comando java com a opção 'jar':

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

Você verá os resultados da execução no cliente ssh; no meu exemplo, a saída será

Olá, do Raspberry Pi!

Isso funciona porque as informações no arquivo jar identificam qual classe principal do jar deve ser executada.

Você também pode alterar o diretório de trabalho (via cd) para a localização do arquivo jar e então emitir um comando mais curto para produzir os mesmos resultados.

java -jar MyRemoteProg.jar

Etapa 9: construir e baixar, mas não executar o programa via NetBeans

Existem situações em que você deseja que o NetBeans crie e baixe seu programa, mas não o execute. Uma dessas situações ocorre quando seu programa precisa de entrada do teclado. Se for esse o caso, usando a técnica da etapa anterior, depois de criar e baixar, o programa é executado no Raspberry Pi e, portanto, espera a entrada do teclado do Pi, mas é claro, não há teclado conectado ao Pi, então o programa trava - não é bom.

Você deve usar uma técnica um pouco diferente para executar o programa. Fundamentalmente, você cria um arquivo de classe principal "fictício" que essencialmente não faz nada e o identifica como o programa a ser executado após o download. Neste caso, o "dummy" é executado e você pode então rodar seu programa "real" diretamente no Pi.

Para usar essa técnica, primeiro crie uma nova classe principal:

1. Abra o menu do projeto como na etapa 5 e clique em Novo-> Classe Principal Java. Você verá o pop-up New Java Main Class.
2. No campo Nome da classe, insira um nome. O nome pode ser o que você quiser; Eu usei "Dummy". O campo Pacote permite que você identifique o pacote da classe; você seleciona o pacote usando a lista suspensa à direita do campo. A classe pode estar no mesmo pacote que seu programa "real" ou em um pacote diferente; Coloquei a nova classe no mesmo pacote. Clique em Concluir. Agora você verá a janela principal do NetBeans com o novo arquivo no painel superior direito (imagem um). Eu adicionei uma instrução de impressão simples sobre a execução no Pi, mas nada é realmente necessário.

Para executar o "Dummy" após o download, você deve torná-lo a "classe principal a ser executada por padrão" para o projeto:

1. Abra as Propriedades do projeto como na etapa 5. Selecione a categoria Executar. Clique em Navegar à direita do campo Classe principal. Você verá o pop-up Browse Main Classes (figura dois).
2. Selecione a classe "Dummy". Clique em Selecionar classe principal. Você verá mais uma vez as Propriedades do Projeto.
3. Clique OK. Você retornará à janela principal.

Agora, quando você clica no ícone Executar, o NetBeans compila / constrói todo o projeto, baixa o jar contendo todos os arquivos de classe para o Pi e executa a classe "Dummy" (figura três).

Para executar seu programa real no Pi, você deve agora usar o comando java com a opção 'classpath', que requer que você identifique explicitamente a classe principal a ser executada. De um cliente ssh, vá para o diretório dist do seu projeto. O comando adequado tem o formato:

java -cp project_name.jar package_name.class_name

O project_name obviamente se refere ao projeto; que muda apenas quando se trata de um novo projeto. O package_name obviamente se refere ao pacote, e o class_name se refere à classe principal a ser executada. Como dito anteriormente, um projeto pode conter muitos pacotes. Da mesma forma, um pacote pode conter muitas classes e todas podem ser classes principais ou programas que podem ser executados a partir da linha de comando. Assim, a técnica de 'classpath' é bastante útil para desenvolver programas sofisticados com muitas classes, algumas das quais são classes principais apenas para auxiliar no teste de unidade.

O seguinte comando executa meu programa de exemplo:

java -cp MyRemoteProg.jar myremoteprog. MyRemoteProg

Etapa 10: Aproveite o gerenciamento da biblioteca NetBeans

Um dos aspectos mais difíceis, mas mais importantes, de programas sofisticados é lidar com bibliotecas, ou seja, código que outra pessoa já escreveu. O NetBeans faz um trabalho admirável de remover a maior parte da dor do gerenciamento de bibliotecas.

Usarei como exemplo o Pi4J, que dá aos programas Java acesso ao Raspberry Pi GPIO, barramento I2C e outras E / S de hardware. Pi4J é apenas um exemplo de suporte para fazer muitas coisas divertidas no Pi com Java.

Você deve primeiro fazer o download da biblioteca para sua estação de trabalho. Consulte a página de download do Pi4J. Como você não está instalando o Pi4J no Pi, baixe o zip para sua estação de trabalho. Você pode ou não ter que descompactar explicitamente depois que o zip for baixado.

Agora você deve criar uma "biblioteca global" no NetBeans:

1. No menu principal do NetBeans, clique em Ferramentas -> Bibliotecas. Você verá o popup Ant Library Manager (imagem um).
2. Clique em Nova Biblioteca na parte inferior esquerda. Você verá o pop-up Nova Biblioteca (figura dois).
3. Digite um nome significativo que deseja usar e clique em OK. Você verá mais uma vez o pop-up Ant Library Manager. Agora mostra a nova biblioteca que você criou (figura três).
4. Clique em Adicionar JAR / Pasta à direita. Você verá o popup Browse JAR / Folder (figura quatro).
5. Acesse e selecione pi4j-core.jar. Em seguida, clique em Adicionar JAR / Pasta. Você retornará ao pop-up Ant Library Manager.
6. No pop-up Ant Library Manager, clique em OK. Você retornará à janela principal do NetBeans.

Você adicionou a biblioteca para que ela possa ser usada em qualquer projeto. Agora você deve adicionar a biblioteca ao seu projeto:

1. Abra o pop-up Propriedades do projeto (consulte a etapa 5) e selecione a categoria Bibliotecas (figura cinco).
2. Clique em Adicionar biblioteca no lado direito da janela pop-up. Você verá o pop-up Adicionar Biblioteca (imagem seis).
3. Navegue até a biblioteca e selecione-a. Em seguida, clique em Adicionar biblioteca. Você verá novamente o pop-up Propriedades do projeto. A biblioteca agora aparece na lista de Bibliotecas de tempo de compilação no pop-up.
4. No pop-up Propriedades do projeto, clique em OK. Você retornará à janela principal.

Você adicionou a biblioteca ao seu projeto para que seu programa possa usá-la. Você pode fazer a mesma sequência de ações para qualquer biblioteca necessária para um programa.

Existem três momentos em que você precisa da biblioteca - compilar, construir e executar. Felizmente, com o NetBeans, adicionar a biblioteca conforme mostrado acima trata de tudo. Para confirmar isso, criei outra classe principal que faz o mínimo absoluto necessário para usar a capacidade I2C no Pi4J (figura sete). O fato de não haver erros exibidos significa que a classe TestPi4J compila. Clicar em Executar cria e baixa com sucesso; O NetBeans baixa a biblioteca além do arquivo jar, para que o programa seja executado. Para verificar o último, você pode usar a técnica na etapa 9 e no cliente ssh inserir o seguinte comando (do diretório dist):

java -cp MyRemoteProg.jar myremoteprog. TestPi4J

É instrutivo entender como o NetBeans lida com bibliotecas. Enquanto estiver no diretório dist para seu projeto, liste o conteúdo do diretório (use o comando ls) e você verá um subdiretório lib. Liste o conteúdo desse diretório e você verá o arquivo jar identificado na biblioteca global, que em meu exemplo é pi4j-core.jar. Todas as bibliotecas adicionadas ao projeto aparecerão no diretório lib e, portanto, estarão disponíveis para todos os programas no arquivo jar do projeto.

Etapa 11: Divirta-se

Descrevi uma abordagem para obter um desenvolvimento Java muito eficiente para o Raspberry Pi. O Raspberry Pi é uma tecnologia extremamente popular para um amplo espectro de projetos. Java é uma linguagem de programação de nível profissional que oferece vantagens de desempenho em relação ao Python e oferece vantagens de segurança em relação ao C / C ++. O NetBeans é um IDE de nível profissional que aumenta muito a produtividade do programador.

Acho que a combinação é bastante atraente. Agora, divirta-se usando a combinação para seus projetos.