Java ME 8 + Raspberry Pi + Sensores =IoT World (Parte 1)

Saiba como conectar sensores ao Raspberry Pi e controlá-los com Java.

Publicado em setembro de 2014

A versão mais recente do Java ME 8 inclui uma API poderosa para controlar dispositivos como LEDs, relés, LCDs, sensores, motores e interruptores.



Este artigo é o primeiro de uma série de três partes sobre como conectar sensores eletrônicos ao Raspberry Pi Modelo B usando entrada / saída de uso geral (GPIO), barramento de circuito integrado (I2C), barramento de interface periférica serial (SPI) ou interfaces de receptor / transmissor assíncrono universal (UART).

Usando o Java ME 8 para controlar dispositivos com diferentes tipos de interfaces e conectando os dispositivos a um Raspberry Pi, podemos criar um mundo de Internet das Coisas (IoT).

Este artigo se concentra no uso de GPIO e mostra exemplos de como desenvolver classes em Java ME 8 que podem

• Detecte uma chama usando um sensor de chama DFRobot (modelo DFR0076)
• Detecte o movimento usando um detector de movimento infravermelho passivo (PIR) HC-SR501
• Meça a distância usando um módulo de alcance ultrassônico HC-SR04

Nota :O código de exemplo completo para este projeto NetBeans IDE 8.0 pode ser baixado aqui.

API de E / S do dispositivo

A especificação Device I / O API define uma API de I / O de dispositivo periférico genérico para aplicativos Java executados em pequenos dispositivos incorporados. Ele define APIs para alguns dos dispositivos periféricos mais comuns, incluindo o seguinte:

• dispositivos GPIO
• dispositivos I2C
• Dispositivos SPI
• Conversores analógico para digital (ADCs)
• Conversores digital para analógico (DACs)
• Dispositivos UART
• Dispositivos I / O mapeados por memória (MMIO)
• Dispositivos de comando AT
• cronômetros de watchdog
• Contadores de pulso
• Geradores de modulação por largura de pulso (PWM)
• Dispositivos genéricos

Circuitos que criaremos

Um dispositivo GPIO pode ser usado como entrada ou saída digital, pode ser desabilitado ou habilitado e pode ser usado para direcionar linhas de “interrupção”. No entanto, uma consideração muito importante é que todos os pinos GPIO do Raspberry Pi operam a 3,3 V. Portanto, é muito importante verificar as especificações técnicas dos dispositivos que você deseja conectar para determinar se eles estão usando 3,3 V ou 5 V. Em alguns casos , você precisará usar um conversor de nível lógico como este.

Conectando o Detector de Chama

O sensor de chama DFR0076 da DFRobot pode ser usado para detectar fogo ou outros comprimentos de onda de luz entre aproximadamente 760 nm e 1100 nm. Podemos conectá-lo a 3,3 V ou 5 V, e a faixa de detecção é de aproximadamente 20 cm (4,8 V) a 100 cm (1 V). Quando o fogo é detectado, ele puxa o pino de sinal.

Vamos conectar o sensor de chama aos pinos 3,3 V, Gnd e GPIO 22 do Raspberry Pi, conforme mostrado na Figura 3, e criar uma classe Java ME 8 para o controle do sensor do detector de chama.

Primeiro, crie uma classe DFR0076Device que usa a API de acesso ao dispositivo e define uma variável pin que suporta a interface para GPIO, conforme mostrado na Listagem 1.

 classe pública DFR0076Device {private GPIOPin pin =null; // Defina o pino para controle do sensor de chama 

Listagem 1. Classe para o controle do sensor detector de chama

Em seguida, crie um construtor de classe que inicializa e ativa o pino GPIO 22 usando o DeviceManager API e o GPIOPinConfig classe (consulte a Listagem 2) para estabelecer as seguintes condições:

• Nome do dispositivo:0
• Número do PIN:GPIO 22 (especificado por meio de pinGPIO )
• Direção:entrada apenas
• Modo:pull-up
• Gatilho:borda ascendente
• Valor inicial:falso

 public DFR0076Device (int pinGPIO) {... pin =(GPIOPin) DeviceManager.open (novo GPIOPinConfig (0, pinGPIO, GPIOPinConfig.DIR_INPUT_ONLY, GPIOPinConfig.MODE_INPUT_PIGER_UP, GPIOPINTRigERGERGE_TRIG.RIGER_TRIG.RIGO_TRIG.FALSO}, FALSO_TRIG.TRig.- / pre> 
  Listagem 2. Estabelecendo as condições iniciais  
 
 Agora, crie um método que recebe uma classe de ouvinte definida que suporta eventos de detecção de chama, conforme mostrado na Listagem 3. 
 
 public void setListener (PinListener flameListener) {... if (pin! =null) pin.setInputListener (flameListener); ...} 
 
  Listagem 3. Método que suporta eventos de detecção de chama  
 
 Também é importante que você feche o pino quando terminar e também certifique-se de liberar o ouvinte de pino, conforme mostrado na Listagem 4. 
 
 public void close () {... if (pin! =null) {pin.setInputListener (null); pin.close (); } ...} 
 
  Listagem 4. Fechando o pino e liberando o ouvinte  
 
 Agora, crie um MIDlet principal que invoca nosso código e define uma classe de ouvinte para processar eventos de detecção de chama, conforme mostrado na Listagem 5. 
 
 public class TestSensors extends MIDlet {DFR0076Device flame; final estático privado int FLAME_DETECTOR_PIN =22; public void startApp () {// Inicializar o sensor de chama flame =new DFR0076Device (FLAME_DETECTOR_PIN); flame.setListener (new FlameSensor ()); } public void destroyApp (boolean incondicional) {flame.close (); } private static int waitnext =1; classe FlameSensor implementa PinListener {public void valueChanged (evento PinEvent) {if (event.getValue () &&--waitnext ==0) {System.out.println ("WARNING Flame detectado !!!"); waitnext =10; }}}} 
 
  Listagem 5. Criando um MIDlet para invocar nosso código  
 
 Conectando o detector de movimento 
 
 Agora vamos adicionar a funcionalidade de detector de movimento aos nossos  TestSensors  MIDlet. Para fazer isso, precisamos de um sensor de movimento como o HC-SR501 mostrado na Figura 2. 
 
 Os sensores PIR permitem sentir o movimento. Tudo emite uma pequena quantidade de radiação infravermelha e, quanto mais quente alguma coisa, mais radiação emite. Os sensores PIR são capazes de detectar uma mudança nos níveis de IV que ocorrem dentro de sua zona de detecção (por exemplo, quando um humano entra em uma sala) e, portanto, detectar movimento. 
 
 O sensor PIR que usaremos tem três pinos:terra, saída digital e entrada de 3–5 Vcc. Em inatividade, quando nenhum movimento foi detectado, o sinal de saída digital permanecerá baixo. No entanto, quando o movimento é detectado, o sinal de saída digital irá pulsar alto (3,3 V). Não há problema em conectar o pino de saída digital diretamente ao Raspberry Pi. 
 
 Para teste, o sensor PIR possui um jumper (consulte a Figura 4). 
 
 
 Definir o jumper para a posição “L” cria um único gatilho (não repetível). Quando o jumper está nesta posição, a detecção é habilitada após a ocorrência de um evento de detecção, o que permite a detecção de movimento contínuo. A saída ainda está travada por 3 segundos após o movimento não ser mais detectado. 
 
 Definir o jumper para a posição “H” cria um gatilho repetível. Quando o jumper é definido para a posição “H” (padrão), a detecção é desativada após a ocorrência de um evento de detecção (ou seja, quando a saída é alta). 
 
 
 Você pode fazer os seguintes ajustes:
 
 
 Ajustar o potenciômetro de sensibilidade no sentido horário aumenta a distância de detecção para cerca de 7 metros; ajustá-lo no sentido anti-horário diminui a distância de detecção para cerca de 3 metros. 
 
 Ajustar o potenciômetro de retardo de tempo no sentido horário aumenta o retardo de indução para 300 segundos; ajustá-lo no sentido anti-horário reduz o atraso de indução para 5 segundos. 
 
 
 Vamos conectar o sensor PIR aos pinos Raspberry Pi 5 V, Gnd e GPIO 24, conforme mostrado na Figura 3, e criar uma classe Java ME 8  HCSR501Device  para controlá-lo usando a API de acesso ao dispositivo, conforme mostrado na Listagem 6. 
 
 public class HCSR501Device {private GPIOPin pin =null; 
 
  Listagem 6.  HCSR501Device  classe  
 
 Em seguida, crie um construtor de classe que inicializa e ativa o pino GPIO 24 usando o  DeviceManager  API e o  GPIOPinConfig  classe (consulte a Listagem 7) para estabelecer as seguintes condições:
 
 
 Nome do dispositivo:0 
 
 Número do PIN:GPIO 24 (especificado por meio de  pinGPIO  ) 
 
 Direção:entrada apenas 
 
 Modo:suspenso 
 
 Gatilho:borda ascendente 
 
 Valor inicial:falso 
 
 Espere três segundos antes de inicializar o PIR 
 
 
 public HCSR501Device (int pinGPIO) {... pin =(GPIOPin) DeviceManager.open (novo GPIOPinConfig (0, pinGPIO, GPIOPinConfig.DIR_INPUT_ONLY, GPIOPinConfig.MODE_INPUT_PULL_DOWN, GPIOPING_DOWN); I2CUtils.I2Cdelay (3000); // aguarde 3 segundos ...} 
 
  Listagem 7. Estabelecendo as condições iniciais  
 
 Agora, crie um método que recebe uma classe de ouvinte definida que suporta eventos de detecção de movimento, conforme mostrado na Listagem 8. 
 
 public void setListener (PinListener pirListener) {... if (pin! =null) pin.setInputListener (pirListener); ...} 
 
  Listagem 8. Método que suporta eventos de detecção de movimento  
 
 Também é importante que você feche o pino quando terminar e também certifique-se de liberar o ouvinte de pino, conforme mostrado na Listagem 9. 
 
 public void close () {... if (pin! =null) {pin.setInputListener (null); pin.close (); } ...} 
 
  Listagem 9. Fechando o pino e liberando o ouvinte  
 
 
 
 Vamos estender nossa classe MIDlet para oferecer suporte ao sensor PIR e seu ouvinte, conforme mostrado na Listagem 10. 
 
 // Define HCSR501 Device objectHCSR501Device pir; private static final int MOTION_DETECTOR_PIN =24; @Overridepublic void startApp () {... // Inicializa o sensor PIR pir =new HCSR501Device (MOTION_DETECTOR_PIN); pir.setListener (new PirSensor ()); ...} @Overridepublic void destroyApp (boolean incondicional) {... pir.close (); ...} // Verifique o sensor PIR para detecção de movimento da classe PirSensor implementa PinListener {@Override public void valueChanged (PinEvent event) {if (event.getValue ()) {System.out.println ("AVISO movimento detectado !!!"); }}} 
 
  Listagem 10. Estendendo a classe MIDlet para suportar o sensor PIR e seu listener  
 
 
 
 Para obter mais detalhes:Java ME 8 + Raspberry Pi + Sensores =IoT World (Parte 1) 
 

            

            

               Sensor de termômetro digital de 1 fio Raspberry Pi (DS18B20)        
                Alarme de água Raspberry pi 2 com t sapateiro mais